@readium/navigator 2.2.9 → 2.4.0-alpha.0

package/types/src/protection/AutomationDetector.d.ts

@@ -0,0 +1,14 @@
+export interface AutomationDetectorOptions {
+    /** Callback when an automation tool is detected */
+    onDetected?: (tool: string) => void;
+}
+export declare class AutomationDetector {
+    private options;
+    private detectedTools;
+    private observer?;
+    constructor(options: AutomationDetectorOptions);
+    private isAutomationToolPresent;
+    private setupDetection;
+    private handleDetected;
+    destroy(): void;
+}

package/types/src/protection/ContextMenuProtector.d.ts

@@ -0,0 +1,11 @@
+import { ContextMenuEvent } from "@readium/navigator-html-injectables";
+export interface ContextMenuProtectionOptions {
+    onContextMenuBlocked?: (event: ContextMenuEvent) => void;
+}
+export declare class ContextMenuProtector {
+    private contextMenuHandler?;
+    private onContextMenuBlocked?;
+    constructor(options?: ContextMenuProtectionOptions);
+    private handleContextMenu;
+    destroy(): void;
+}

package/types/src/protection/DevToolsDetector.d.ts

@@ -0,0 +1,75 @@
+export interface DevToolsDetectorOptions {
+    /** Callback when Developer Tools are detected as open */
+    onDetected?: () => void;
+    /** Callback when Developer Tools are detected as closed */
+    onClosed?: () => void;
+    /** Detection interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Enable debugger-based detection (fallback, impacts UX) */
+    enableDebuggerDetection?: boolean;
+}
+export declare class DevToolsDetector {
+    private options;
+    private isOpen;
+    private intervalId?;
+    private checkCount;
+    private maxChecks;
+    private maxPrintTime;
+    private largeObjectArray;
+    private workerConsole?;
+    constructor(options?: DevToolsDetectorOptions);
+    /**
+     * Create large object array for performance testing
+     */
+    private createLargeObjectArray;
+    /**
+     * Get cached large object array
+     */
+    private getLargeObjectArray;
+    /**
+     * Performance-based detection using console.table timing
+     */
+    private calcTablePrintTime;
+    /**
+     * Performance-based detection using console.log timing
+     */
+    private calcLogPrintTime;
+    /**
+     * Check if performance-based detection is enabled for current browser
+     */
+    private isPerformanceDetectionEnabled;
+    /**
+     * Check if debugger detection is enabled for current browser
+     */
+    private isDebuggerDetectionEnabled;
+    /**
+     * Performance-based detection using large object timing differences
+     */
+    private checkPerformanceBased;
+    /**
+     * Debugger-based detection (fallback method)
+     * WARNING: This method impacts user experience
+     */
+    private checkDebuggerBased;
+    /**
+     * Main detection method combining multiple approaches
+     * Prioritizes performance-based detection
+     */
+    private detectDevTools;
+    /**
+     * Start continuous detection monitoring
+     */
+    private startDetection;
+    /**
+     * Get current DevTools state
+     */
+    isDevToolsOpen(): boolean;
+    /**
+     * Force an immediate check
+     */
+    checkNow(): Promise<boolean>;
+    /**
+     * Stop detection and cleanup resources
+     */
+    destroy(): void;
+}

package/types/src/protection/IframeEmbeddingDetector.d.ts

@@ -0,0 +1,14 @@
+export interface IframeEmbeddingDetectorOptions {
+    /** Callback when iframe embedding is detected */
+    onDetected?: (isCrossOrigin: boolean) => void;
+}
+export declare class IframeEmbeddingDetector {
+    private options;
+    private observer?;
+    private detected;
+    constructor(options: IframeEmbeddingDetectorOptions);
+    private isIframed;
+    private setupDetection;
+    private handleDetected;
+    destroy(): void;
+}

package/types/src/protection/NavigatorProtector.d.ts

@@ -0,0 +1,12 @@
+import { IContentProtectionConfig } from "../Navigator";
+export declare const NAVIGATOR_SUSPICIOUS_ACTIVITY_EVENT = "readium:navigator:suspiciousActivity";
+export declare class NavigatorProtector {
+    private automationDetector?;
+    private devToolsDetector?;
+    private iframeEmbeddingDetector?;
+    private printProtector?;
+    private contextMenuProtector?;
+    private dispatchSuspiciousActivity;
+    constructor(config?: IContentProtectionConfig);
+    destroy(): void;
+}

package/types/src/protection/PrintProtector.d.ts

@@ -0,0 +1,13 @@
+export interface NavigatorPrintProtectionConfig {
+    disable?: boolean;
+    watermark?: string;
+    onPrintAttempt?: () => void;
+}
+export declare class PrintProtector {
+    private styleElement;
+    private beforePrintHandler;
+    private onPrintAttempt?;
+    constructor(config?: NavigatorPrintProtectionConfig);
+    private setupPrintProtection;
+    destroy(): void;
+}

package/types/src/protection/utils/WorkerConsole.d.ts

