Improvement: Extracted the hash blocking functionality into a service.

Author: NiffirgkcaJ

gnome-extensions/extension/features/Clipboard/logic/clipboardMonitor.js

@@ -13,8 +13,6 @@ import { LinkProcessor } from '../processors/clipboardLinkProcessor.js';
 import { TextProcessor } from '../processors/clipboardTextProcessor.js';
 
 // Configuration
-const EXCLUDED_HASH_TTL_MS = 5000;
-const MAX_BLOCKED_HASHES = 50;
 const MAX_RETRIES = 5;
 const RETRY_DELAY_MS = 200;
 
@@ -34,18 +32,18 @@ export class ClipboardMonitor {
      * @param {ExclusionUtils} exclusionUtils Utility for handling exclusion rules.
      * @param {string} imagesDir Path for generating color processor gradients.
      * @param {Function} onContentCaptured Callback for when content is captured.
+     * @param {ClipboardCaptureGuardService} captureGuard Guard for suppression decisions.
      */
-    constructor(exclusionUtils, imagesDir, onContentCaptured) {
+    constructor(exclusionUtils, imagesDir, onContentCaptured, captureGuard) {
         this._exclusionUtils = exclusionUtils;
         this._imagesDir = imagesDir;
         this._onContentCaptured = onContentCaptured;
+        this._captureGuard = captureGuard;
 
         this._selection = null;
         this._isPaused = false;
         this._processClipboardTimeoutId = 0;
         this._retryTimeoutId = 0;
-
-        this._blockedContentHashes = new Map();
     }
 
     /**
@@ -111,54 +109,61 @@ export class ClipboardMonitor {
             // Image
             const imageResult = await ImageProcessor.extract();
             if (imageResult) {
-                this._onContentCaptured(imageResult);
+                if (!this._shouldSuppress(imageResult)) {
+                    this._onContentCaptured(imageResult);
+                }
                 return;
             }
 
             // Text
             const textResult = await TextProcessor.extract();
             if (textResult) {
                 const text = textResult.text;
-                const hash = this._hashString(text);
-
-                if (this._blockedContentHashes.has(hash)) {
-                    const expiry = this._blockedContentHashes.get(hash);
-                    if (Date.now() < expiry) return;
-                    this._blockedContentHashes.delete(hash);
-                }
 
                 const fileResult = await FileProcessor.process(text);
                 if (fileResult) {
-                    this._onContentCaptured(fileResult);
+                    if (!this._shouldSuppress(fileResult)) {
+                        this._onContentCaptured(fileResult);
+                    }
                     return;
                 }
 
                 const linkResult = LinkProcessor.process(text);
                 if (linkResult) {
-                    this._onContentCaptured(linkResult);
+                    if (!this._shouldSuppress(linkResult)) {
+                        this._onContentCaptured(linkResult);
+                    }
                     return;
                 }
 
                 const contactResult = await ContactProcessor.process(text);
                 if (contactResult) {
-                    this._onContentCaptured(contactResult);
+                    if (!this._shouldSuppress(contactResult)) {
+                        this._onContentCaptured(contactResult);
+                    }
                     return;
                 }
 
                 const colorResult = ColorProcessor.process(text, this._imagesDir);
                 if (colorResult) {
-                    this._onContentCaptured(colorResult);
+                    if (!this._shouldSuppress(colorResult)) {
+                        this._onContentCaptured(colorResult);
+                    }
                     return;
                 }
 
                 const codeResult = CodeProcessor.process(text);
                 if (codeResult) {
-                    this._onContentCaptured(codeResult);
+                    if (!this._shouldSuppress(codeResult)) {
+                        this._onContentCaptured(codeResult);
+                    }
                     return;
                 }
 
                 // Fallback
-                this._onContentCaptured(textResult);
+                if (!this._shouldSuppress(textResult)) {
+                    this._onContentCaptured(textResult);
+                }
                 return;
             }
 
@@ -184,15 +189,7 @@ export class ClipboardMonitor {
     _hashAndBlockClipboardContent() {
         clipboardGetText()
             .then((text) => {
-                if (text) {
-                    const hash = this._hashString(text);
-                    this._blockedContentHashes.set(hash, Date.now() + EXCLUDED_HASH_TTL_MS);
-
-                    if (this._blockedContentHashes.size > MAX_BLOCKED_HASHES) {
-                        const first = this._blockedContentHashes.keys().next().value;
-                        this._blockedContentHashes.delete(first);
-                    }
-                }
+                if (text) this._captureGuard?.registerText(text);
             })
             .catch(() => {});
     }
@@ -202,18 +199,19 @@ export class ClipboardMonitor {
     // ========================================================================
 
     /**
-     * Generate a simple hash from a string.
+     * Decide whether a capture should be suppressed and register allowed hashes.
      *
-     * @param {string} str Input string.
-     * @returns {number} Generated hash.
+     * @param {Object} result Extracted result with hash.
+     * @returns {boolean} True if suppressed.
      * @private
      */
-    _hashString(str) {
-        let hash = 5381;
-        for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
-        }
-        return hash;
+    _shouldSuppress(result) {
+        if (!this._captureGuard || !result?.hash) return false;
+
+        if (this._captureGuard.shouldBlockHash(result.hash)) return true;
+
+        this._captureGuard.registerHash(result.hash);
+        return false;
     }
 
     // ========================================================================

gnome-extensions/extension/features/Clipboard/managers/clipboardManager.js

@@ -3,6 +3,7 @@ import GObject from 'gi://GObject';
 import { ExclusionUtils } from '../../../shared/utilities/utilityExclusions.js';
 import { Logger } from '../../../shared/utilities/utilityLogger.js';
 
+import { ClipboardCaptureGuardService } from '../services/clipboardCaptureGuardService.js';
 import { ClipboardContentRouter } from '../services/clipboardContentRouter.js';
 import { ClipboardCopyService } from '../services/clipboardCopyService.js';
 import { ClipboardMonitor } from '../logic/clipboardMonitor.js';
@@ -48,7 +49,8 @@ export const ClipboardManager = GObject.registerClass(
             this._exclusionUtils = new ExclusionUtils();
             this._exclusionUtils.initialize(settings);
 
-            this._monitor = new ClipboardMonitor(this._exclusionUtils, this._storage.imagesDir, (result) => this._contentRouter.processResult(result));
+            this._captureGuard = new ClipboardCaptureGuardService();
+            this._monitor = new ClipboardMonitor(this._exclusionUtils, this._storage.imagesDir, (result) => this._contentRouter.processResult(result), this._captureGuard);
 
             this._history = [];
             this._pinned = [];
@@ -590,6 +592,7 @@ export const ClipboardManager = GObject.registerClass(
             this._storage.destroy();
             this._contentRouter?.destroy();
             this._exclusionUtils?.destroy();
+            this._captureGuard?.destroy();
         }
     },
 );

gnome-extensions/extension/features/Clipboard/services/clipboardCaptureGuardService.js

@@ -0,0 +1,76 @@
+import { ProcessorUtils } from '../utilities/clipboardProcessorUtils.js';
+
+// Configuration
+const DEFAULT_TTL_MS = 5000;
+const MAX_BLOCKED_HASHES = 50;
+
+/**
+ * ClipboardCaptureGuardService
+ *
+ * Stores short-lived hash blocks to suppress immediate re-capture.
+ */
+export class ClipboardCaptureGuardService {
+    constructor(ttlMs = DEFAULT_TTL_MS, maxHashes = MAX_BLOCKED_HASHES) {
+        this._ttlMs = ttlMs;
+        this._maxHashes = maxHashes;
+        this._hashExpiry = new Map();
+    }
+
+    /**
+     * Check whether a hash is currently blocked.
+     *
+     * @param {string} hash
+     * @returns {boolean}
+     */
+    shouldBlockHash(hash) {
+        if (!hash) return false;
+
+        const expiry = this._hashExpiry.get(hash);
+        if (!expiry) return false;
+
+        if (Date.now() >= expiry) {
+            this._hashExpiry.delete(hash);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Register a hash to be blocked for the TTL window.
+     *
+     * @param {string} hash
+     * @param {number} ttlMs
+     */
+    registerHash(hash, ttlMs = this._ttlMs) {
+        if (!hash) return;
+
+        this._hashExpiry.set(hash, Date.now() + ttlMs);
+
+        if (this._hashExpiry.size > this._maxHashes) {
+            const oldestKey = this._hashExpiry.keys().next().value;
+            if (oldestKey !== undefined) {
+                this._hashExpiry.delete(oldestKey);
+            }
+        }
+    }
+
+    /**
+     * Convenience registration for text values.
+     *
+     * @param {string} text
+     * @param {number} ttlMs
+     */
+    registerText(text, ttlMs = this._ttlMs) {
+        if (!text) return;
+        const hash = ProcessorUtils.computeHashForString(text);
+        this.registerHash(hash, ttlMs);
+    }
+
+    /**
+     * Clear all suppression entries.
+     */
+    destroy() {
+        this._hashExpiry.clear();
+    }
+}