@mearl/plugin-tracking 0.0.0-stage → 3.0.0-beta.7

package/dist/capability/node.cjs

@@ -0,0 +1,410 @@
+"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);
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  createTrackingPlugin: () => createTrackingPlugin,
+  default: () => createTrackingPlugin
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/eventParsers.ts
+var APLUS_URL_PATTERN = /\.mmstat\.com\//;
+var RUM_URL_PATTERN = /\.rum\.aliyuncs\.com\//;
+var ARMS_URL_PATTERN = /^arms-retcode\.aliyuncs\.com\//;
+function trackingHostname(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.hostname : "";
+  } catch {
+    return "";
+  }
+}
+function matchesTrackingHost(url, pattern) {
+  return pattern.test(`${trackingHostname(url)}/`);
+}
+function isTrackingUrl(url) {
+  const hostname = trackingHostname(url);
+  return matchesTrackingHost(url, APLUS_URL_PATTERN) || matchesTrackingHost(url, RUM_URL_PATTERN) || matchesTrackingHost(url, ARMS_URL_PATTERN) || /^(?:retcode\.alicdn\.com|beacon\.taobao\.com)$|(?:^|\.)tbsec\./i.test(hostname);
+}
+var aplusCounter = 0;
+var armsCounter = 0;
+var rumCounter = 0;
+function formatTimestamp(ms) {
+  const d = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}/${pad(d.getMonth() + 1)}/${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function parseParams(value) {
+  const params = {};
+  value.split("&").forEach((pair) => {
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) return;
+    const rawKey = pair.slice(0, eqIndex);
+    const rawValue = pair.slice(eqIndex + 1);
+    try {
+      params[decodeURIComponent(rawKey)] = rawValue;
+    } catch {
+      params[rawKey] = rawValue;
+    }
+  });
+  return params;
+}
+function decodeParamValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseJsonParamValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    const decoded = decodeParamValue(value);
+    if (decoded === value) return void 0;
+    try {
+      return JSON.parse(decoded);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function parseUrlParams(search) {
+  const encodedParams = parseParams(search.startsWith("?") ? search.slice(1) : search);
+  return Object.fromEntries(
+    Object.entries(encodedParams).map(([key, value]) => [key, decodeParamValue(value)])
+  );
+}
+function extractSpmFromUrl(spmOrUrl) {
+  if (!/^https?:\/\//i.test(spmOrUrl)) return spmOrUrl;
+  try {
+    return new URL(spmOrUrl).searchParams.get("spm") ?? spmOrUrl;
+  } catch {
+    return spmOrUrl;
+  }
+}
+function resolveAplusSpm(eventType, raw) {
+  const expdata = Array.isArray(raw.expdata) ? raw.expdata : [];
+  const expSpm = expdata[0]?.spm || "";
+  const gokeyParams = parseParams(raw.gokey || "");
+  const gokeySpm = decodeParamValue(gokeyParams.spm || "");
+  const rawSpmUrl = raw["spm-url"] || decodeParamValue(gokeyParams["spm-url"] || "");
+  const spmUrl = extractSpmFromUrl(rawSpmUrl);
+  let pointSpm;
+  switch (eventType) {
+    case "CLK":
+      pointSpm = gokeySpm || expSpm;
+      break;
+    case "EXP":
+      pointSpm = expSpm;
+      break;
+    case "PV":
+      pointSpm = spmUrl;
+      break;
+    default:
+      pointSpm = gokeySpm || expSpm;
+  }
+  return {
+    mainSpm: pointSpm,
+    highlightSpm: pointSpm
+  };
+}
+function parseAplusRequest(url, options = {}) {
+  if (!matchesTrackingHost(url, APLUS_URL_PATTERN)) return null;
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch {
+    return null;
+  }
+  const params = parseUrlParams(urlObj.search);
+  const gmkey = params.gmkey ?? "UNKNOWN";
+  const urlPathName = urlObj.pathname.slice(1);
+  const pathCategory = urlPathName.split(".")[1];
+  const eventType = pathCategory === "selfdefine" ? "SDF" : gmkey;
+  const gokeyRaw = params.gokey ?? "";
+  const gokeyParams = parseParams(gokeyRaw);
+  let expdata = [];
+  if (gokeyParams.expdata) {
+    const parsedExpdata = parseJsonParamValue(gokeyParams.expdata);
+    if (Array.isArray(parsedExpdata)) {
+      expdata = parsedExpdata.map((item) => {
+        if (!item?.exargs || typeof item.exargs !== "object") return item;
+        const decoded = {};
+        for (const [key, value] of Object.entries(item.exargs)) {
+          if (typeof value !== "string") {
+            decoded[key] = value;
+            continue;
+          }
+          const parsedValue = parseJsonParamValue(value);
+          decoded[key] = parsedValue === void 0 ? value : parsedValue;
+        }
+        return { ...item, exargs: decoded };
+      });
+    }
+  }
+  const rawBizArgs = gokeyParams.bizArgs;
+  const parsedBizArgs = rawBizArgs === void 0 ? void 0 : parseJsonParamValue(rawBizArgs);
+  const bizArgs = parsedBizArgs === void 0 ? rawBizArgs : parsedBizArgs;
+  const pageUrl = params["_p_url"] ?? (gokeyParams["_p_url"] ? decodeParamValue(gokeyParams["_p_url"]) : "");
+  const { gokey: rawGokey, ...topLevelParams } = params;
+  const rawData = {
+    ...topLevelParams,
+    _path: urlPathName,
+    _url: url,
+    gokey: rawGokey,
+    ...expdata.length > 0 ? { expdata } : {},
+    ...bizArgs !== void 0 ? { bizArgs } : {}
+  };
+  const spm = resolveAplusSpm(eventType, rawData).mainSpm;
+  const pathName = urlPathName.split(".").slice(1).join(".");
+  const eventName = eventType === "SDF" ? pathName : spm || pathName || pageUrl;
+  const now = options.now ?? Date.now();
+  const sequence = options.sequence ?? ++aplusCounter;
+  return {
+    id: `aplus-${sequence}-${now}`,
+    source: "aplus",
+    batchId: 0,
+    batchTimestampMs: now,
+    batchTimestamp: formatTimestamp(now),
+    event_type: eventType,
+    name: eventName,
+    url,
+    timestamp: now,
+    _raw: rawData,
+    _context: {
+      requestUrl: url,
+      app: {},
+      user: {
+        ...params.uidaplus ? { uidaplus: params.uidaplus } : {},
+        ...params["_gr_uid_"] ? { _gr_uid_: params["_gr_uid_"] } : {}
+      },
+      session: {},
+      view: {
+        ...params["spm-url"] ? { "spm-url": params["spm-url"] } : {},
+        ...params["spm-pre"] ? { "spm-pre": params["spm-pre"] } : {},
+        ...params["spm-cnt"] ? { "spm-cnt": params["spm-cnt"] } : {},
+        ...pageUrl ? { page_url: pageUrl } : {}
+      },
+      properties: {},
+      os: {},
+      net: {}
+    }
+  };
+}
+var RUM_TYPE_ALIAS = {
+  cst: "custom"
+};
+var I18N_TRACKER_TYPE_MAP = {
+  "i18n-tracker-exp": "EXP",
+  "i18n-tracker-clk": "CLK"
+};
+function parseRumBody(postData) {
+  if (!postData) return null;
+  if (typeof postData === "object") return postData;
+  try {
+    return JSON.parse(postData);
+  } catch {
+    return null;
+  }
+}
+function tryConvertI18nTracker(event, base) {
+  const normalizedType = RUM_TYPE_ALIAS[event.type] ?? event.type;
+  if (event.event_type !== "action" || normalizedType !== "custom") return null;
+  let snapshots;
+  try {
+    snapshots = typeof event.snapshots === "string" ? JSON.parse(event.snapshots) : event.snapshots;
+  } catch {
+    return null;
+  }
+  if (!snapshots || typeof snapshots !== "object") return null;
+  const eventType = I18N_TRACKER_TYPE_MAP[snapshots.message];
+  if (!eventType) return null;
+  const spm = [snapshots.c1 ?? "", snapshots.c2 ?? ""].filter(Boolean).join(".");
+  const exargs = {};
+  if (typeof snapshots.c3 === "string") {
+    snapshots.c3.split("&").forEach((pair) => {
+      const eqIndex = pair.indexOf("=");
+      if (eqIndex === -1) return;
+      const key = pair.slice(0, eqIndex);
+      const rawValue = pair.slice(eqIndex + 1);
+      try {
+        exargs[key] = JSON.parse(decodeURIComponent(rawValue));
+      } catch {
+        exargs[key] = rawValue;
+      }
+    });
+  }
+  const dataAttrs = snapshots.trackerInfo?.dataAttrs;
+  if (dataAttrs && typeof dataAttrs === "object" && dataAttrs["data-biz-args"] && !exargs.bizArgs) {
+    try {
+      exargs.bizArgs = JSON.parse(dataAttrs["data-biz-args"]);
+    } catch {
+      exargs.bizArgs = dataAttrs["data-biz-args"];
+    }
+  }
+  return {
+    ...base,
+    event_type: eventType,
+    name: spm,
+    _raw: {
+      ...event,
+      expdata: [
+        {
+          spm,
+          ...Object.keys(exargs).length > 0 ? { exargs } : {}
+        }
+      ],
+      "spm-url": spm
+    }
+  };
+}
+function parseRumRequest(url, postData, options = {}) {
+  if (!matchesTrackingHost(url, RUM_URL_PATTERN)) return [];
+  const parsed = parseRumBody(postData);
+  const rawEvents = Array.isArray(parsed?.events) ? parsed.events : [];
+  if (rawEvents.length === 0) return [];
+  const now = options.now ?? Date.now();
+  const batchId = options.sequence ?? ++rumCounter;
+  const context = {
+    requestUrl: url,
+    app: parsed?.app ?? {},
+    user: parsed?.user ?? {},
+    session: parsed?.session ?? {},
+    view: parsed?.view ?? {},
+    properties: parsed?.properties ?? {},
+    os: parsed?.os ?? {},
+    net: parsed?.net ?? {}
+  };
+  return rawEvents.flatMap((rawEvent, index) => {
+    if (!rawEvent || typeof rawEvent !== "object" || Array.isArray(rawEvent)) return [];
+    const event = rawEvent;
+    const normalizedType = RUM_TYPE_ALIAS[event.type] ?? event.type;
+    const base = {
+      id: `${batchId}-${event.event_id ?? index}`,
+      batchId,
+      batchTimestampMs: now,
+      batchTimestamp: formatTimestamp(now),
+      type: normalizedType,
+      url: event.url,
+      timestamp: event.timestamp ?? now,
+      success: event.success,
+      status_code: event.status_code,
+      method: event.method,
+      duration: event.duration,
+      source: "rum",
+      _context: context
+    };
+    const converted = tryConvertI18nTracker(event, base);
+    if (converted) return [converted];
+    return [
+      {
+        ...base,
+        event_type: event.event_type ?? "unknown",
+        name: event.name,
+        _raw: event
+      }
+    ];
+  });
+}
+function parseArmsRequest(url, options = {}) {
+  if (!matchesTrackingHost(url, ARMS_URL_PATTERN)) return null;
+  let urlObj;
+  try {
+    urlObj = new URL(url);
+  } catch {
+    return null;
+  }
+  const params = {};
+  urlObj.searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  const eventType = (params.t ?? "unknown").toLowerCase();
+  const page = params.page ?? "";
+  const now = options.now ?? Date.now();
+  const sequence = options.sequence ?? ++armsCounter;
+  const parsedTimestamp = params.begin ? Number.parseInt(params.begin, 10) : now;
+  const timestamp = Number.isFinite(parsedTimestamp) ? parsedTimestamp : now;
+  return {
+    id: `arms-${sequence}-${now}`,
+    source: "arms",
+    batchId: 0,
+    batchTimestampMs: now,
+    batchTimestamp: formatTimestamp(now),
+    event_type: eventType,
+    name: page || url,
+    url,
+    timestamp,
+    _raw: { ...params, _url: url },
+    _context: {
+      requestUrl: url,
+      app: {
+        ...params.pid ? { pid: params.pid } : {},
+        ...params.release ? { release: params.release } : {},
+        ...params.environment ? { environment: params.environment } : {},
+        ...params._v ? { sdk_version: params._v } : {}
+      },
+      user: {
+        ...params.uid ? { uid: params.uid } : {}
+      },
+      session: {
+        ...params.sid ? { sid: params.sid } : {}
+      },
+      view: {
+        ...page ? { page } : {},
+        ...params.tag ? { tag: params.tag } : {}
+      },
+      properties: {},
+      os: {},
+      net: {
+        ...params.ct ? { ct: params.ct } : {}
+      }
+    }
+  };
+}
+function parseTrackingRequest(url, postData, options = {}) {
+  const rumEvents = parseRumRequest(url, postData, options);
+  if (rumEvents.length > 0) return rumEvents;
+  const aplusEvent = parseAplusRequest(url, options);
+  if (aplusEvent) return [aplusEvent];
+  const armsEvent = parseArmsRequest(url, options);
+  return armsEvent ? [armsEvent] : [];
+}
+
+// src/runtime.ts
+function createTrackingPlugin() {
+  return {
+    tracking: () => ({ matches: isTrackingUrl, parse: parseTrackingRequest }),
+    decode: (inputs) => inputs.map(({ url, body, options }) => {
+      try {
+        return { tracking: isTrackingUrl(url), events: parseTrackingRequest(url, body, options) };
+      } catch (error) {
+        return { tracking: isTrackingUrl(url), events: [], error: error instanceof Error ? error.message : String(error) };
+      }
+    }),
+    spm: ({ eventType, raw }) => resolveAplusSpm(eventType, raw)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTrackingPlugin
+});
+module.exports = module.exports.default;

package/dist/capability/preset.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "id": "tracking",
+  "version": "1.0.0",
+  "packages": {
+    "tracking": {
+      "source": "./bundle.json",
+      "version": "^1",
+      "targets": [
+        "node",
+        "browser"
+      ]
+    }
+  }
+}

package/dist/eventParsers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure parsers for tracking requests. Callers provide the request URL/body and
+ * may provide a stable sequence and timestamp when deterministic IDs are needed.
+ */
+import type { RumEvent } from '@mearl/browser-core';
+export declare const APLUS_URL_PATTERN: RegExp;
+export declare const RUM_URL_PATTERN: RegExp;
+export declare const ARMS_URL_PATTERN: RegExp;
+export declare function isTrackingUrl(url: string): boolean;
+export interface TrackingParseOptions {
+    /** Event receive time in milliseconds. Defaults to Date.now(). */
+    now?: number;
+    /** Stable request sequence supplied by the owning per-tab/session buffer. */
+    sequence?: number;
+}
+export interface AplusSpmResolution {
+    mainSpm: string;
+    highlightSpm: string;
+}
+/** If spm-url is a full URL, return its spm query parameter. */
+export declare function extractSpmFromUrl(spmOrUrl: string): string;
+/**
+ * Resolve the point SPM according to event semantics.
+ * CLK uses gokey.spm, EXP uses expdata[0].spm, and PV uses spm-url.
+ */
+export declare function resolveAplusSpm(eventType: string | undefined, raw: Record<string, any>): AplusSpmResolution;
+export declare function parseAplusRequest(url: string, options?: TrackingParseOptions): RumEvent | null;
+export declare function parseRumRequest(url: string, postData: string | Record<string, any> | null | undefined, options?: TrackingParseOptions): RumEvent[];
+export declare function parseArmsRequest(url: string, options?: TrackingParseOptions): RumEvent | null;
+/** Parse any supported tracking request into zero or more normalized events. */
+export declare function parseTrackingRequest(url: string, postData?: string | Record<string, any> | null, options?: TrackingParseOptions): RumEvent[];