@purespectrum1/purescore-client 0.7.0 → 1.0.0

package/lib/domain/services/single-script-injection/schedule-store.js

@@ -14,17 +14,18 @@ exports.LOI_CHECKPOINT_FRACTIONS = [1 / 3, 2 / 3, 1, 2];
 /** Most calls a transaction can make: the initial one plus each LOI fraction. */
 exports.CHECKPOINT_COUNT = 1 + exports.LOI_CHECKPOINT_FRACTIONS.length;
 /**
- * Owns the `ps_di_schedule_<surveyId>` record: which checkpoints are still
- * outstanding on a later page load. Storage is injected, so this holds only the
- * schedule rules, not where the record lives.
+ * Owns the `ps_di_schedule_<projectId>_<supplierId>_<supplierMemberId|emailHash>`
+ * record: which checkpoints are still outstanding on a later page load. Parts
+ * that were not provided are left out of the key. Storage is injected, so this
+ * holds only the schedule rules, not where the record lives.
  */
 class ScheduleStore {
-    constructor(surveyId, storage) {
-        this.surveyId = surveyId;
+    constructor({ projectId, supplierId, supplierMemberId, emailHash }, storage) {
         this.storage = storage;
-    }
-    get key() {
-        return `ps_di_schedule_${this.surveyId}`;
+        this.projectId = projectId;
+        this.key = ['ps_di_schedule', projectId, supplierId, supplierMemberId || emailHash]
+            .filter(Boolean)
+            .join('_');
     }
     /**
      * Checkpoint 1 fires `INITIAL_CHECKPOINT_DELAY_MS` in regardless; the rest are
@@ -78,7 +79,7 @@ class ScheduleStore {
         const startedAt = this.now();
         const checkpoints = ScheduleStore.buildCheckpoints(startedAt, null);
         const record = {
-            surveyId: this.surveyId,
+            projectId: this.projectId,
             loi: null,
             startedAt,
             checkpoints,
@@ -119,7 +120,7 @@ class ScheduleStore {
         return record;
     }
     /**
-     * Stores the latest Device-Intelligence response alongside the schedule so it
+     * Stores the latest PureScore-Intelligence response alongside the schedule so it
      * can be replayed on the next page load.
      */
     storeResponse(response) {

package/lib/domain/services/snapshot-store.d.ts

@@ -14,6 +14,7 @@ export declare class SnapshotStore<T extends object> {
     constructor(key: string, getData: () => T, storage: GetStorage & SetStorage & RemoveStorage, intervalMs?: number);
     start(): void;
     stop(): void;
+    save(): void;
     read(): T | null;
     clear(): void;
 }

package/lib/domain/services/snapshot-store.js

@@ -26,6 +26,9 @@ class SnapshotStore {
             this.interval = null;
         }
     }
+    save() {
+        this.storage.set(this.key, this.getData());
+    }
     read() {
         return this.storage.get(this.key);
     }

package/lib/domain/services/translation-detector.d.ts

@@ -0,0 +1,20 @@
+export interface TranslationListener {
+    onDetected: () => void;
+    onSample: (sample: string) => void;
+}
+export declare class TranslationDetector {
+    private attributeObserver;
+    private textObserver;
+    private initialLang;
+    private markSeen;
+    private detected;
+    private sample;
+    start(listener: TranslationListener): void;
+    stop(): void;
+    private handleAttributes;
+    private isTranslationMark;
+    private handleText;
+    private translatedLength;
+    private extendSample;
+    private readableText;
+}

package/lib/domain/services/translation-detector.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslationDetector = void 0;
+const MIN_TRANSLATED_TEXT_LENGTH = 4;
+const MAX_TRANSLATED_TEXT_LENGTH = 256;
+const GOOGLE_CLASS_PREFIX = 'translate';
+const GOOGLE_CLASS_MARK = 'translated';
+const EDGE_ATTRIBUTES = new Set(['_msthash', '_msttexthash']);
+const NON_CONTENT_PARENTS = new Set(['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE']);
+const TAG_LIKE = /<[^>]*>/g;
+const WHITESPACE = /\s+/g;
+class TranslationDetector {
+    constructor() {
+        this.attributeObserver = null;
+        this.textObserver = null;
+        this.initialLang = null;
+        this.markSeen = false;
+        this.detected = false;
+        this.sample = '';
+    }
+    start(listener) {
+        if (this.attributeObserver || typeof document === 'undefined' || typeof MutationObserver === 'undefined')
+            return;
+        const root = document.documentElement;
+        if (!root)
+            return;
+        const targets = [root];
+        const title = document.getElementsByTagName('title')[0];
+        if (title)
+            targets.push(title);
+        this.initialLang = root.getAttribute('lang');
+        this.markSeen = false;
+        this.detected = false;
+        this.sample = '';
+        this.attributeObserver = new MutationObserver(mutations => this.handleAttributes(mutations));
+        this.textObserver = new MutationObserver(mutations => this.handleText(mutations, listener));
+        for (const target of targets) {
+            this.attributeObserver.observe(target, { attributes: true, attributeOldValue: true });
+            this.textObserver.observe(target, { characterData: true, characterDataOldValue: true, subtree: true });
+        }
+    }
+    stop() {
+        var _a, _b;
+        (_a = this.attributeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        (_b = this.textObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
+        this.attributeObserver = null;
+        this.textObserver = null;
+        this.markSeen = false;
+    }
+    handleAttributes(mutations) {
+        for (const mutation of mutations) {
+            if (mutation.type === 'attributes' && this.isTranslationMark(mutation)) {
+                this.markSeen = true;
+                return;
+            }
+        }
+    }
+    isTranslationMark(mutation) {
+        const target = mutation.target;
+        if (!(target instanceof HTMLElement))
+            return false;
+        const name = mutation.attributeName;
+        const className = typeof target.className === 'string' ? target.className : '';
+        const google = name === 'class' && (className.startsWith(GOOGLE_CLASS_PREFIX) || className.includes(GOOGLE_CLASS_MARK));
+        const edge = name !== null && EDGE_ATTRIBUTES.has(name);
+        const safari = name === 'lang' && target === document.documentElement && target.getAttribute('lang') !== this.initialLang;
+        return google || edge || safari;
+    }
+    handleText(mutations, listener) {
+        var _a;
+        if (!this.markSeen)
+            return;
+        const changed = mutations.filter(mutation => mutation.target instanceof CharacterData && mutation.oldValue !== mutation.target.data);
+        if (!this.detected && this.translatedLength(changed) > MIN_TRANSLATED_TEXT_LENGTH) {
+            this.detected = true;
+            (_a = this.attributeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+            listener.onDetected();
+        }
+        if (!this.detected)
+            return;
+        const sample = this.extendSample(changed);
+        if (sample !== this.sample) {
+            this.sample = sample;
+            listener.onSample(sample);
+        }
+        if (this.sample.length >= MAX_TRANSLATED_TEXT_LENGTH)
+            this.stop();
+    }
+    translatedLength(changed) {
+        const texts = [];
+        let length = 0;
+        for (const mutation of changed) {
+            const data = mutation.target.data;
+            texts.push(data);
+            length += data.length;
+            if (length >= MAX_TRANSLATED_TEXT_LENGTH)
+                break;
+        }
+        return texts.join(' ').length;
+    }
+    extendSample(changed) {
+        const parts = this.sample ? [this.sample] : [];
+        for (const mutation of changed) {
+            const text = this.readableText(mutation.target);
+            if (text)
+                parts.push(text);
+        }
+        return parts.join(' ').slice(0, MAX_TRANSLATED_TEXT_LENGTH);
+    }
+    readableText(node) {
+        var _a, _b, _c;
+        if (node.nodeType !== Node.TEXT_NODE)
+            return '';
+        if (NON_CONTENT_PARENTS.has((_b = (_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.tagName) !== null && _b !== void 0 ? _b : ''))
+            return '';
+        return ((_c = node.textContent) !== null && _c !== void 0 ? _c : '').replace(TAG_LIKE, ' ').replace(WHITESPACE, ' ').trim();
+    }
+}
+exports.TranslationDetector = TranslationDetector;

package/lib/domain/services/verisoul.d.ts

@@ -0,0 +1,27 @@
+import { VerisoulEnvConfig } from '../models/crosscutting';
+import { VerisoulSessionProvider } from '../protocols/services/verisoul';
+/**
+ * How long to wait for the SDK to load, and then for it to hand back a session,
+ * before giving up. Bounded so an ad-blocked or slow SDK only costs the first
+ * checkpoint a few seconds instead of stalling it.
+ */
+export declare const VERISOUL_TIMEOUT_MS = 5000;
+/**
+ * Loads the Verisoul SDK into the page and reads the session id off it.
+ *
+ * The script is injected once per page: a tag already carrying the same `src`
+ * (from an earlier bundle instance, or the page itself) is reused rather than
+ * duplicated.
+ */
+export declare class VerisoulService implements VerisoulSessionProvider {
+    private readonly config;
+    private readonly timeoutMs;
+    private ready?;
+    constructor(config: VerisoulEnvConfig, timeoutMs?: number);
+    /** Starts loading the SDK. Safe to call more than once. */
+    load(): void;
+    getSessionId(): Promise<string | undefined>;
+    private sdk;
+    private inject;
+    private withTimeout;
+}

package/lib/domain/services/verisoul.js

@@ -0,0 +1,96 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerisoulService = exports.VERISOUL_TIMEOUT_MS = void 0;
+/**
+ * How long to wait for the SDK to load, and then for it to hand back a session,
+ * before giving up. Bounded so an ad-blocked or slow SDK only costs the first
+ * checkpoint a few seconds instead of stalling it.
+ */
+exports.VERISOUL_TIMEOUT_MS = 5000;
+/**
+ * Loads the Verisoul SDK into the page and reads the session id off it.
+ *
+ * The script is injected once per page: a tag already carrying the same `src`
+ * (from an earlier bundle instance, or the page itself) is reused rather than
+ * duplicated.
+ */
+class VerisoulService {
+    constructor(config, timeoutMs = exports.VERISOUL_TIMEOUT_MS) {
+        this.config = config;
+        this.timeoutMs = timeoutMs;
+    }
+    /** Starts loading the SDK. Safe to call more than once. */
+    load() {
+        this.sdk();
+    }
+    getSessionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const verisoul = yield this.sdk();
+                if (!verisoul)
+                    return undefined;
+                const session = yield this.withTimeout(verisoul.session());
+                const sessionId = session === null || session === void 0 ? void 0 : session.session_id;
+                return typeof sessionId === 'string' && sessionId.length > 0 ? sessionId : undefined;
+            }
+            catch (error) {
+                console.error('Error getting Verisoul session id:', error);
+                return undefined;
+            }
+        });
+    }
+    sdk() {
+        if (!this.ready) {
+            this.ready = this.withTimeout(this.inject()).catch(error => {
+                console.error('Error loading Verisoul SDK:', error);
+                // Let a later call try again rather than caching the failure for the page.
+                this.ready = undefined;
+                return undefined;
+            });
+        }
+        return this.ready;
+    }
+    inject() {
+        return new Promise((resolve, reject) => {
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                reject(new Error('Verisoul needs a browser environment'));
+                return;
+            }
+            if (window.Verisoul) {
+                resolve(window.Verisoul);
+                return;
+            }
+            let script = document.querySelector(`script[src="${this.config.sdkUrl}"]`);
+            if (!script) {
+                script = document.createElement('script');
+                script.src = this.config.sdkUrl;
+                script.async = true;
+                script.setAttribute('verisoul-project-id', this.config.projectId);
+                (document.head || document.documentElement).appendChild(script);
+            }
+            script.addEventListener('load', () => {
+                if (window.Verisoul)
+                    resolve(window.Verisoul);
+                else
+                    reject(new Error('Verisoul SDK loaded but window.Verisoul is missing'));
+            });
+            script.addEventListener('error', () => reject(new Error('Failed to load the Verisoul SDK')));
+        });
+    }
+    withTimeout(promise) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Verisoul timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
+            promise.then(value => { clearTimeout(timer); resolve(value); }, error => { clearTimeout(timer); reject(error); });
+        });
+    }
+}
+exports.VerisoulService = VerisoulService;

