content-security-toolkit 1.0.0 → 1.0.1

package/dist/strategies/StrategyRegistry.js

@@ -1,379 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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;
-}