content-security-toolkit 1.0.0

package/dist/core/mediator/handlers/iFrameEventHandlers.js

@@ -0,0 +1,93 @@
+import { ProtectionEventType } from "../../mediator/protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for frame embedding events
+ */
+export class FrameEmbeddingEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new FrameEmbeddingEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "FrameEmbeddingEventHandler", debugMode);
+    }
+    /**
+     * Initialize the handler and set up event subscriptions
+     */
+    initialize() {
+        // Subscribe to the FRAME_EMBEDDING_DETECTED event
+        this.subscribe(ProtectionEventType.FRAME_EMBEDDING_DETECTED, this.handleFrameEmbeddingDetected.bind(this));
+        this.log("Initialized and subscribed to frame embedding events");
+    }
+    /**
+     * Handle frame embedding detection event
+     * @param event The protection event containing frame embedding data
+     */
+    handleFrameEmbeddingDetected(event) {
+        try {
+            const frameEvent = event;
+            this.log("Handling frame embedding detected event", frameEvent);
+            const data = frameEvent.data;
+            if (!data) {
+                this.warn("Received invalid frame embedding event data");
+                return;
+            }
+            // Only handle external frames
+            if (data.isEmbedded && data.isExternalFrame) {
+                this.log(`Applying protection for external frame embedding from ${data.parentDomain || "unknown domain"}`);
+                // Show overlay if configured
+                if (data.showOverlay) {
+                    this.mediator.publish({
+                        type: ProtectionEventType.OVERLAY_SHOWN,
+                        source: this.COMPONENT_NAME,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: this.COMPONENT_NAME,
+                            overlayType: "frame_embedding",
+                            options: {
+                                ...data.overlayOptions,
+                                blockEvents: true,
+                                autoRestore: true,
+                            },
+                            priority: 9, // High priority for frame embedding
+                        },
+                    });
+                }
+                // Hide content if configured
+                if (data.hideContent) {
+                    this.mediator.publish({
+                        type: ProtectionEventType.CONTENT_HIDDEN,
+                        source: this.COMPONENT_NAME,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: this.COMPONENT_NAME,
+                            reason: "frame_embedding",
+                            targetElement: data.targetElement,
+                            options: {
+                                title: data.overlayOptions?.title,
+                                message: data.overlayOptions?.message,
+                                secondaryMessage: data.overlayOptions?.secondaryMessage,
+                                textColor: "black",
+                                backgroundColor: "rgba(0, 0, 0, 0.05)",
+                            },
+                            priority: 9, // High priority for frame embedding
+                        },
+                    });
+                }
+            }
+            else {
+                this.log("Skipping protection for non-external frame embedding");
+            }
+        }
+        catch (error) {
+            this.error("Error handling frame embedding detected event:", error);
+        }
+    }
+    /**
+     * Clean up resources when the handler is disposed
+     */
+    onDispose() {
+        // No additional cleanup needed beyond what the base class does
+    }
+}

package/dist/core/mediator/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import type { ProtectionMediator } from "../types";
+export declare class HandlerRegistry {
+    private handlers;
+    private mediator;
+    private debugMode;
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    private initializeHandlers;
+    setDebugMode(enabled: boolean): void;
+}

package/dist/core/mediator/handlers/index.js