package/lib/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Two responsibilities and nothing else: re-export what consumers are allowed to
  * reach, and run the self-initializing script tag. Everything with behaviour
- * lives behind a layer — `application` for the Device-Identifier and the
+ * lives behind a layer — `application` for the Purescore-Client and the
  * bootstrap that drives it, `domain` for the services they are built from,
  * `validation` for the rules.
  */
@@ -17,3 +17,4 @@ export { DeviceIdentifier };
 export type { DeviceIdentifierOptions, DeviceIdentifierConfig, DeviceIdentifierMetadata, TrackDetails, TrackDetailsContext, TransactionDetails, CreateTransaction, } from './domain/protocols/services/device-identifier';
 export type { DisplayChecks, DisplayChecksInput, Language, NavigatorUABrandVersion, UADataValues, NavigatorUAData, NetworkInformation, UAParserDeviceType, NavigationTiming, NetworkTimes, } from './domain/protocols/services/device-fingerprint';
 export type { AutoInitConfig, ScheduleRecord, ScheduleCheckpoint, } from './domain/protocols/services/single-script-injection';
+export type { ClipboardActivityType, ClipboardActivity, TabSwitch, InteractionActivity, } from './domain/protocols/services/interaction-activity';

package/lib/index.js

@@ -6,7 +6,7 @@ exports.DeviceIdentifier = void 0;
  *
  * Two responsibilities and nothing else: re-export what consumers are allowed to
  * reach, and run the self-initializing script tag. Everything with behaviour
- * lives behind a layer — `application` for the Device-Identifier and the
+ * lives behind a layer — `application` for the Purescore-Client and the
  * bootstrap that drives it, `domain` for the services they are built from,
  * `validation` for the rules.
  */
@@ -18,7 +18,7 @@ const auto_init_1 = require("./application/auto-init");
  *
  * When the tag that loaded this bundle carries `data-auto-init="true"`, the
  * bundle bootstraps itself from its own `data-*` attributes and drives the three
- * Device-Intelligence calls off an LOI-derived schedule — the buyer writes no
+ * PureScore-Intelligence calls off an LOI-derived schedule — the buyer writes no
  * bootstrap code and no `trackDetails` call at all.
  *
  * Without that attribute this is a no-op, which is what keeps the existing

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@purespectrum1/purescore-client",
   "description": "A library to identify purescore devices",
-  "version": "0.7.0",
+  "version": "1.0.0",
   "main": "lib/index.js",
   "scripts": {
     "clean": "rm -rf lib && rm -rf dist",