content-security-toolkit 1.0.1 → 1.0.2

package/dist/utils/protectedContentManager-simple.d.ts

@@ -0,0 +1,86 @@
+import type { MediatorAware, ProtectionMediator } from "../core/mediator/types";
+/**
+ * Options for the protected content placeholder
+ */
+export interface PlaceholderOptions {
+    /**
+     * Title to display in the placeholder
+     */
+    title?: string;
+    /**
+     * Main message to display
+     */
+    message?: string;
+    /**
+     * Secondary message to display
+     */
+    secondaryMessage?: string;
+    /**
+     * Text color for the placeholder
+     */
+    textColor?: string;
+    /**
+     * Background color for the placeholder
+     */
+    backgroundColor?: string;
+}
+/**
+ * Utility class to manage protected content by hiding and revealing it
+ */
+export declare class ProtectedContentManager implements MediatorAware {
+    readonly COMPONENT_NAME = "ProtectedContentManager";
+    private mediator;
+    private targetElement;
+    private originalContent;
+    private debugMode;
+    /**
+     * Create a new ProtectedContentManager
+     * @param targetElement Element containing sensitive content to protect
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(targetElement: HTMLElement, debugMode?: boolean);
+    /**
+     * Set the mediator
+     * to communicate with the other components
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Handle content hidden event
+     */
+    private handleContentHidden;
+    /**
+     * Handle content restored event
+     */
+    private handleContentRestored;
+    /**
+     * Hide the original content and replace it with a placeholder
+     * @param options Options for customizing the placeholder
+     * @returns True if content was hidden, false if there was no content to hide
+     */
+    hideContent(options: PlaceholderOptions): boolean;
+    /**
+     * Restore the original content
+     * @returns True if content was restored, false if there was no content to restore
+     */
+    restoreContent(): boolean;
+    /**
+     * Check if content is currently hidden
+     * @returns True if content is hidden, false otherwise
+     */
+    isContentHidden(): boolean;
+    /**
+     * Update the target element
+     * @param element New target element
+     */
+    updateTargetElement(element: HTMLElement): void;
+    /**
+     * Get the current target element
+     * @returns The current target element
+     */
+    getTargetElement(): HTMLElement;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}

package/dist/utils/protectedContentManager-simple.js