@@ -0,0 +1,34 @@
+import { DevToolsEventHandler } from "./devToolsEventHandler";
+import { BrowserExtensionEventHandler } from "./extensionEventHandlers";
+import { FrameEmbeddingEventHandler } from "./iFrameEventHandlers";
+import { ScreenshotEventHandler } from "./screenShotEventHandlers";
+export class HandlerRegistry {
+    constructor(mediator, debugMode = false) {
+        this.handlers = {};
+        this.mediator = mediator;
+        this.debugMode = debugMode;
+        this.initializeHandlers();
+    }
+    initializeHandlers() {
+        // Initialize all handlers
+        this.handlers.devTools = new DevToolsEventHandler(this.mediator, this.debugMode);
+        this.handlers.extension = new BrowserExtensionEventHandler(this.mediator, this.debugMode);
+        this.handlers.screenshot = new ScreenshotEventHandler(this.mediator, this.debugMode);
+        this.handlers.iFrame = new FrameEmbeddingEventHandler(this.mediator, this.debugMode);
+        // Add more handlers as you implement them
+        // this.handlers.screenshot = new ScreenshotEventHandler(this.mediator, this.debugMode);
+        // this.handlers.frameEmbedding = new FrameEmbeddingEventHandler(this.mediator, this.debugMode);
+        if (this.debugMode) {
+            console.log("HandlerRegistry: Initialized all event handlers");
+        }
+    }
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        // Update debug mode for all handlers
+        Object.values(this.handlers).forEach(handler => {
+            if (typeof handler.setDebugMode === 'function') {
+                handler.setDebugMode(enabled);
+            }
+        });
+    }
+}

package/dist/core/mediator/handlers/screenShotEventHandlers.d.ts

@@ -0,0 +1,34 @@
+import type { ProtectionMediator } from "../../mediator/types";
+import { type ProtectionEvent } from "../protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for screenshot detection events
+ */
+export declare class ScreenshotEventHandler extends AbstractEventHandler {
+    private timeoutManager;
+    private activeTimeouts;
+    /**
+     * Create a new ScreenshotEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    protected initialize(): void;
+    /**
+     * Handle screenshot attempt event
+     * @param event The protection event
+     */
+    handleScreenshotAttempt(event: ProtectionEvent): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    protected onDispose(): void;
+}

package/dist/core/mediator/handlers/screenShotEventHandlers.js

@@ -0,0 +1,111 @@
+import { ProtectionEventType } from "../protection-event";
+import { TimeoutManager } from "../../../utils/timeoutManager";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for screenshot detection events
+ */
+export class ScreenshotEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new ScreenshotEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "ScreenshotEventHandler", debugMode);
+        this.activeTimeouts = new Set(); // Track active timeouts
+        this.timeoutManager = TimeoutManager.getInstance();
+        this.timeoutManager.setDebugMode(this.debugMode);
+    }
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    initialize() {
+        // Subscribe to the SCREENSHOT_ATTEMPT event
+        this.subscribe(ProtectionEventType.SCREENSHOT_ATTEMPT, this.handleScreenshotAttempt.bind(this));
+    }
+    /**
+     * Handle screenshot attempt event
+     * @param event The protection event
+     */
+    handleScreenshotAttempt(event) {
+        const screenshotEvent = event;
+        this.log("Handling screenshot attempt event", screenshotEvent);
+        // Generate a unique ID for this protection instance
+        const protectionId = `screenshot_${Date.now()}`;
+        if (screenshotEvent.data.showOverlay) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: screenshotEvent.source,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: screenshotEvent.source,
+                    overlayType: "screenshot",
+                    options: {
+                        ...screenshotEvent.data.overlayOptions,
+                        blockEvents: false, // Don't block events, just show a notification
+                        autoRestore: true,
+                    },
+                    priority: screenshotEvent.data.priority || 5,
+                    duration: screenshotEvent.data.overlayOptions?.duration || 3000
+                },
+            });
+        }
+        if (screenshotEvent.data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_HIDDEN,
+                source: screenshotEvent.source,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: screenshotEvent.source,
+                    reason: "screenshot_attempt",
+                    options: {
+                        title: screenshotEvent.data.overlayOptions?.title,
+                        message: screenshotEvent.data.overlayOptions?.message,
+                        secondaryMessage: screenshotEvent.data.overlayOptions?.secondaryMessage,
+                        textColor: 'black',
+                        backgroundColor: screenshotEvent.data.overlayOptions?.backgroundColor || "rgba(0, 0, 0, 0.05)",
+                    },
+                    targetElement: screenshotEvent.data.target,
+                    priority: screenshotEvent.data.priority || 5,
+                },
+            });
+            // Create a unique timeout ID for this screenshot event
+            const contentTimeoutId = `${protectionId}_content`;
+            this.activeTimeouts.add(contentTimeoutId);
+            // If duration is specified, set a timeout to restore content
+            if (screenshotEvent.data.overlayOptions?.duration) {
+                this.timeoutManager.setTimeout(contentTimeoutId, () => {
+                    this.mediator.publish({
+                        type: ProtectionEventType.CONTENT_RESTORED,
+                        source: screenshotEvent.source,
+                        timestamp: Date.now(),
+                        data: {
+                            strategyName: screenshotEvent.source,
+                            targetElement: screenshotEvent.data.target,
+                        },
+                    });
+                    this.activeTimeouts.delete(contentTimeoutId);
+                }, screenshotEvent.data.overlayOptions?.duration);
+                this.log(`Set timeout ${contentTimeoutId} to restore content after ${screenshotEvent.data.overlayOptions.duration}s`);
+            }
+        }
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        super.setDebugMode(enabled);
+        this.timeoutManager.setDebugMode(enabled);
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    onDispose() {
+        // Clear all active timeouts
+        for (const timeoutId of this.activeTimeouts) {
+            this.timeoutManager.clearTimeout(timeoutId);
+        }
+        this.activeTimeouts.clear();
+    }
+}

