content-security-toolkit 1.0.0 → 1.0.1

package/dist/strategies/DevToolsStrategy copy.js

@@ -1,362 +0,0 @@
-import { isBrowser } from "../utils/detection";
-import { getOrientationType } from "../utils/orientation";
-import { ProtectedContentManager } from "../utils/protectedContentManager";
-import { SecurityOverlayManager } from "../utils/securityOverlayManager";
-import { intervalManager } from "../utils/intervalManager";
-import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
-/**
- * Strategy for detecting and responding to DevTools usage
- */
-export class DevToolsStrategy extends AbstractStrategy {
-    /**
-     * Create a new DevToolsStrategy
-     * @param options Options for customizing the DevTools protection
-     * @param targetElement Element containing sensitive content
-     * @param customHandler Optional custom handler for DevTools detection
-     * @param debugMode Enable debug mode for troubleshooting
-     */
-    constructor(options, targetElement = null, customHandler, debugMode = false) {
-        super("DevToolsStrategy", debugMode);
-        this.intervalId = null;
-        this.taskId = null;
-        this.isDevToolsOpen = false;
-        this.targetElement = null;
-        this.contentManager = null;
-        this.resizeEventId = "";
-        // Store dimensions
-        this.originalWidth = 0;
-        this.originalHeight = 0;
-        // Track orientation
-        this.previousOrientation = null;
-        this.options = {
-            title: "Developer Tools Detected",
-            message: "For security reasons, this content is not available while developer tools are open.",
-            secondaryMessage: "Please close developer tools to continue viewing this content.",
-            textColor: "white",
-            backgroundColor: "rgba(255, 0, 0, 0.7)",
-            checkFrequency: 1000,
-            ...options,
-        };
-        this.targetElement = targetElement;
-        this.customHandler = customHandler;
-        this.resizeHandler = this.handleResize.bind(this);
-        // Initialize content manager if target element is provided
-        if (targetElement) {
-            this.contentManager = new ProtectedContentManager(targetElement, debugMode);
-        }
-        // Initialize overlay manager
-        this.overlayManager = new SecurityOverlayManager(debugMode);
-        this.log("Initialized with checkFrequency:", this.options.checkFrequency);
-    }
-    /**
-     * Detect if DevTools is open based on window dimensions
-     * @returns True if DevTools is likely open, false otherwise
-     */
-    detectDevTools() {
-        return (this.safeExecute("detectDevTools", StrategyErrorType.APPLICATION, () => {
-            if (typeof window === "undefined")
-                return false;
-            const currentWidth = window.innerWidth;
-            const currentHeight = window.innerHeight;
-            const currentOrientation = getOrientationType();
-            this.log(`Current dimensions: ${currentWidth}x${currentHeight}, original: ${this.originalWidth}x${this.originalHeight}`);
-            this.log(`Current orientation: ${currentOrientation}, previous: ${this.previousOrientation}`);
-            // Calculate differences
-            const widthDifference = currentWidth - this.originalWidth;
-            const heightDifference = currentHeight - this.originalHeight;
-            // Check if orientation has changed
-            const orientationChanged = this.previousOrientation !== null && this.previousOrientation !== currentOrientation;
-            // If orientation has changed, update our reference dimensions
-            if (orientationChanged) {
-                this.log(`Orientation changed from ${this.previousOrientation} to ${currentOrientation}`);
-                // Update the original dimensions to the current ones when orientation changes
-                this.originalWidth = currentWidth;
-                this.originalHeight = currentHeight;
-                // Update previous orientation
-                this.previousOrientation = currentOrientation;
-                // Don't trigger DevTools detection on orientation change
-                return false;
-            }
-            // Only consider DevTools open if dimensions get smaller (with a small tolerance)
-            // This prevents false positives when closing DevTools that were open on page load
-            if (widthDifference < -20 || heightDifference < -20) {
-                // If dimensions are significantly smaller, DevTools is likely open
-                this.log("Significant size reduction detected, DevTools likely open");
-                return true;
-            }
-            else {
-                // If dimensions are larger or about the same, DevTools is likely closed
-                // Update the original dimensions to the current ones if they're larger
-                // This ensures we always compare against the largest known viewport size
-                if (currentWidth > this.originalWidth) {
-                    this.originalWidth = currentWidth;
-                }
-                if (currentHeight > this.originalHeight) {
-                    this.originalHeight = currentHeight;
-                }
-                return false;
-            }
-        }) || false); // Return false as fallback if error occurs
-    }
-    /**
-     * Handle window resize events to detect DevTools
-     */
-    handleResize() {
-        return this.safeExecute("handleResize", StrategyErrorType.EVENT_HANDLING, () => {
-            const devToolsOpen = this.detectDevTools();
-            this.log("Resize handler called, devToolsOpen:", devToolsOpen, "current state:", this.isDevToolsOpen);
-            // Update state and take action if state has changed
-            if (devToolsOpen !== this.isDevToolsOpen) {
-                this.isDevToolsOpen = devToolsOpen;
-                this.log(`DevTools state changed: ${devToolsOpen ? "open" : "closed"}`);
-                if (devToolsOpen) {
-                    this.applyDevToolsProtection();
-                }
-                else {
-                    this.removeDevToolsProtection();
-                }
-                // Call custom handler if provided
-                if (this.customHandler) {
-                    this.customHandler(devToolsOpen);
-                }
-            }
-        });
-    }
-    /**
-     * Start monitoring for DevTools usage
-     */
-    startMonitoring() {
-        return this.safeExecute("startMonitoring", StrategyErrorType.APPLICATION, () => {
-            if (typeof window === "undefined")
-                return;
-            this.log("Starting DevTools monitoring");
-            // Store initial dimensions
-            this.originalWidth = window.innerWidth;
-            this.originalHeight = window.innerHeight;
-            // Store initial orientation
-            this.previousOrientation = getOrientationType();
-            this.log(`Initial dimensions: ${this.originalWidth}x${this.originalHeight}`);
-            this.log(`Initial orientation: ${this.previousOrientation}`);
-            // Add resize event listener using our registerEvent method
-            this.resizeEventId = this.registerEvent(window, "resize", this.resizeHandler, { priority: 10 });
-            // Register with IntervalManager for periodic checks
-            this.taskId = intervalManager.registerTask("devtools-detection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
-                const devToolsOpen = this.detectDevTools();
-                // Force state update and action if state has changed
-                if (devToolsOpen !== this.isDevToolsOpen) {
-                    this.isDevToolsOpen = devToolsOpen;
-                    this.log(`DevTools state changed: ${devToolsOpen ? "open" : "closed"}`);
-                    if (devToolsOpen) {
-                        this.applyDevToolsProtection();
-                    }
-                    else {
-                        this.removeDevToolsProtection();
-                    }
-                    if (this.customHandler) {
-                        this.customHandler(devToolsOpen);
-                    }
-                }
-                // Always check overlay state through the overlay manager
-                if (this.isDevToolsOpen) {
-                    this.overlayManager.checkAndRestoreOverlay();
-                }
-            }), this.options.checkFrequency);
-            // Force initial check
-            this.handleResize();
-        });
-    }
-    /**
-     * Apply DevTools protection by creating overlay and event blocker
-     */
-    applyDevToolsProtection() {
-        return this.safeExecute("applyDevToolsProtection", StrategyErrorType.APPLICATION, () => {
-            if (!isBrowser())
-                return;
-            // Hide sensitive content
-            this.hideSensitiveContent();
-            // Create overlay using the overlay manager
-            this.overlayManager.showOverlay({
-                title: this.options.title,
-                message: this.options.message,
-                secondaryMessage: this.options.secondaryMessage,
-                backgroundColor: this.options.backgroundColor,
-                textColor: this.options.textColor,
-                blockEvents: true, // Block all events
-                autoRestore: true, // Restore overlay if removed from DOM
-            });
-            this.log("DevTools protection applied");
-        });
-    }
-    /**
-     * Hide sensitive content when DevTools is open
-     */
-    hideSensitiveContent() {
-        return this.safeExecute("hideSensitiveContent", StrategyErrorType.APPLICATION, () => {
-            if (!this.targetElement || !this.contentManager)
-                return;
-            this.contentManager.hideContent({
-                title: this.options.title,
-                message: this.options.message,
-                secondaryMessage: this.options.secondaryMessage,
-                textColor: "black",
-                backgroundColor: "rgba(0, 0, 0, 0.05)",
-            });
-            this.log("Sensitive content hidden");
-        });
-    }
-    /**
-     * Restore sensitive content when DevTools is closed
-     */
-    restoreSensitiveContent() {
-        return this.safeExecute("restoreSensitiveContent", StrategyErrorType.REMOVAL, () => {
-            if (!this.contentManager)
-                return;
-            this.contentManager.restoreContent();
-            this.log("Sensitive content restored");
-        });
-    }
-    /**
-     * Remove DevTools protection
-     */
-    removeDevToolsProtection() {
-        return this.safeExecute("removeDevToolsProtection", StrategyErrorType.REMOVAL, () => {
-            if (typeof document === "undefined")
-                return;
-            // Restore sensitive content
-            this.restoreSensitiveContent();
-            // Remove overlay using the overlay manager
-            this.overlayManager.removeOverlay();
-            this.log("DevTools protection removed");
-        });
-    }
-    /**
-     * Apply the protection strategy
-     */
-    apply() {
-        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
-            if (this.isAppliedFlag) {
-                this.log("Protection already applied");
-                return;
-            }
-            this.startMonitoring();
-            this.isAppliedFlag = true;
-            this.log("Protection applied");
-        });
-    }
-    /**
-     * Remove the protection strategy
-     * Override the base implementation to handle additional cleanup
-     */
-    remove() {
-        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
-            if (!this.isAppliedFlag) {
-                this.log("Protection not applied");
-                return;
-            }
-            // Clear interval via IntervalManager
-            if (this.taskId !== null) {
-                intervalManager.unregisterTask(this.taskId);
-                this.taskId = null;
-                this.log("Interval task unregistered");
-            }
-            // Also clear the old interval for backwards compatibility or if both are used
-            if (this.intervalId !== null && typeof window !== "undefined") {
-                window.clearInterval(this.intervalId);
-                this.intervalId = null;
-                this.log("Legacy interval cleared");
-            }
-            // Call the parent class remove method to handle event cleanup
-            super.remove();
-            // Restore content if it was hidden
-            this.restoreSensitiveContent();
-            // Remove overlay and blocker
-            this.removeDevToolsProtection();
-            this.isAppliedFlag = false;
-            this.isDevToolsOpen = false;
-            this.log("Protection removed");
-        });
-    }
-    /**
-     * Update DevTools protection options
-     * @param options New options
-     */
-    updateOptions(options) {
-        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
-            const typedOptions = options;
-            this.log("Updating options", typedOptions);
-            // Store previous options for comparison
-            const previousOptions = { ...this.options };
-            this.options = {
-                ...this.options,
-                ...typedOptions,
-            };
-            // If protection is already applied, update the overlay if needed
-            if (this.isAppliedFlag && this.isDevToolsOpen) {
-                // Check if any visual options changed
-                const visualOptionsChanged = previousOptions.title !== this.options.title ||
-                    previousOptions.message !== this.options.message ||
-                    previousOptions.secondaryMessage !== this.options.secondaryMessage ||
-                    previousOptions.backgroundColor !== this.options.backgroundColor ||
-                    previousOptions.textColor !== this.options.textColor;
-                if (visualOptionsChanged) {
-                    this.removeDevToolsProtection();
-                    this.applyDevToolsProtection();
-                    this.log("Reapplied protection with updated visual options");
-                }
-            }
-            // Update check frequency if it changed
-            if (typedOptions.checkFrequency &&
-                this.taskId !== null &&
-                previousOptions.checkFrequency !== typedOptions.checkFrequency) {
-                // Unregister and re-register with new frequency
-                intervalManager.unregisterTask(this.taskId);
-                this.taskId = intervalManager.registerTask("devtools-detection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
-                    const devToolsOpen = this.detectDevTools();
-                    if (devToolsOpen !== this.isDevToolsOpen) {
-                        this.isDevToolsOpen = devToolsOpen;
-                        if (devToolsOpen) {
-                            this.applyDevToolsProtection();
-                        }
-                        else {
-                            this.removeDevToolsProtection();
-                        }
-                        if (this.customHandler) {
-                            this.customHandler(devToolsOpen);
-                        }
-                    }
-                    if (this.isDevToolsOpen) {
-                        this.overlayManager.checkAndRestoreOverlay();
-                    }
-                }), this.options.checkFrequency);
-                this.log(`Check frequency updated to ${this.options.checkFrequency}ms`);
-            }
-        });
-    }
-    /**
-     * Set debug mode
-     * @param enabled Whether debug mode should be enabled
-     */
-    setDebugMode(enabled) {
-        return this.safeExecute("setDebugMode", StrategyErrorType.OPTION_UPDATE, () => {
-            super.setDebugMode(enabled);
-            // Also update debug mode for managers
-            if (this.contentManager && this.targetElement) {
-                this.contentManager = new ProtectedContentManager(this.targetElement, enabled);
-            }
-            this.overlayManager = new SecurityOverlayManager(enabled);
-        });
-    }
-    /**
-     * Check if strategy is applied
-     */
-    isApplied() {
-        return this.isAppliedFlag;
-    }
-    /**
-     * Check if debug mode is enabled
-     * @returns True if debug mode is enabled
-     */
-    isDebugEnabled() {
-        return this.debugMode;
-    }
-}

