@schibsted/pulse-tracker-proxy 1.0.0

package/dist/cjs/consts.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_METHODS = exports.MESSAGE_TYPE_RETURN_ERROR = exports.MESSAGE_TYPE_RETURN = exports.MESSAGE_TYPE_INVOKE = exports.MESSAGE_TYPE_ACK = exports.MESSAGE_TYPE_REQUEST = exports.MESSAGE_PREFIX = void 0;
+exports.isPulseProxyMessage = isPulseProxyMessage;
+// Sync the content between files below this line:
+exports.MESSAGE_PREFIX = 'pulse-tracker-proxy';
+exports.MESSAGE_TYPE_REQUEST = `${exports.MESSAGE_PREFIX}:request`;
+exports.MESSAGE_TYPE_ACK = `${exports.MESSAGE_PREFIX}:ack`;
+exports.MESSAGE_TYPE_INVOKE = `${exports.MESSAGE_PREFIX}:invoke`;
+exports.MESSAGE_TYPE_RETURN = `${exports.MESSAGE_PREFIX}:return`;
+exports.MESSAGE_TYPE_RETURN_ERROR = `${exports.MESSAGE_PREFIX}:return-error`;
+exports.ALLOWED_METHODS = ['track'];
+function isPulseProxyMessage(message) {
+    return (message !== null &&
+        typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        message.type.startsWith(exports.MESSAGE_PREFIX));
+}

package/dist/cjs/get-proxy.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPulseTrackerProxy = getPulseTrackerProxy;
+const consts_1 = require("./consts");
+const load_autotracker_1 = require("./load-autotracker");
+const send_message_1 = require("./send-message");
+const tracker_proxy_1 = require("./tracker-proxy");
+/**
+ * Pulse Tracker Proxy System Architecture
+ * --------------------------------------
+ * The proxy system allows for cross-frame/cross-window tracking events without directly exposing
+ * the tracking API to child frames. It works in two modes:
+ *
+ * 1. Mobile App Webview Mode:
+ *    - Detects if running in a mobile app webview by checking for `pulseEventHandler`
+ *    - Loads the Pulse autotracker with the specified version and provider
+ *    - Directly communicates with the native app's tracking system
+ *
+ * 2. Iframe/Cross-window Mode:
+ *    - Establishes a connection with the parent window (or specified target)
+ *    - Uses postMessage for communication
+ *    - Handles timeouts, retries, and error cases for reliable messaging
+ *    - Proxies tracking calls to the parent window which can then handle them
+ *
+ * The system adds a proxy version to all events to help with debugging and tracking.
+ */
+/**
+ * Establishes a connection with the target frame and returns a pulse tracker proxy object.
+ * This function automatically detects whether it's running in a mobile app webview or
+ * needs to use iframe/cross-window communication.
+ *
+ * Usage:
+ * ```typescript
+ * const tracker = await getPulseTrackerProxy({
+ *   provider: 'my-provider',
+ *   debug: console.log
+ * });
+ *
+ * tracker.track('trackerEvent', { ... });
+ * ```
+ *
+ * @param options - Configuration options for the pulse tracker proxy
+ * @returns A promise that resolves to a proxy object implementing the Pulse tracker interface
+ * @throws Error if connection fails, timeout occurs, or required options are missing
+ */
+function getPulseTrackerProxy({ provider, autotrackerVersion = '3', window = globalThis.window, target = window.parent, timeout = 5000, retries = 3, retryTimeout = 1000, debug = () => { }, } = {}) {
+    debug('[Pulse Tracker Proxy] Checking if `pulseEventHandler` is provided in the current window...');
+    if (window.pulseEventHandler) {
+        debug(`[Pulse Tracker Proxy] \`pulseEventHandler\` found in the current window. Assuming it is the app webview. Loading autotracker version ${autotrackerVersion}...`);
+        if (!provider) {
+            debug('[Pulse Tracker Proxy] `provider` is not set - cannot create pulse tracker.');
+            return Promise.reject('`provider` is not set - cannot create pulse tracker.');
+        }
+        return (0, load_autotracker_1.loadAutotracker)(window, provider, autotrackerVersion);
+    }
+    debug('[Pulse Tracker Proxy] `pulseEventHandler` not found in the current window - not a mobile app webview.');
+    debug('[Pulse Tracker Proxy] Trying to establish connection...', { target, timeout, retries });
+    if (!target) {
+        return Promise.reject(new Error('Target window not provided. Possibly window.parent is not available.'));
+    }
+    let ackTimeout;
+    let alreadyTimedOut = false;
+    const timeoutPromise = new Promise((_, reject) => {
+        ackTimeout = setTimeout(() => {
+            alreadyTimedOut = true;
+            debug('[Pulse Tracker Proxy] Ack timeout. Sorry, target seems to not support the proxy.');
+            reject(new Error(`Pulse tracker proxy not found within ${timeout} ms`));
+        }, timeout);
+    });
+    const connectionPromise = (async () => {
+        for (let i = 0; i < retries; i++) {
+            if (alreadyTimedOut) {
+                debug('[Pulse Tracker Proxy] Configured timeout has passed before the next attempt');
+                throw new Error('Configured timeout has passed before the next attempt.');
+            }
+            try {
+                debug(`[Pulse Tracker Proxy] Sending request to target window (attempt: ${i + 1})...`);
+                await (0, send_message_1.sendMessage)({ type: consts_1.MESSAGE_TYPE_REQUEST }, { target, timeout: retryTimeout });
+            }
+            catch (error) {
+                debug(`[Pulse Tracker Proxy] Ack Request failed: ${error}`);
+                continue;
+            }
+            clearTimeout(ackTimeout);
+            debug(`[Pulse Tracker Proxy] Ack Request successful (attempt: ${i + 1})`);
+            return new tracker_proxy_1.PulseTrackerProxyImpl(target, debug);
+        }
+        clearTimeout(ackTimeout);
+        debug('[Pulse Tracker Proxy] Retries exhausted. Target did not respond. Failing.');
+        throw new Error('Failed to establish connection with pulse tracker proxy');
+    })();
+    return Promise.race([timeoutPromise, connectionPromise]);
+}

