@momentumcms/plugins-analytics 0.3.0 → 0.4.1

package/lib/collectors/block-field-injector.cjs

@@ -0,0 +1,206 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/plugins/analytics/src/lib/collectors/block-field-injector.ts
+var block_field_injector_exports = {};
+__export(block_field_injector_exports, {
+  injectBlockAnalyticsFields: () => injectBlockAnalyticsFields
+});
+module.exports = __toCommonJS(block_field_injector_exports);
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function checkbox(name, options = {}) {
+  return {
+    name,
+    type: "checkbox",
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  };
+}
+function group(name, options) {
+  return {
+    name,
+    type: "group",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/plugins/analytics/src/lib/collectors/block-field-injector.ts
+function createAnalyticsGroupField() {
+  return group("_analytics", {
+    label: "Analytics",
+    admin: { collapsible: true, defaultOpen: false },
+    fields: [
+      checkbox("trackImpressions", { label: "Track Impressions" }),
+      checkbox("trackHover", { label: "Track Hover" })
+    ]
+  });
+}
+function hasAnalyticsField(fields) {
+  return fields.some((f) => f.name === "_analytics" && f.type === "group");
+}
+function hasBlocks(field) {
+  return field.type === "blocks" && "blocks" in field;
+}
+function hasNestedFields(field) {
+  return "fields" in field && Array.isArray(field.fields);
+}
+function hasTabs(field) {
+  return field.type === "tabs" && "tabs" in field;
+}
+function injectIntoFields(fields) {
+  for (const field of fields) {
+    if (hasBlocks(field)) {
+      for (const blockConfig of field.blocks) {
+        if (!hasAnalyticsField(blockConfig.fields)) {
+          blockConfig.fields.push(createAnalyticsGroupField());
+        }
+      }
+    }
+    if ((field.type === "group" || field.type === "array" || field.type === "collapsible" || field.type === "row") && hasNestedFields(field)) {
+      injectIntoFields(field.fields);
+    }
+    if (hasTabs(field)) {
+      for (const tab of field.tabs) {
+        injectIntoFields(tab.fields);
+      }
+    }
+  }
+}
+function injectBlockAnalyticsFields(collections) {
+  for (const collection of collections) {
+    injectIntoFields(collection.fields);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectBlockAnalyticsFields
+});

package/lib/collectors/block-field-injector.js

@@ -0,0 +1,179 @@
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function checkbox(name, options = {}) {
+  return {
+    name,
+    type: "checkbox",
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  };
+}
+function group(name, options) {
+  return {
+    name,
+    type: "group",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/plugins/analytics/src/lib/collectors/block-field-injector.ts
+function createAnalyticsGroupField() {
+  return group("_analytics", {
+    label: "Analytics",
+    admin: { collapsible: true, defaultOpen: false },
+    fields: [
+      checkbox("trackImpressions", { label: "Track Impressions" }),
+      checkbox("trackHover", { label: "Track Hover" })
+    ]
+  });
+}
+function hasAnalyticsField(fields) {
+  return fields.some((f) => f.name === "_analytics" && f.type === "group");
+}
+function hasBlocks(field) {
+  return field.type === "blocks" && "blocks" in field;
+}
+function hasNestedFields(field) {
+  return "fields" in field && Array.isArray(field.fields);
+}
+function hasTabs(field) {
+  return field.type === "tabs" && "tabs" in field;
+}
+function injectIntoFields(fields) {
+  for (const field of fields) {
+    if (hasBlocks(field)) {
+      for (const blockConfig of field.blocks) {
+        if (!hasAnalyticsField(blockConfig.fields)) {
+          blockConfig.fields.push(createAnalyticsGroupField());
+        }
+      }
+    }
+    if ((field.type === "group" || field.type === "array" || field.type === "collapsible" || field.type === "row") && hasNestedFields(field)) {
+      injectIntoFields(field.fields);
+    }
+    if (hasTabs(field)) {
+      for (const tab of field.tabs) {
+        injectIntoFields(tab.fields);
+      }
+    }
+  }
+}
+function injectBlockAnalyticsFields(collections) {
+  for (const collection of collections) {
+    injectIntoFields(collection.fields);
+  }
+}
+export {
+  injectBlockAnalyticsFields
+};

package/lib/page-view-tracker.cjs

@@ -0,0 +1,208 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// libs/plugins/analytics/src/lib/page-view-tracker.ts
+var page_view_tracker_exports = {};
+__export(page_view_tracker_exports, {
+  DEFAULT_EXCLUDE_PREFIXES: () => DEFAULT_EXCLUDE_PREFIXES,
+  PAGE_VIEW_TRACKING_CONFIG: () => PAGE_VIEW_TRACKING_CONFIG,
+  PageViewTrackerService: () => PageViewTrackerService,
+  buildPageViewEvent: () => buildPageViewEvent,
+  providePageViewTracking: () => providePageViewTracking,
+  shouldTrackNavigation: () => shouldTrackNavigation
+});
+module.exports = __toCommonJS(page_view_tracker_exports);
+var import_core = require("@angular/core");
+var import_common = require("@angular/common");
+var import_router = require("@angular/router");
+var import_http = require("@angular/common/http");
+var import_rxjs = require("rxjs");
+
+// libs/plugins/analytics/src/lib/utils/content-route-matcher.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileContentRoute(collection, pattern) {
+  const segments = pattern.split("/").filter(Boolean);
+  const paramNames = [];
+  let staticCount = 0;
+  const regexParts = segments.map((seg) => {
+    if (seg.startsWith(":")) {
+      paramNames.push(seg.slice(1));
+      return "([^/]+)";
+    }
+    staticCount++;
+    return escapeRegex(seg);
+  });
+  const regexStr = "^/" + regexParts.join("/") + "/?$";
+  return {
+    collection,
+    pattern,
+    regex: new RegExp(regexStr),
+    paramNames,
+    staticSegments: staticCount
+  };
+}
+function compileContentRoutes(routes) {
+  const compiled = Object.entries(routes).map(
+    ([collection, pattern]) => compileContentRoute(collection, pattern)
+  );
+  compiled.sort((a, b) => b.staticSegments - a.staticSegments);
+  return compiled;
+}
+function matchContentRoute(path, routes) {
+  for (const route of routes) {
+    const match = route.regex.exec(path);
+    if (match) {
+      const params = {};
+      for (let i = 0; i < route.paramNames.length; i++) {
+        params[route.paramNames[i]] = match[i + 1];
+      }
+      return { collection: route.collection, params };
+    }
+  }
+  return void 0;
+}
+
+// libs/plugins/analytics/src/lib/page-view-tracker.utils.ts
+var DEFAULT_EXCLUDE_PREFIXES = ["/admin", "/api/"];
+function shouldTrackNavigation(url, isFirstNavigation, excludePrefixes) {
+  if (isFirstNavigation)
+    return false;
+  const path = url.split("?")[0].split("#")[0];
+  for (const prefix of excludePrefixes) {
+    if (path.startsWith(prefix))
+      return false;
+  }
+  return true;
+}
+function buildPageViewEvent(url, compiledRoutes) {
+  const path = url.split("?")[0].split("#")[0];
+  const properties = { path };
+  if (compiledRoutes) {
+    const routeMatch = matchContentRoute(path, compiledRoutes);
+    if (routeMatch) {
+      properties["collection"] = routeMatch.collection;
+      properties["slug"] = routeMatch.params["slug"];
+    }
+  }
+  return {
+    name: "page_view",
+    category: "page",
+    properties
+  };
+}
+
+// libs/plugins/analytics/src/lib/page-view-tracker.ts
+var PAGE_VIEW_TRACKING_CONFIG = new import_core.InjectionToken(
+  "PAGE_VIEW_TRACKING_CONFIG"
+);
+function getOrCreateStorageId(storage, key) {
+  let id = storage.getItem(key);
+  if (!id) {
+    id = Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+    storage.setItem(key, id);
+  }
+  return id;
+}
+var PageViewTrackerService = class {
+  constructor() {
+    this.router = (0, import_core.inject)(import_router.Router);
+    this.http = (0, import_core.inject)(import_http.HttpClient);
+    this.platformId = (0, import_core.inject)(import_core.PLATFORM_ID);
+    this.destroyRef = (0, import_core.inject)(import_core.DestroyRef);
+    this.config = (0, import_core.inject)(PAGE_VIEW_TRACKING_CONFIG);
+    this.doc = (0, import_core.inject)(import_common.DOCUMENT);
+    this.isFirstNavigation = true;
+    this.endpoint = this.config.endpoint ?? "/api/analytics/collect";
+    this.compiledRoutes = this.config.contentRoutes ? compileContentRoutes(this.config.contentRoutes) : void 0;
+    this.excludePrefixes = this.config.excludePrefixes ? [...DEFAULT_EXCLUDE_PREFIXES, ...this.config.excludePrefixes] : DEFAULT_EXCLUDE_PREFIXES;
+    if (!(0, import_common.isPlatformBrowser)(this.platformId))
+      return;
+    const sub = this.router.events.pipe((0, import_rxjs.filter)((e) => e instanceof import_router.NavigationEnd)).subscribe((event) => {
+      const url = event.urlAfterRedirects;
+      if (!shouldTrackNavigation(url, this.isFirstNavigation, this.excludePrefixes)) {
+        this.isFirstNavigation = false;
+        return;
+      }
+      this.isFirstNavigation = false;
+      this.trackPageView(url);
+    });
+    this.destroyRef.onDestroy(() => sub.unsubscribe());
+  }
+  trackPageView(url) {
+    const eventPayload = buildPageViewEvent(url, this.compiledRoutes);
+    const win = this.doc.defaultView;
+    let visitorId;
+    let sessionId;
+    try {
+      if (win?.localStorage)
+        visitorId = getOrCreateStorageId(win.localStorage, "_m_vid");
+      if (win?.sessionStorage)
+        sessionId = getOrCreateStorageId(win.sessionStorage, "_m_sid");
+    } catch {
+    }
+    const clientEvent = {
+      ...eventPayload,
+      context: {
+        url: win?.location?.href ?? "",
+        referrer: this.doc.referrer
+      },
+      visitorId,
+      sessionId
+    };
+    this.http.post(this.endpoint, { events: [clientEvent] }).subscribe();
+  }
+};
+PageViewTrackerService = __decorateClass([
+  (0, import_core.Injectable)()
+], PageViewTrackerService);
+function providePageViewTracking(config) {
+  return (0, import_core.makeEnvironmentProviders)([
+    { provide: PAGE_VIEW_TRACKING_CONFIG, useValue: config },
+    PageViewTrackerService,
+    {
+      provide: import_core.ENVIRONMENT_INITIALIZER,
+      multi: true,
+      useFactory: () => {
+        (0, import_core.inject)(PageViewTrackerService);
+        return () => {
+        };
+      }
+    }
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_EXCLUDE_PREFIXES,
+  PAGE_VIEW_TRACKING_CONFIG,
+  PageViewTrackerService,
+  buildPageViewEvent,
+  providePageViewTracking,
+  shouldTrackNavigation
+});