@@ -0,0 +1,15 @@
+export type WorkerConsoleMethod<Args extends any[]> = (...args: Args) => Promise<{
+    time: number;
+}>;
+export declare class WorkerConsole {
+    static workerScript: string;
+    private readonly worker;
+    private readonly blobUrl;
+    private callbacks;
+    readonly log: WorkerConsoleMethod<Parameters<Console['log']>>;
+    readonly table: WorkerConsoleMethod<Parameters<Console['table']>>;
+    readonly clear: WorkerConsoleMethod<Parameters<Console['clear']>>;
+    constructor(worker: Worker, blobUrl: string);
+    private send;
+    destroy(): void;
+}

package/types/src/protection/utils/console.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cache console methods to prevent third-party code from hooking them
+ */
+export declare const log: (...data: any[]) => void;
+export declare const table: (tabularData?: any, properties?: string[]) => void;
+export declare const clear: () => void;

package/types/src/protection/utils/match.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Match utilities for browser compatibility checking
+ */
+export interface MatchOptions {
+    includes: (() => boolean)[];
+    excludes: (() => boolean)[];
+}
+export declare function match(options: MatchOptions): boolean;

package/types/src/protection/utils/platform.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Platform detection utilities
+ */
+export declare function isBrave(): Promise<boolean>;

package/types/src/webpub/WebPubFrameManager.d.ts

@@ -1,5 +1,6 @@
 import { Loader, ModuleName } from "@readium/navigator-html-injectables";
 import { FrameComms } from "../epub/frame/FrameComms";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export declare class WebPubFrameManager {
     private frame;
     private loader;
@@ -7,9 +8,12 @@ export declare class WebPubFrameManager {
     private comms;
     private hidden;
     private destroyed;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     private currModules;
-    constructor(source: string);
+    constructor(source: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     load(modules?: ModuleName[]): Promise<Window>;
+    private applyContentProtection;
     destroy(): Promise<void>;
     hide(): Promise<void>;
     show(atProgress?: number): Promise<void>;

package/types/src/webpub/WebPubFramePoolManager.d.ts

@@ -2,6 +2,7 @@ import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 import { Injector } from "../injection/Injector";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export declare class WebPubFramePoolManager {
     private readonly container;
     private _currentFrame;
@@ -12,9 +13,11 @@ export declare class WebPubFramePoolManager {
     private pendingUpdates;
     private currentBaseURL;
     private readonly injector?;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     constructor(container: HTMLElement, cssProperties?: {
         [key: string]: string;
-    }, injector?: Injector | null);
+    }, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     destroy(): Promise<void>;
     update(pub: Publication, locator: Locator, modules: ModuleName[]): Promise<void>;
     setCSSProperties(properties: {

package/types/src/webpub/WebPubNavigator.d.ts

@@ -1,7 +1,7 @@
 import { Link, Locator, Publication, ReadingProgression } from "@readium/shared";
 import { VisualNavigator, VisualNavigatorViewport } from "../Navigator";
 import { Configurable } from "../preferences/Configurable";
-import { BasicTextSelection, CommsEventKey, FrameClickEvent } from "@readium/navigator-html-injectables";
+import { BasicTextSelection, CommsEventKey, ContextMenuEvent, FrameClickEvent, KeyboardEventData, SuspiciousActivityEvent } from "@readium/navigator-html-injectables";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 import { ManagerEventKey } from "../epub/EpubNavigator";
 import { IWebPubPreferences, WebPubPreferences } from "./preferences/WebPubPreferences";
@@ -9,10 +9,13 @@ import { IWebPubDefaults } from "./preferences/WebPubDefaults";
 import { WebPubSettings } from "./preferences/WebPubSettings";
 import { IPreferencesEditor } from "../preferences/PreferencesEditor";
 import { IInjectablesConfig } from "../injection/Injectable";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export interface WebPubNavigatorConfiguration {
     preferences: IWebPubPreferences;
     defaults: IWebPubDefaults;
     injectables?: IInjectablesConfig;
+    contentProtection?: IContentProtectionConfig;
+    keyboardPeripherals?: IKeyboardPeripheralsConfig;
 }
 export interface WebPubNavigatorListeners {
     frameLoaded: (wnd: Window) => void;
@@ -24,6 +27,9 @@ export interface WebPubNavigatorListeners {
     customEvent: (key: string, data: unknown) => void;
     handleLocator: (locator: Locator) => boolean;
     textSelected: (selection: BasicTextSelection) => void;
+    contentProtection: (type: string, data: SuspiciousActivityEvent) => void;
+    contextMenu: (data: ContextMenuEvent) => void;
+    peripheral: (data: KeyboardEventData) => void;
 }
 export declare class WebPubNavigator extends VisualNavigator implements Configurable<WebPubSettings, WebPubPreferences> {
     private readonly pub;
@@ -38,6 +44,12 @@ export declare class WebPubNavigator extends VisualNavigator implements Configur
     private _css;
     private _preferencesEditor;
     private readonly _injector;
+    private readonly _contentProtection;
+    private readonly _keyboardPeripherals;
+    private readonly _navigatorProtector;
+    private readonly _keyboardPeripheralsManager;
+    private readonly _suspiciousActivityListener;
+    private readonly _keyboardPeripheralListener;
     private webViewport;
     constructor(container: HTMLElement, pub: Publication, listeners: WebPubNavigatorListeners, initialPosition?: Locator | undefined, configuration?: WebPubNavigatorConfiguration);
     load(): Promise<void>;