package/dist/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-proxy"), exports);

package/dist/cjs/load-autotracker.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAutotracker = loadAutotracker;
+/**
+ * Loads the Pulse autotracker script onto the page and initializes it with the provided configuration.
+ *
+ * @param window - The browser window object to attach the script to
+ * @param provider - The provider ID to initialize the Pulse tracker with
+ * @param version - The version of the Pulse autotracker to load
+ * @returns A promise that resolves to the configured Tracker instance
+ * @throws Error if script loading fails or Pulse doesn't initialize correctly
+ */
+async function loadAutotracker(window, provider, version) {
+    await new Promise((resolve, reject) => {
+        const element = window.document.createElement('script');
+        element.src = `//sdk.pulse.schibsted.com/versioned/${version}/pulse.min.js`;
+        element.async = true;
+        element.onload = resolve;
+        element.onerror = () => {
+            reject(new Error(`Failed to load autotracker script from src: ${element.src}`));
+        };
+        window.document.head.appendChild(element);
+    });
+    return new Promise((resolve, reject) => {
+        if (!window.pulse) {
+            reject(new Error('Pulse autotracker did not load correctly!'));
+            return;
+        }
+        window.pulse('init', provider);
+        window.pulse((tracker) => {
+            resolve(tracker);
+        });
+    });
+}