@@ -0,0 +1,180 @@
+import { ProtectionEventType } from "../core/mediator/protection-event";
+/**
+ * Utility class to manage protected content by hiding and revealing it
+ */
+export class ProtectedContentManager {
+    /**
+     * Create a new ProtectedContentManager
+     * @param targetElement Element containing sensitive content to protect
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(targetElement, debugMode = false) {
+        this.COMPONENT_NAME = "ProtectedContentManager";
+        this.mediator = null;
+        this.originalContent = null;
+        this.targetElement = targetElement;
+        this.debugMode = debugMode;
+    }
+    /**
+     * Set the mediator
+     * to communicate with the other components
+     */
+    setMediator(mediator) {
+        this.mediator = mediator;
+        // Subscribe only to general events directly related to content management
+        this.mediator.subscribe(ProtectionEventType.CONTENT_HIDDEN, this.handleContentHidden.bind(this), {
+            context: this.COMPONENT_NAME,
+        });
+        this.mediator.subscribe(ProtectionEventType.CONTENT_RESTORED, this.handleContentRestored.bind(this), {
+            context: this.COMPONENT_NAME,
+        });
+        if (this.debugMode) {
+            console.log("ProtectedContentManager: Mediator set and subscriptions established");
+        }
+    }
+    /**
+     * Handle content hidden event
+     */
+    handleContentHidden(event) {
+        try {
+            if (this.debugMode) {
+                console.log(`ProtectedContentManager: Received content hidden event from ${event.source}`, event.data);
+            }
+            const data = event.data;
+            if (!data || !data.options)
+                return;
+            // Only process if this is for our target element or we're the default handler
+            if (data.targetElement && data.targetElement !== this.targetElement)
+                return;
+            this.hideContent(data.options);
+        }
+        catch (error) {
+            console.error("ProtectedContentManager: Error handling content hidden event", error);
+        }
+    }
+    /**
+     * Handle content restored event
+     */
+    handleContentRestored(event) {
+        try {
+            if (this.debugMode) {
+                console.log(`ProtectedContentManager: Received content restored event from ${event.source}`, event.data);
+            }
+            const data = event.data;
+            // Only process if this is for our target element or we're the default handler
+            if (data && data.targetElement && data.targetElement !== this.targetElement)
+                return;
+            this.restoreContent();
+        }
+        catch (error) {
+            console.error("ProtectedContentManager: Error handling content restored event", error);
+        }
+    }
+    /**
+     * Hide the original content and replace it with a placeholder
+     * @param options Options for customizing the placeholder
+     * @returns True if content was hidden, false if there was no content to hide
+     */
+    hideContent(options) {
+        if (!this.targetElement)
+            return false;
+        // Store original content if not already stored
+        if (this.originalContent === null) {
+            this.originalContent = this.targetElement.innerHTML;
+            if (this.debugMode) {
+                console.log("ProtectedContentManager: Original content stored");
+            }
+        }
+        // Create placeholder content with custom styles
+        const placeholderStyles = {
+            padding: "20px",
+            textAlign: "center",
+            color: options.textColor || "white",
+            backgroundColor: options.backgroundColor || "rgba(0, 0, 0, 0.05)",
+            borderRadius: "8px",
+            margin: "20px",
+            boxShadow: "0 2px 10px rgba(0, 0, 0, 0.1)",
+        };
+        // Convert styles object to inline style string
+        const styleString = Object.entries(placeholderStyles)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join("; ");
+        // Replace content with a placeholder that uses the options text
+        this.targetElement.innerHTML = `
+      <div style="${styleString}">
+        <h2 style="font-size: 24px; margin-bottom: 20px; color: ${options.textColor || "black"};">
+          ${options.title || "Content Protected"}
+        </h2>
+        <p style="font-size: 16px; margin-bottom: 15px; color: ${options.textColor || "black"};">
+          ${options.message || "This content is protected for security reasons."}
+        </p>
+        ${options.secondaryMessage
+            ? `
+          <p style="font-size: 16px; color: ${options.textColor || "black"};">
+            ${options.secondaryMessage}
+          </p>
+        `
+            : ""}
+        <div style="margin-top: 20px; padding-top: 20px; border-top: 1px solid rgba(255, 255, 255, 0.2);">
+          <p style="font-size: 14px; color: ${options.textColor || "black"}; opacity: 0.8;">
+            This content is protected by ContentSecurityToolkit
+          </p>
+        </div>
+      </div>
+    `;
+        if (this.debugMode) {
+            console.log("ProtectedContentManager: Content hidden");
+        }
+        return true;
+    }
+    /**
+     * Restore the original content
+     * @returns True if content was restored, false if there was no content to restore
+     */
+    restoreContent() {
+        if (!this.targetElement || this.originalContent === null)
+            return false;
+        // Restore the original content
+        this.targetElement.innerHTML = this.originalContent;
+        this.originalContent = null;
+        if (this.debugMode) {
+            console.log("ProtectedContentManager: Original content restored");
+        }
+        return true;
+    }
+    /**
+     * Check if content is currently hidden
+     * @returns True if content is hidden, false otherwise
+     */
+    isContentHidden() {
+        return this.originalContent !== null;
+    }
+    /**
+     * Update the target element
+     * @param element New target element
+     */
+    updateTargetElement(element) {
+        // If content is hidden, restore it before changing the target
+        if (this.isContentHidden()) {
+            this.restoreContent();
+        }
+        this.targetElement = element;
+        if (this.debugMode) {
+            console.log("ProtectedContentManager: Target element updated");
+        }
+    }
+    /**
+     * Get the current target element
+     * @returns The current target element
+     */
+    getTargetElement() {
+        return this.targetElement;
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+}

package/dist/utils/securityOverlayManager-observer-pause.d.ts

@@ -0,0 +1,283 @@
+import type { MediatorAware, ProtectionMediator } from "../core/mediator/types";
+/**
+ * Options for the security overlay
+ */
+export interface OverlayOptions {
+    /**
+     * Title to display in the overlay
+     */
+    title?: string;
+    /**
+     * Main message to display
+     */
+    message?: string;
+    /**
+     * Secondary message to display
+     */
+    secondaryMessage?: string;
+    /**
+     * Text color for the overlay
+     */
+    textColor?: string;
+    /**
+     * Background color for the overlay
+     */
+    backgroundColor?: string;
+    /**
+     * Z-index for the overlay (default: 2147483647)
+     */
+    zIndex?: string;
+    /**
+     * Whether to show a close button
+     */
+    showCloseButton?: boolean;
+    /**
+     * Text for the close button
+     */
+    closeButtonText?: string;
+    /**
+     * Callback when close button is clicked
+     */
+    onCloseButtonClick?: () => void;
+    /**
+     * Duration in milliseconds to show the overlay (0 for indefinite)
+     */
+    duration?: number;
+    /**
+     * Additional custom styles for the overlay
+     */
+    customStyles?: Record<string, string>;
+    /**
+     * Additional custom styles for the text
+     */
+    textStyles?: Record<string, string>;
+    /**
+     * Font size (ScreenshotStrategy - refactor)
+     */
+    fontSize?: string;
+    /**
+     * Additional HTML content to display in the overlay
+     */
+    additionalContent?: string;
+    /**
+     * Whether to block events (create an event blocker)
+     */
+    blockEvents?: boolean;
+    /**
+     * Whether to automatically restore the overlay if it's removed from the DOM
+     * @default true
+     */
+    autoRestore?: boolean;
+}
+/**
+ * Utility class to manage security overlays
+ */
+export declare class SecurityOverlayManager implements MediatorAware {
+    readonly COMPONENT_NAME = "SecurityOverlayManager";
+    private mediator;
+    private debugMode;
+    private logger;
+    private domObserver;
+    private overlays;
+    private activeOverlayId;
+    private overlayQueue;
+    private isObserverPaused;
+    private onElementsRemovedCallbacks;
+    /**
+     * Create a new SecurityOverlayManager
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(debugMode?: boolean);
+    /**
+     * Set the mediator to communicate with the other components
+     * @param mediator The protection mediator
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Handle overlay shown event
+     * @param event The protection event
+     */
+    private handleOverlayShown;
+    /**
+     * Handle overlay removed event
+     * @param event The protection event
+     */
+    private handleOverlayRemoved;
+    /**
+     * Handle overlay restored event
+     * @param event The protection event
+     */
+    private handleOverlayRestored;
+    /**
+     * Register a new overlay
+     * @param owner The strategy or component that owns this overlay
+     * @param overlayType The type of overlay (e.g., "screenshot", "devtools")
+     * @param options Options for the overlay
+     * @param priority Priority for display order (higher displays on top)
+     * @returns The ID of the registered overlay
+     */
+    registerOverlay(owner: string, overlayType: string, options: OverlayOptions, priority?: number): string;
+    /**
+     * Add an overlay to the queue
+     * @param overlayId ID of the overlay to add to queue
+     */
+    private addToQueue;
+    /**
+     * Show a specific overlay by ID
+     * @param overlayId ID of the overlay to show
+     * @returns True if the overlay was shown successfully
+     */
+    private showOverlayById;
+    /**
+     * Hide a specific overlay by ID without removing it from storage
+     * @param overlayId ID of the overlay to hide
+     * @param processQueue Whether to process the queue after hiding
+     * @returns True if the overlay was hidden successfully
+     */
+    private hideOverlayById;
+    /**
+     * Create overlay and blocker elements
+     * @param overlay The stored overlay information
+     * @returns Object containing the created elements
+     */
+    private createOverlayElements;
+    /**
+     * Remove a specific overlay by ID
+     * @param overlayId ID of the overlay to remove
+     * @param disableAutoRestore Whether to disable auto-restoration for this overlay
+     * @returns True if the overlay was removed successfully
+     */
+    removeOverlayById(overlayId: string, disableAutoRestore?: boolean): boolean;
+    /**
+     * Remove all overlays for a specific owner
+     * @param owner The owner to remove overlays for
+     * @param disableAutoRestore Whether to disable auto-restoration for these overlays
+     * @returns The number of overlays removed
+     */
+    removeOverlaysByOwner(owner: string, disableAutoRestore?: boolean): number;
+    /**
+     * Check and restore overlays for a specific owner
+     * @param owner The owner to check overlays for
+     * @returns The number of overlays restored
+     */
+    checkAndRestoreOverlaysByOwner(owner: string): number;
+    /**
+     * Create an overlay element
+     * @param options Options for the overlay
+     * @param owner The owner of the overlay (for data attribute)
+     * @returns The created overlay element
+     */
+    private createOverlay;
+    /**
+     * Create an event blocker that prevents interaction with the page
+     * @returns The created event blocker element
+     */
+    private createEventBlocker;
+    /**
+     * Pause the DOM observer to prevent auto-restoration during intentional removal
+     */
+    private pauseObserver;
+    /**
+     * Resume the DOM observer after intentional removal
+     */
+    private resumeObserver;
+    /**
+     * Set up DOM observer to detect when overlay elements are removed
+     * @param overlay The overlay to observe
+     */
+    private setupObserver;
+    /**
+     * Set up DOM observer for multiple overlays
+     * @param overlays Array of overlays to observe
+     */
+    private setupObserverForMultipleOverlays;
+    /**
+     * Remove global event listeners that were added to document and window
+     */
+    private removeGlobalEventListeners;
+    /**
+     * Notify all callbacks when elements are removed
+     * @param removedElements The elements that were removed
+     */
+    private notifyElementsRemovedCallbacks;
+    /**
+     * Add a callback to be called when overlay elements are removed
+     * @param callback Callback function
+     */
+    addElementsRemovedCallback(callback: (removedElements: HTMLElement[]) => void): void;
+    /**
+     * Remove a callback
+     * @param callback Callback function to remove
+     */
+    removeElementsRemovedCallback(callback: (removedElements: HTMLElement[]) => void): void;
+    /**
+     * Disable auto-restoration for a specific overlay
+     * @param overlayId ID of the overlay to disable auto-restoration for
+     * @returns True if the overlay was found and updated
+     */
+    disableAutoRestoreForOverlay(overlayId: string): boolean;
+    /**
+     * Disable auto-restoration for all overlays owned by a specific owner
+     * @param owner The owner to disable auto-restoration for
+     * @returns The number of overlays updated
+     */
+    disableAutoRestoreForOwner(owner: string): number;
+    /**
+     * Get all overlays for a specific owner
+     * @param owner The owner to get overlays for
+     * @returns Array of overlay IDs
+     */
+    getOverlaysByOwner(owner: string): string[];
+    /**
+     * Get all active overlays
+     * @returns Array of active overlay IDs
+     */
+    getActiveOverlays(): string[];
+    /**
+     * Check if an overlay exists
+     * @param overlayId The overlay ID
+     * @returns True if the overlay exists
+     */
+    hasOverlay(overlayId: string): boolean;
+    /**
+     * Get the currently active overlay ID
+     * @returns The active overlay ID or null if none is active
+     */
+    getActiveOverlayId(): string | null;
+    /**
+     * Get the overlay queue
+     * @returns Array of overlay IDs in the queue
+     */
+    getOverlayQueue(): string[];
+    /**
+     * Clear all overlays
+     * @returns The number of overlays removed
+     */
+    clearAllOverlays(): number;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Get debug information about registered overlays
+     * @returns Object with debug information
+     */
+    getDebugInfo(): {
+        totalOverlays: number;
+        overlaysByOwner: Record<string, number>;
+        overlaysByType: Record<string, number>;
+        activeOverlayId: string | null;
+        queueLength: number;
+        observerPaused: boolean;
+        overlayDetails: Array<{
+            id: string;
+            owner: string;
+            type: string;
+            isVisible: boolean;
+            priority: number;
+            autoRestoreEnabled: boolean;
+            createdAt: number;
+        }>;
+    };
+}