content-security-toolkit 1.0.0

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/strategies/WatermarkStrategy.d.ts

@@ -0,0 +1,47 @@
+import type { WatermarkOptions } from "../types";
+import { AbstractStrategy } from "./AbstractStrategy";
+/**
+ * Strategy for adding watermarks to content
+ */
+export declare class WatermarkStrategy extends AbstractStrategy {
+    private targetElement;
+    private options;
+    private watermarkElements;
+    private domObserver;
+    private isFullPageWatermark;
+    private watermarkContainer;
+    private osInfo;
+    /**
+     * Create a new WatermarkStrategy
+     * @param targetElement Element to watermark (defaults to document.body)
+     * @param options Watermark options
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options?: WatermarkOptions, targetElement?: HTMLElement | null, debugMode?: boolean);
+    /**
+     * Create watermarks
+     */
+    private createWatermarks;
+    /**
+     * Set up DOM observer to detect watermark removal
+     */
+    private setupObserver;
+    /**
+     * Remove watermark elements
+     */
+    private removeWatermarkElements;
+    /**
+     * Apply watermark protection
+     */
+    apply(): void;
+    /**
+     * Remove watermark protection
+     * Override the base implementation to handle additional cleanup
+     */
+    remove(): void;
+    /**
+     * Update watermark options
+     * @param options New watermark options
+     */
+    updateOptions(options: Record<string, unknown>): void;
+}

package/dist/strategies/WatermarkStrategy.js

