@tindalabs/shield 0.1.0

package/dist/utils/intervalManager.js

@@ -0,0 +1,221 @@
+import { isBrowser } from "./environment";
+import { LoggableComponent } from "./base/LoggableComponent";
+/**
+ * Manages periodic tasks for the content protection toolkit
+ * Consolidates multiple interval timers into a single efficient timer
+ */
+export class IntervalManager extends LoggableComponent {
+    /**
+     * Create a new IntervalManager
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(debugMode = false) {
+        super("IntervalManager", debugMode);
+        this.tasks = new Map();
+        this.intervalId = null;
+        this.intervalFrequency = 500; // Base interval in ms (2 checks per second)
+        this.isRunning = false;
+        this.logger.log("Initialized");
+    }
+    /**
+     * Register a new task to be executed periodically
+     * @param id Unique identifier for the task
+     * @param callback Function to execute
+     * @param frequency How often to run the task in milliseconds
+     * @returns The task ID for later reference
+     */
+    registerTask(id, callback, frequency) {
+        if (!isBrowser())
+            return id;
+        // Ensure we have a unique ID by appending a timestamp if needed
+        let taskId = id;
+        if (this.tasks.has(taskId)) {
+            taskId = `${id}-${Date.now()}`;
+        }
+        this.tasks.set(taskId, {
+            id: taskId,
+            callback,
+            frequency,
+            lastRun: 0,
+            isActive: true,
+        });
+        this.logger.log(`Registered task "${taskId}" with frequency ${frequency}ms`);
+        // Start the interval if it's not already running
+        this.startInterval();
+        return taskId;
+    }
+    /**
+     * Unregister a task by ID
+     * @param id Task ID to remove
+     * @returns True if the task was found and removed
+     */
+    unregisterTask(id) {
+        if (!isBrowser())
+            return false;
+        const result = this.tasks.delete(id);
+        if (result) {
+            this.logger.log(`Unregistered task "${id}"`);
+        }
+        // If no tasks remain, stop the interval
+        if (this.tasks.size === 0) {
+            this.stopInterval();
+        }
+        return result;
+    }
+    /**
+     * Pause a specific task without removing it
+     * @param id Task ID to pause
+     * @returns True if the task was found and paused
+     */
+    pauseTask(id) {
+        if (!isBrowser())
+            return false;
+        const task = this.tasks.get(id);
+        if (task) {
+            task.isActive = false;
+            this.tasks.set(id, task);
+            this.logger.log(`Paused task "${id}"`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Resume a paused task
+     * @param id Task ID to resume
+     * @returns True if the task was found and resumed
+     */
+    resumeTask(id) {
+        if (!isBrowser())
+            return false;
+        const task = this.tasks.get(id);
+        if (task) {
+            task.isActive = true;
+            this.tasks.set(id, task);
+            this.logger.log(`Resumed task "${id}"`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Start the interval timer
+     */
+    startInterval() {
+        if (this.isRunning || !isBrowser())
+            return;
+        this.intervalId = window.setInterval(() => {
+            this.executeEligibleTasks();
+        }, this.intervalFrequency);
+        this.isRunning = true;
+        this.logger.log(`Started interval timer with frequency ${this.intervalFrequency}ms`);
+    }
+    /**
+     * Stop the interval timer
+     */
+    stopInterval() {
+        if (!this.isRunning || !isBrowser())
+            return;
+        if (this.intervalId !== null) {
+            window.clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.isRunning = false;
+        this.logger.log("Stopped interval timer");
+    }
+    /**
+     * Execute all tasks that are due to run
+     */
+    executeEligibleTasks() {
+        const now = Date.now();
+        this.tasks.forEach((task) => {
+            // Skip inactive tasks
+            if (!task.isActive)
+                return;
+            // Check if the task is due to run
+            const timeSinceLastRun = now - (task.lastRun || 0);
+            if (timeSinceLastRun >= task.frequency) {
+                try {
+                    this.logger.log(`Executing task "${task.id}"`);
+                    // Execute the task
+                    task.callback();
+                    // Update the last run time
+                    task.lastRun = now;
+                    this.tasks.set(task.id, task);
+                }
+                catch (error) {
+                    this.logger.error(`Error executing task "${task.id}":`, error);
+                }
+            }
+        });
+    }
+    /**
+     * Force execution of a specific task immediately
+     * @param id Task ID to execute
+     * @returns True if the task was found and executed
+     */
+    executeTaskNow(id) {
+        if (!isBrowser())
+            return false;
+        const task = this.tasks.get(id);
+        if (task && task.isActive) {
+            try {
+                this.logger.log(`Executing task "${id}" immediately`);
+                task.callback();
+                task.lastRun = Date.now();
+                this.tasks.set(id, task);
+                return true;
+            }
+            catch (error) {
+                this.logger.error(`Error executing task "${id}" immediately:`, error);
+            }
+        }
+        return false;
+    }
+    /**
+     * Get the current status of all registered tasks
+     * @returns Array of task status objects
+     */
+    getTasksStatus() {
+        const now = Date.now();
+        const result = [];
+        this.tasks.forEach((task) => {
+            result.push({
+                id: task.id,
+                isActive: task.isActive,
+                frequency: task.frequency,
+                lastRun: task.lastRun,
+                timeSinceLastRun: task.lastRun ? now - task.lastRun : null,
+            });
+        });
+        return result;
+    }
+    /**
+     * Clean up and stop all intervals
+     */
+    dispose() {
+        if (!isBrowser())
+            return;
+        this.stopInterval();
+        this.tasks.clear();
+        this.logger.log("Disposed");
+    }
+    /**
+     * Update the base interval frequency
+     * @param frequency New frequency in milliseconds
+     */
+    setIntervalFrequency(frequency) {
+        if (frequency < 100) {
+            this.logger.warn("Frequency below 100ms may cause performance issues");
+        }
+        this.intervalFrequency = frequency;
+        // Restart the interval with the new frequency if it's running
+        if (this.isRunning) {
+            this.stopInterval();
+            this.startInterval();
+        }
+        this.logger.log(`Updated interval frequency to ${frequency}ms`);
+    }
+}
+/**
+ * Create a singleton instance for use throughout the application
+ */
+export const intervalManager = new IntervalManager(false);

package/dist/utils/keyboardShortcutManager/keyboardShortcutManager.d.ts

@@ -0,0 +1,41 @@
+import { ShortcutCategory, KeyboardShortcut } from "./keyboardShortcuts";
+export type OSType = "windows" | "mac" | "linux" | "unknown";
+export declare class KeyboardShortcutManager {
+    private static instance;
+    private shortcuts;
+    private osType;
+    private constructor();
+    static getInstance(): KeyboardShortcutManager;
+    /**
+     * Get all registered shortcuts
+     */
+    getAllShortcuts(): KeyboardShortcut[];
+    /**
+     * Get shortcuts by category
+     */
+    getShortcutsByCategory(category: ShortcutCategory): KeyboardShortcut[];
+    /**
+     * Get shortcuts for multiple categories
+     */
+    getShortcutsByCategories(categories: ShortcutCategory[]): KeyboardShortcut[];
+    /**
+     * Check if a keyboard event matches any shortcut in the given categories
+     */
+    matchesShortcut(event: KeyboardEvent, categories?: ShortcutCategory[]): KeyboardShortcut | null;
+    /**
+     * Check if a keyboard event matches a specific shortcut
+     */
+    private eventMatchesShortcut;
+    /**
+     * Check if modifiers in the event match the required modifiers
+     */
+    private checkModifiers;
+    /**
+     * Get a description of a keyboard shortcut for the current OS
+     */
+    getShortcutDescription(shortcut: KeyboardShortcut): string;
+    /**
+     * Format keys for display (e.g., "Ctrl+C")
+     */
+    private formatKeysForDisplay;
+}

package/dist/utils/keyboardShortcutManager/keyboardShortcutManager.js

@@ -0,0 +1,135 @@
+import { ShortcutCategory, ALL_SHORTCUTS } from "./keyboardShortcuts";
+import { getOS } from "../environment";
+export class KeyboardShortcutManager {
+    constructor() {
+        this.shortcuts = ALL_SHORTCUTS;
+        const os = getOS();
+        this.osType = os.name;
+    }
+    static getInstance() {
+        if (!KeyboardShortcutManager.instance) {
+            KeyboardShortcutManager.instance = new KeyboardShortcutManager();
+        }
+        return KeyboardShortcutManager.instance;
+    }
+    /**
+     * Get all registered shortcuts
+     */
+    getAllShortcuts() {
+        return this.shortcuts;
+    }
+    /**
+     * Get shortcuts by category
+     */
+    getShortcutsByCategory(category) {
+        return this.shortcuts.filter(shortcut => shortcut.category === category);
+    }
+    /**
+     * Get shortcuts for multiple categories
+     */
+    getShortcutsByCategories(categories) {
+        return this.shortcuts.filter(shortcut => categories.includes(shortcut.category));
+    }
+    /**
+     * Check if a keyboard event matches any shortcut in the given categories
+     */
+    matchesShortcut(event, categories = Object.values(ShortcutCategory)) {
+        const relevantShortcuts = this.getShortcutsByCategories(categories);
+        for (const shortcut of relevantShortcuts) {
+            if (this.eventMatchesShortcut(event, shortcut)) {
+                return shortcut;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a keyboard event matches a specific shortcut
+     */
+    eventMatchesShortcut(event, shortcut) {
+        // Get the appropriate keys based on platform
+        let keysToCheck = shortcut.keys;
+        if (this.osType === "mac" && shortcut.macKeys) {
+            keysToCheck = shortcut.macKeys;
+        }
+        else if (this.osType === "linux" && shortcut.linuxKeys) {
+            keysToCheck = shortcut.linuxKeys;
+        }
+        // If there are no keys for this platform, this shortcut doesn't apply
+        if (!keysToCheck || keysToCheck.length === 0) {
+            return false;
+        }
+        // Special case for modifier keys
+        const modifiersMatch = this.checkModifiers(event, keysToCheck);
+        // Check if the main key matches (non-modifier key)
+        const mainKeys = keysToCheck.filter(key => !["Control", "Alt", "Shift", "Meta", "Win", "Option"].includes(key));
+        // If there's no main key, just check modifiers
+        if (mainKeys.length === 0) {
+            return modifiersMatch;
+        }
+        // Check if any of the main keys match the event key
+        const keyMatches = mainKeys.some(key => {
+            // Handle special cases like PrintScreen which might be reported differently
+            if (key === "PrintScreen" &&
+                (event.key === "PrintScreen" ||
+                    event.key === "PrtScn" ||
+                    event.key === "Print" ||
+                    event.code === "PrintScreen" ||
+                    event.keyCode === 44)) {
+                return true;
+            }
+            // Handle function keys
+            if (key.startsWith("F") && !isNaN(parseInt(key.substring(1)))) {
+                return event.key === key;
+            }
+            // Normal key matching
+            return event.key.toLowerCase() === key.toLowerCase() ||
+                event.code.toLowerCase() === key.toLowerCase();
+        });
+        return modifiersMatch && keyMatches;
+    }
+    /**
+     * Check if modifiers in the event match the required modifiers
+     */
+    checkModifiers(event, keys) {
+        // Handle different naming conventions
+        const hasCtrl = keys.includes("Control") || keys.includes("Ctrl");
+        const hasAlt = keys.includes("Alt") || keys.includes("Option");
+        const hasShift = keys.includes("Shift");
+        const hasMeta = keys.includes("Meta") || keys.includes("Win") || keys.includes("Command");
+        return ((hasCtrl === event.ctrlKey) &&
+            (hasAlt === event.altKey) &&
+            (hasShift === event.shiftKey) &&
+            (hasMeta === event.metaKey));
+    }
+    /**
+     * Get a description of a keyboard shortcut for the current OS
+     */
+    getShortcutDescription(shortcut) {
+        let keysToUse = shortcut.keys;
+        if (this.osType === "mac" && shortcut.macKeys) {
+            keysToUse = shortcut.macKeys;
+        }
+        else if (this.osType === "linux" && shortcut.linuxKeys) {
+            keysToUse = shortcut.linuxKeys;
+        }
+        // Format the keys for display
+        return this.formatKeysForDisplay(keysToUse);
+    }
+    /**
+     * Format keys for display (e.g., "Ctrl+C")
+     */
+    formatKeysForDisplay(keys) {
+        return keys.map(key => {
+            // Replace with more readable versions
+            switch (key) {
+                case "Control": return this.osType === "mac" ? "Ctrl" : "Ctrl";
+                case "Meta": return this.osType === "mac" ? "⌘" : "Win";
+                case "Alt": return this.osType === "mac" ? "Option" : "Alt";
+                case "Shift": return this.osType === "mac" ? "⇧" : "Shift";
+                case "Option": return "Option";
+                case "Win": return "Win";
+                default: return key;
+            }
+        }).join(this.osType === "mac" ? " + " : "+");
+    }
+}

package/dist/utils/keyboardShortcutManager/keyboardShortcuts.d.ts

@@ -0,0 +1,18 @@
+export declare enum ShortcutCategory {
+    COPY = "copy",
+    SAVE = "save",
+    PRINT = "print",
+    VIEW_SOURCE = "viewSource",
+    DEVTOOLS = "devTools",
+    SCREENSHOT = "screenshot",
+    FULLSCREEN = "fullscreen"
+}
+export interface KeyboardShortcut {
+    id: string;
+    category: ShortcutCategory;
+    description: string;
+    keys: string[];
+    macKeys?: string[];
+    linuxKeys?: string[];
+}
+export declare const ALL_SHORTCUTS: KeyboardShortcut[];

package/dist/utils/keyboardShortcutManager/keyboardShortcuts.js

@@ -0,0 +1,195 @@
+export var ShortcutCategory;
+(function (ShortcutCategory) {
+    ShortcutCategory["COPY"] = "copy";
+    ShortcutCategory["SAVE"] = "save";
+    ShortcutCategory["PRINT"] = "print";
+    ShortcutCategory["VIEW_SOURCE"] = "viewSource";
+    ShortcutCategory["DEVTOOLS"] = "devTools";
+    ShortcutCategory["SCREENSHOT"] = "screenshot";
+    ShortcutCategory["FULLSCREEN"] = "fullscreen";
+})(ShortcutCategory || (ShortcutCategory = {}));
+// Define all shortcuts
+export const ALL_SHORTCUTS = [
+    {
+        id: "save",
+        category: ShortcutCategory.SAVE,
+        description: "Save page",
+        keys: ["Control", "s"],
+        macKeys: ["Meta", "s"],
+        // Linux typically uses the same as Windows for this
+    },
+    {
+        id: "print",
+        category: ShortcutCategory.PRINT,
+        description: "Print page",
+        keys: ["Control", "p"],
+        macKeys: ["Meta", "p"],
+    },
+    {
+        id: "view-source",
+        category: ShortcutCategory.VIEW_SOURCE,
+        description: "View page source",
+        keys: ["Control", "u"],
+        macKeys: ["Meta", "u"],
+    },
+    {
+        id: "copy",
+        category: ShortcutCategory.COPY,
+        description: "Copy selected content",
+        keys: ["Control", "c"],
+        macKeys: ["Meta", "c"],
+    },
+    {
+        id: "cut",
+        category: ShortcutCategory.COPY,
+        description: "Cut selected content",
+        keys: ["Control", "x"],
+        macKeys: ["Meta", "x"],
+    },
+    {
+        id: "devtools-open",
+        category: ShortcutCategory.DEVTOOLS,
+        description: "Open developer tools",
+        keys: ["F12"],
+        macKeys: ["F12"],
+        linuxKeys: ["F12"],
+    },
+    {
+        id: "devtools-inspect",
+        category: ShortcutCategory.DEVTOOLS,
+        description: "Open developer tools inspector",
+        keys: ["Control", "Shift", "i"],
+        macKeys: ["Meta", "Option", "i"],
+        linuxKeys: ["Control", "Shift", "i"],
+    },
+    {
+        id: "devtools-console",
+        category: ShortcutCategory.DEVTOOLS,
+        description: "Open developer tools console",
+        keys: ["Control", "Shift", "j"],
+        macKeys: ["Meta", "Option", "j"],
+        linuxKeys: ["Control", "Shift", "j"],
+    },
+    {
+        id: "screenshot-printscreen",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Take screenshot (Windows/Linux)",
+        keys: ["PrintScreen"],
+        linuxKeys: ["PrintScreen"],
+    },
+    {
+        id: "screenshot-area-linux",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Take area screenshot (Linux)",
+        keys: ["Shift", "PrintScreen"],
+        linuxKeys: ["Shift", "PrintScreen"],
+    },
+    {
+        id: "screenshot-window-linux",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Take window screenshot (Linux)",
+        keys: ["Alt", "PrintScreen"],
+        linuxKeys: ["Alt", "PrintScreen"],
+    },
+    {
+        id: "screenshot-clipboard-linux",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Copy screenshot to clipboard (Linux)",
+        keys: ["Control", "PrintScreen"],
+        linuxKeys: ["Control", "PrintScreen"],
+    },
+    {
+        id: "screenshot-gnome-special",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "GNOME special screenshot shortcut",
+        keys: ["Control", "Shift", "p"],
+        linuxKeys: ["Control", "Shift", "p"],
+    },
+    {
+        id: "screenshot-flameshot",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Flameshot screenshot tool (Linux)",
+        keys: ["F10"],
+        linuxKeys: ["F10"],
+    },
+    {
+        id: "screenshot-mac-full",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Take full screenshot (Mac)",
+        keys: [], // Empty for Windows/Linux
+        macKeys: ["Shift", "Meta", "3"],
+    },
+    {
+        id: "screenshot-mac-area",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Take area screenshot (Mac)",
+        keys: [], // Empty for Windows/Linux
+        macKeys: ["Shift", "Meta", "4"],
+    },
+    {
+        id: "screenshot-mac-tools",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Open screenshot tools (Mac)",
+        keys: [], // Empty for Windows/Linux
+        macKeys: ["Shift", "Meta", "5"],
+    },
+    {
+        id: "screenshot-win-snipping",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Open Snipping Tool (Windows)",
+        keys: ["Win", "Shift", "s"],
+    },
+    {
+        id: "screenshot-win-snapshot",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Windows SnapshotKey",
+        keys: ["SnapshotKey"],
+    },
+    {
+        id: "screenshot-firefox-save",
+        category: ShortcutCategory.SCREENSHOT,
+        description: "Firefox Save Page As (can be used for screenshots)",
+        keys: ["Alt", "s"],
+    },
+    {
+        id: "fullscreen",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen mode",
+        keys: ["F11"],
+        macKeys: ["F11"],
+        linuxKeys: ["F11"],
+    },
+    {
+        id: "fullscreen-alt-enter",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen mode (Alt+Enter)",
+        keys: ["Alt", "Enter"],
+        linuxKeys: ["Alt", "Enter"],
+    },
+    {
+        id: "fullscreen-ctrl-f",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen in some browsers",
+        keys: ["Control", "f"],
+        macKeys: ["Meta", "f"],
+    },
+    {
+        id: "fullscreen-alt-f",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen in some applications",
+        keys: ["Alt", "f"],
+    },
+    {
+        id: "fullscreen-alt-k",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen in some media players",
+        keys: ["Alt", "k"],
+    },
+    {
+        id: "fullscreen-mac",
+        category: ShortcutCategory.FULLSCREEN,
+        description: "Toggle fullscreen on Mac",
+        keys: [],
+        macKeys: ["Control", "Meta", "f"],
+    },
+];

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

@@ -0,0 +1,33 @@
+/**
+ * Interface for components that support logging
+ */
+export interface Loggable {
+    /**
+     * 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/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;
+}