content-security-toolkit 1.0.1 → 1.0.2

package/dist/strategies/StrategyRegistry.js

@@ -0,0 +1,379 @@
+import { SimpleLoggingService } from "../utils/logging/simple/SimpleLoggingService";
+import { ProtectionEventType } from "../core/mediator/protection-event";
+/**
+ * Error types for strategy operations
+ */
+export var StrategyErrorType;
+(function (StrategyErrorType) {
+    StrategyErrorType["REGISTRATION_ERROR"] = "registration_error";
+    StrategyErrorType["UNREGISTRATION_ERROR"] = "unregistration_error";
+    StrategyErrorType["APPLICATION_ERROR"] = "application_error";
+    StrategyErrorType["REMOVAL_ERROR"] = "removal_error";
+    StrategyErrorType["INVALID_STRATEGY"] = "invalid_strategy";
+    StrategyErrorType["STRATEGY_NOT_FOUND"] = "strategy_not_found";
+    StrategyErrorType["STRATEGY_ALREADY_REGISTERED"] = "strategy_already_registered";
+})(StrategyErrorType || (StrategyErrorType = {}));
+/**
+ * Custom error class for strategy registry operations
+ */
+export class StrategyRegistryError extends Error {
+    constructor(errorType, message, strategyId, originalError) {
+        super(message);
+        this.errorType = errorType;
+        this.strategyId = strategyId;
+        this.originalError = originalError;
+        this.name = "StrategyRegistryError";
+        // Maintain the stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, StrategyRegistryError);
+        }
+    }
+}
+/**
+ * Registry for managing protection strategies
+ * Provides centralized access and lifecycle management
+ */
+export class StrategyRegistry {
+    constructor(options = {}) {
+        this.COMPONENT_NAME = "StrategyRegistry";
+        this.strategies = new Map();
+        this.mediator = null;
+        this.logger = new SimpleLoggingService(this.COMPONENT_NAME, !!options.debugMode);
+        this.logger.log("Initialized");
+    }
+    /**
+     * Set the mediator to communicate with other components
+     * @param mediator The protection mediator
+     */
+    setMediator(mediator) {
+        this.mediator = mediator;
+        this.logger.log("Mediator set");
+    }
+    /**
+     * 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, strategy) {
+        try {
+            // Validate inputs
+            if (!id) {
+                throw new StrategyRegistryError(StrategyErrorType.INVALID_STRATEGY, "Strategy ID cannot be empty");
+            }
+            if (!strategy) {
+                throw new StrategyRegistryError(StrategyErrorType.INVALID_STRATEGY, `Strategy instance for "${id}" is invalid`, id);
+            }
+            if (this.strategies.has(id)) {
+                throw new StrategyRegistryError(StrategyErrorType.STRATEGY_ALREADY_REGISTERED, `Strategy with ID "${id}" is already registered`, id);
+            }
+            // Set mediator on the strategy if it's mediator-aware
+            if (this.mediator && 'setMediator' in strategy) {
+                strategy.setMediator(this.mediator);
+            }
+            // Register the strategy
+            this.strategies.set(id, strategy);
+            this.logger.log(`Registered strategy "${id}"`);
+            return true;
+        }
+        catch (error) {
+            // Handle errors
+            if (error instanceof StrategyRegistryError) {
+                this.logger.warn(error.message);
+                // Publish error event through mediator
+                this.publishErrorEvent(id, error);
+                throw error;
+            }
+            else {
+                const registryError = new StrategyRegistryError(StrategyErrorType.REGISTRATION_ERROR, `Failed to register strategy "${id}": ${error instanceof Error ? error.message : String(error)}`, id, error instanceof Error ? error : undefined);
+                this.logger.error(registryError.message);
+                // Publish error event through mediator
+                this.publishErrorEvent(id, registryError);
+                throw registryError;
+            }
+        }
+    }
+    /**
+     * 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) {
+        try {
+            if (!id) {
+                throw new StrategyRegistryError(StrategyErrorType.INVALID_STRATEGY, "Strategy ID cannot be empty");
+            }
+            if (!this.strategies.has(id)) {
+                throw new StrategyRegistryError(StrategyErrorType.STRATEGY_NOT_FOUND, `Strategy with ID "${id}" is not registered`, id);
+            }
+            // Get the strategy and remove it if it's applied
+            const strategy = this.strategies.get(id);
+            if (strategy.isApplied()) {
+                try {
+                    strategy.remove();
+                    // Publish removal event through mediator
+                    this.publishStrategyRemovedEvent(id);
+                }
+                catch (removeError) {
+                    this.logger.error(`Error removing strategy "${id}" during unregistration:`, removeError);
+                    // Publish error event through mediator
+                    this.publishErrorEvent(id, removeError instanceof Error ? removeError : new Error(String(removeError)));
+                    // Continue with unregistration despite removal error
+                }
+            }
+            // Remove from map
+            this.strategies.delete(id);
+            this.logger.log(`Unregistered strategy "${id}"`);
+            return true;
+        }
+        catch (error) {
+            // Handle errors
+            if (error instanceof StrategyRegistryError) {
+                this.logger.warn(error.message);
+                // Publish error event through mediator
+                this.publishErrorEvent(id, error);
+                throw error;
+            }
+            else {
+                const registryError = new StrategyRegistryError(StrategyErrorType.UNREGISTRATION_ERROR, `Failed to unregister strategy "${id}": ${error instanceof Error ? error.message : String(error)}`, id, error instanceof Error ? error : undefined);
+                this.logger.error(registryError.message);
+                // Publish error event through mediator
+                this.publishErrorEvent(id, registryError);
+                throw registryError;
+            }
+        }
+    }
+    /**
+     * Get a strategy by ID
+     * @param id Strategy ID
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(id) {
+        return this.strategies.get(id);
+    }
+    /**
+     * Check if a strategy is registered
+     * @param id Strategy ID
+     * @returns True if the strategy is registered
+     */
+    hasStrategy(id) {
+        return this.strategies.has(id);
+    }
+    /**
+     * 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) {
+        try {
+            if (!id) {
+                throw new StrategyRegistryError(StrategyErrorType.INVALID_STRATEGY, "Strategy ID cannot be empty");
+            }
+            if (!this.strategies.has(id)) {
+                throw new StrategyRegistryError(StrategyErrorType.STRATEGY_NOT_FOUND, `Cannot apply strategy "${id}" because it is not registered`, id);
+            }
+            const strategy = this.strategies.get(id);
+            // Only apply if not already applied
+            if (!strategy.isApplied()) {
+                strategy.apply();
+                this.logger.log(`Applied strategy "${id}"`);
+                // Publish event through mediator
+                this.publishStrategyAppliedEvent(id);
+            }
+            else {
+                this.logger.log(`Strategy "${id}" is already applied`);
+            }
+            return true;
+        }
+        catch (error) {
+            // Handle errors
+            const registryError = new StrategyRegistryError(StrategyErrorType.APPLICATION_ERROR, `Error applying strategy "${id}": ${error instanceof Error ? error.message : String(error)}`, id, error instanceof Error ? error : undefined);
+            this.logger.error(registryError.message);
+            // Publish error event through mediator
+            this.publishErrorEvent(id, registryError);
+            throw registryError;
+        }
+    }
+    /**
+     * Apply all registered strategies
+     * @returns Array of strategy IDs that failed to apply
+     */
+    applyAllStrategies() {
+        const failed = [];
+        for (const id of this.strategies.keys()) {
+            try {
+                this.applyStrategy(id);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                failed.push(id);
+                // Error already logged and event published in applyStrategy
+            }
+        }
+        return failed;
+    }
+    /**
+     * Remove a specific strategy
+     * @param id Strategy ID to remove
+     * @returns True if removal was successful
+     * @throws StrategyRegistryError if removal fails
+     */
+    removeStrategy(id) {
+        try {
+            if (!id) {
+                throw new StrategyRegistryError(StrategyErrorType.INVALID_STRATEGY, "Strategy ID cannot be empty");
+            }
+            if (!this.strategies.has(id)) {
+                throw new StrategyRegistryError(StrategyErrorType.STRATEGY_NOT_FOUND, `Cannot remove strategy "${id}" because it is not registered`, id);
+            }
+            const strategy = this.strategies.get(id);
+            // Only remove if applied
+            if (strategy.isApplied()) {
+                strategy.remove();
+                this.logger.log(`Removed strategy "${id}"`);
+                // Publish event through mediator
+                this.publishStrategyRemovedEvent(id);
+            }
+            else {
+                this.logger.log(`Strategy "${id}" is not applied, nothing to remove`);
+            }
+            return true;
+        }
+        catch (error) {
+            // Handle errors
+            const registryError = new StrategyRegistryError(StrategyErrorType.REMOVAL_ERROR, `Error removing strategy "${id}": ${error instanceof Error ? error.message : String(error)}`, id, error instanceof Error ? error : undefined);
+            this.logger.error(registryError.message);
+            // Publish error event through mediator
+            this.publishErrorEvent(id, registryError);
+            throw registryError;
+        }
+    }
+    /**
+     * Remove all registered strategies
+     * @returns Array of strategy IDs that failed to remove
+     */
+    removeAllStrategies() {
+        const failed = [];
+        for (const id of this.strategies.keys()) {
+            try {
+                this.removeStrategy(id);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                failed.push(id);
+                // Error already logged and event published in removeStrategy
+            }
+        }
+        return failed;
+    }
+    /**
+     * Get all registered strategy IDs
+     * @returns Array of strategy IDs
+     */
+    getStrategyIds() {
+        return Array.from(this.strategies.keys());
+    }
+    /**
+     * Get all registered strategies
+     * @returns Map of strategy IDs to strategy instances
+     */
+    getAllStrategies() {
+        return new Map(this.strategies);
+    }
+    /**
+     * Get all applied strategies
+     * @returns Array of strategy IDs that are currently applied
+     */
+    getAppliedStrategies() {
+        const applied = [];
+        for (const [id, strategy] of this.strategies.entries()) {
+            if (strategy.isApplied()) {
+                applied.push(id);
+            }
+        }
+        return applied;
+    }
+    /**
+     * Set debug mode for all strategies that support it
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.logger.setDebugMode(enabled);
+        for (const [id, strategy] of this.strategies.entries()) {
+            try {
+                strategy.setDebugMode(enabled);
+            }
+            catch (error) {
+                this.logger.error(`Error setting debug mode for strategy "${id}":`, error);
+            }
+        }
+        this.logger.log(`Set debug mode to ${enabled} for all strategies`);
+    }
+    /**
+     * Clear the registry (remove all strategies first)
+     */
+    clear() {
+        // Remove all strategies first
+        this.removeAllStrategies();
+        // Clear the map
+        this.strategies.clear();
+        this.logger.log("Cleared registry");
+    }
+    /**
+     * Publish a strategy applied event through the mediator
+     * @param strategyId ID of the strategy that was applied
+     */
+    publishStrategyAppliedEvent(strategyId) {
+        if (!this.mediator)
+            return;
+        this.mediator.publish({
+            type: ProtectionEventType.STRATEGY_APPLIED,
+            source: this.COMPONENT_NAME,
+            timestamp: Date.now(),
+            data: {
+                strategyName: strategyId,
+                options: {}
+            }
+        });
+    }
+    /**
+     * Publish a strategy removed event through the mediator
+     * @param strategyId ID of the strategy that was removed
+     */
+    publishStrategyRemovedEvent(strategyId) {
+        if (!this.mediator)
+            return;
+        this.mediator.publish({
+            type: ProtectionEventType.STRATEGY_REMOVED,
+            source: this.COMPONENT_NAME,
+            timestamp: Date.now(),
+            data: {
+                strategyName: strategyId,
+                reason: "registry_operation"
+            }
+        });
+    }
+    /**
+     * Publish an error event through the mediator
+     * @param strategyId ID of the strategy that had an error
+     * @param error The error that occurred
+     */
+    publishErrorEvent(strategyId, error) {
+        if (!this.mediator)
+            return;
+        this.mediator.publish({
+            type: ProtectionEventType.ERROR_OCCURRED,
+            source: this.COMPONENT_NAME,
+            timestamp: Date.now(),
+            data: {
+                strategyName: strategyId,
+                errorType: error instanceof StrategyRegistryError ? error.errorType : "unknown",
+                message: error.message,
+                stack: error.stack
+            }
+        });
+    }
+}

