content-security-toolkit 1.0.0

package/dist/utils/logging/simple/Loggable.js

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

package/dist/utils/logging/simple/LoggingDelegate.d.ts

@@ -0,0 +1,42 @@
+import { Loggable } from "./Loggable";
+/**
+ * Delegate class that implements logging functionality
+ * Can be composed into any class that needs logging
+ */
+export declare class LoggingDelegate implements Loggable {
+    private logger;
+    /**
+     * Create a new LoggingDelegate
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName: string, debugMode?: boolean);
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Check if debug mode is enabled
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled(): boolean;
+}

package/dist/utils/logging/simple/LoggingDelegate.js

@@ -0,0 +1,53 @@
+import { SimpleLoggingService } from "./SimpleLoggingService";
+/**
+ * Delegate class that implements logging functionality
+ * Can be composed into any class that needs logging
+ */
+export class LoggingDelegate {
+    /**
+     * Create a new LoggingDelegate
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName, debugMode = false) {
+        this.logger = new SimpleLoggingService(componentName, debugMode);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.logger.setDebugMode(enabled);
+    }
+    /**
+     * Check if debug mode is enabled
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled() {
+        return this.logger.isDebugEnabled();
+    }
+}

package/dist/utils/logging/simple/SimpleLoggingService.d.ts

@@ -0,0 +1,39 @@
+export declare class SimpleLoggingService {
+    private componentName;
+    private debugMode;
+    /**
+     * Create a new SimpleLoggingService
+     * for consistent logging across the toolkit
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName: string, debugMode?: boolean);
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Get current debug mode
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled(): boolean;
+}

package/dist/utils/logging/simple/SimpleLoggingService.js

@@ -0,0 +1,58 @@
+export class SimpleLoggingService {
+    /**
+     * Create a new SimpleLoggingService
+     * for consistent logging across the toolkit
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName, debugMode = false) {
+        this.componentName = componentName;
+        this.debugMode = debugMode;
+    }
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message, ...args) {
+        if (this.debugMode) {
+            console.log(`${this.componentName}: ${message}`, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.debugMode) {
+            console.warn(`${this.componentName}: ${message}`, ...args);
+        }
+        else {
+            // In non-debug mode, only log the message without args for brevity
+            console.warn(`${this.componentName}: ${message}`);
+        }
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        console.error(`${this.componentName}: ${message}`, ...args);
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+    /**
+     * Get current debug mode
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled() {
+        return this.debugMode;
+    }
+}

package/dist/utils/orientation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Check if the device is currently in landscape mode using the Screen Orientation API
+ * @returns true if in landscape mode, false if in portrait mode
+ */
+export declare function isLandscape(): boolean;
+/**
+ * Get the current orientation type
+ * @returns The orientation type string or null if not available
+ */
+export declare function getOrientationType(): string | null;
+/**
+ * Get the current orientation angle in degrees
+ * @returns The orientation angle in degrees or 0 if not available
+ */
+export declare function getOrientationAngle(): number;

package/dist/utils/orientation.js

@@ -0,0 +1,32 @@
+/**
+ * Check if the device is currently in landscape mode using the Screen Orientation API
+ * @returns true if in landscape mode, false if in portrait mode
+ */
+export function isLandscape() {
+    if (typeof screen === 'undefined' || !screen.orientation) {
+        // Fallback to window dimensions if Screen Orientation API is not available
+        return window.innerWidth > window.innerHeight;
+    }
+    // Use Screen Orientation API
+    return screen.orientation.type.includes('landscape');
+}
+/**
+ * Get the current orientation type
+ * @returns The orientation type string or null if not available
+ */
+export function getOrientationType() {
+    if (typeof screen === 'undefined' || !screen.orientation) {
+        return window.innerWidth > window.innerHeight ? 'landscape' : 'portrait';
+    }
+    return screen.orientation.type;
+}
+/**
+ * Get the current orientation angle in degrees
+ * @returns The orientation angle in degrees or 0 if not available
+ */
+export function getOrientationAngle() {
+    if (typeof screen === 'undefined' || !screen.orientation) {
+        return 0;
+    }
+    return screen.orientation.angle;
+}

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

@@ -0,0 +1,162 @@
+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;
+    private logger;
+    private contentStates;
+    private activeStateId;
+    private stateQueue;
+    private onContentHiddenCallback?;
+    private onContentRestoredCallback?;
+    private lastHideReason;
+    /**
+     * 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
+     * @param mediator The protection mediator instance
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Handle content hidden event
+     * @param event The protection event containing content hidden data
+     */
+    private handleContentHidden;
+    /**
+     * Handle content restored event
+     * @param event The protection event containing content restored data
+     */
+    private handleContentRestored;
+    /**
+     * Register a new content state
+     * @param owner The strategy or component that owns this state
+     * @param reason The reason for hiding content
+     * @param options Options for the placeholder
+     * @param priority Priority for content hiding (higher numbers take precedence)
+     * @returns The ID of the registered content state
+     */
+    private registerContentState;
+    /**
+     * Add a content state to the queue
+     * @param stateId ID of the content state to add to queue
+     */
+    private addToQueue;
+    /**
+     * Apply a specific content state by ID
+     * @param stateId ID of the content state to apply
+     * @returns True if the state was applied successfully
+     */
+    private applyContentStateById;
+    /**
+     * Remove content states for a specific owner
+     * @param owner The owner to remove states for
+     * @returns The number of states removed
+     */
+    private removeContentStatesByOwner;
+    /**
+     * 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;
+    /**
+     * Get the currently active content state ID
+     * @returns The active content state ID or null if none is active
+     */
+    getActiveContentStateId(): string | null;
+    /**
+     * Get all content states for a specific owner
+     * @param owner The owner to get states for
+     * @returns Array of content state IDs
+     */
+    getContentStatesByOwner(owner: string): string[];
+    /**
+     * 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;
+    /**
+     * Set callbacks for content visibility changes
+     * Useful for frameworks like Vue that need to re-mount components after content restoration
+     * @param onHidden Callback invoked when content is hidden
+     * @param onRestored Callback invoked when content is restored
+     */
+    setContentCallbacks(onHidden?: (reason: string, targetElement: HTMLElement | null) => void, onRestored?: (targetElement: HTMLElement | null) => void): void;
+    /**
+     * Clear all content states
+     * @returns The number of states removed
+     */
+    clearAllContentStates(): number;
+    /**
+     * Get debug information about content states
+     * @returns Object with debug information
+     */
+    getDebugInfo(): {
+        totalStates: number;
+        statesByOwner: Record<string, number>;
+        statesByReason: Record<string, number>;
+        activeStateId: string | null;
+        queueLength: number;
+        stateDetails: Array<{
+            id: string;
+            owner: string;
+            reason: string;
+            priority: number;
+            hiddenAt: number;
+        }>;
+    };
+}