content-security-toolkit 1.0.0 → 1.0.1

package/dist/strategies/DevToolsStrategy-simple.js

@@ -1,366 +0,0 @@
-import { isBrowser, getBrowser } from "../utils/detection";
-import { ProtectedContentManager } from "../utils/protectedContentManager";
-import { SecurityOverlayManager } from "../utils/securityOverlayManager";
-import { intervalManager } from "../utils/intervalManager";
-import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
-import { DebuggerDetector } from "../utils/detectors/debuggerDetector";
-import { TimingDetector } from "../utils/detectors/timingDetector";
-import { DateToStringDetector } from "../utils/detectors/dateToStringDetector";
-/**
- * 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;
-        // Detectors
-        this.debuggerDetector = null;
-        this.timingDetector = null;
-        this.dateToStringDetector = null;
-        this.activeDetector = null;
-        this.options = {
-            overlayOptions: {
-                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)",
-            },
-            showOverlay: true,
-            checkFrequency: 1000,
-            hideContent: false,
-            ...options,
-        };
-        this.targetElement = targetElement;
-        this.customHandler = customHandler;
-        this.browserInfo = getBrowser();
-        // 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);
-        this.log("Detected browser:", this.browserInfo.name, this.browserInfo.version);
-        // Initialize the appropriate detector based on browser
-        this.initDetectors();
-    }
-    /**
-     * Initialize the appropriate detector based on browser
-     */
-    initDetectors() {
-        return this.safeExecute("initDetectors", StrategyErrorType.INITIALIZATION, () => {
-            if (!isBrowser())
-                return;
-            try {
-                // Common callback for all detectors
-                const onDevToolsChange = (isOpen) => {
-                    this.handleDevToolsStateChange(isOpen);
-                };
-                // Initialize the debugger detector (for Chrome and Edge)
-                this.debuggerDetector = new DebuggerDetector({
-                    timeoutDuration: 50, // 50ms timeout for detection
-                    onDevToolsChange,
-                    debugMode: this.debugMode,
-                });
-                // Initialize the timing detector (for Firefox)
-                this.timingDetector = new TimingDetector({
-                    onDevToolsChange,
-                    debugMode: this.debugMode,
-                    thresholdMultiplier: 4, // Adjust sensitivity
-                });
-                // Initialize the date-to-string detector (for Safari and fallback)
-                if (DateToStringDetector.isSupported()) {
-                    this.dateToStringDetector = new DateToStringDetector({
-                        onDevToolsChange,
-                        debugMode: this.debugMode,
-                        threshold: 2, // Default threshold
-                    });
-                }
-                // Set the active detector based on browser
-                if (this.browserInfo.name === "firefox") {
-                    this.activeDetector = this.timingDetector;
-                    this.log("Using TimingDetector for Firefox");
-                }
-                else if (this.browserInfo.name === "safari") {
-                    if (this.dateToStringDetector) {
-                        this.activeDetector = this.dateToStringDetector;
-                        this.log("Using DateToStringDetector for Safari");
-                    }
-                    else {
-                        this.activeDetector = this.debuggerDetector;
-                        this.log("Using DebuggerDetector for Safari (fallback)");
-                    }
-                }
-                else {
-                    this.activeDetector = this.debuggerDetector;
-                    this.log("Using DebuggerDetector for", this.browserInfo.name);
-                }
-                this.log("Detectors initialized");
-            }
-            catch (error) {
-                this.handleError(StrategyErrorType.INITIALIZATION, "Failed to initialize detectors", error);
-                // Log more details about the error to help with troubleshooting
-                if (this.debugMode) {
-                    console.error("Detector initialization error details:", error);
-                }
-            }
-        });
-    }
-    /**
-     * Handle DevTools state changes from any detection method
-     */
-    handleDevToolsStateChange(isOpen) {
-        return this.safeExecute("handleDevToolsStateChange", StrategyErrorType.APPLICATION, () => {
-            // Only take action if state has changed
-            if (isOpen !== this.isDevToolsOpen) {
-                this.isDevToolsOpen = isOpen;
-                this.log(`DevTools state changed: ${isOpen ? "open" : "closed"}`);
-                if (isOpen) {
-                    this.applyDevToolsProtection();
-                }
-                else {
-                    this.removeDevToolsProtection();
-                }
-                // Call custom handler if provided
-                if (this.customHandler) {
-                    this.customHandler(isOpen);
-                }
-            }
-        });
-    }
-    /**
-     * Start monitoring for DevTools usage
-     */
-    startMonitoring() {
-        return this.safeExecute("startMonitoring", StrategyErrorType.APPLICATION, () => {
-            if (typeof window === "undefined")
-                return;
-            this.log("Starting DevTools monitoring");
-            // Register with IntervalManager for periodic checks
-            this.taskId = intervalManager.registerTask("devtools-detection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
-                // Use the active detector
-                if (this.activeDetector) {
-                    this.activeDetector.checkDevTools();
-                }
-                // Always check overlay state if DevTools are open
-                if (this.isDevToolsOpen) {
-                    this.overlayManager.checkAndRestoreOverlay();
-                }
-            }), this.options.checkFrequency);
-            // Force initial check
-            if (this.activeDetector) {
-                this.activeDetector.checkDevTools();
-            }
-        });
-    }
-    /**
-     * Apply DevTools protection by creating overlay and event blocker
-     */
-    applyDevToolsProtection() {
-        return this.safeExecute("applyDevToolsProtection", StrategyErrorType.APPLICATION, () => {
-            if (!isBrowser())
-                return;
-            if (this.options.hideContent) {
-                // Hide sensitive content
-                this.hideSensitiveContent();
-            }
-            if (this.options.showOverlay) {
-                // Create overlay using the overlay manager
-                this.overlayManager.showOverlay({
-                    ...this.options.overlayOptions,
-                    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.overlayOptions?.title,
-                message: this.options.overlayOptions?.message,
-                secondaryMessage: this.options.overlayOptions?.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;
-            if (this.options.hideContent) {
-                // Restore sensitive content
-                this.restoreSensitiveContent();
-            }
-            if (this.options.showOverlay) {
-                // 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;
-            }
-            // Clean up the detectors
-            if (this.debuggerDetector) {
-                this.debuggerDetector.dispose();
-                this.debuggerDetector = null;
-            }
-            if (this.timingDetector) {
-                this.timingDetector.dispose();
-                this.timingDetector = null;
-            }
-            if (this.dateToStringDetector) {
-                this.dateToStringDetector.dispose();
-                this.dateToStringDetector = null;
-            }
-            this.activeDetector = null;
-            // 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();
-            // Remove protections
-            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.overlayOptions?.title !== this.options.overlayOptions?.title ||
-                    previousOptions.overlayOptions?.message !== this.options.overlayOptions?.message ||
-                    previousOptions.overlayOptions?.secondaryMessage !== this.options.overlayOptions?.secondaryMessage ||
-                    previousOptions.overlayOptions?.backgroundColor !== this.options.overlayOptions?.backgroundColor ||
-                    previousOptions.overlayOptions?.textColor !== this.options.overlayOptions?.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, () => {
-                    // Use active detector
-                    if (this.activeDetector) {
-                        this.activeDetector.checkDevTools();
-                    }
-                    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);
-            // Update debug mode for the detectors
-            if (this.debuggerDetector) {
-                this.debuggerDetector.setDebugMode(enabled);
-            }
-            if (this.timingDetector) {
-                this.timingDetector.setDebugMode(enabled);
-            }
-            if (this.dateToStringDetector) {
-                this.dateToStringDetector.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);
-        });
-    }
-}

package/dist/strategies/StrategyRegistry.d.ts

@@ -1,133 +0,0 @@
-import type { ProtectionStrategy } from "../types";
-import type { MediatorAware, ProtectionMediator } from "../core/mediator/types";
-/**
- * Error types for strategy operations
- */
-export declare enum StrategyErrorType {
-    REGISTRATION_ERROR = "registration_error",
-    UNREGISTRATION_ERROR = "unregistration_error",
-    APPLICATION_ERROR = "application_error",
-    REMOVAL_ERROR = "removal_error",
-    INVALID_STRATEGY = "invalid_strategy",
-    STRATEGY_NOT_FOUND = "strategy_not_found",
-    STRATEGY_ALREADY_REGISTERED = "strategy_already_registered"
-}
-/**
- * Custom error class for strategy registry operations
- */
-export declare class StrategyRegistryError extends Error {
-    readonly errorType: StrategyErrorType;
-    readonly strategyId?: string | undefined;
-    readonly originalError?: Error | undefined;
-    constructor(errorType: StrategyErrorType, message: string, strategyId?: string | undefined, originalError?: Error | undefined);
-}
-export interface StrategyRegistryOptions {
-    debugMode?: boolean;
-}
-/**
- * Registry for managing protection strategies
- * Provides centralized access and lifecycle management
- */
-export declare class StrategyRegistry implements MediatorAware {
-    readonly COMPONENT_NAME = "StrategyRegistry";
-    private strategies;
-    private logger;
-    private mediator;
-    constructor(options?: StrategyRegistryOptions);
-    /**
-     * Set the mediator to communicate with other components
-     * @param mediator The protection mediator
-     */
-    setMediator(mediator: ProtectionMediator): void;
-    /**
-     * Register a strategy with the registry
-     * @param id Unique identifier for the strategy
-     * @param strategy Strategy instance
-     * @returns True if registration was successful
-     * @throws StrategyRegistryError if registration fails
-     */
-    register(id: string, strategy: ProtectionStrategy): boolean;
-    /**
-     * Unregister a strategy from the registry
-     * @param id Strategy ID to unregister
-     * @returns True if unregistration was successful
-     * @throws StrategyRegistryError if unregistration fails
-     */
-    unregister(id: string): boolean;
-    /**
-     * Get a strategy by ID
-     * @param id Strategy ID
-     * @returns The strategy instance or undefined if not found
-     */
-    getStrategy(id: string): ProtectionStrategy | undefined;
-    /**
-     * Check if a strategy is registered
-     * @param id Strategy ID
-     * @returns True if the strategy is registered
-     */
-    hasStrategy(id: string): boolean;
-    /**
-     * Apply a specific strategy
-     * @param id Strategy ID to apply
-     * @returns True if the strategy was applied successfully
-     * @throws StrategyRegistryError if application fails
-     */
-    applyStrategy(id: string): boolean;
-    /**
-     * Apply all registered strategies
-     * @returns Array of strategy IDs that failed to apply
-     */
-    applyAllStrategies(): string[];
-    /**
-     * Remove a specific strategy
-     * @param id Strategy ID to remove
-     * @returns True if removal was successful
-     * @throws StrategyRegistryError if removal fails
-     */
-    removeStrategy(id: string): boolean;
-    /**
-     * Remove all registered strategies
-     * @returns Array of strategy IDs that failed to remove
-     */
-    removeAllStrategies(): string[];
-    /**
-     * Get all registered strategy IDs
-     * @returns Array of strategy IDs
-     */
-    getStrategyIds(): string[];
-    /**
-     * Get all registered strategies
-     * @returns Map of strategy IDs to strategy instances
-     */
-    getAllStrategies(): Map<string, ProtectionStrategy>;
-    /**
-     * Get all applied strategies
-     * @returns Array of strategy IDs that are currently applied
-     */
-    getAppliedStrategies(): string[];
-    /**
-     * Set debug mode for all strategies that support it
-     * @param enabled Whether debug mode should be enabled
-     */
-    setDebugMode(enabled: boolean): void;
-    /**
-     * Clear the registry (remove all strategies first)
-     */
-    clear(): void;
-    /**
-     * Publish a strategy applied event through the mediator
-     * @param strategyId ID of the strategy that was applied
-     */
-    private publishStrategyAppliedEvent;
-    /**
-     * Publish a strategy removed event through the mediator
-     * @param strategyId ID of the strategy that was removed
-     */
-    private publishStrategyRemovedEvent;
-    /**
-     * Publish an error event through the mediator
-     * @param strategyId ID of the strategy that had an error
-     * @param error The error that occurred
-     */
-    private publishErrorEvent;
-}