package/dist/cjs/send-message.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = sendMessage;
+const consts_1 = require("./consts");
+/**
+ * Sends a message to a target window and returns a promise that resolves with the response.
+ *
+ * This function creates a MessageChannel to facilitate two-way communication with the target.
+ * It handles timeouts and error responses appropriately.
+ *
+ * @param message - The message object to send to the target window
+ * @param options - Configuration options for sending the message
+ * @param options.target - The target window to send the message to (e.g., iframe.contentWindow)
+ * @param options.timeout - Optional timeout in milliseconds after which the promise will reject
+ * @param options.debug - Optional debug function for logging message events
+ * @returns A promise that resolves with the response message or rejects with an error
+ *
+ * @example
+ * ```typescript
+ * import { sendMessage } from './send-message';
+ *
+ * const message = { type: 'SOME_MESSAGE_TYPE', payload: { ... } };
+ * sendMessage(message, {
+ *   target: document.querySelector('iframe').contentWindow,
+ *   timeout: 5000,
+ *   debug: console.log
+ * }).then(response => {
+ *   // Handle response
+ * }).catch(error => {
+ *   // Handle error
+ * });
+ * ```
+ */
+function sendMessage(message, { target, timeout, debug = () => { } }) {
+    return new Promise((resolve, reject) => {
+        const channel = new MessageChannel();
+        const requestTimeout = timeout
+            ? setTimeout(() => {
+                channel.port1.close();
+                reject(new Error(`Message of type ${message.type} timed out`));
+            }, timeout)
+            : undefined;
+        const responseHandler = (event) => {
+            debug('[Pulse Tracker Proxy] Received the response on the MessageChannel', event);
+            if (!(0, consts_1.isPulseProxyMessage)(event.data)) {
+                debug('[Pulse Tracker Proxy] Response was not a valid Proxy Message', event.data);
+                return;
+            }
+            if (event.data.type === consts_1.MESSAGE_TYPE_RETURN_ERROR) {
+                debug('[Pulse Tracker Proxy] Received an return error response', event.data.error);
+                clearTimeout(requestTimeout);
+                channel.port1.close();
+                reject(new Error(event.data.error));
+            }
+            debug('[Pulse Tracker Proxy] Received a valid response', event.data);
+            clearTimeout(requestTimeout);
+            channel.port1.close();
+            resolve(event.data);
+        };
+        channel.port1.onmessage = responseHandler;
+        debug('[Pulse Tracker Proxy] Sending message to target window', message);
+        target.postMessage(message, '*', [channel.port2]);
+    });
+}

package/dist/cjs/tracker-proxy.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PulseTrackerProxyImpl = void 0;
+const consts_1 = require("./consts");
+const send_message_1 = require("./send-message");
+const version_json_1 = __importDefault(require("./version.json"));
+/**
+ * Adds proxy version information to the event input.
+ * This helps with debugging and allows tracking which proxy version was used for the event.
+ *
+ * @param input - The original event input to be decorated
+ * @returns The input with added proxyVersion in the tracker object
+ */
+function decorateWithProxyVersion(input) {
+    const tracker = 'tracker' in input && typeof input.tracker === 'object' ? input.tracker : {};
+    return {
+        ...input,
+        tracker: { ...tracker, proxyVersion: version_json_1.default.PROXY_VERSION },
+    };
+}
+/**
+ * Implementation of the Pulse Tracker Proxy that forwards tracking calls to a target window.
+ * This class handles the communication between frames/windows and ensures proper message handling.
+ */
+class PulseTrackerProxyImpl {
+    constructor(target, debug) {
+        this.target = target;
+        this.debug = debug;
+    }
+    /**
+     * Tracks an event by forwarding the call to the target window.
+     * Automatically decorates the event with proxy version information.
+     *
+     * @param args - Arguments that would normally be passed to the Pulse tracker's track method
+     * @returns A promise that resolves with the response from the target window
+     */
+    track(...args) {
+        this.debug('[Pulse Tracker Proxy] Calling `track`', args);
+        const [eventType, input, ...rest] = args;
+        const modifiedArgs = [eventType, decorateWithProxyVersion(input), ...rest];
+        return this.invoke({ method: 'track', args: modifiedArgs });
+    }
+    /**
+     * Invokes a remote function in the target window and handles the response.
+     *
+     * @param invocation - The invocation details including method name and arguments
+     * @returns A promise that resolves with the response payload or rejects with an error
+     * @private
+     */
+    async invoke(invocation) {
+        this.debug('[Pulse Tracker Proxy] Invoking remote function', invocation);
+        const response = await (0, send_message_1.sendMessage)({ type: consts_1.MESSAGE_TYPE_INVOKE, payload: invocation }, { target: this.target });
+        if (!(0, consts_1.isPulseProxyMessage)(response)) {
+            this.debug('[Pulse Tracker Proxy] Invalid response from proxy', response);
+            throw new Error('Invalid response from proxy');
+        }
+        if (response.type === consts_1.MESSAGE_TYPE_RETURN_ERROR) {
+            this.debug('[Pulse Tracker Proxy] Error response from proxy', response.error);
+            throw new Error(response.error);
+        }
+        if (response.type === consts_1.MESSAGE_TYPE_RETURN) {
+            this.debug('[Pulse Tracker Proxy] Successful response from proxy', response.payload);
+            return response.payload;
+        }
+        this.debug('[Pulse Tracker Proxy] Unhandled response from proxy', response);
+        throw new Error('Unexpected response from proxy');
+    }
+}
+exports.PulseTrackerProxyImpl = PulseTrackerProxyImpl;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/version.json

