@axeptio/behavior-detection 1.0.2 → 1.0.3

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@axeptio/behavior-detection",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Lightweight behavior detection library to assess human likelihood of user sessions",
-  "main": "./dist/cjs/index.js",
+  "type": "module",
+  "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.cjs"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "npm run build:cjs && npm run build:esm && npm run build:types",
-    "build:cjs": "tsc --module commonjs --outDir dist/cjs",
+    "build": "npm run build:esm && npm run build:cjs && npm run build:types",
+    "build:cjs": "esbuild dist/esm/index.js --bundle --format=cjs --platform=node --target=es2017 --outfile=dist/cjs/index.cjs",
     "build:esm": "tsc --module es2015 --outDir dist/esm",
     "build:types": "tsc --declaration --emitDeclarationOnly --outDir dist",
     "build:bundle": "npm run build:esm && esbuild dist/esm/index.js --bundle --minify --sourcemap --target=es2020 --tree-shaking=true --outfile=dist/behavior-detection.esm.min.js",
@@ -25,19 +26,19 @@
     "build:browser:dev": "npm run build:esm && esbuild dist/esm/browser.js --bundle --minify --sourcemap --format=iife --global-name=BehaviorDetector --target=es2020 --tree-shaking=true --outfile=dist/behavior-detection.min.js",
     "build:all": "npm run build && npm run build:bundle && npm run build:browser",
     "clean": "rm -rf dist",
-    "deploy": "node scripts/deploy.js",
+    "deploy": "node scripts/deploy.cjs",
     "release:patch": "npm version patch && git push && git push --tags",
     "release:minor": "npm version minor && git push && git push --tags",
     "release:major": "npm version major && git push && git push --tags",