package/dist/core/mediator/protection-event.d.ts

@@ -0,0 +1,94 @@
+import { EventDataMap } from "./eventDataTypes";
+/**
+ * Types of protection events that can be published and subscribed to
+ */
+export declare enum ProtectionEventType {
+    STRATEGY_APPLIED = "strategy:applied",
+    STRATEGY_REMOVED = "strategy:removed",
+    STRATEGY_UPDATED = "strategy:updated",
+    CONTEXT_MENU_ATTEMPT = "interaction:contextmenu",
+    SELECTION_ATTEMPT = "interaction:selection",
+    DRAG_ATTEMPT = "interaction:drag",
+    KEYBOARD_SHORTCUT_BLOCKED = "interaction:keyboard",
+    PRINT_ATTEMPT = "protection:print",
+    SCREENSHOT_ATTEMPT = "protection:screenshot",
+    DEVTOOLS_STATE_CHANGE = "protection:devtools",
+    EXTENSION_DETECTED = "protection:extension",
+    FRAME_EMBEDDING_DETECTED = "protection:frame",
+    FULLSCREEN_CHANGE = "protection:fullscreen",
+    WATERMARK_TAMPERED = "protection:watermark_tampered",
+    OVERLAY_SHOWN = "overlay:shown",
+    OVERLAY_REMOVED = "overlay:removed",
+    OVERLAY_RESTORED = "overlay:restored",
+    CONTENT_HIDDEN = "content:hidden",
+    CONTENT_RESTORED = "content:restored",
+    WATERMARK_CREATED = "content:watermark_created",
+    WATERMARK_REMOVED = "content:watermark_removed",
+    MEDIATOR_INITIALIZED = "mediator:initialized",
+    MEDIATOR_DISPOSED = "mediator:disposed",
+    ERROR_OCCURRED = "system:error",
+    DEBUG_MESSAGE = "system:debug",
+    CONFIG_UPDATED = "system:config_updated",
+    KEYBOARD_SHORTCUTS_REQUESTED = "keyboard:shortcuts_requested",
+    KEYBOARD_SHORTCUTS_PROVIDED = "keyboard:shortcuts_provided",
+    KEYBOARD_SHORTCUTS_UPDATED = "keyboard:shortcuts_updated"
+}
+/**
+ * Base protection event interface
+ */
+export interface ProtectionEvent {
+    /**
+     * Type of the event
+     */
+    type: ProtectionEventType;
+    /**
+     * Source of the event (usually strategy name)
+     */
+    source: string;
+    /**
+     * Timestamp when the event occurred
+     */
+    timestamp: number;
+    /**
+     * Additional data specific to the event type
+     */
+    data?: unknown;
+}
+/**
+ * Event for DevTools state changes
+ */
+export interface DevToolsEvent extends ProtectionEvent {
+    type: ProtectionEventType.DEVTOOLS_STATE_CHANGE;
+    data: EventDataMap[ProtectionEventType.DEVTOOLS_STATE_CHANGE];
+}
+/**
+ * Event for extension detection
+ */
+export interface ExtensionEvent extends ProtectionEvent {
+    type: ProtectionEventType.EXTENSION_DETECTED;
+    data: EventDataMap[ProtectionEventType.EXTENSION_DETECTED];
+}
+/**
+ * Event for screenshot detection
+ */
+export interface ScreenshotEvent extends ProtectionEvent {
+    type: ProtectionEventType.SCREENSHOT_ATTEMPT;
+    data: EventDataMap[ProtectionEventType.SCREENSHOT_ATTEMPT];
+}
+/**
+ * Event for frame embedding detection
+ */
+export interface FrameEmbeddingEvent extends ProtectionEvent {
+    type: ProtectionEventType.FRAME_EMBEDDING_DETECTED;
+    data: EventDataMap[ProtectionEventType.FRAME_EMBEDDING_DETECTED];
+}
+/**
+ * Event for watermark-related events
+ */
+export interface WatermarkEvent extends ProtectionEvent {
+    data: {
+        targetElement?: HTMLElement | null;
+        watermarkId?: string;
+        [key: string]: unknown;
+    };
+}