@@ -0,0 +1 @@
+{ "PROXY_VERSION": "1.0.0", "GIT_COMMIT": "6ca09707" }

package/dist/ejs/consts.js

@@ -0,0 +1,15 @@
+// Sync the content between files below this line:
+export const MESSAGE_PREFIX = 'pulse-tracker-proxy';
+export const MESSAGE_TYPE_REQUEST = `${MESSAGE_PREFIX}:request`;
+export const MESSAGE_TYPE_ACK = `${MESSAGE_PREFIX}:ack`;
+export const MESSAGE_TYPE_INVOKE = `${MESSAGE_PREFIX}:invoke`;
+export const MESSAGE_TYPE_RETURN = `${MESSAGE_PREFIX}:return`;
+export const MESSAGE_TYPE_RETURN_ERROR = `${MESSAGE_PREFIX}:return-error`;
+export const ALLOWED_METHODS = ['track'];
+export function isPulseProxyMessage(message) {
+    return (message !== null &&
+        typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        message.type.startsWith(MESSAGE_PREFIX));
+}

package/dist/ejs/get-proxy.js

@@ -0,0 +1,90 @@
+import { MESSAGE_TYPE_REQUEST } from './consts';
+import { loadAutotracker } from './load-autotracker';
+import { sendMessage } from './send-message';
+import { PulseTrackerProxyImpl } from './tracker-proxy';
+/**
+ * Pulse Tracker Proxy System Architecture
+ * --------------------------------------
+ * The proxy system allows for cross-frame/cross-window tracking events without directly exposing
+ * the tracking API to child frames. It works in two modes:
+ *
+ * 1. Mobile App Webview Mode:
+ *    - Detects if running in a mobile app webview by checking for `pulseEventHandler`
+ *    - Loads the Pulse autotracker with the specified version and provider
+ *    - Directly communicates with the native app's tracking system
+ *
+ * 2. Iframe/Cross-window Mode:
+ *    - Establishes a connection with the parent window (or specified target)
+ *    - Uses postMessage for communication
+ *    - Handles timeouts, retries, and error cases for reliable messaging
+ *    - Proxies tracking calls to the parent window which can then handle them
+ *
+ * The system adds a proxy version to all events to help with debugging and tracking.
+ */
+/**
+ * Establishes a connection with the target frame and returns a pulse tracker proxy object.
+ * This function automatically detects whether it's running in a mobile app webview or
+ * needs to use iframe/cross-window communication.
+ *
+ * Usage:
+ * ```typescript
+ * const tracker = await getPulseTrackerProxy({
+ *   provider: 'my-provider',
+ *   debug: console.log
+ * });
+ *
+ * tracker.track('trackerEvent', { ... });
+ * ```
+ *
+ * @param options - Configuration options for the pulse tracker proxy
+ * @returns A promise that resolves to a proxy object implementing the Pulse tracker interface
+ * @throws Error if connection fails, timeout occurs, or required options are missing
+ */
+export function getPulseTrackerProxy({ provider, autotrackerVersion = '3', window = globalThis.window, target = window.parent, timeout = 5000, retries = 3, retryTimeout = 1000, debug = () => { }, } = {}) {
+    debug('[Pulse Tracker Proxy] Checking if `pulseEventHandler` is provided in the current window...');
+    if (window.pulseEventHandler) {
+        debug(`[Pulse Tracker Proxy] \`pulseEventHandler\` found in the current window. Assuming it is the app webview. Loading autotracker version ${autotrackerVersion}...`);
+        if (!provider) {
+            debug('[Pulse Tracker Proxy] `provider` is not set - cannot create pulse tracker.');
+            return Promise.reject('`provider` is not set - cannot create pulse tracker.');
+        }
+        return loadAutotracker(window, provider, autotrackerVersion);
+    }
+    debug('[Pulse Tracker Proxy] `pulseEventHandler` not found in the current window - not a mobile app webview.');
+    debug('[Pulse Tracker Proxy] Trying to establish connection...', { target, timeout, retries });
+    if (!target) {
+        return Promise.reject(new Error('Target window not provided. Possibly window.parent is not available.'));
+    }
+    let ackTimeout;
+    let alreadyTimedOut = false;
+    const timeoutPromise = new Promise((_, reject) => {
+        ackTimeout = setTimeout(() => {
+            alreadyTimedOut = true;
+            debug('[Pulse Tracker Proxy] Ack timeout. Sorry, target seems to not support the proxy.');
+            reject(new Error(`Pulse tracker proxy not found within ${timeout} ms`));
+        }, timeout);
+    });
+    const connectionPromise = (async () => {
+        for (let i = 0; i < retries; i++) {
+            if (alreadyTimedOut) {
+                debug('[Pulse Tracker Proxy] Configured timeout has passed before the next attempt');
+                throw new Error('Configured timeout has passed before the next attempt.');
+            }
+            try {
+                debug(`[Pulse Tracker Proxy] Sending request to target window (attempt: ${i + 1})...`);
+                await sendMessage({ type: MESSAGE_TYPE_REQUEST }, { target, timeout: retryTimeout });
+            }
+            catch (error) {
+                debug(`[Pulse Tracker Proxy] Ack Request failed: ${error}`);
+                continue;
+            }
+            clearTimeout(ackTimeout);
+            debug(`[Pulse Tracker Proxy] Ack Request successful (attempt: ${i + 1})`);
+            return new PulseTrackerProxyImpl(target, debug);
+        }
+        clearTimeout(ackTimeout);
+        debug('[Pulse Tracker Proxy] Retries exhausted. Target did not respond. Failing.');
+        throw new Error('Failed to establish connection with pulse tracker proxy');
+    })();
+    return Promise.race([timeoutPromise, connectionPromise]);
+}

