@purespectrum1/purescore-client 0.7.0

package/lib/domain/services/behavioural-biometrics/cursor-behavior.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorBehavior = void 0;
+class CursorBehavior {
+    constructor() {
+        this.movements = [];
+        this.velocities = [];
+        this.accelerations = [];
+        this.scrolls = [];
+        this.lastPoint = null;
+        this.lastVelocity = null;
+        this.lastSampleTime = 0;
+        this.angleChangeCount = 0;
+        this.lastAngle = null;
+        this.hoverStart = null;
+        this.isTracking = false;
+        this.sampleRate = 50;
+        this.significantAngleChange = Math.PI / 6;
+        this.maxDataPoints = 500;
+        this.pruneInterval = 50;
+        this.pruneCounter = 0;
+        this.mouseMoveHandler = this.handleMouseMove.bind(this);
+        this.mouseDownHandler = this.handleMouseDown.bind(this);
+        this.wheelHandler = this.handleWheel.bind(this);
+        this.scrollHandler = this.handleScroll.bind(this);
+    }
+    /**
+     * Start tracking mouse behavior
+     */
+    startTracking(maxDataPoints) {
+        if (this.isTracking || typeof window === 'undefined') {
+            return;
+        }
+        this.maxDataPoints = maxDataPoints !== null && maxDataPoints !== void 0 ? maxDataPoints : 1000;
+        this.resetData();
+        this.isTracking = true;
+        window.addEventListener('mousemove', this.mouseMoveHandler);
+        window.addEventListener('mousedown', this.mouseDownHandler);
+        window.addEventListener('wheel', this.wheelHandler, { passive: true });
+        window.addEventListener('scroll', this.scrollHandler, { passive: true });
+    }
+    /**
+     * Stops tracking cursor behavior without clearing collected data.
+     */
+    stopTracking() {
+        if (!this.isTracking)
+            return;
+        this.isTracking = false;
+        window.removeEventListener('mousemove', this.mouseMoveHandler);
+        window.removeEventListener('mousedown', this.mouseDownHandler);
+        window.removeEventListener('wheel', this.wheelHandler);
+        window.removeEventListener('scroll', this.scrollHandler);
+    }
+    /**
+     * Returns true if this tracker currently has its DOM listeners attached.
+     */
+    hasActiveListeners() {
+        return this.isTracking;
+    }
+    /**
+     * Snapshot of raw event buffers for cross-page persistence.
+     */
+    getState() {
+        return {
+            movements: this.movements,
+            velocities: this.velocities,
+            accelerations: this.accelerations,
+            scrolls: this.scrolls,
+            angleChangeCount: this.angleChangeCount,
+        };
+    }
+    /**
+     * Restores raw event buffers from a snapshot. Transient fields (lastPoint,
+     * lastVelocity, hoverStart, etc.) are not restored — they only make sense
+     * within a continuous interaction sequence on a single page.
+     */
+    restoreState(state) {
+        if (state.movements)
+            this.movements = state.movements;
+        if (state.velocities)
+            this.velocities = state.velocities;
+        if (state.accelerations)
+            this.accelerations = state.accelerations;
+        if (state.scrolls)
+            this.scrolls = state.scrolls;
+        if (typeof state.angleChangeCount === 'number')
+            this.angleChangeCount = state.angleChangeCount;
+    }
+    /**
+     * Reset all collected data
+     */
+    resetData() {
+        this.movements = [];
+        this.velocities = [];
+        this.accelerations = [];
+        this.scrolls = [];
+        this.lastPoint = null;
+        this.lastVelocity = null;
+        this.lastSampleTime = 0;
+        this.angleChangeCount = 0;
+        this.lastAngle = null;
+        this.hoverStart = null;
+        this.pruneCounter = 0;
+    }
+    /**
+     * Get current behavioral metrics
+     */
+    getCursorBehaviorBiometrics() {
+        const averageSpeed = this.calculateAverageSpeed();
+        return {
+            movementMetrics: {
+                averageSpeed: averageSpeed,
+                maxSpeed: this.calculateMaxSpeed(),
+                minSpeed: this.calculateMinSpeed(),
+                speedStdDev: this.calculateSpeedStdDev(averageSpeed),
+            },
+            accelerationMetrics: {
+                averageAcceleration: this.calculateAverageAcceleration(),
+                maxAcceleration: this.calculateMaxAcceleration(),
+                decelerationCount: this.countDecelerations(),
+                accelerationCount: this.countAccelerations(),
+            },
+            trajectoryMetrics: {
+                averageCurvature: this.calculateAverageCurvature(),
+                straightLinePercentage: this.calculateStraightLinePercentage(),
+                averageJerkiness: this.calculateAverageJerkiness(),
+                angleChanges: this.angleChangeCount,
+            },
+            scrollMetrics: {
+                totalScrollDistance: this.calculateTotalScrollDistance(),
+                averageScrollVelocity: this.calculateAverageScrollVelocity(),
+                wheelScrollCount: this.scrolls.filter(s => s.type === 'wheel').length,
+                dragScrollCount: this.scrolls.filter(s => s.type === 'drag').length,
+            },
+            sessionInfo: {
+                totalMovements: this.movements.length,
+            },
+        };
+    }
+    handleMouseMove(event) {
+        const now = Date.now();
+        // Apply sample rate throttling
+        if (now - this.lastSampleTime < this.sampleRate) {
+            return;
+        }
+        this.lastSampleTime = now;
+        const point = {
+            x: event.clientX,
+            y: event.clientY,
+            timestamp: now
+        };
+        this.movements.push(point);
+        // Calculate velocity and acceleration
+        if (this.lastPoint) {
+            const velocity = this.calculateVelocity(this.lastPoint, point);
+            this.velocities.push(velocity);
+            // Track angle changes
+            const angle = Math.atan2(velocity.vy, velocity.vx);
+            if (this.lastAngle !== null) {
+                const angleDiff = Math.abs(angle - this.lastAngle);
+                if (angleDiff > this.significantAngleChange) {
+                    this.angleChangeCount++;
+                }
+            }
+            this.lastAngle = angle;
+            if (this.lastVelocity) {
+                const acceleration = this.calculateAcceleration(this.lastVelocity, velocity, point.timestamp - this.lastPoint.timestamp);
+                this.accelerations.push(acceleration);
+            }
+            this.lastVelocity = velocity;
+        }
+        this.lastPoint = point;
+        // Update hover tracking
+        if (!this.hoverStart) {
+            this.hoverStart = point;
+        }
+        // Batch prune every N events
+        if (++this.pruneCounter >= this.pruneInterval) {
+            this.pruneCounter = 0;
+            this.pruneOldData();
+        }
+    }
+    ;
+    handleMouseDown(event) {
+        // Track when user starts hovering before clicking
+        const now = Date.now();
+        this.hoverStart = {
+            x: event.clientX,
+            y: event.clientY,
+            timestamp: now
+        };
+    }
+    ;
+    handleWheel(event) {
+        const now = Date.now();
+        const scrollEvent = {
+            deltaX: event.deltaX,
+            deltaY: event.deltaY,
+            timestamp: now,
+            velocity: Math.sqrt(event.deltaX ** 2 + event.deltaY ** 2),
+            type: 'wheel'
+        };
+        this.scrolls.push(scrollEvent);
+    }
+    ;
+    handleScroll(event) {
+        // This detects programmatic or drag scrolling
+        const now = Date.now();
+        // Avoid duplicate events from wheel
+        if (this.scrolls.length > 0) {
+            const lastScroll = this.scrolls[this.scrolls.length - 1];
+            if (now - lastScroll.timestamp < 50) {
+                return; // Too close to last scroll event, likely duplicate
+            }
+        }
+        const scrollEvent = {
+            deltaX: 0,
+            deltaY: 0,
+            timestamp: now,
+            velocity: 0,
+            type: 'drag'
+        };
+        this.scrolls.push(scrollEvent);
+    }
+    ;
+    calculateVelocity(p1, p2) {
+        const dt = p2.timestamp - p1.timestamp;
+        if (dt === 0) {
+            return { vx: 0, vy: 0, speed: 0 };
+        }
+        const vx = (p2.x - p1.x) / dt;
+        const vy = (p2.y - p1.y) / dt;
+        const speed = Math.sqrt(vx ** 2 + vy ** 2);
+        return { vx, vy, speed };
+    }
+    calculateAcceleration(v1, v2, dt) {
+        if (dt === 0) {
+            return { ax: 0, ay: 0, magnitude: 0 };
+        }
+        const ax = (v2.vx - v1.vx) / dt;
+        const ay = (v2.vy - v1.vy) / dt;
+        const magnitude = Math.sqrt(ax ** 2 + ay ** 2);
+        return { ax, ay, magnitude };
+    }
+    calculateDistance(p1, p2) {
+        return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
+    }
+    pruneOldData() {
+        if (this.movements.length > this.maxDataPoints) {
+            this.movements = this.movements.slice(-this.maxDataPoints);
+        }
+        if (this.velocities.length > this.maxDataPoints) {
+            this.velocities = this.velocities.slice(-this.maxDataPoints);
+        }
+        if (this.accelerations.length > this.maxDataPoints) {
+            this.accelerations = this.accelerations.slice(-this.maxDataPoints);
+        }
+        if (this.scrolls.length > this.maxDataPoints) {
+            this.scrolls = this.scrolls.slice(-this.maxDataPoints);
+        }
+    }
+    // Metric calculation methods
+    calculateAverageSpeed() {
+        if (this.velocities.length === 0)
+            return null;
+        const sum = this.velocities.reduce((acc, v) => acc + v.speed, 0);
+        return sum / this.velocities.length;
+    }
+    calculateMaxSpeed() {
+        if (this.velocities.length === 0)
+            return null;
+        return Math.max(...this.velocities.map(v => v.speed));
+    }
+    calculateMinSpeed() {
+        if (this.velocities.length === 0)
+            return null;
+        return Math.min(...this.velocities.map(v => v.speed));
+    }
+    calculateSpeedStdDev(averageSpeed) {
+        if (this.velocities.length < 2 || averageSpeed === null)
+            return null;
+        const squaredDiffs = this.velocities.map(v => (v.speed - averageSpeed) ** 2);
+        const variance = squaredDiffs.reduce((acc, val) => acc + val, 0) / this.velocities.length;
+        return Math.sqrt(variance);
+    }
+    calculateAverageAcceleration() {
+        if (this.accelerations.length === 0)
+            return null;
+        const sum = this.accelerations.reduce((acc, a) => acc + a.magnitude, 0);
+        return sum / this.accelerations.length;
+    }
+    calculateMaxAcceleration() {
+        if (this.accelerations.length === 0)
+            return null;
+        return Math.max(...this.accelerations.map(a => a.magnitude));
+    }
+    countDecelerations() {
+        let count = 0;
+        for (let i = 1; i < this.velocities.length; i++) {
+            if (this.velocities[i].speed < this.velocities[i - 1].speed) {
+                count++;
+            }
+        }
+        return count;
+    }
+    countAccelerations() {
+        let count = 0;
+        for (let i = 1; i < this.velocities.length; i++) {
+            if (this.velocities[i].speed > this.velocities[i - 1].speed) {
+                count++;
+            }
+        }
+        return count;
+    }
+    calculateAverageCurvature() {
+        if (this.movements.length < 3)
+            return null;
+        let totalCurvature = 0;
+        let count = 0;
+        for (let i = 1; i < this.movements.length - 1; i++) {
+            const p1 = this.movements[i - 1];
+            const p2 = this.movements[i];
+            const p3 = this.movements[i + 1];
+            const angle1 = Math.atan2(p2.y - p1.y, p2.x - p1.x);
+            const angle2 = Math.atan2(p3.y - p2.y, p3.x - p2.x);
+            let curvature = Math.abs(angle2 - angle1);
+            if (curvature > Math.PI) {
+                curvature = 2 * Math.PI - curvature;
+            }
+            totalCurvature += curvature;
+            count++;
+        }
+        return count > 0 ? totalCurvature / count : null;
+    }
+    calculateStraightLinePercentage() {
+        if (this.movements.length < 3)
+            return null;
+        const start = this.movements[0];
+        const end = this.movements[this.movements.length - 1];
+        const directDistance = this.calculateDistance(start, end);
+        let pathDistance = 0;
+        for (let i = 1; i < this.movements.length; i++) {
+            pathDistance += this.calculateDistance(this.movements[i - 1], this.movements[i]);
+        }
+        if (pathDistance === 0)
+            return null;
+        return directDistance / pathDistance;
+    }
+    calculateAverageJerkiness() {
+        if (this.accelerations.length < 2)
+            return null;
+        let totalJerk = 0;
+        for (let i = 1; i < this.accelerations.length; i++) {
+            const da = this.accelerations[i].magnitude - this.accelerations[i - 1].magnitude;
+            totalJerk += Math.abs(da);
+        }
+        return totalJerk / (this.accelerations.length - 1);
+    }
+    calculateTotalScrollDistance() {
+        return this.scrolls.reduce((acc, s) => acc + Math.sqrt(s.deltaX ** 2 + s.deltaY ** 2), 0);
+    }
+    calculateAverageScrollVelocity() {
+        if (this.scrolls.length === 0)
+            return null;
+        const sum = this.scrolls.reduce((acc, s) => acc + s.velocity, 0);
+        return sum / this.scrolls.length;
+    }
+}
+exports.CursorBehavior = CursorBehavior;

