Improve search performance

Author: sylhare

dest/simple-jekyll-search.js

@@ -218,33 +218,14 @@
     return { ...target, ...source };
   }
   function isJSON(json) {
-    try {
-      return !!(json instanceof Object && JSON.parse(JSON.stringify(json)));
-    } catch (_err) {
-      return false;
-    }
+    return Array.isArray(json) || json !== null && typeof json === "object";
   }
   function NoSort() {
     return 0;
   }
   function isObject(obj) {
     return Boolean(obj) && Object.prototype.toString.call(obj) === "[object Object]";
   }
-  function clone(input) {
-    if (input === null || typeof input !== "object") {
-      return input;
-    }
-    if (Array.isArray(input)) {
-      return input.map((item) => clone(item));
-    }
-    const output = {};
-    for (const key in input) {
-      if (Object.prototype.hasOwnProperty.call(input, key)) {
-        output[key] = clone(input[key]);
-      }
-    }
-    return output;
-  }
   const DEFAULT_OPTIONS = {
     searchInput: null,
     resultsContainer: null,
@@ -278,6 +259,7 @@
   class Repository {
     constructor(initialOptions = {}) {
       this.data = [];
+      this.excludePatterns = [];
       this.setOptions(initialOptions);
     }
     put(input) {
@@ -297,19 +279,22 @@
       if (!criteria) {
         return [];
       }
-      return clone(this.findMatches(this.data, criteria).sort(this.options.sortMiddleware));
+      const matches = this.findMatches(this.data, criteria).sort(this.options.sortMiddleware);
+      return matches.map((item) => ({ ...item }));
     }
     setOptions(newOptions) {
       let strategy = (newOptions == null ? void 0 : newOptions.strategy) || DEFAULT_OPTIONS.strategy;
       if ((newOptions == null ? void 0 : newOptions.fuzzy) && !(newOptions == null ? void 0 : newOptions.strategy)) {
         console.warn('[Simple Jekyll Search] Warning: fuzzy option is deprecated. Use strategy: "fuzzy" instead.');
         strategy = "fuzzy";
       }
+      const exclude = (newOptions == null ? void 0 : newOptions.exclude) || DEFAULT_OPTIONS.exclude;
+      this.excludePatterns = exclude.map((pattern) => new RegExp(pattern));
       this.options = {
         limit: (newOptions == null ? void 0 : newOptions.limit) || DEFAULT_OPTIONS.limit,
         searchStrategy: this.searchStrategy(strategy),
         sortMiddleware: (newOptions == null ? void 0 : newOptions.sortMiddleware) || DEFAULT_OPTIONS.sortMiddleware,
-        exclude: (newOptions == null ? void 0 : newOptions.exclude) || DEFAULT_OPTIONS.exclude,
+        exclude,
         strategy
       };
     }
@@ -355,12 +340,8 @@
       return hasMatch ? result : void 0;
     }
     isExcluded(term) {
-      for (const excludedTerm of this.options.exclude) {
-        if (new RegExp(excludedTerm).test(String(term))) {
-          return true;
-        }
-      }
-      return false;
+      const termStr = String(term);
+      return this.excludePatterns.some((regex) => regex.test(termStr));
     }
     searchStrategy(strategy) {
       if (StrategyFactory.isValidStrategy(strategy)) {

src/Repository.ts

@@ -1,13 +1,14 @@
 import { FuzzySearchStrategy, LiteralSearchStrategy, WildcardSearchStrategy } from './SearchStrategies/SearchStrategy';
 import { Matcher } from './SearchStrategies/types';
 import { StrategyFactory, StrategyType } from './SearchStrategies/StrategyFactory';
-import { clone, isObject } from './utils';
+import { isObject } from './utils';
 import { DEFAULT_OPTIONS } from './utils/default';
 import { RepositoryData, RepositoryOptions } from './utils/types';
 
 export class Repository {
   private data: RepositoryData[] = [];
   private options!: Required<Omit<RepositoryOptions, 'fuzzy'>> & Pick<RepositoryOptions, 'fuzzy'>;
+  private excludePatterns: RegExp[] = [];
 
   constructor(initialOptions: RepositoryOptions = {}) {
     this.setOptions(initialOptions);
@@ -32,7 +33,8 @@ export class Repository {
     if (!criteria) {
       return [];
     }
-    return clone(this.findMatches(this.data, criteria).sort(this.options.sortMiddleware));
+    const matches = this.findMatches(this.data, criteria).sort(this.options.sortMiddleware);
+    return matches.map(item => ({ ...item }));
   }
 
   public setOptions(newOptions: RepositoryOptions): void {
@@ -43,11 +45,14 @@ export class Repository {
       strategy = 'fuzzy';
     }
 
+    const exclude = newOptions?.exclude || DEFAULT_OPTIONS.exclude;
+    this.excludePatterns = exclude.map(pattern => new RegExp(pattern));
+    
     this.options = {
       limit: newOptions?.limit || DEFAULT_OPTIONS.limit,
       searchStrategy: this.searchStrategy(strategy),
       sortMiddleware: newOptions?.sortMiddleware || DEFAULT_OPTIONS.sortMiddleware,
-      exclude: newOptions?.exclude || DEFAULT_OPTIONS.exclude,
+      exclude: exclude,
       strategy: strategy,
     };
   }
@@ -101,12 +106,8 @@ export class Repository {
   }
 
   private isExcluded(term: any): boolean {
-    for (const excludedTerm of this.options.exclude) {
-      if (new RegExp(excludedTerm).test(String(term))) {
-        return true;
-      }
-    }
-    return false;
+    const termStr = String(term);
+    return this.excludePatterns.some(regex => regex.test(termStr));
   }
 
   private searchStrategy(

src/utils.ts

@@ -5,12 +5,7 @@ export function merge<T>(target: T, source: Partial<T>): T {
 }
 
 export function isJSON(json: any): boolean {
-  try {
-    return !!(json instanceof Object && JSON.parse(JSON.stringify(json)));
-
-  } catch (_err) {
-    return false;
-  }
+  return Array.isArray(json) || (json !== null && typeof json === 'object');
 }
 
 export function NoSort(): number {

tests/utils.test.ts

@@ -51,8 +51,46 @@ describe('utils', () => {
   });
 
   describe('isJSON', () => {
-    it('returns true if is JSON object', () => {
+    it('returns true for plain objects', () => {
       expect(isJSON({ foo: 'bar' })).toBe(true);
+      expect(isJSON({})).toBe(true);
+      expect(isJSON({ nested: { key: 'value' } })).toBe(true);
+    });
+
+    it('returns true for arrays', () => {
+      expect(isJSON([])).toBe(true);
+      expect(isJSON([1, 2, 3])).toBe(true);
+      expect(isJSON([{ foo: 'bar' }])).toBe(true);
+    });
+
+    it('returns false for null', () => {
+      expect(isJSON(null)).toBe(false);
+    });
+
+    it('returns false for undefined', () => {
+      expect(isJSON(undefined)).toBe(false);
+    });
+
+    it('returns false for primitives', () => {
+      expect(isJSON(42)).toBe(false);
+      expect(isJSON(0)).toBe(false);
+      expect(isJSON('string')).toBe(false);
+      expect(isJSON('')).toBe(false);
+      expect(isJSON(true)).toBe(false);
+      expect(isJSON(false)).toBe(false);
+    });
+
+    it('returns true for Date objects', () => {
+      expect(isJSON(new Date())).toBe(true);
+    });
+
+    it('returns true for RegExp objects', () => {
+      expect(isJSON(/regex/)).toBe(true);
+    });
+
+    it('returns false for functions', () => {
+      expect(isJSON(() => {})).toBe(false);
+      expect(isJSON(function() {})).toBe(false);
     });
   });