package/dist/ejs/index.js

@@ -0,0 +1 @@
+export * from './get-proxy';

package/dist/ejs/load-autotracker.js

@@ -0,0 +1,31 @@
+/**
+ * Loads the Pulse autotracker script onto the page and initializes it with the provided configuration.
+ *
+ * @param window - The browser window object to attach the script to
+ * @param provider - The provider ID to initialize the Pulse tracker with
+ * @param version - The version of the Pulse autotracker to load
+ * @returns A promise that resolves to the configured Tracker instance
+ * @throws Error if script loading fails or Pulse doesn't initialize correctly
+ */
+export async function loadAutotracker(window, provider, version) {
+    await new Promise((resolve, reject) => {
+        const element = window.document.createElement('script');
+        element.src = `//sdk.pulse.schibsted.com/versioned/${version}/pulse.min.js`;
+        element.async = true;
+        element.onload = resolve;
+        element.onerror = () => {
+            reject(new Error(`Failed to load autotracker script from src: ${element.src}`));
+        };
+        window.document.head.appendChild(element);
+    });
+    return new Promise((resolve, reject) => {
+        if (!window.pulse) {
+            reject(new Error('Pulse autotracker did not load correctly!'));
+            return;
+        }
+        window.pulse('init', provider);
+        window.pulse((tracker) => {
+            resolve(tracker);
+        });
+    });
+}

package/dist/ejs/send-message.js

@@ -0,0 +1,61 @@
+import { isPulseProxyMessage, MESSAGE_TYPE_RETURN_ERROR } from './consts';
+/**
+ * Sends a message to a target window and returns a promise that resolves with the response.
+ *
+ * This function creates a MessageChannel to facilitate two-way communication with the target.
+ * It handles timeouts and error responses appropriately.
+ *
+ * @param message - The message object to send to the target window
+ * @param options - Configuration options for sending the message
+ * @param options.target - The target window to send the message to (e.g., iframe.contentWindow)
+ * @param options.timeout - Optional timeout in milliseconds after which the promise will reject
+ * @param options.debug - Optional debug function for logging message events
+ * @returns A promise that resolves with the response message or rejects with an error
+ *
+ * @example
+ * ```typescript
+ * import { sendMessage } from './send-message';
+ *
+ * const message = { type: 'SOME_MESSAGE_TYPE', payload: { ... } };
+ * sendMessage(message, {
+ *   target: document.querySelector('iframe').contentWindow,
+ *   timeout: 5000,
+ *   debug: console.log
+ * }).then(response => {
+ *   // Handle response
+ * }).catch(error => {
+ *   // Handle error
+ * });
+ * ```
+ */
+export function sendMessage(message, { target, timeout, debug = () => { } }) {
+    return new Promise((resolve, reject) => {
+        const channel = new MessageChannel();
+        const requestTimeout = timeout
+            ? setTimeout(() => {
+                channel.port1.close();
+                reject(new Error(`Message of type ${message.type} timed out`));
+            }, timeout)
+            : undefined;
+        const responseHandler = (event) => {
+            debug('[Pulse Tracker Proxy] Received the response on the MessageChannel', event);
+            if (!isPulseProxyMessage(event.data)) {
+                debug('[Pulse Tracker Proxy] Response was not a valid Proxy Message', event.data);
+                return;
+            }
+            if (event.data.type === MESSAGE_TYPE_RETURN_ERROR) {
+                debug('[Pulse Tracker Proxy] Received an return error response', event.data.error);
+                clearTimeout(requestTimeout);
+                channel.port1.close();
+                reject(new Error(event.data.error));
+            }
+            debug('[Pulse Tracker Proxy] Received a valid response', event.data);
+            clearTimeout(requestTimeout);
+            channel.port1.close();
+            resolve(event.data);
+        };
+        channel.port1.onmessage = responseHandler;
+        debug('[Pulse Tracker Proxy] Sending message to target window', message);
+        target.postMessage(message, '*', [channel.port2]);
+    });
+}