package/lib/domain/services/behavioural-biometrics/index.d.ts

@@ -0,0 +1,4 @@
+export * from './collector';
+export * from './cursor-behavior';
+export * from './keystroke-metrics';
+export * from './touch-behavior';

package/lib/domain/services/behavioural-biometrics/index.js

@@ -0,0 +1,20 @@
+"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("./collector"), exports);
+__exportStar(require("./cursor-behavior"), exports);
+__exportStar(require("./keystroke-metrics"), exports);
+__exportStar(require("./touch-behavior"), exports);

package/lib/domain/services/behavioural-biometrics/keystroke-metrics.d.ts

@@ -0,0 +1,60 @@
+import { KeyLog, KeyboardMetric } from '../../protocols/services/behavioural-biometrics/keystorke-metrics';
+export declare class KeyboardMetrics {
+    private keyHistory;
+    private activeKeys;
+    private isTracking;
+    private startTime;
+    private backspaceCount;
+    private deleteCount;
+    private shiftCount;
+    private totalKeyCount;
+    private keyDownHandler;
+    private keyUpHandler;
+    private maxDataPoints;
+    private readonly pruneInterval;
+    private pruneCounter;
+    constructor();
+    startTracking(maxDataPoints?: number): void;
+    stopTracking(): void;
+    /**
+     * Returns true if this tracker currently has its DOM listeners attached.
+     */
+    hasActiveListeners(): boolean;
+    /**
+     * Snapshot of raw event buffers + counters for cross-page persistence.
+     * `startTime` is included so typing speed is computed over the full session,
+     * not just the duration on the current page.
+     */
+    getState(): {
+        keyHistory: KeyLog[];
+        backspaceCount: number;
+        deleteCount: number;
+        shiftCount: number;
+        totalKeyCount: number;
+        startTime: number;
+    };
+    /**
+     * Restores raw event buffers + counters from a snapshot. Transient state
+     * (activeKeys map for in-progress key presses) is not restored.
+     */
+    restoreState(state: {
+        keyHistory?: KeyLog[];
+        backspaceCount?: number;
+        deleteCount?: number;
+        shiftCount?: number;
+        totalKeyCount?: number;
+        startTime?: number;
+    }): void;
+    resetData(): void;
+    private handleKeyDown;
+    private handleKeyUp;
+    private pruneOldData;
+    /**
+     * Metric Calculations
+     */
+    getKeyboardMetrics(): KeyboardMetric;
+    private calculateDwellTimes;
+    private calculateFlightTimes;
+    private calculateTypingSpeed;
+    private countQuickCorrections;
+}