package/dist/utils/base/LoggableComponent.d.ts

@@ -0,0 +1,62 @@
+import { SimpleLoggingService } from "../logging/simple/SimpleLoggingService";
+/**
+ * Base class providing common logging and error handling functionality.
+ * Extract shared functionality from AbstractStrategy, AbstractDevToolsDetector, and AbstractEventHandler.
+ */
+export declare abstract class LoggableComponent {
+    readonly COMPONENT_NAME: string;
+    protected debugMode: boolean;
+    protected logger: SimpleLoggingService;
+    /**
+     * Create a new LoggableComponent
+     * @param componentName Unique name for the component (used in logging)
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(componentName: string, debugMode?: boolean);
+    /**
+     * Get the debug mode status
+     * @returns True if debug mode is enabled
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    protected log(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    protected warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    protected error(message: string, ...args: unknown[]): void;
+    /**
+     * Execute a function with error handling
+     * This method can be overridden in subclasses to add type-specific error handling.
+     * @param operation Name of the operation for error reporting
+     * @param errorTypeOrFn Either an error type (for subclasses) or the function to execute
+     * @param fn Function to execute (only if errorTypeOrFn is an error type)
+     * @returns The result of the function or undefined if an error occurred
+     */
+    protected safeExecute<T>(operation: string, errorTypeOrFn: unknown, fn?: () => T): T | undefined;
+    /**
+     * Execute an async function with error handling
+     * This method can be overridden in subclasses to add type-specific error handling.
+     * @param operation Name of the operation for error reporting
+     * @param errorTypeOrFn Either an error type (for subclasses) or the async function to execute
+     * @param fn Async function to execute (only if errorTypeOrFn is an error type)
+     * @returns Promise resolving to the result of the function or undefined if an error occurred
+     */
+    protected safeExecuteAsync<T>(operation: string, errorTypeOrFn: unknown, fn?: () => Promise<T>): Promise<T | undefined>;
+}