package/dist/core/mediator/protection-event.js

@@ -0,0 +1,43 @@
+/**
+ * Types of protection events that can be published and subscribed to
+ */
+export var ProtectionEventType;
+(function (ProtectionEventType) {
+    // Strategy lifecycle events
+    ProtectionEventType["STRATEGY_APPLIED"] = "strategy:applied";
+    ProtectionEventType["STRATEGY_REMOVED"] = "strategy:removed";
+    ProtectionEventType["STRATEGY_UPDATED"] = "strategy:updated";
+    // User interaction events
+    ProtectionEventType["CONTEXT_MENU_ATTEMPT"] = "interaction:contextmenu";
+    ProtectionEventType["SELECTION_ATTEMPT"] = "interaction:selection";
+    ProtectionEventType["DRAG_ATTEMPT"] = "interaction:drag";
+    ProtectionEventType["KEYBOARD_SHORTCUT_BLOCKED"] = "interaction:keyboard";
+    // Protection events
+    ProtectionEventType["PRINT_ATTEMPT"] = "protection:print";
+    ProtectionEventType["SCREENSHOT_ATTEMPT"] = "protection:screenshot";
+    ProtectionEventType["DEVTOOLS_STATE_CHANGE"] = "protection:devtools";
+    ProtectionEventType["EXTENSION_DETECTED"] = "protection:extension";
+    ProtectionEventType["FRAME_EMBEDDING_DETECTED"] = "protection:frame";
+    ProtectionEventType["FULLSCREEN_CHANGE"] = "protection:fullscreen";
+    ProtectionEventType["WATERMARK_TAMPERED"] = "protection:watermark_tampered";
+    // Overlay events
+    ProtectionEventType["OVERLAY_SHOWN"] = "overlay:shown";
+    ProtectionEventType["OVERLAY_REMOVED"] = "overlay:removed";
+    ProtectionEventType["OVERLAY_RESTORED"] = "overlay:restored";
+    // Content events
+    ProtectionEventType["CONTENT_HIDDEN"] = "content:hidden";
+    ProtectionEventType["CONTENT_RESTORED"] = "content:restored";
+    ProtectionEventType["WATERMARK_CREATED"] = "content:watermark_created";
+    ProtectionEventType["WATERMARK_REMOVED"] = "content:watermark_removed";
+    // Mediator events
+    ProtectionEventType["MEDIATOR_INITIALIZED"] = "mediator:initialized";
+    ProtectionEventType["MEDIATOR_DISPOSED"] = "mediator:disposed";
+    // System events
+    ProtectionEventType["ERROR_OCCURRED"] = "system:error";
+    ProtectionEventType["DEBUG_MESSAGE"] = "system:debug";
+    ProtectionEventType["CONFIG_UPDATED"] = "system:config_updated";
+    // Keyboard 
+    ProtectionEventType["KEYBOARD_SHORTCUTS_REQUESTED"] = "keyboard:shortcuts_requested";
+    ProtectionEventType["KEYBOARD_SHORTCUTS_PROVIDED"] = "keyboard:shortcuts_provided";
+    ProtectionEventType["KEYBOARD_SHORTCUTS_UPDATED"] = "keyboard:shortcuts_updated";
+})(ProtectionEventType || (ProtectionEventType = {}));