package/lib/domain/services/behavioural-biometrics/keystroke-metrics.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardMetrics = void 0;
+class KeyboardMetrics {
+    constructor() {
+        this.keyHistory = [];
+        this.activeKeys = new Map();
+        this.isTracking = false;
+        this.startTime = 0;
+        this.backspaceCount = 0;
+        this.deleteCount = 0;
+        this.shiftCount = 0;
+        this.totalKeyCount = 0;
+        this.maxDataPoints = 1000;
+        this.pruneInterval = 50;
+        this.pruneCounter = 0;
+        this.keyDownHandler = this.handleKeyDown.bind(this);
+        this.keyUpHandler = this.handleKeyUp.bind(this);
+    }
+    startTracking(maxDataPoints) {
+        if (this.isTracking || typeof document === 'undefined')
+            return;
+        this.maxDataPoints = maxDataPoints !== null && maxDataPoints !== void 0 ? maxDataPoints : 1000;
+        this.resetData();
+        this.isTracking = true;
+        this.startTime = Date.now();
+        document.addEventListener('keydown', this.keyDownHandler);
+        document.addEventListener('keyup', this.keyUpHandler);
+    }
+    stopTracking() {
+        if (!this.isTracking)
+            return;
+        document.removeEventListener('keydown', this.keyDownHandler);
+        document.removeEventListener('keyup', this.keyUpHandler);
+        this.isTracking = false;
+    }
+    /**
+     * Returns true if this tracker currently has its DOM listeners attached.
+     */
+    hasActiveListeners() {
+        return this.isTracking;
+    }
+    /**
+     * Snapshot of raw event buffers + counters for cross-page persistence.
+     * `startTime` is included so typing speed is computed over the full session,
+     * not just the duration on the current page.
+     */
+    getState() {
+        return {
+            keyHistory: this.keyHistory,
+            backspaceCount: this.backspaceCount,
+            deleteCount: this.deleteCount,
+            shiftCount: this.shiftCount,
+            totalKeyCount: this.totalKeyCount,
+            startTime: this.startTime,
+        };
+    }
+    /**
+     * Restores raw event buffers + counters from a snapshot. Transient state
+     * (activeKeys map for in-progress key presses) is not restored.
+     */
+    restoreState(state) {
+        if (state.keyHistory)
+            this.keyHistory = state.keyHistory;
+        if (typeof state.backspaceCount === 'number')
+            this.backspaceCount = state.backspaceCount;
+        if (typeof state.deleteCount === 'number')
+            this.deleteCount = state.deleteCount;
+        if (typeof state.shiftCount === 'number')
+            this.shiftCount = state.shiftCount;
+        if (typeof state.totalKeyCount === 'number')
+            this.totalKeyCount = state.totalKeyCount;
+        if (typeof state.startTime === 'number')
+            this.startTime = state.startTime;
+    }
+    resetData() {
+        this.keyHistory = [];
+        this.activeKeys.clear();
+        this.backspaceCount = 0;
+        this.deleteCount = 0;
+        this.shiftCount = 0;
+        this.totalKeyCount = 0;
+        this.pruneCounter = 0;
+        this.startTime = Date.now();
+    }
+    handleKeyDown(event) {
+        if (event.repeat)
+            return;
+        const now = Date.now();
+        this.activeKeys.set(event.key, now);
+        this.totalKeyCount++;
+        if (event.key === 'Backspace')
+            this.backspaceCount++;
+        if (event.key === 'Delete')
+            this.deleteCount++;
+        if (event.key === 'Shift')
+            this.shiftCount++;
+    }
+    handleKeyUp(event) {
+        const now = Date.now();
+        const pressTime = this.activeKeys.get(event.key);
+        if (pressTime) {
+            const duration = now - pressTime;
+            this.keyHistory.push({
+                key: event.key,
+                pressTime,
+                releaseTime: now,
+                duration
+            });
+            this.activeKeys.delete(event.key);
+        }
+        if (++this.pruneCounter >= this.pruneInterval) {
+            this.pruneCounter = 0;
+            this.pruneOldData();
+        }
+    }
+    pruneOldData() {
+        if (this.keyHistory.length > this.maxDataPoints) {
+            this.keyHistory = this.keyHistory.slice(-this.maxDataPoints);
+        }
+    }
+    /**
+     * Metric Calculations
+     */
+    getKeyboardMetrics() {
+        const dwellTimes = this.calculateDwellTimes();
+        const flightTimes = this.calculateFlightTimes();
+        const typingSpeed = this.calculateTypingSpeed();
+        const totalCorrections = this.backspaceCount + this.deleteCount;
+        const correctionRate = this.totalKeyCount > 0 ? (totalCorrections / this.totalKeyCount) : null;
+        // Error Rate Calculation:
+        // Ratio of corrections to the total intended characters produced
+        const allChars = Math.max(0, this.totalKeyCount - (2 * totalCorrections));
+        const errorRate = (allChars + totalCorrections) > 0
+            ? (totalCorrections / (allChars + totalCorrections))
+            : null;
+        return {
+            dwellTimes,
+            flightTimes,
+            statistics: {
+                backspaceCount: this.backspaceCount,
+                shiftKeyUsage: this.shiftCount,
+                deleteKeyCount: this.deleteCount,
+            },
+            errors: {
+                totalErrors: totalCorrections,
+                quickCorrections: this.countQuickCorrections(),
+                errorRate: errorRate,
+                correctionRate: correctionRate
+            },
+            typingSpeed
+        };
+    }
+    calculateDwellTimes() {
+        const map = new Map();
+        this.keyHistory.forEach(k => {
+            const stats = map.get(k.key) || { total: 0, count: 0, last: 0 };
+            stats.total += k.duration;
+            stats.count += 1;
+            stats.last = k.duration;
+            map.set(k.key, stats);
+        });
+        return Array.from(map.entries()).map(([key, stats]) => ({
+            key,
+            averageDuration: stats.total / stats.count,
+            duration: stats.last,
+            count: stats.count
+        }));
+    }
+    calculateFlightTimes() {
+        const flightMap = new Map();
+        for (let i = 1; i < this.keyHistory.length; i++) {
+            const from = this.keyHistory[i - 1];
+            const to = this.keyHistory[i];
+            const flightDuration = to.pressTime - from.releaseTime;
+            const pairKey = `${from.key}->${to.key}`;
+            const stats = flightMap.get(pairKey) || { total: 0, count: 0, last: 0 };
+            stats.total += flightDuration;
+            stats.count += 1;
+            stats.last = flightDuration;
+            flightMap.set(pairKey, stats);
+        }
+        return Array.from(flightMap.entries()).map(([pair, stats]) => {
+            const [fromKey, toKey] = pair.split('->');
+            return {
+                fromKey,
+                toKey,
+                averageDuration: stats.total / stats.count,
+                duration: stats.last,
+                count: stats.count
+            };
+        });
+    }
+    calculateTypingSpeed() {
+        if (this.totalKeyCount === 0)
+            return null;
+        const elapsedMinutes = (Date.now() - this.startTime) / 60000;
+        if (elapsedMinutes <= 0)
+            return null;
+        return (this.totalKeyCount / 5) / elapsedMinutes;
+    }
+    countQuickCorrections() {
+        let quickCorrections = 0;
+        for (let i = 1; i < this.keyHistory.length; i++) {
+            const isCorrective = this.keyHistory[i].key === 'Backspace' || this.keyHistory[i].key === 'Delete';
+            if (isCorrective && (this.keyHistory[i].pressTime - this.keyHistory[i - 1].releaseTime < 500)) {
+                quickCorrections++;
+            }
+        }
+        return quickCorrections;
+    }
+}
+exports.KeyboardMetrics = KeyboardMetrics;