package/dist/utils/base/LoggableComponent.js

@@ -0,0 +1,95 @@
+import { SimpleLoggingService } from "../logging/simple/SimpleLoggingService";
+/**
+ * Base class providing common logging and error handling functionality.
+ * Extract shared functionality from AbstractStrategy, AbstractDevToolsDetector, and AbstractEventHandler.
+ */
+export class LoggableComponent {
+    /**
+     * Create a new LoggableComponent
+     * @param componentName Unique name for the component (used in logging)
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(componentName, debugMode = false) {
+        this.COMPONENT_NAME = componentName;
+        this.debugMode = debugMode;
+        this.logger = new SimpleLoggingService(componentName, debugMode);
+    }
+    /**
+     * Get the debug mode status
+     * @returns True if debug mode is enabled
+     */
+    isDebugEnabled() {
+        return this.debugMode;
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        this.logger.setDebugMode(enabled);
+        this.logger.log(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+    }
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message, ...args) {
+        this.logger.log(message, ...args);
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    /**
+     * Execute a function with error handling
+     * This method can be overridden in subclasses to add type-specific error handling.
+     * @param operation Name of the operation for error reporting
+     * @param errorTypeOrFn Either an error type (for subclasses) or the function to execute
+     * @param fn Function to execute (only if errorTypeOrFn is an error type)
+     * @returns The result of the function or undefined if an error occurred
+     */
+    safeExecute(operation, errorTypeOrFn, fn) {
+        // If only two args were provided (operation, fn), fn is actually in errorTypeOrFn
+        const actualFn = fn || errorTypeOrFn;
+        try {
+            return actualFn();
+        }
+        catch (error) {
+            this.logger.error(`Error during ${operation}:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Execute an async function with error handling
+     * This method can be overridden in subclasses to add type-specific error handling.
+     * @param operation Name of the operation for error reporting
+     * @param errorTypeOrFn Either an error type (for subclasses) or the async function to execute
+     * @param fn Async function to execute (only if errorTypeOrFn is an error type)
+     * @returns Promise resolving to the result of the function or undefined if an error occurred
+     */
+    async safeExecuteAsync(operation, errorTypeOrFn, fn) {
+        // If only two args were provided (operation, fn), fn is actually in errorTypeOrFn
+        const actualFn = fn || errorTypeOrFn;
+        try {
+            return await actualFn();
+        }
+        catch (error) {
+            this.logger.error(`Error during ${operation}:`, error);
+            return undefined;
+        }
+    }
+}

package/dist/utils/debuggerDetector/debuggerDetectionWorker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Worker script for DevTools detection
+ * This worker helps detect DevTools by using the debugger statement
+ * in a separate thread, which won't block the main UI thread
+ */
+export type DebuggerDetectionWorker = typeof self;

package/dist/utils/debuggerDetector/debuggerDetectionWorker.js

@@ -0,0 +1,24 @@
+/**
+ * Worker script for DevTools detection
+ * This worker helps detect DevTools by using the debugger statement
+ * in a separate thread, which won't block the main UI thread
+ */
+// Set up message handler
+self.onmessage = (e) => {
+    if (e.data === "checkDevTools") {
+        // Send immediate response (opening heartbeat)
+        console.log("DebuggerDetectionWorker: Received checkDevTools message");
+        self.postMessage("heartbeatStart");
+        // This will pause execution if DevTools is open
+        // We use a function to make it harder to bypass
+        function triggerDebugger() {
+            // eslint-disable-next-line no-debugger
+            debugger;
+        }
+        // Call the function to trigger the debugger
+        triggerDebugger();
+        // If we reach here without significant delay, DevTools is closed
+        self.postMessage("heartbeatEnd");
+    }
+};
+export {};

package/dist/utils/debuggerDetector/debuggerDetector.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Utility class for detecting DevTools using a Web Worker
+ * This approach works across browsers and provides immediate feedback
+ */
+export interface DebuggerDetectorOptions {
+    /**
+     * Timeout duration in milliseconds
+     * If the worker doesn't respond within this time, DevTools is considered open
+     */
+    timeoutDuration?: number;
+    /**
+     * Callback function when DevTools state changes
+     */
+    onDevToolsChange?: (isOpen: boolean) => void;
+    /**
+     * Enable debug mode for troubleshooting
+     */
+    debugMode?: boolean;
+}
+export declare class DebuggerDetector {
+    private worker;
+    private firefoxDetector;
+    private isChecking;
+    private timeoutId;
+    private timeoutDuration;
+    private onDevToolsChange;
+    private debugMode;
+    private isDevToolsOpen;
+    /**
+     * Create a new DebuggerDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DebuggerDetectorOptions);
+    private initWorker;
+    /**
+     * Check if DevTools is open
+     * @returns Promise that resolves to true if DevTools is open
+     */
+    checkDevTools(): void;
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen(): boolean;
+    private terminateWorker;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}