@@ -0,0 +1,273 @@
+import { DomObserver } from "../utils/DOMObserver";
+import { isBrowser, getOS } from "../utils/environment";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+/**
+ * Strategy for adding watermarks to content
+ */
+export class WatermarkStrategy extends AbstractStrategy {
+    /**
+     * Create a new WatermarkStrategy
+     * @param targetElement Element to watermark (defaults to document.body)
+     * @param options Watermark options
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options, targetElement, debugMode = false) {
+        super("WatermarkStrategy", debugMode);
+        this.targetElement = null;
+        this.watermarkElements = [];
+        this.domObserver = null;
+        this.isFullPageWatermark = false;
+        this.watermarkContainer = null;
+        this.targetElement = targetElement || (isBrowser() ? document.body : null);
+        this.options = {
+            text: "CONFIDENTIAL",
+            opacity: 0.15,
+            density: 3,
+            ...options,
+        };
+        this.osInfo = getOS();
+        this.watermarkElements = [];
+        // Determine if we're doing a full-page watermark
+        if (isBrowser() && this.targetElement === document.body) {
+            this.isFullPageWatermark = true;
+        }
+        this.log("Initialized with OS:", this.osInfo, "Full-page:", this.isFullPageWatermark);
+    }
+    /**
+     * Create watermarks
+     */
+    createWatermarks() {
+        return this.safeExecute("createWatermarks", StrategyErrorType.APPLICATION, () => {
+            if (!this.targetElement || !isBrowser())
+                return;
+            // Check if watermark container already exists
+            const existingContainer = document.querySelector(".content-security-watermark-container");
+            if (existingContainer) {
+                this.log("Watermark container already exists, removing first");
+                if (existingContainer.parentNode) {
+                    existingContainer.parentNode.removeChild(existingContainer);
+                }
+            }
+            // Clear any existing watermarks
+            this.removeWatermarkElements();
+            // Calculate density
+            const density = Math.min(Math.max(this.options.density || 3, 1), 10);
+            const rows = density * 3;
+            const cols = density * 3;
+            // Create watermark container
+            const container = document.createElement("div");
+            container.className = "content-security-watermark-container";
+            container.setAttribute("data-watermark-id", `watermark-${Date.now()}`);
+            this.watermarkContainer = container;
+            // Set container styles based on whether it's full-page or element-specific
+            if (this.isFullPageWatermark) {
+                // Full-page watermark (fixed position covering viewport)
+                Object.assign(container.style, {
+                    position: "fixed",
+                    top: "0",
+                    left: "0",
+                    width: "100%",
+                    height: "100%",
+                    overflow: "hidden",
+                    pointerEvents: "none",
+                    zIndex: "2147483647", // Max z-index
+                    userSelect: "none",
+                });
+            }
+            else {
+                // Element-specific watermark
+                // Get the computed style of the target element
+                const targetStyle = window.getComputedStyle(this.targetElement);
+                const targetPosition = targetStyle.position;
+                // If the target element doesn't have a position set, we need to set it to relative
+                // so that our absolutely positioned watermark container stays within it
+                if (targetPosition === "static") {
+                    this.targetElement.style.position = "relative";
+                }
+                Object.assign(container.style, {
+                    position: "absolute",
+                    top: "0",
+                    left: "0",
+                    width: "100%",
+                    height: "100%",
+                    overflow: "hidden",
+                    pointerEvents: "none",
+                    zIndex: "999", // High z-index but not max to avoid breaking page layout
+                    userSelect: "none",
+                });
+            }
+            // Generate timestamp and user info for watermark
+            const timestamp = new Date().toISOString();
+            const userInfo = this.options.userId ? ` - User: ${this.options.userId}` : "";
+            const watermarkText = `${this.options.text}${userInfo} - ${timestamp}`;
+            // Create watermark pattern
+            for (let i = 0; i < rows; i++) {
+                for (let j = 0; j < cols; j++) {
+                    const watermark = document.createElement("div");
+                    watermark.className = "content-security-watermark";
+                    watermark.textContent = watermarkText;
+                    // Position watermark - use % for element-specific watermarks instead of vh/vw
+                    const positionUnit = this.isFullPageWatermark ? "vh" : "%";
+                    const horizontalUnit = this.isFullPageWatermark ? "vw" : "%";
+                    Object.assign(watermark.style, {
+                        position: "absolute",
+                        top: `${(i * 100) / rows}${positionUnit}`,
+                        left: `${(j * 100) / cols}${horizontalUnit}`,
+                        transform: "rotate(-45deg) translateX(-30%) translateY(-200%)",
+                        transformOrigin: "center",
+                        opacity: String(this.options.opacity || 0.15),
+                        fontSize: this.isFullPageWatermark ? "16px" : "14px", // Slightly smaller for element watermarks
+                        color: "rgba(0, 0, 0, 0.7)",
+                        whiteSpace: "nowrap",
+                        pointerEvents: "none",
+                        userSelect: "none",
+                        ...this.options.style,
+                    });
+                    container.appendChild(watermark);
+                    this.watermarkElements.push(watermark);
+                }
+            }
+            // Add container to target
+            this.targetElement.appendChild(container);
+            this.watermarkElements.push(container);
+            this.log("Created watermark container with", this.watermarkElements.length - 1, "watermarks");
+            // Set up observer to detect if watermarks are removed
+            this.setupObserver();
+        });
+    }
+    /**
+     * Set up DOM observer to detect watermark removal
+     */
+    setupObserver() {
+        return this.safeExecute("setupObserver", StrategyErrorType.APPLICATION, () => {
+            if (!this.targetElement || !isBrowser())
+                return;
+            // Create a handler for element removal
+            const handleElementsRemoved = (removedElements) => {
+                this.log("Watermark elements removed from DOM", removedElements);
+                // Only restore if auto-restore is enabled
+                if (this.isAppliedFlag) {
+                    this.log("Auto-restoring watermarks");
+                    // Restore the watermarks
+                    this.createWatermarks();
+                }
+            };
+            // Create a new observer if needed
+            if (!this.domObserver) {
+                this.domObserver = new DomObserver({
+                    targetElement: this.targetElement,
+                    elementsToWatch: this.watermarkContainer ? [this.watermarkContainer] : [],
+                    onElementsRemoved: handleElementsRemoved,
+                    observeSubtree: true,
+                    debugMode: this.debugMode,
+                    name: "WatermarkStrategy",
+                });
+            }
+            else {
+                // Update the elements to watch
+                this.domObserver.updateElementsToWatch(this.watermarkContainer ? [this.watermarkContainer] : []);
+            }
+            // Start observing
+            this.domObserver.startObserving();
+            this.log("DOM observer set up to detect watermark removal");
+        });
+    }
+    /**
+     * Remove watermark elements
+     */
+    removeWatermarkElements() {
+        return this.safeExecute("removeWatermarkElements", StrategyErrorType.REMOVAL, () => {
+            if (!isBrowser())
+                return;
+            // First, try to remove by container reference
+            if (this.watermarkContainer && this.watermarkContainer.parentNode) {
+                this.watermarkContainer.parentNode.removeChild(this.watermarkContainer);
+                this.watermarkContainer = null;
+            }
+            // Then try to remove individual elements
+            for (const element of this.watermarkElements) {
+                if (element.parentNode) {
+                    element.parentNode.removeChild(element);
+                }
+            }
+            // Also try to remove by class name in case references were lost
+            const containers = document.querySelectorAll(".content-security-watermark-container");
+            containers.forEach((container) => {
+                if (container.parentNode) {
+                    container.parentNode.removeChild(container);
+                }
+            });
+            // If we modified the target element's position, restore it
+            if (!this.isFullPageWatermark && this.targetElement) {
+                // Only remove the position if we added it
+                // This is a simplification - ideally we'd store the original position
+                if (this.targetElement.style.position === "relative") {
+                    this.targetElement.style.position = "";
+                }
+            }
+            this.watermarkElements = [];
+            this.log("Removed all watermark elements");
+        });
+    }
+    /**
+     * Apply watermark protection
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Already applied, skipping");
+                return;
+            }
+            this.log("Applying watermark protection", {
+                text: this.options.text,
+                opacity: this.options.opacity,
+                density: this.options.density,
+                userId: this.options.userId,
+                isFullPage: this.isFullPageWatermark,
+                os: this.osInfo.name,
+            });
+            this.createWatermarks();
+            this.isAppliedFlag = true;
+        });
+    }
+    /**
+     * Remove watermark protection
+     * Override the base implementation to handle additional cleanup
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Not applied, skipping removal");
+                return;
+            }
+            if (this.domObserver) {
+                this.domObserver.stopObserving();
+                this.domObserver = null;
+                this.log("DOM observer stopped");
+            }
+            this.removeWatermarkElements();
+            this.isAppliedFlag = false;
+            this.log("Watermark protection removed");
+        });
+    }
+    /**
+     * Update watermark options
+     * @param options New watermark options
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            const typedOptions = options;
+            this.log("Updating options", typedOptions);
+            this.options = {
+                ...this.options,
+                ...typedOptions,
+            };
+            if (this.isAppliedFlag) {
+                // Reapply with new options
+                this.remove();
+                this.apply();
+                this.log("Reapplied watermarks with updated options");
+            }
+        });
+    }
+}