content-security-toolkit 1.0.0

package/dist/strategies/SelectionStrategy.js

@@ -0,0 +1,216 @@
+import { isBrowser, isMobile } from "../utils/environment";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+/**
+ * Strategy for preventing text selection
+ */
+export class SelectionStrategy extends AbstractStrategy {
+    /**
+     * Create a new SelectionStrategy
+     * @param targetElement Element to protect (defaults to document.body)
+     * @param customHandler Optional custom handler for selection attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(targetElement, customHandler, debugMode = false) {
+        super("SelectionStrategy", debugMode);
+        this.targetElement = null;
+        this.styleElement = null;
+        this.preventDrag = true;
+        this.targetElement = targetElement || (isBrowser() ? document.body : null);
+        this.customHandler = customHandler;
+        this.selectionHandler = this.handleSelection.bind(this);
+        this.dragHandler = this.handleDrag.bind(this);
+        this.log("Initialized with target:", this.targetElement === document.body ? "document.body" : "custom element");
+    }
+    /**
+     * Handle selection event
+     */
+    handleSelection(e) {
+        return (this.safeExecute("handleSelection", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("Selection attempt detected", {
+                eventType: e.type,
+                target: e.target,
+            });
+            // Call custom handler if provided
+            if (this.customHandler) {
+                this.customHandler(e);
+            }
+            if (isBrowser() && window.getSelection) {
+                const selection = window.getSelection();
+                if (selection) {
+                    selection.removeAllRanges();
+                }
+            }
+            e.preventDefault();
+            e.stopPropagation();
+            return false;
+        }) || false);
+    }
+    /**
+     * Handle drag event
+     */
+    handleDrag(e) {
+        this.safeExecute("handleDrag", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("Drag attempt detected", {
+                eventType: e.type,
+                target: e.target,
+            });
+            // Call custom handler if provided
+            if (this.customHandler) {
+                this.customHandler(e);
+            }
+            e.preventDefault();
+            e.stopPropagation();
+        });
+    }
+    /**
+     * Inject CSS to prevent selection
+     */
+    injectSelectionStyles() {
+        this.safeExecute("injectSelectionStyles", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser())
+                return;
+            this.styleElement = document.createElement("style");
+            this.styleElement.setAttribute("type", "text/css");
+            this.styleElement.setAttribute("data-content-security", "selection-blocker");
+            const selector = this.targetElement === document.body ? "body" : ".protected-content";
+            const css = `
+        ${selector} {
+          -webkit-user-select: none;
+          -moz-user-select: none;
+          -ms-user-select: none;
+          user-select: none;
+        }
+        
+        ${selector} ::selection {
+          background: transparent;
+        }
+      `;
+            this.styleElement.textContent = css;
+            document.head.appendChild(this.styleElement);
+            // Add class if not targeting body
+            if (this.targetElement !== document.body) {
+                this.targetElement?.classList.add("protected-content");
+            }
+            this.log("Selection-blocking CSS injected");
+        });
+    }
+    /**
+     * Remove selection-blocking CSS
+     */
+    removeSelectionStyles() {
+        this.safeExecute("removeSelectionStyles", StrategyErrorType.REMOVAL, () => {
+            if (!this.styleElement || !isBrowser())
+                return;
+            try {
+                document.head.removeChild(this.styleElement);
+                this.styleElement = null;
+                // Remove class if not targeting body
+                if (this.targetElement !== document.body) {
+                    this.targetElement?.classList.remove("protected-content");
+                }
+                this.log("Selection-blocking CSS removed");
+            }
+            catch (error) {
+                this.handleError(StrategyErrorType.REMOVAL, "Error removing selection styles", error);
+                // Try to find and remove by selector as fallback
+                try {
+                    const styles = document.querySelectorAll('style[data-content-security="selection-blocker"]');
+                    styles.forEach((style) => {
+                        if (style.parentNode) {
+                            style.parentNode.removeChild(style);
+                        }
+                    });
+                    this.styleElement = null;
+                    if (styles.length > 0) {
+                        this.log(`Removed ${styles.length} selection-blocking styles by selector`);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (fallbackError) {
+                    // Last resort fallback
+                    this.styleElement = null;
+                }
+            }
+        });
+    }
+    /**
+     * Apply selection protection
+     */
+    apply() {
+        this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag || !this.targetElement)
+                return;
+            this.log("Applying selection protection", {
+                targetElement: this.targetElement === document.body ? "document.body" : "custom element",
+                hasCustomHandler: !!this.customHandler,
+                preventDrag: this.preventDrag,
+                isMobile: isMobile(),
+            });
+            // Add CSS
+            this.injectSelectionStyles();
+            // Add event listeners using the registerEvent method from AbstractStrategy
+            this.registerEvent(this.targetElement, "selectstart", this.selectionHandler);
+            this.registerEvent(this.targetElement, "mousedown", this.selectionHandler, { capture: true });
+            // Disable drag
+            if (this.preventDrag) {
+                this.registerEvent(this.targetElement, "dragstart", this.dragHandler);
+            }
+            this.isAppliedFlag = true;
+        });
+    }
+    /**
+     * Remove selection protection
+     */
+    remove() {
+        this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag || !this.targetElement)
+                return;
+            // Remove CSS
+            this.removeSelectionStyles();
+            // Remove all events for this owner using the parent class method
+            this.removeEventsByOwner();
+            // Second attempt - try direct DOM removal as fallback
+            try {
+                if (this.targetElement) {
+                    this.targetElement.removeEventListener("selectstart", this.selectionHandler);
+                    this.targetElement.removeEventListener("mousedown", this.selectionHandler, { capture: true });
+                    this.targetElement.removeEventListener("dragstart", this.dragHandler);
+                    this.log("Removed events via direct DOM API");
+                }
+            }
+            catch (domError) {
+                // Ignore errors in direct DOM removal
+                this.handleError(StrategyErrorType.REMOVAL, "Error in fallback DOM removal", domError);
+            }
+            // Clear tracked event IDs
+            this.eventIds = [];
+            this.isAppliedFlag = false;
+            this.log("Selection protection removed");
+        });
+    }
+    /**
+     * Update selection protection options
+     * @param options New options for selection protection
+     */
+    updateOptions(options) {
+        this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            this.log("Updating options", options);
+            // Update debug mode if specified
+            if (options.debugMode !== undefined) {
+                this.setDebugMode(!!options.debugMode);
+            }
+            // Update preventDrag if specified
+            if (options.preventDrag !== undefined) {
+                const oldPreventDrag = this.preventDrag;
+                this.preventDrag = !!options.preventDrag;
+                // If we need to update the applied strategy
+                if (this.isAppliedFlag && oldPreventDrag !== this.preventDrag) {
+                    // Remove and reapply to update event listeners
+                    this.remove();
+                    this.apply();
+                    this.log("Reapplied with updated options");
+                }
+            }
+        });
+    }
+}

package/dist/strategies/StrategyRegistry.d.ts

@@ -0,0 +1,133 @@
+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;
+}