@tindalabs/shield 0.1.0

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

@@ -0,0 +1,155 @@
+import type { MediatorAware, ProtectionMediator } from "../core/mediator/types";
+import { LoggableComponent } from "./base/LoggableComponent";
+/**
+ * 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 extends LoggableComponent implements MediatorAware {
+    private mediator;
+    private targetElement;
+    private originalContent;
+    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 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;
+        }>;
+    };
+}