@chordcommerce/analytics 1.23.1 → 1.25.0-beta.2

package/dist/types/client.d.ts

@@ -88,10 +88,23 @@ type MiddlewarePayload = {
             page: PageContext;
         };
     };
+    /**
+     * The current user and anonymous ids, read from the CDP at send time.
+     * Segment's middleware payload exposes these as `userId()`/`anonymousId()`
+     * methods on a facade; they are plain values here.
+     */
+    userId?: string;
+    anonymousId?: string;
 };
 type MiddlewareArgs = {
     payload: MiddlewarePayload;
     next: <T>(arg: T) => T;
 };
-export type AnalyticsMiddleware = (args: MiddlewareArgs) => Partial<EventProperties> | void;
+export type MiddlewareResult = Partial<EventProperties> | void;
+/**
+ * A source middleware may be synchronous or asynchronous. An asynchronous one
+ * is awaited before the event is dispatched, bounded by a timeout — see
+ * `addSourceMiddleware` in the README.
+ */
+export type AnalyticsMiddleware = (args: MiddlewareArgs) => MiddlewareResult | Promise<MiddlewareResult>;
 export {};

package/dist/utils.d.ts

@@ -1,2 +1,21 @@
 import type { EventProperties } from './types/index.js';
 export declare const pruneNullValues: (props: EventProperties) => EventProperties;
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+export declare const MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+export declare const TIMED_OUT: unique symbol;
+export declare const isPromise: (value: unknown) => value is Promise<unknown>;
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+export declare const withTimeout: <T>(promise: Promise<T>, ms: number) => Promise<typeof TIMED_OUT | T>;

package/dist/utils.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 export const pruneNullValues = (props) => {
     if (typeof props !== 'object' || props === null)
         return props;
@@ -19,3 +28,33 @@ export const pruneNullValues = (props) => {
     }
     return props;
 };
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+export const MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+export const TIMED_OUT = Symbol('timed-out');
+export const isPromise = (value) => typeof (value === null || value === void 0 ? void 0 : value.then) === 'function';
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+export const withTimeout = (promise, ms) => __awaiter(void 0, void 0, void 0, function* () {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(TIMED_OUT), ms);
+    });
+    try {
+        return yield Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+});

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@chordcommerce/analytics",
   "description": "Chord Commerce event tracking",
-  "version": "1.23.1",
+  "version": "1.25.0-beta.2",
   "author": "Chord Commerce <help@chord.co> (https://www.chord.co)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chordcommerce/chord-pixel.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "@chordcommerce:registry": "https://registry.npmjs.org/",
+    "provenance": false
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",