package/dist/core/mediator/types.d.ts

@@ -0,0 +1,105 @@
+import { EventDataMap } from './eventDataTypes';
+import { ProtectionEvent, ProtectionEventType } from './protection-event';
+/**
+ * Event handler function type
+ */
+export type ProtectionEventHandler = (event: ProtectionEvent) => void;
+/**
+ * Subscription information
+ */
+export interface Subscription {
+    /**
+     * Unique ID for the subscription
+     */
+    id: string;
+    /**
+     * Event type being subscribed to
+     */
+    eventType: ProtectionEventType;
+    /**
+     * Handler function for the event
+     */
+    handler: ProtectionEventHandler;
+    /**
+     * Optional filter function to determine if the handler should be called
+     */
+    filter?: (event: ProtectionEvent) => boolean;
+    /**
+     * Optional priority for the handler (higher numbers execute first)
+     */
+    priority?: number;
+    /**
+     * Optional context information (e.g., strategy name)
+     */
+    context?: string;
+}
+/**
+ * Subscription options
+ */
+export interface SubscriptionOptions {
+    /**
+     * Optional filter function to determine if the handler should be called
+     */
+    filter?: (event: ProtectionEvent) => boolean;
+    /**
+     * Optional priority for the handler (higher numbers execute first)
+     */
+    priority?: number;
+    /**
+     * Optional context information (e.g., strategy name)
+     */
+    context?: string;
+}
+/**
+ * Interface for the protection mediator
+ */
+export interface ProtectionMediator {
+    /**
+     * Subscribe to an event
+     * @param eventType Type of event to subscribe to
+     * @param handler Handler function for the event
+     * @param options Optional subscription options
+     * @returns Subscription ID for later unsubscribing
+     */
+    subscribe(eventType: ProtectionEventType, handler: ProtectionEventHandler, options?: SubscriptionOptions): string;
+    /**
+     * Unsubscribe from an event
+     * @param subscriptionId ID of the subscription to remove
+     * @returns True if the subscription was found and removed
+     */
+    unsubscribe(subscriptionId: string): boolean;
+    /**
+     * Publish an event to all subscribers
+     * @param event Event to publish
+     */
+    publish<T extends ProtectionEventType | string>(event: Omit<ProtectionEvent, "data"> & {
+        type: T;
+        data?: T extends ProtectionEventType ? EventDataMap[T] : Record<string, unknown>;
+    }): void;
+    /**
+     * Get all subscriptions for a specific event type
+     * @param eventType Type of event to get subscriptions for
+     * @returns Array of subscriptions
+     */
+    getSubscriptions(eventType: ProtectionEventType): Subscription[];
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}
+/**
+ * Interface for components that can work with the mediator
+ */
+export interface MediatorAware {
+    /**
+     * Set the mediator for this component
+     * @param mediator The protection mediator
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Get the component name
+     * Used to identify the component in mediator communications
+     */
+    readonly COMPONENT_NAME: string;
+}

package/dist/core/mediator/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ContentProtector } from './core/index.js';
+export * from './types/index.js';
+export * from './strategies/index.js';
+export * from './utils/index.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+// MAIN ENTRY POINT
+export { ContentProtector } from './core/index.js';
+export * from './types/index.js';
+export * from './strategies/index.js';
+export * from './utils/index.js';