-    "tryme": "npm run build && node scripts/serve.js",
-    "test": "npm run build && node tests/adversarial/run-tests.js",
-    "test:adversarial": "npm run build && node tests/adversarial/run-all.js",
-    "test:playwright": "npm run build && node tests/adversarial/playwright-test.js",
-    "test:selenium": "npm run build && node tests/adversarial/selenium-test.js",
-    "test:puppeteer": "npm run build && node tests/adversarial/puppeteer-test.js",
-    "test:stress": "npm run build && node tests/adversarial/detector-stress-test.js",
-    "test:stress:quick": "npm run build && node tests/adversarial/detector-stress-test.js --cycles=3 --duration=5000",
-    "test:stress:intense": "npm run build && node tests/adversarial/detector-stress-test.js --cycles=10 --duration=20000"
+    "tryme": "npm run build && node scripts/serve.cjs",
+    "test": "npm run build && node tests/adversarial/run-tests.cjs",
+    "test:adversarial": "npm run build && node tests/adversarial/run-all.cjs",
+    "test:playwright": "npm run build && node tests/adversarial/playwright-test.cjs",
+    "test:selenium": "npm run build && node tests/adversarial/selenium-test.cjs",
+    "test:puppeteer": "npm run build && node tests/adversarial/puppeteer-test.cjs",
+    "test:stress": "npm run build && node tests/adversarial/detector-stress-test.cjs",
+    "test:stress:quick": "npm run build && node tests/adversarial/detector-stress-test.cjs --cycles=3 --duration=5000",
+    "test:stress:intense": "npm run build && node tests/adversarial/detector-stress-test.cjs --cycles=10 --duration=20000"
   },
   "keywords": [
     "behavior-detection",

package/dist/cjs/behavior-detector.d.ts

@@ -1,102 +0,0 @@
-import type { ScoreOptions, ScoreResult } from './types.js';
-import type { DetectionStrategy, StrategyConfig, TickOptions } from './strategy.js';
-/**
- * Main class for behavior detection
- * Uses modular strategy pattern for tree-shakeable, autonomous detection modules
- */
-export declare class BehaviorDetector {
-    private strategies;
-    private isTracking;
-    private isPausedByVisibility;
-    private tickInterval;
-    private tickIntervalMs;
-    private pauseOnHidden;
-    private visibilityChangeHandler;
-    private confidenceScore;
-    private readonly CONFIDENCE_TARGET;
-    private readonly CONFIDENCE_DECAY;
-    constructor(tickOptions?: TickOptions);
-    /**
-     * Add a detection strategy
-     */
-    addStrategy(strategy: DetectionStrategy, weight?: number): this;
-    /**
-     * Handle event from strategy - update confidence
-     */
-    private onStrategyEvent;
-    /**
-     * Remove a detection strategy
-     */
-    removeStrategy(name: string): this;
-    /**
-     * Enable/disable a strategy
-     */
-    setStrategyEnabled(name: string, enabled: boolean): this;
-    /**
-     * Get all registered strategies
-     */
-    getStrategies(): ReadonlyMap<string, StrategyConfig>;
-    /**
-     * Start tracking
-     */
-    start(): void;
-    /**
-     * Stop tracking
-     */
-    stop(): void;
-    /**
-     * Reset all data
-     */
-    reset(): void;
-    /**
-     * Calculate human likelihood score
-     */
-    score(options?: ScoreOptions): Promise<ScoreResult>;
-    /**
-     * Check if currently tracking
-     */
-    isActive(): boolean;
-    /**
-     * Check if currently paused due to tab visibility
-     */
-    isPaused(): boolean;
-    /**
-     * Get event count from all strategies
-     */
-    getEventCount(): Record<string, number>;
-    /**
-     * Get debug info from all strategies
-     */
-    getStrategyDebugInfo(): Record<string, any>;
-    /**
-     * Get current confidence score (0-1)
-     * Represents how much interaction data we've collected
-     * Higher confidence = more reliable classification
-     */
-    getConfidence(): number;
-    /**
-     * Check if confidence is above threshold for reliable classification
-     * @param threshold - Minimum confidence (0-1), default 0.3
-     */
-    hasConfidentData(threshold?: number): boolean;
-    /**
-     * Cleanup resources
-     */
-    destroy(): void;
-    /**
-     * Handle visibility change events
-     */
-    private handleVisibilityChange;
-    /**
-     * Start tick mechanism for strategies
-     */
-    private startTick;
-    /**
-     * Stop tick mechanism
-     */
-    private stopTick;
-    /**
-     * Calculate score using strategies
-     */
-    private calculateStrategyScore;
-}

package/dist/cjs/behavior-detector.js

@@ -1,315 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BehaviorDetector = void 0;
-/**
- * Main class for behavior detection
- * Uses modular strategy pattern for tree-shakeable, autonomous detection modules
- */
-class BehaviorDetector {
-    constructor(tickOptions) {
-        // Strategy mode
-        this.strategies = new Map();
-        this.isTracking = false;
-        this.isPausedByVisibility = false;
-        this.tickInterval = null;
-        this.tickIntervalMs = 1000; // Default: 1 second
-        this.pauseOnHidden = true;
-        this.visibilityChangeHandler = null;
-        // Confidence tracking
-        this.confidenceScore = 0;
-        this.CONFIDENCE_TARGET = 1.0; // Target confidence for reliable classification
-        this.CONFIDENCE_DECAY = 0.95; // Per event decay to prevent infinite growth
-        if (tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.interval) {
-            this.tickIntervalMs = tickOptions.interval;
-        }
-        if ((tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.pauseOnHidden) !== undefined) {
-            this.pauseOnHidden = tickOptions.pauseOnHidden;
-        }
-    }
-    /**
-     * Add a detection strategy
-     */
-    addStrategy(strategy, weight) {
-        const config = {
-            strategy,
-            weight: weight !== null && weight !== void 0 ? weight : strategy.defaultWeight,
-            enabled: true,
-        };
-        this.strategies.set(strategy.name, config);
-        // Set up event callback for confidence tracking
-        if (strategy.setEventCallback) {
-            strategy.setEventCallback((event) => {
-                this.onStrategyEvent(event, config.weight);
-            });
-        }
-        // If already tracking, start this strategy immediately
-        if (this.isTracking) {
-            strategy.start();
-        }
-        return this;
-    }
-    /**
-     * Handle event from strategy - update confidence
-     */
-    onStrategyEvent(event, strategyWeight) {
-        // Apply decay to existing confidence to prevent infinite growth
-        this.confidenceScore *= this.CONFIDENCE_DECAY;
-        // Add weighted contribution from this event
-        // eventWeight (0-1) * strategyWeight (e.g. 0.3 for mouse) = contribution
-        const contribution = event.weight * strategyWeight;
-        this.confidenceScore = Math.min(this.CONFIDENCE_TARGET, this.confidenceScore + contribution);
-    }
-    /**
-     * Remove a detection strategy
-     */
-    removeStrategy(name) {
-        const config = this.strategies.get(name);
-        if (config) {
-            if (this.isTracking) {
-                config.strategy.stop();
-            }
-            this.strategies.delete(name);
-        }
-        return this;
-    }
-    /**
-     * Enable/disable a strategy
-     */
-    setStrategyEnabled(name, enabled) {
-        const config = this.strategies.get(name);
-        if (config) {
-            config.enabled = enabled;
-            // If tracking and being disabled, stop it
-            if (!enabled && this.isTracking) {
-                config.strategy.stop();
-            }
-            // If tracking and being enabled, start it
-            if (enabled && this.isTracking) {
-                config.strategy.start();
-            }
-        }
-        return this;
-    }
-    /**
-     * Get all registered strategies
-     */
-    getStrategies() {
-        return this.strategies;
-    }
-    /**
-     * Start tracking
-     */
-    start() {
-        if (this.isTracking)
-            return;
-        this.isTracking = true;
-        // Set up visibility change listener
-        if (this.pauseOnHidden && typeof document !== 'undefined') {
-            this.visibilityChangeHandler = this.handleVisibilityChange.bind(this);
-            document.addEventListener('visibilitychange', this.visibilityChangeHandler);
-            // Check initial visibility state
-            if (document.hidden) {
-                this.isPausedByVisibility = true;
-                return; // Don't start strategies if already hidden
-            }
-        }
-        // Start all enabled strategies
-        for (const [_, config] of this.strategies) {
-            if (config.enabled) {
-                config.strategy.start();
-            }
-        }
-        // Start tick mechanism
-        this.startTick();
-    }
-    /**
-     * Stop tracking
-     */
-    stop() {
-        if (!this.isTracking)
-            return;
-        this.isTracking = false;
-        this.isPausedByVisibility = false;
-        // Remove visibility change listener
-        if (this.visibilityChangeHandler && typeof document !== 'undefined') {
-            document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
-            this.visibilityChangeHandler = null;
-        }
-        // Stop all strategies
-        for (const [_, config] of this.strategies) {
-            config.strategy.stop();
-        }
-        // Stop tick
-        this.stopTick();
-    }
-    /**
-     * Reset all data
-     */
-    reset() {
-        this.confidenceScore = 0;
-        for (const [_, config] of this.strategies) {
-            config.strategy.reset();
-        }
-    }
-    /**
-     * Calculate human likelihood score
-     */
-    async score(options = {}) {
-        const breakdown = this.calculateStrategyScore();
-        const result = {
-            score: breakdown.overall,
-        };
-        if (options.breakdown) {
-            result.breakdown = breakdown;
-        }
-        // Note: auditTrail not available in strategy mode
-        // Each strategy manages its own data independently
-        return result;
-    }
-    /**
-     * Check if currently tracking
-     */
-    isActive() {
-        return this.isTracking;
-    }
-    /**
-     * Check if currently paused due to tab visibility
-     */
-    isPaused() {
-        return this.isPausedByVisibility;
-    }
-    /**
-     * Get event count from all strategies
-     */
-    getEventCount() {
-        var _a, _b;
-        const counts = {};
-        for (const [name, config] of this.strategies) {
-            const debug = (_b = (_a = config.strategy).getDebugInfo) === null || _b === void 0 ? void 0 : _b.call(_a);
-            if ((debug === null || debug === void 0 ? void 0 : debug.eventCount) !== undefined) {
-                counts[name] = debug.eventCount;
-            }
-        }
-        return counts;
-    }
-    /**
-     * Get debug info from all strategies
-     */
-    getStrategyDebugInfo() {
-        const debug = {};
-        for (const [name, config] of this.strategies) {
-            if (config.strategy.getDebugInfo) {
-                debug[name] = config.strategy.getDebugInfo();
-            }
-        }
-        return debug;
-    }
-    /**
-     * Get current confidence score (0-1)
-     * Represents how much interaction data we've collected
-     * Higher confidence = more reliable classification
-     */
-    getConfidence() {
-        return Math.min(1, this.confidenceScore);
-    }
-    /**
-     * Check if confidence is above threshold for reliable classification
-     * @param threshold - Minimum confidence (0-1), default 0.3
-     */
-    hasConfidentData(threshold = 0.3) {
-        return this.getConfidence() >= threshold;
-    }
-    /**
-     * Cleanup resources
-     */
-    destroy() {
-        this.stop();
-        this.strategies.clear();
-    }
-    /**
-     * Handle visibility change events
-     */
-    handleVisibilityChange() {
-        if (!this.isTracking)
-            return;
-        if (document.hidden) {
-            // Tab became hidden - pause detection
-            if (!this.isPausedByVisibility) {
-                this.isPausedByVisibility = true;
-                // Stop all strategies
-                for (const [_, config] of this.strategies) {
-                    if (config.enabled) {
-                        config.strategy.stop();
-                    }
-                }
-                // Stop tick
-                this.stopTick();
-            }
-        }
-        else {
-            // Tab became visible - resume detection
-            if (this.isPausedByVisibility) {
-                this.isPausedByVisibility = false;
-                // Restart all enabled strategies
-                for (const [_, config] of this.strategies) {
-                    if (config.enabled) {
-                        config.strategy.start();
-                    }
-                }
-                // Restart tick
-                this.startTick();
-            }
-        }
-    }
-    /**
-     * Start tick mechanism for strategies
-     */
-    startTick() {
-        if (this.tickInterval !== null)
-            return;
-        this.tickInterval = window.setInterval(() => {
-            const now = Date.now();
-            for (const [_, config] of this.strategies) {
-                if (config.enabled && config.strategy.onTick) {
-                    config.strategy.onTick(now);
-                }
-            }
-        }, this.tickIntervalMs);
-    }
-    /**
-     * Stop tick mechanism
-     */
-    stopTick() {
-        if (this.tickInterval !== null) {
-            clearInterval(this.tickInterval);
-            this.tickInterval = null;
-        }
-    }
-    /**
-     * Calculate score using strategies
-     */
-    calculateStrategyScore() {
-        const factors = {};
-        const weights = {};
-        let totalWeight = 0;
-        let weightedSum = 0;
-        for (const [name, config] of this.strategies) {
-            if (!config.enabled)
-                continue;
-            const score = config.strategy.score();
-            factors[name] = score;
-            weights[name] = config.weight;
-            if (score !== undefined && score !== null) {
-                totalWeight += config.weight;
-                weightedSum += score * config.weight;
-            }
-        }
-        const overall = totalWeight > 0 ? weightedSum / totalWeight : 0.5;
-        return {
-            overall: Math.max(0, Math.min(1, overall)),
-            factors,
-            weights,
-        };
-    }
-}
-exports.BehaviorDetector = BehaviorDetector;

package/dist/cjs/browser.d.ts

@@ -1,33 +0,0 @@
-/**
- * Browser Build - Auto-initializing standalone bundle for CDN usage
- *
- * Usage:
- * <script src="https://cdn.../behavior-detector.js"></script>
- * <script>
- * window.bdSettings = {
- *   strategies: {
- *     mouse: { weight: 0.3 },
- *     scroll: { weight: 0.15 },
- *     click: { weight: 0.3 },
- *     keyboard: { weight: 0.1 },
- *     environment: { weight: 0.08 },
- *     resize: { weight: 0.02 }
- *   },
- *   autoStart: true,
- *   checkMs: 2000,
- *   pauseOnHidden: true,  // Auto-pause when tab hidden (default: true)
- *   onScore: (result) => {
- *     console.log('Human likelihood:', result.score);
- *     if (result.score < 0.3) {
- *       // Likely bot
- *     }
- *   },
- *   ifBot: (result) => {
- *     // Called when score < threshold
- *     console.warn('Bot detected:', result);
- *   },
- *   botThreshold: 0.3
- * }
- * </script>
- */
-export {};