Add on error catch

Author: sylhare

dest/simple-jekyll-search.js

@@ -242,6 +242,7 @@
     exclude: [],
     onSearch: () => {
     },
+    onError: (error) => console.error("SimpleJekyllSearch error:", error),
     fuzzy: false
     // Deprecated, use strategy: 'fuzzy' instead
   };
@@ -401,6 +402,9 @@
   let SimpleJekyllSearch$1 = class SimpleJekyllSearch {
     constructor() {
       this.debounceTimerHandle = null;
+      this.eventHandler = null;
+      this.pendingRequest = null;
+      this.isInitialized = false;
       this.options = { ...DEFAULT_OPTIONS };
       this.repository = new Repository();
       this.optionsValidator = new OptionsValidator({
@@ -436,15 +440,28 @@
       });
     }
     registerInput() {
-      this.options.searchInput.addEventListener("input", (e) => {
-        const inputEvent = e;
-        if (!WHITELISTED_KEYS.has(inputEvent.key)) {
-          this.emptyResultsContainer();
-          this.debounce(() => {
-            this.search(e.target.value);
-          }, this.options.debounceTime ?? null);
+      this.eventHandler = (e) => {
+        var _a, _b;
+        try {
+          const inputEvent = e;
+          if (!WHITELISTED_KEYS.has(inputEvent.key)) {
+            this.emptyResultsContainer();
+            this.debounce(() => {
+              var _a2, _b2;
+              try {
+                this.search(e.target.value);
+              } catch (searchError) {
+                console.error("Search error:", searchError);
+                (_b2 = (_a2 = this.options).onError) == null ? void 0 : _b2.call(_a2, searchError);
+              }
+            }, this.options.debounceTime ?? null);
+          }
+        } catch (error) {
+          console.error("Input handler error:", error);
+          (_b = (_a = this.options).onError) == null ? void 0 : _b.call(_a, error);
         }
-      });
+      };
+      this.options.searchInput.addEventListener("input", this.eventHandler);
     }
     search(query) {
       var _a, _b;

src/SimpleJekyllSearch.ts

@@ -11,6 +11,9 @@ class SimpleJekyllSearch {
   private repository: Repository;
   private optionsValidator: OptionsValidator;
   private debounceTimerHandle: NodeJS.Timeout | null = null;
+  private eventHandler: ((e: Event) => void) | null = null;
+  private pendingRequest: XMLHttpRequest | null = null;
+  private isInitialized: boolean = false;
 
   constructor() {
     this.options = { ...DEFAULT_OPTIONS };
@@ -54,15 +57,27 @@ class SimpleJekyllSearch {
   }
 
   private registerInput(): void {
-    this.options.searchInput.addEventListener('input', (e: Event) => {
-      const inputEvent = e as KeyboardEvent;
-      if (!WHITELISTED_KEYS.has(inputEvent.key)) {
-        this.emptyResultsContainer();
-        this.debounce(() => {
-          this.search((e.target as HTMLInputElement).value);
-        }, this.options.debounceTime ?? null);
+    this.eventHandler = (e: Event) => {
+      try {
+        const inputEvent = e as KeyboardEvent;
+        if (!WHITELISTED_KEYS.has(inputEvent.key)) {
+          this.emptyResultsContainer();
+          this.debounce(() => {
+            try {
+              this.search((e.target as HTMLInputElement).value);
+            } catch (searchError) {
+              console.error('Search error:', searchError);
+              this.options.onError?.(searchError as Error);
+            }
+          }, this.options.debounceTime ?? null);
+        }
+      } catch (error) {
+        console.error('Input handler error:', error);
+        this.options.onError?.(error as Error);
       }
-    });
+    };
+    
+    this.options.searchInput.addEventListener('input', this.eventHandler);
   }
 
   public search(query: string): void {

src/utils/default.ts

@@ -15,6 +15,7 @@ export const DEFAULT_OPTIONS: Required<SearchOptions> = {
   debounceTime: null,
   exclude: [],
   onSearch: () => {},
+  onError: (error: Error) => console.error('SimpleJekyllSearch error:', error),
   fuzzy: false  // Deprecated, use strategy: 'fuzzy' instead
 };
 

src/utils/types.ts

@@ -46,6 +46,7 @@ export interface SearchOptions extends Omit<RepositoryOptions, 'searchStrategy'>
   noResultsText?: string;
   debounceTime?: number | null;
   onSearch?: () => void;
+  onError?: (error: Error) => void;
 }
 
 export interface SimpleJekyllSearchInstance {

tests/SimpleJekyllSearch.test.ts

@@ -1,5 +1,5 @@
 import { JSDOM } from 'jsdom';
-import { beforeEach, describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import SimpleJekyllSearch from '../src/SimpleJekyllSearch';
 import { SearchData, SearchOptions } from '../src/utils/types';
 
@@ -144,4 +144,98 @@ describe('SimpleJekyllSearch', () => {
       expect(resultsContainer.innerHTML).toContain('Test Post');
     });
   });
+
+  describe('error handling', () => {
+    beforeEach(() => {
+      mockOptions.json = mockSearchData;
+    });
+
+    it('should call onError callback when provided', async () => {
+      const onErrorSpy = vi.fn();
+      const optionsWithErrorHandler = { ...mockOptions, onError: onErrorSpy };
+      
+      searchInstance.init(optionsWithErrorHandler);
+      
+      const input = mockOptions.searchInput;
+      input.value = 'test';
+      input.dispatchEvent(new dom.window.KeyboardEvent('input', { key: 't' }));
+
+      await new Promise(resolve => setTimeout(resolve, mockOptions.debounceTime! + 10));
+      
+      expect(onErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle malformed search data gracefully', async () => {
+      const onErrorSpy = vi.fn();
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      const malformedData = [
+        { title: 'Valid Post', url: '/valid' },
+        { title: null, url: undefined },
+        { title: 'Another Valid Post', url: '/another' }
+      ];
+      
+      const optionsWithMalformedData = { 
+        ...mockOptions, 
+        json: malformedData as any,
+        onError: onErrorSpy 
+      };
+      
+      expect(() => searchInstance.init(optionsWithMalformedData)).not.toThrow();
+      
+      const input = mockOptions.searchInput;
+      input.value = 'Valid';
+      input.dispatchEvent(new dom.window.KeyboardEvent('input', { key: 'V' }));
+
+      await new Promise(resolve => setTimeout(resolve, mockOptions.debounceTime! + 10));
+      
+      expect(onErrorSpy).toHaveBeenCalledWith(expect.any(Error));
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle missing DOM elements gracefully', async () => {
+      const onErrorSpy = vi.fn();
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      const optionsWithMissingElement = { 
+        ...mockOptions, 
+        searchInput: null as any,
+        onError: onErrorSpy 
+      };
+      
+      expect(() => searchInstance.init(optionsWithMissingElement)).toThrow();
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should use default error handler when onError not provided', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      searchInstance.init(mockOptions);
+      
+      const input = mockOptions.searchInput;
+      input.value = 'test';
+      input.dispatchEvent(new dom.window.KeyboardEvent('input', { key: 't' }));
+
+      await new Promise(resolve => setTimeout(resolve, mockOptions.debounceTime! + 10));
+      
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle invalid search queries gracefully', async () => {
+      const onErrorSpy = vi.fn();
+      const optionsWithErrorHandler = { ...mockOptions, onError: onErrorSpy };
+      
+      searchInstance.init(optionsWithErrorHandler);
+      
+      const input = mockOptions.searchInput;
+      input.value = 'a'.repeat(10000);
+      input.dispatchEvent(new dom.window.KeyboardEvent('input', { key: 'a' }));
+
+      await new Promise(resolve => setTimeout(resolve, mockOptions.debounceTime! + 10));
+      
+      expect(mockOptions.resultsContainer.innerHTML).toContain('No results found');
+      expect(onErrorSpy).not.toHaveBeenCalled();
+    });
+  });
 });