content-security-toolkit 1.0.0

package/dist/utils/environment.js

@@ -0,0 +1,267 @@
+// FEATURE/ENVIRONMENT DETECTION
+/**
+ * Detect browser environment
+ */
+export const isBrowser = () => {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+};
+/**
+ * Detect mobile device
+ */
+export const isMobile = () => {
+    if (!isBrowser())
+        return false;
+    const userAgent = navigator.userAgent;
+    // Standard mobile OS and browser detection
+    if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent)) {
+        return true;
+    }
+    // Chinese mobile devices
+    if (/Huawei|HUAWEI|Honor|HONOR|Xiaomi|MI\/|Redmi|POCO|OPPO|vivo|OnePlus|Realme/i.test(userAgent)) {
+        return true;
+    }
+    // Korean mobile devices
+    if (/Samsung|SAMSUNG|LG|Tizen/i.test(userAgent)) {
+        return true;
+    }
+    // Japanese mobile devices
+    if (/Sony|SONY|Xperia|Sharp|SHARP|Fujitsu|FOMA|KDDI/i.test(userAgent)) {
+        return true;
+    }
+    // Russian mobile devices
+    if (/Yandex.Phone|YandexPhone|BQ-|BQru/i.test(userAgent)) {
+        return true;
+    }
+    // Other mobile platforms
+    if (/Windows Phone|WindowsPhone|Lumia|Mobile|Tablet|Phone|WPDesktop|ZuneWP|WP7|wds|Fennec|Firefox OS|KaiOS|KAIOS|Sailfish/i.test(userAgent)) {
+        return true;
+    }
+    // Mobile browser detection
+    if (/Mobile|Tablet|Android|Touch/i.test(userAgent) && !/Windows NT|Mac OS X/i.test(userAgent)) {
+        return true;
+    }
+    // Feature detection for touch devices (most mobile devices have touch capability)
+    if (isBrowser() && ("ontouchstart" in window || navigator.maxTouchPoints > 0)) {
+        // Additional check to avoid false positives on desktops with touch screens
+        if (window.innerWidth <= 1024 || /Mobi|Android/i.test(userAgent)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Detect specific browser
+ */
+export const getBrowser = () => {
+    if (!isBrowser())
+        return { name: "unknown", version: "0" };
+    const ua = navigator.userAgent;
+    let browserName = "unknown";
+    let version = "0";
+    // Order matters here - we need to check more specific browsers first
+    // before falling back to more generic ones
+    // --- Chinese Browsers ---
+    if (/MicroMessenger|WeChat/.test(ua)) {
+        browserName = "wechat";
+        const match = ua.match(/MicroMessenger\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // QQ Browser
+    else if (/QQBrowser/.test(ua)) {
+        browserName = "qq";
+        const match = ua.match(/QQBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // UC Browser
+    else if (/UCBrowser/.test(ua)) {
+        browserName = "uc";
+        const match = ua.match(/UCBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Baidu Browser
+    else if (/Baidu|BIDUBrowser|baiduboxapp/.test(ua)) {
+        browserName = "baidu";
+        const match = ua.match(/(?:Baidu|BIDUBOX)(?:Browser)?\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Mi Browser
+    else if (/MiuiBrowser/.test(ua)) {
+        browserName = "mi";
+        const match = ua.match(/MiuiBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Russian Browsers ---
+    // Yandex Browser
+    else if (/YaBrowser/.test(ua)) {
+        browserName = "yandex";
+        const match = ua.match(/YaBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Korean Browsers ---
+    // Naver Whale
+    else if (/Whale/.test(ua)) {
+        browserName = "whale";
+        const match = ua.match(/Whale\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Mobile Browsers ---
+    // Samsung Internet
+    else if (/SamsungBrowser/.test(ua)) {
+        browserName = "samsung";
+        const match = ua.match(/SamsungBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Huawei Browser
+    else if (/HuaweiBrowser/.test(ua)) {
+        browserName = "huawei";
+        const match = ua.match(/HuaweiBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Alternative Browsers ---
+    // Vivaldi
+    else if (/Vivaldi/.test(ua)) {
+        browserName = "vivaldi";
+        const match = ua.match(/Vivaldi\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Lunascape
+    else if (/Lunascape/.test(ua)) {
+        browserName = "lunascape";
+        const match = ua.match(/Lunascape[/| ](\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Opera
+    else if (/OPR|Opera/.test(ua)) {
+        browserName = "opera";
+        const match = ua.match(/(?:OPR|Opera)[/| ](\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Emulators ---
+    // Nox Browser/Emulator
+    else if (/Nox/.test(ua)) {
+        browserName = "nox";
+        const match = ua.match(/Nox\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // BlueStacks
+    else if (/BlueStacks/.test(ua)) {
+        browserName = "bluestacks";
+        const match = ua.match(/BlueStacks\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Major Browsers (keep these last as fallbacks) ---
+    // Edge
+    else if (/Edg/.test(ua)) {
+        browserName = "edge";
+        const match = ua.match(/Edg\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Chrome
+    else if (/Chrome/.test(ua) && !/Chromium|Edge|Edg|OPR|Opera/.test(ua)) {
+        browserName = "chrome";
+        const match = ua.match(/Chrome\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Firefox
+    else if (/Firefox/.test(ua)) {
+        browserName = "firefox";
+        const match = ua.match(/Firefox\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Safari
+    else if (/Safari/.test(ua) && !/Chrome/.test(ua)) {
+        browserName = "safari";
+        const match = ua.match(/Version\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // IE
+    else if (/Trident|MSIE/.test(ua)) {
+        browserName = "ie";
+        const match = ua.match(/(?:rv:|MSIE )(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Chromium-based browsers not caught above
+    else if (/Chromium/.test(ua)) {
+        browserName = "chromium";
+        const match = ua.match(/Chromium\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    return { name: browserName, version };
+};
+/**
+ * Detect operating system
+ */
+export const getOS = () => {
+    if (!isBrowser())
+        return { name: "unknown" };
+    const platform = navigator.platform.toLowerCase();
+    const userAgent = navigator.userAgent.toLowerCase();
+    // macOS and iOS devices
+    if (platform.includes("mac") ||
+        platform.includes("ipad") ||
+        platform.includes("ipod") ||
+        platform.includes("iphone") ||
+        userAgent.includes("mac") ||
+        userAgent.includes("iphone") ||
+        userAgent.includes("ipad") ||
+        (userAgent.includes("safari") && !userAgent.includes("chrome") && !userAgent.includes("android"))) {
+        return { name: "mac" };
+    }
+    // Windows detection
+    else if (platform.includes("win") || userAgent.includes("win") || userAgent.includes("windows nt")) {
+        return { name: "windows" };
+    }
+    // Linux and Linux-based OS detection
+    else if (
+    // Standard Linux
+    platform.includes("linux") ||
+        userAgent.includes("linux") ||
+        // Android (Linux-based)
+        userAgent.includes("android") ||
+        // Chinese OS (most are Linux-based)
+        userAgent.includes("harmonyos") ||
+        userAgent.includes("deepin") ||
+        userAgent.includes("uos") ||
+        userAgent.includes("cos") ||
+        // Russian Linux distributions
+        userAgent.includes("astra linux") ||
+        userAgent.includes("alt linux") ||
+        userAgent.includes("rosa") ||
+        // Korean OS
+        userAgent.includes("tizen") ||
+        userAgent.includes("gooroom") ||
+        // Other Linux-based OS
+        userAgent.includes("ubuntu") ||
+        userAgent.includes("debian") ||
+        userAgent.includes("fedora") ||
+        userAgent.includes("red hat") ||
+        userAgent.includes("suse") ||
+        userAgent.includes("mint") ||
+        // Chrome OS (Linux-based)
+        userAgent.includes("cros") ||
+        userAgent.includes("chromium os") ||
+        userAgent.includes("chrome os") ||
+        // BSD variants (Unix-like, grouped with Linux for simplicity)
+        userAgent.includes("freebsd") ||
+        userAgent.includes("openbsd") ||
+        userAgent.includes("netbsd")) {
+        return { name: "linux" };
+    }
+    // Fallback for undetected OS
+    return { name: "unknown" };
+};
+/**
+ * Check if print is supported
+ */
+export const isPrintSupported = () => {
+    return isBrowser() && typeof window.print === 'function';
+};
+/**
+ * Check if beforeprint event is supported
+ */
+export const isBeforePrintSupported = () => {
+    if (!isBrowser())
+        return false;
+    const mediaQueryList = window.matchMedia('print');
+    return !!mediaQueryList.addListener || 'onbeforeprint' in window;
+};

package/dist/utils/eventManager.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Options for event registration
+ */
+export interface EventRegistrationOptions extends AddEventListenerOptions {
+    /**
+     * Optional ID for the event (auto-generated if not provided)
+     */
+    id?: string;
+    /**
+     * Priority for the event handler (higher executes first)
+     * @default 0
+     */
+    priority?: number;
+}
+/**
+ * EventManager centralizes event handling across protection strategies
+ * It provides a unified API for registering and removing event listeners
+ * and ensures proper cleanup when strategies are removed
+ */
+export declare class EventManager {
+    private static instance;
+    private events;
+    private targetMap;
+    private readonly DOCUMENT_SYMBOL;
+    private readonly WINDOW_SYMBOL;
+    private logger;
+    /**
+     * Create a new EventManager
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    private constructor();
+    /**
+     * Get the EventManager instance (singleton)
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    static getInstance(debugMode?: boolean): EventManager;
+    /**
+     * Register an event listener
+     * @param target The target element, document, or window
+     * @param eventType The type of event (e.g., "click", "keydown")
+     * @param handler The event handler function
+     * @param owner The component or strategy that owns this event
+     * @param options Additional options for the event listener
+     * @returns The ID of the registered event
+     */
+    addEventListener(target: EventTarget | null, eventType: string, handler: EventListener, owner: string, options?: EventRegistrationOptions): string;
+    /**
+     * Remove a specific event listener by ID
+     * @param target The target element, document, or window
+     * @param eventId The ID of the event to remove
+     * @returns True if the event was removed, false otherwise
+     */
+    removeEventListener(target: EventTarget | null, eventId: string): boolean;
+    /**
+     * Remove all event listeners for a specific owner (strategy/component)
+     * @param owner The owner to remove events for
+     * @returns The number of events removed
+     */
+    removeEventsByOwner(owner: string): number;
+    /**
+     * Remove all event listeners for a specific target
+     * @param target The target to remove events from
+     * @returns The number of events removed
+     */
+    removeAllEventsForTarget(target: EventTarget | null): number;
+    /**
+     * Get all event IDs for a specific owner
+     * @param owner The owner to get events for
+     * @returns Array of event IDs
+     */
+    getEventsByOwner(owner: string): string[];
+    /**
+     * Check if an event exists
+     * @param target The target element
+     * @param eventId The event ID
+     * @returns True if the event exists
+     */
+    hasEvent(target: EventTarget | null, eventId: string): boolean;
+    /**
+     * Get a unique identifier for a target
+     * @param target The target element, document, or window
+     * @param create Whether to create a new ID if one doesn't exist
+     * @returns The target ID
+     */
+    private getTargetId;
+    /**
+     * Get a target from its ID
+     * @param targetId The target ID
+     * @returns The target element or null
+     */
+    private getTargetFromId;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Get the number of registered events
+     * @returns The total number of registered events
+     */
+    getEventCount(): number;
+    /**
+     * Get debug information about registered events
+     * @returns Object with debug information
+     */
+    getDebugInfo(): {
+        totalEvents: number;
+        eventsByOwner: Record<string, number>;
+        eventsByType: Record<string, number>;
+        eventDetails: Array<{
+            targetId: string | symbol;
+            eventId: string;
+            eventType: string;
+            owner: string;
+            priority: number;
+        }>;
+    };
+    /**
+     * Clear all registered events
+     * @returns The number of events removed
+     */
+    clearAllEvents(): number;
+    /**
+     * Check if an event handler is already registered for this target, event type, and owner
+     * This helps prevent duplicate registrations
+     * @param target The target element
+     * @param eventType The event type (e.g., "click", "contextmenu")
+     * @param owner The owner of the event handler
+     * @returns True if an event handler is already registered
+     */
+    hasRegisteredEventType(target: EventTarget | null, eventType: string, owner: string): boolean;
+    /**
+     * Check for potential conflicts with existing event listeners
+     * @param target The target element
+     * @param eventType The event type (e.g., "click", "contextmenu")
+     * @param owner The owner of the event handler
+     * @returns Object with conflict information
+     */
+    checkForConflicts(target: EventTarget | null, eventType: string, owner: string): {
+        hasConflicts: boolean;
+        conflictsWith: Array<{
+            owner: string;
+            eventId: string;
+        }>;
+    };
+    /**
+     * Get events of a specific type for a target
+     * @param target The target element
+     * @param eventType The event type (e.g., "click", "contextmenu")
+     * @returns Array of event information
+     */
+    getEventsByType(target: EventTarget | null, eventType: string): Array<{
+        eventId: string;
+        owner: string;
+        priority: number;
+    }>;
+    /**
+     * Remove event listeners by selector
+     * Useful for Vue components and other dynamically created elements
+     * @param selector CSS selector to match elements
+     * @param eventType The event type (e.g., "click", "contextmenu")
+     * @param owner The owner of the event handler
+     * @returns The number of events removed
+     */
+    removeEventsBySelector(selector: string, eventType: string, owner: string): number;
+}
+export declare const eventManager: EventManager;