package/dist/strategies/DevToolsStrategy-detectorManager.d.ts

@@ -1,70 +0,0 @@
-import type { CustomEventHandlers, DevToolsOptions } from "../types";
-import { AbstractStrategy } from "./AbstractStrategy";
-/**
- * Strategy for detecting and responding to DevTools usage
- */
-export declare class DevToolsStrategy extends AbstractStrategy {
-    private taskId;
-    private customHandler?;
-    private isDevToolsOpen;
-    private targetElement;
-    private options;
-    private contentManager;
-    private overlayManager;
-    private detectorManager;
-    /**
-     * Create a new DevToolsStrategy
-     * @param options Options for customizing the DevTools protection
-     * @param targetElement Element containing sensitive content
-     * @param customHandler Optional custom handler for DevTools detection
-     * @param debugMode Enable debug mode for troubleshooting
-     */
-    constructor(options?: DevToolsOptions, targetElement?: HTMLElement | null, customHandler?: CustomEventHandlers["onDevToolsOpen"], debugMode?: boolean);
-    /**
-     * Initialize the detector manager
-     */
-    private initDetectorManager;
-    /**
-     * Handle DevTools state changes from any detection method
-     */
-    private handleDevToolsStateChange;
-    /**
-     * Start monitoring for DevTools usage
-     */
-    private startMonitoring;
-    /**
-     * Apply DevTools protection by creating overlay and event blocker
-     */
-    private applyDevToolsProtection;
-    /**
-     * Hide sensitive content when DevTools is open
-     */
-    private hideSensitiveContent;
-    /**
-     * Restore sensitive content when DevTools is closed
-     */
-    private restoreSensitiveContent;
-    /**
-     * Remove DevTools protection
-     */
-    private removeDevToolsProtection;
-    /**
-     * Apply the protection strategy
-     */
-    apply(): void;
-    /**
-     * Remove the protection strategy
-     * Override the base implementation to handle additional cleanup
-     */
-    remove(): void;
-    /**
-     * Update DevTools protection options
-     * @param options New options
-     */
-    updateOptions(options: Record<string, unknown>): void;
-    /**
-     * Set debug mode
-     * @param enabled Whether debug mode should be enabled
-     */
-    setDebugMode(enabled: boolean): void;
-}