@nodewrite-labs/analytics-sdk 0.0.0-stage → 0.1.0

package/dist/chunk-Q4JRXZ6M.js

@@ -0,0 +1,132 @@
+import {
+  AnalyticsEventKind
+} from "./chunk-F7BY2JQ3.js";
+
+// src/core/duration-seconds.ts
+var MIN_DURATION_SECONDS = 0;
+var MAX_DURATION_SECONDS = 1800;
+function acceptDurationSeconds(value) {
+  if (!Number.isFinite(value)) return null;
+  if (value < MIN_DURATION_SECONDS || value > MAX_DURATION_SECONDS) return null;
+  return value;
+}
+
+// src/core/summarize-events.ts
+function summarizeAnalyticsEvents(rows, query, modules) {
+  const filtered = rows.filter((row) => inQuery(row, query));
+  const views = filtered.filter((row) => row.kind === AnalyticsEventKind.VIEW);
+  const summary = {
+    totalViews: views.length,
+    averageDurationSeconds: meanDuration(views),
+    byPath: groupByPath(views)
+  };
+  if (modules.country) {
+    summary.byCountry = groupByCountry(views);
+  }
+  if (modules.city) {
+    summary.byCity = groupByCity(views);
+  }
+  if (modules.sessions) {
+    summary.sessions = groupSessions(filtered);
+    if (query.sessionId !== null) {
+      summary.events = filtered.slice().sort(byOccurredAt).map((row) => ({
+        id: row.id,
+        kind: row.kind,
+        path: row.path,
+        occurredAt: row.occurredAt,
+        eventName: row.eventName
+      }));
+    }
+  }
+  if (modules.clicks) {
+    summary.byEventName = groupByEventName(filtered);
+  }
+  return summary;
+}
+function inQuery(row, query) {
+  if (row.occurredAt < query.from || row.occurredAt > query.to) return false;
+  if (query.country !== null && row.country !== query.country) return false;
+  if (query.path !== null && row.path !== query.path) return false;
+  if (query.sessionId !== null && row.sessionId !== query.sessionId) return false;
+  return true;
+}
+function meanDuration(views) {
+  let total = 0;
+  let count = 0;
+  for (const view of views) {
+    if (view.durationSeconds === null) continue;
+    total += view.durationSeconds;
+    count += 1;
+  }
+  if (count === 0) return 0;
+  return total / count;
+}
+function groupByPath(views) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    const existing = groups.get(view.path);
+    if (existing) existing.push(view);
+    else groups.set(view.path, [view]);
+  }
+  return [...groups.entries()].sort(([left], [right]) => compareString(left, right)).map(([path, pathViews]) => ({
+    path,
+    views: pathViews.length,
+    averageDurationSeconds: meanDuration(pathViews)
+  }));
+}
+function groupByCountry(views) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    if (view.country === null) continue;
+    counts.set(view.country, (counts.get(view.country) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([country, viewCount]) => ({ country, views: viewCount })).sort((left, right) => compareString(left.country, right.country));
+}
+function groupByCity(views) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    if (view.city === null) continue;
+    counts.set(view.city, (counts.get(view.city) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([city, viewCount]) => ({ city, views: viewCount })).sort((left, right) => compareString(left.city, right.city));
+}
+function groupSessions(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.sessionId === null) continue;
+    const existing = groups.get(row.sessionId);
+    if (!existing) {
+      groups.set(row.sessionId, {
+        startedAt: row.occurredAt,
+        pageCount: row.kind === AnalyticsEventKind.VIEW ? 1 : 0
+      });
+      continue;
+    }
+    if (row.occurredAt < existing.startedAt) existing.startedAt = row.occurredAt;
+    if (row.kind === AnalyticsEventKind.VIEW) existing.pageCount += 1;
+  }
+  return [...groups.entries()].map(([id, group]) => ({ id, startedAt: group.startedAt, pageCount: group.pageCount })).sort(
+    (left, right) => compareString(left.startedAt, right.startedAt) || compareString(left.id, right.id)
+  );
+}
+function groupByEventName(rows) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.kind !== AnalyticsEventKind.CLICK || row.eventName === null) continue;
+    counts.set(row.eventName, (counts.get(row.eventName) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([eventName, count]) => ({ eventName, count })).sort((left, right) => compareString(left.eventName, right.eventName));
+}
+function byOccurredAt(left, right) {
+  return compareString(left.occurredAt, right.occurredAt) || compareString(left.id, right.id);
+}
+function compareString(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+export {
+  acceptDurationSeconds,
+  summarizeAnalyticsEvents
+};

package/dist/client/index.d.ts

@@ -0,0 +1,8 @@
+import { A as AnalyticsClientConfig } from '../options-D3s0dcJ-.js';
+export { A as AnalyticsEventBody } from '../event-body-fpV2mYpY.js';
+
+declare function recordNamedClick(name: string): void;
+
+declare function startAnalytics(config: AnalyticsClientConfig): void;
+
+export { AnalyticsClientConfig, recordNamedClick, startAnalytics };

package/dist/client/index.js

@@ -0,0 +1,219 @@
+// src/client/record-named-click.ts
+var EVENT_NAME_PATTERN = /^[a-z0-9_]+$/;
+var active = null;
+function bindAnalyticsClient(client) {
+  active = client;
+}
+function recordNamedClick(name) {
+  if (active === null || !active.clicks) return;
+  if (!EVENT_NAME_PATTERN.test(name)) return;
+  active.send({
+    type: "click",
+    path: location.pathname,
+    locale: active.locale,
+    sessionId: active.sessionId,
+    eventName: name
+  });
+}
+
+// src/client/session-cookie.ts
+var COOKIE_NAME = "analytics_session";
+var ONE_YEAR_SECONDS = 31536e3;
+function readSessionId() {
+  const cookies = document.cookie ? document.cookie.split(";") : [];
+  for (const cookie of cookies) {
+    const separator = cookie.indexOf("=");
+    if (separator === -1) continue;
+    const name = cookie.slice(0, separator).trim();
+    if (name !== COOKIE_NAME) continue;
+    return decodeCookieValue(cookie.slice(separator + 1).trim());
+  }
+  return null;
+}
+function ensureSessionId() {
+  const existing = readSessionId();
+  if (existing !== null) return existing;
+  const id = crypto.randomUUID();
+  document.cookie = `${COOKIE_NAME}=${id}; SameSite=Lax; Path=/; Max-Age=${ONE_YEAR_SECONDS}`;
+  return id;
+}
+function decodeCookieValue(value) {
+  if (value.length === 0) return null;
+  try {
+    const decoded = decodeURIComponent(value);
+    return decoded.length > 0 ? decoded : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/client/start-analytics.ts
+var MAX_DURATION_SECONDS = 1800;
+var endpoint = "";
+var locale = null;
+var sessionId = null;
+var viewGeneration = 0;
+var currentPath = null;
+var currentViewId = null;
+var viewSentAt = 0;
+var restoreHistory = null;
+var removePopState = null;
+var removePageHide = null;
+var removeClick = null;
+function startAnalytics(config) {
+  stopAnalytics();
+  if (!config.enabled) return;
+  endpoint = config.endpoint;
+  locale = config.locale ?? null;
+  sessionId = config.sessions ? ensureSessionId() : null;
+  bindAnalyticsClient({
+    locale,
+    sessionId,
+    clicks: config.clicks,
+    send: (body) => {
+      void postJson(endpoint, body);
+    }
+  });
+  installHistory();
+  installPageHide();
+  if (config.clicks) installClickListener();
+  void sendView();
+}
+function stopAnalytics() {
+  viewGeneration += 1;
+  currentViewId = null;
+  currentPath = null;
+  viewSentAt = 0;
+  bindAnalyticsClient(null);
+  removeClick?.();
+  removeClick = null;
+  removePageHide?.();
+  removePageHide = null;
+  removePopState?.();
+  removePopState = null;
+  restoreHistory?.();
+  restoreHistory = null;
+}
+function installHistory() {
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  history.pushState = (data, unused, url) => {
+    originalPushState(data, unused, url);
+    void onPathChange();
+  };
+  history.replaceState = (data, unused, url) => {
+    originalReplaceState(data, unused, url);
+    void onPathChange();
+  };
+  const onPopState = () => {
+    void onPathChange();
+  };
+  window.addEventListener("popstate", onPopState);
+  restoreHistory = () => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+  };
+  removePopState = () => {
+    window.removeEventListener("popstate", onPopState);
+  };
+}
+function installPageHide() {
+  const onPageHide = () => {
+    if (currentViewId === null) return;
+    const body = {
+      type: "duration",
+      id: currentViewId,
+      durationSeconds: capDuration((Date.now() - viewSentAt) / 1e3)
+    };
+    try {
+      navigator.sendBeacon(endpoint, new Blob([JSON.stringify(body)], { type: "application/json" }));
+    } catch {
+    }
+  };
+  window.addEventListener("pagehide", onPageHide);
+  removePageHide = () => {
+    window.removeEventListener("pagehide", onPageHide);
+  };
+}
+function installClickListener() {
+  const onClick = (event) => {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const marked = target.closest("[data-analytics]");
+    if (marked === null) return;
+    const name = marked.getAttribute("data-analytics");
+    if (name === null) return;
+    recordNamedClick(name);
+  };
+  document.addEventListener("click", onClick);
+  removeClick = () => {
+    document.removeEventListener("click", onClick);
+  };
+}
+async function onPathChange() {
+  const path = location.pathname;
+  if (path === currentPath) return;
+  const previousId = currentViewId;
+  const previousSentAt = viewSentAt;
+  viewGeneration += 1;
+  currentViewId = null;
+  currentPath = path;
+  if (previousId !== null) {
+    const durationBody = {
+      type: "duration",
+      id: previousId,
+      durationSeconds: capDuration((Date.now() - previousSentAt) / 1e3)
+    };
+    try {
+      await postJson(endpoint, durationBody);
+    } catch {
+    }
+  }
+  if (location.pathname !== path) return;
+  await sendView();
+}
+async function sendView() {
+  const generation = ++viewGeneration;
+  const path = location.pathname;
+  currentPath = path;
+  const sentAt = Date.now();
+  viewSentAt = sentAt;
+  currentViewId = null;
+  const body = {
+    type: "view",
+    path,
+    locale,
+    sessionId
+  };
+  try {
+    const response = await postJson(endpoint, body);
+    const id = await readViewId(response);
+    if (generation !== viewGeneration) return;
+    currentViewId = id;
+  } catch {
+    if (generation !== viewGeneration) return;
+    currentViewId = null;
+  }
+}
+async function postJson(url, body) {
+  return fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+}
+async function readViewId(response) {
+  const payload = await response.json();
+  if (typeof payload !== "object" || payload === null || !("id" in payload)) return null;
+  const id = payload.id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function capDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) return 0;
+  if (seconds >= MAX_DURATION_SECONDS) return MAX_DURATION_SECONDS;
+  return seconds;
+}
+export {
+  recordNamedClick,
+  startAnalytics
+};

package/dist/event-body-fpV2mYpY.d.ts

@@ -0,0 +1,18 @@
+type AnalyticsEventBody = {
+    type: "view";
+    path: string;
+    locale: string | null;
+    sessionId: string | null;
+} | {
+    type: "duration";
+    id: string;
+    durationSeconds: number;
+} | {
+    type: "click";
+    path: string;
+    locale: string | null;
+    sessionId: string | null;
+    eventName: string;
+};
+
+export type { AnalyticsEventBody as A };

package/dist/event-store-BhisLdw_.d.ts

@@ -0,0 +1,72 @@
+import { a as AnalyticsModules } from './options-D3s0dcJ-.js';
+
+declare const AnalyticsEventKind: {
+    readonly VIEW: "view";
+    readonly CLICK: "click";
+};
+type AnalyticsEventKind = (typeof AnalyticsEventKind)[keyof typeof AnalyticsEventKind];
+
+interface NewAnalyticsEvent {
+    kind: AnalyticsEventKind;
+    path: string;
+    locale: string | null;
+    durationSeconds: number | null;
+    country: string | null;
+    city: string | null;
+    sessionId: string | null;
+    eventName: string | null;
+}
+interface StoredAnalyticsEvent extends NewAnalyticsEvent {
+    id: string;
+    occurredAt: string;
+}
+
+interface AnalyticsSummaryQuery {
+    from: string;
+    to: string;
+    country: string | null;
+    path: string | null;
+    sessionId: string | null;
+}
+interface AnalyticsSummary {
+    totalViews: number;
+    averageDurationSeconds: number;
+    byPath: {
+        path: string;
+        views: number;
+        averageDurationSeconds: number;
+    }[];
+    byCountry?: {
+        country: string;
+        views: number;
+    }[];
+    byCity?: {
+        city: string;
+        views: number;
+    }[];
+    sessions?: {
+        id: string;
+        startedAt: string;
+        pageCount: number;
+    }[];
+    events?: {
+        id: string;
+        kind: AnalyticsEventKind;
+        path: string;
+        occurredAt: string;
+        eventName: string | null;
+    }[];
+    byEventName?: {
+        eventName: string;
+        count: number;
+    }[];
+}
+
+interface AnalyticsEventStore {
+    insertAnalyticsEvent(event: NewAnalyticsEvent, occurredAt: string): Promise<StoredAnalyticsEvent>;
+    recordAnalyticsDuration(id: string, durationSeconds: number): Promise<void>;
+    summarizeAnalytics(query: AnalyticsSummaryQuery, modules: AnalyticsModules): Promise<AnalyticsSummary>;
+}
+
+export { AnalyticsEventKind as c };
+export type { AnalyticsSummaryQuery as A, NewAnalyticsEvent as N, StoredAnalyticsEvent as S, AnalyticsSummary as a, AnalyticsEventStore as b };

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { S as StoredAnalyticsEvent, A as AnalyticsSummaryQuery, a as AnalyticsSummary, b as AnalyticsEventStore, N as NewAnalyticsEvent } from './event-store-BhisLdw_.js';
+export { c as AnalyticsEventKind } from './event-store-BhisLdw_.js';
+import { a as AnalyticsModules } from './options-D3s0dcJ-.js';
+export { A as AnalyticsClientConfig, b as AnalyticsServerOptions } from './options-D3s0dcJ-.js';
+export { A as AnalyticsEventBody } from './event-body-fpV2mYpY.js';
+
+/** Keeps a duration inside 0..1800. NaN and infinities are rejected. */
+declare function acceptDurationSeconds(value: number): number | null;
+
+declare function summarizeAnalyticsEvents(rows: readonly StoredAnalyticsEvent[], query: AnalyticsSummaryQuery, modules: AnalyticsModules): AnalyticsSummary;
+
+declare class MemoryAnalyticsEventStore implements AnalyticsEventStore {
+    private readonly modules;
+    private readonly rows;
+    constructor(modules: AnalyticsModules);
+    insertAnalyticsEvent(event: NewAnalyticsEvent, occurredAt: string): Promise<StoredAnalyticsEvent>;
+    recordAnalyticsDuration(id: string, durationSeconds: number): Promise<void>;
+    summarizeAnalytics(query: AnalyticsSummaryQuery, modules: AnalyticsModules): Promise<AnalyticsSummary>;
+}
+
+export { AnalyticsEventStore, AnalyticsModules, AnalyticsSummary, AnalyticsSummaryQuery, MemoryAnalyticsEventStore, NewAnalyticsEvent, StoredAnalyticsEvent, acceptDurationSeconds, summarizeAnalyticsEvents };

package/dist/index.js

@@ -0,0 +1,49 @@
+import {
+  acceptDurationSeconds,
+  summarizeAnalyticsEvents
+} from "./chunk-Q4JRXZ6M.js";
+import {
+  AnalyticsEventKind
+} from "./chunk-F7BY2JQ3.js";
+
+// src/core/memory-event-store.ts
+import { randomUUID } from "crypto";
+var MemoryAnalyticsEventStore = class {
+  constructor(modules) {
+    this.modules = modules;
+  }
+  modules;
+  rows = [];
+  async insertAnalyticsEvent(event, occurredAt) {
+    const stored = {
+      kind: event.kind,
+      path: event.path,
+      locale: event.locale,
+      durationSeconds: event.durationSeconds,
+      country: this.modules.country ? event.country : null,
+      city: this.modules.city ? event.city : null,
+      sessionId: this.modules.sessions ? event.sessionId : null,
+      eventName: this.modules.clicks ? event.eventName : null,
+      id: randomUUID(),
+      occurredAt
+    };
+    this.rows.push(stored);
+    return stored;
+  }
+  async recordAnalyticsDuration(id, durationSeconds) {
+    const row = this.rows.find((candidate) => candidate.id === id);
+    if (!row || row.kind !== AnalyticsEventKind.VIEW) return;
+    const accepted = acceptDurationSeconds(durationSeconds);
+    if (accepted === null) return;
+    row.durationSeconds = accepted;
+  }
+  async summarizeAnalytics(query, modules) {
+    return summarizeAnalyticsEvents(this.rows, query, modules);
+  }
+};
+export {
+  AnalyticsEventKind,
+  MemoryAnalyticsEventStore,
+  acceptDurationSeconds,
+  summarizeAnalyticsEvents
+};

package/dist/options-D3s0dcJ-.d.ts

@@ -0,0 +1,19 @@
+interface AnalyticsModules {
+    country: boolean;
+    city: boolean;
+    sessions: boolean;
+    clicks: boolean;
+}
+interface AnalyticsServerOptions {
+    enabled: boolean;
+    modules: AnalyticsModules;
+}
+interface AnalyticsClientConfig {
+    endpoint: string;
+    enabled: boolean;
+    locale?: string;
+    sessions: boolean;
+    clicks: boolean;
+}
+
+export type { AnalyticsClientConfig as A, AnalyticsModules as a, AnalyticsServerOptions as b };

package/dist/payload/admin-view.d.ts

@@ -0,0 +1,6 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AdminViewServerProps } from 'payload';
+
+declare function AnalyticsAdminView(props: AdminViewServerProps): Promise<react_jsx_runtime.JSX.Element | null>;
+
+export { AnalyticsAdminView };