package/dist/ejs/tracker-proxy.js

@@ -0,0 +1,65 @@
+import { isPulseProxyMessage, MESSAGE_TYPE_INVOKE, MESSAGE_TYPE_RETURN, MESSAGE_TYPE_RETURN_ERROR, } from './consts';
+import { sendMessage } from './send-message';
+import version from './version.json';
+/**
+ * Adds proxy version information to the event input.
+ * This helps with debugging and allows tracking which proxy version was used for the event.
+ *
+ * @param input - The original event input to be decorated
+ * @returns The input with added proxyVersion in the tracker object
+ */
+function decorateWithProxyVersion(input) {
+    const tracker = 'tracker' in input && typeof input.tracker === 'object' ? input.tracker : {};
+    return {
+        ...input,
+        tracker: { ...tracker, proxyVersion: version.PROXY_VERSION },
+    };
+}
+/**
+ * Implementation of the Pulse Tracker Proxy that forwards tracking calls to a target window.
+ * This class handles the communication between frames/windows and ensures proper message handling.
+ */
+export class PulseTrackerProxyImpl {
+    constructor(target, debug) {
+        this.target = target;
+        this.debug = debug;
+    }
+    /**
+     * Tracks an event by forwarding the call to the target window.
+     * Automatically decorates the event with proxy version information.
+     *
+     * @param args - Arguments that would normally be passed to the Pulse tracker's track method
+     * @returns A promise that resolves with the response from the target window
+     */
+    track(...args) {
+        this.debug('[Pulse Tracker Proxy] Calling `track`', args);
+        const [eventType, input, ...rest] = args;
+        const modifiedArgs = [eventType, decorateWithProxyVersion(input), ...rest];
+        return this.invoke({ method: 'track', args: modifiedArgs });
+    }
+    /**
+     * Invokes a remote function in the target window and handles the response.
+     *
+     * @param invocation - The invocation details including method name and arguments
+     * @returns A promise that resolves with the response payload or rejects with an error
+     * @private
+     */
+    async invoke(invocation) {
+        this.debug('[Pulse Tracker Proxy] Invoking remote function', invocation);
+        const response = await sendMessage({ type: MESSAGE_TYPE_INVOKE, payload: invocation }, { target: this.target });
+        if (!isPulseProxyMessage(response)) {
+            this.debug('[Pulse Tracker Proxy] Invalid response from proxy', response);
+            throw new Error('Invalid response from proxy');
+        }
+        if (response.type === MESSAGE_TYPE_RETURN_ERROR) {
+            this.debug('[Pulse Tracker Proxy] Error response from proxy', response.error);
+            throw new Error(response.error);
+        }
+        if (response.type === MESSAGE_TYPE_RETURN) {
+            this.debug('[Pulse Tracker Proxy] Successful response from proxy', response.payload);
+            return response.payload;
+        }
+        this.debug('[Pulse Tracker Proxy] Unhandled response from proxy', response);
+        throw new Error('Unexpected response from proxy');
+    }
+}

package/dist/ejs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/version.json

@@ -0,0 +1 @@
+{ "PROXY_VERSION": "1.0.0", "GIT_COMMIT": "6ca09707" }