@alliance-droid/svelte-docs-system 0.0.1

package/src/lib/search-functionality.test.ts

@@ -0,0 +1,493 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+/**
+ * Comprehensive search functionality tests
+ * Tests search capabilities including filtering, ranking, and result display
+ */
+
+describe('Search Functionality', () => {
+  describe('Basic Search', () => {
+    it('should find documents by title', () => {
+      const documents = [
+        {
+          id: '1',
+          title: 'Getting Started Guide',
+          content: 'Introduction to the system'
+        },
+        { id: '2', title: 'API Reference', content: 'API documentation' }
+      ];
+
+      const query = 'Getting';
+      const results = documents.filter((doc) =>
+        doc.title.toLowerCase().includes(query.toLowerCase())
+      );
+
+      expect(results.length).toBe(1);
+      expect(results[0].title).toContain('Getting');
+    });
+
+    it('should find documents by content', () => {
+      const documents = [
+        {
+          id: '1',
+          title: 'Guide',
+          content: 'Learn about authentication'
+        },
+        { id: '2', title: 'API', content: 'REST endpoints' }
+      ];
+
+      const query = 'authentication';
+      const results = documents.filter((doc) =>
+        doc.content.toLowerCase().includes(query.toLowerCase())
+      );
+
+      expect(results.length).toBe(1);
+      expect(results[0].content).toContain('authentication');
+    });
+
+    it('should be case-insensitive', () => {
+      const documents = [
+        { id: '1', title: 'JavaScript Tutorial', content: 'Learn JS' }
+      ];
+
+      const queries = ['javascript', 'JavaScript', 'JAVASCRIPT'];
+      queries.forEach((query) => {
+        const results = documents.filter((doc) =>
+          doc.title.toLowerCase().includes(query.toLowerCase())
+        );
+        expect(results.length).toBe(1);
+      });
+    });
+
+    it('should handle empty search', () => {
+      const documents = [
+        { id: '1', title: 'Doc 1', content: 'Content 1' },
+        { id: '2', title: 'Doc 2', content: 'Content 2' }
+      ];
+
+      const query = '';
+      const results = documents.filter((doc) =>
+        doc.title.toLowerCase().includes(query.toLowerCase())
+      );
+
+      // Empty query matches all
+      expect(results.length).toBe(2);
+    });
+  });
+
+  describe('Advanced Filtering', () => {
+    it('should filter by document type', () => {
+      const documents = [
+        { id: '1', title: 'Guide', type: 'guide', content: 'Content' },
+        { id: '2', title: 'API', type: 'reference', content: 'API' },
+        { id: '3', title: 'Tutorial', type: 'guide', content: 'Learn' }
+      ];
+
+      const filterType = 'guide';
+      const results = documents.filter((doc) => doc.type === filterType);
+
+      expect(results.length).toBe(2);
+      results.forEach((doc) => {
+        expect(doc.type).toBe('guide');
+      });
+    });
+
+    it('should filter by multiple categories', () => {
+      const documents = [
+        {
+          id: '1',
+          title: 'Doc 1',
+          tags: ['javascript', 'beginner']
+        },
+        {
+          id: '2',
+          title: 'Doc 2',
+          tags: ['python', 'beginner']
+        },
+        { id: '3', title: 'Doc 3', tags: ['javascript', 'advanced'] }
+      ];
+
+      const filterTags = ['javascript'];
+      const results = documents.filter((doc) =>
+        filterTags.every((tag) => doc.tags.includes(tag))
+      );
+
+      expect(results.length).toBe(2);
+    });
+
+    it('should filter by date range', () => {
+      const documents = [
+        { id: '1', title: 'Doc 1', date: '2024-01-15' },
+        { id: '2', title: 'Doc 2', date: '2024-02-10' },
+        { id: '3', title: 'Doc 3', date: '2024-03-05' }
+      ];
+
+      const startDate = '2024-02-01';
+      const endDate = '2024-03-01';
+
+      const results = documents.filter((doc) => {
+        return doc.date >= startDate && doc.date <= endDate;
+      });
+
+      expect(results.length).toBe(1);
+      expect(results[0].id).toBe('2');
+    });
+
+    it('should exclude documents by filter', () => {
+      const documents = [
+        { id: '1', title: 'Public Docs', private: false },
+        { id: '2', title: 'Private Docs', private: true },
+        { id: '3', title: 'More Public', private: false }
+      ];
+
+      const excludePrivate = true;
+      const results = documents.filter((doc) => !doc.private || !excludePrivate);
+
+      expect(results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Search Ranking and Relevance', () => {
+    it('should rank exact title matches higher', () => {
+      const documents = [
+        {
+          id: '1',
+          title: 'Getting Started Guide',
+          content: 'Content here',
+          score: 0
+        },
+        {
+          id: '2',
+          title: 'Advanced Guide to Getting',
+          content: 'Other content',
+          score: 0
+        }
+      ];
+
+      const query = 'Getting Started Guide';
+
+      documents.forEach((doc) => {
+        if (doc.title === query) {
+          doc.score = 100;
+        } else if (doc.title.includes(query)) {
+          doc.score = 80;
+        } else if (doc.title.toLowerCase().includes(query.toLowerCase())) {
+          doc.score = 60;
+        }
+      });
+
+      const sorted = documents.sort((a, b) => b.score - a.score);
+
+      expect(sorted[0].score).toBeGreaterThanOrEqual(sorted[1].score);
+    });
+
+    it('should rank title matches higher than content matches', () => {
+      const documents = [
+        {
+          id: '1',
+          title: 'Authentication',
+          content: 'How to use API',
+          score: 0
+        },
+        {
+          id: '2',
+          title: 'API Reference',
+          content: 'Authentication methods',
+          score: 0
+        }
+      ];
+
+      const query = 'Authentication';
+
+      documents.forEach((doc) => {
+        if (doc.title.includes(query)) {
+          doc.score += 100;
+        }
+        if (doc.content.includes(query)) {
+          doc.score += 50;
+        }
+      });
+
+      const sorted = documents.sort((a, b) => b.score - a.score);
+
+      expect(sorted[0].id).toBe('1');
+      expect(sorted[0].score).toBeGreaterThan(sorted[1].score);
+    });
+
+    it('should consider word frequency', () => {
+      const documents = [
+        {
+          id: '1',
+          content: 'JavaScript JavaScript JavaScript',
+          score: 0
+        },
+        { id: '2', content: 'JavaScript is great', score: 0 }
+      ];
+
+      const query = 'JavaScript';
+
+      documents.forEach((doc) => {
+        const matches = (doc.content.match(/JavaScript/g) || []).length;
+        doc.score = matches;
+      });
+
+      const sorted = documents.sort((a, b) => b.score - a.score);
+
+      expect(sorted[0].score).toBeGreaterThan(sorted[1].score);
+    });
+
+    it('should boost recent documents', () => {
+      const documents = [
+        { id: '1', title: 'Old Doc', date: '2023-01-01', score: 50 },
+        { id: '2', title: 'New Doc', date: '2024-03-01', score: 50 }
+      ];
+
+      documents.forEach((doc) => {
+        const daysSinceUpdate = Math.floor(
+          (Date.now() - new Date(doc.date).getTime()) / (1000 * 60 * 60 * 24)
+        );
+        const recencyBoost = Math.max(0, 100 - daysSinceUpdate);
+        doc.score += recencyBoost * 0.1;
+      });
+
+      const sorted = documents.sort((a, b) => b.score - a.score);
+      expect(sorted[0].score).toBeGreaterThanOrEqual(sorted[1].score);
+    });
+  });
+
+  describe('Search Results Display', () => {
+    it('should return paginated results', () => {
+      const allResults = Array(50)
+        .fill(0)
+        .map((_, i) => ({ id: `${i}`, title: `Result ${i}` }));
+
+      const pageSize = 10;
+      const pageNumber = 0;
+
+      const paginated = allResults.slice(
+        pageNumber * pageSize,
+        (pageNumber + 1) * pageSize
+      );
+
+      expect(paginated.length).toBe(10);
+      expect(paginated[0].id).toBe('0');
+    });
+
+    it('should handle result excerpt extraction', () => {
+      const result = {
+        title: 'Documentation',
+        content:
+          'This is a long document. It contains important information. The search term appears here.'
+      };
+
+      const excerptLength = 150;
+      const excerpt =
+        result.content.length > excerptLength
+          ? result.content.substring(0, excerptLength) + '...'
+          : result.content;
+
+      expect(excerpt).toContain('This is a long');
+      expect(excerpt.length).toBeLessThanOrEqual(excerptLength + 3);
+    });
+
+    it('should highlight search terms in results', () => {
+      const result = {
+        title: 'Getting Started',
+        content: 'Getting started with the Getting Started guide'
+      };
+
+      const query = 'Getting';
+      const highlighted = result.content.replace(
+        new RegExp(`(${query})`, 'gi'),
+        '<mark>$1</mark>'
+      );
+
+      expect(highlighted).toContain('<mark>Getting</mark>');
+      expect(highlighted.match(/<mark>/g)?.length).toBe(2);
+    });
+
+    it('should show result metadata', () => {
+      const result = {
+        id: '123',
+        url: '/docs/guide',
+        title: 'Guide',
+        breadcrumb: ['Docs', 'Guide'],
+        lastUpdated: '2024-03-01'
+      };
+
+      expect(result.url).toBeTruthy();
+      expect(result.breadcrumb).toEqual(['Docs', 'Guide']);
+      expect(result.lastUpdated).toBeTruthy();
+    });
+
+    it('should show result count', () => {
+      const results = [
+        { id: '1', title: 'Result 1' },
+        { id: '2', title: 'Result 2' },
+        { id: '3', title: 'Result 3' }
+      ];
+
+      const resultCount = results.length;
+      expect(resultCount).toBe(3);
+    });
+
+    it('should handle "no results" state', () => {
+      const results: any[] = [];
+      const message =
+        results.length === 0
+          ? 'No results found. Try different keywords.'
+          : `Found ${results.length} results`;
+
+      expect(message).toContain('No results found');
+    });
+  });
+
+  describe('Search Performance', () => {
+    it('should search large index quickly', () => {
+      const largeIndex = Array(10000)
+        .fill(0)
+        .map((_, i) => ({
+          id: `${i}`,
+          title: `Document ${i}`,
+          content: `Content for document ${i}`
+        }));
+
+      const query = 'Document 5000';
+
+      const startTime = Date.now();
+      const results = largeIndex.filter((doc) =>
+        doc.title.includes(query) || doc.content.includes(query)
+      );
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(100); // Should be very fast
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('should debounce search input', () => {
+      let searchCount = 0;
+      const executeSearch = () => {
+        searchCount++;
+      };
+
+      let debounceTimer: NodeJS.Timeout | null = null;
+      const debouncedSearch = () => {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          executeSearch();
+        }, 300);
+      };
+
+      // Simulate rapid user input
+      for (let i = 0; i < 10; i++) {
+        debouncedSearch();
+      }
+
+      // Clear the timeout to check the count
+      if (debounceTimer) clearTimeout(debounceTimer);
+
+      expect(searchCount).toBe(0); // No search executed yet (due to debounce)
+    });
+  });
+
+  describe('Special Search Features', () => {
+    it('should support phrase search with quotes', () => {
+      const documents = [
+        { id: '1', content: 'getting started guide' },
+        { id: '2', content: 'started guide getting' },
+        { id: '3', content: 'guide for getting started' }
+      ];
+
+      const query = '"getting started"';
+      const results = documents.filter((doc) =>
+        doc.content.includes(query.replace(/"/g, ''))
+      );
+
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('should support excluding terms with minus', () => {
+      const documents = [
+        { id: '1', content: 'JavaScript tutorial' },
+        { id: '2', content: 'Python tutorial' },
+        { id: '3', content: 'JavaScript advanced' }
+      ];
+
+      const includeTerms = ['tutorial'];
+      const excludeTerms = ['JavaScript'];
+
+      const results = documents.filter((doc) => {
+        const hasInclude = includeTerms.every((term) =>
+          doc.content.includes(term)
+        );
+        const hasExclude = excludeTerms.some((term) =>
+          doc.content.includes(term)
+        );
+        return hasInclude && !hasExclude;
+      });
+
+      expect(results.length).toBe(1);
+      expect(results[0].id).toBe('2');
+    });
+
+    it('should support wildcard search', () => {
+      const documents = [
+        { id: '1', title: 'JavaScripting' },
+        { id: '2', title: 'JavaScript' },
+        { id: '3', title: 'Script' }
+      ];
+
+      const query = 'Java*';
+      const pattern = new RegExp(query.replace(/\*/g, '.*'));
+
+      const results = documents.filter((doc) => pattern.test(doc.title));
+
+      expect(results.length).toBe(2);
+    });
+
+    it('should support field-specific search', () => {
+      const documents = [
+        { id: '1', title: 'Guide', content: 'getting started' },
+        { id: '2', title: 'Getting Started', content: 'introduction' }
+      ];
+
+      const fieldSearch = 'title:Getting';
+      const [field, term] = fieldSearch.split(':');
+
+      const results = documents.filter((doc: any) => {
+        return doc[field]?.includes(term);
+      });
+
+      expect(results.length).toBe(1);
+      expect(results[0].id).toBe('2');
+    });
+  });
+
+  describe('Search Analytics', () => {
+    it('should track popular searches', () => {
+      const searchLog = [
+        { query: 'getting started', count: 150 },
+        { query: 'api reference', count: 120 },
+        { query: 'installation', count: 95 }
+      ];
+
+      const sorted = searchLog.sort((a, b) => b.count - a.count);
+
+      expect(sorted[0].query).toBe('getting started');
+      expect(sorted[0].count).toBe(150);
+    });
+
+    it('should track search quality metrics', () => {
+      const searches = [
+        { query: 'guide', resultCount: 45, clickCount: 23 },
+        { query: 'help', resultCount: 0, clickCount: 0 }
+      ];
+
+      const goodSearches = searches.filter(
+        (s) => s.resultCount > 0 && s.clickCount > 0
+      );
+
+      expect(goodSearches.length).toBe(1);
+    });
+  });
+});

package/src/lib/stores/i18n.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { i18n } from './i18n';
+
+// Mock localStorage
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+
+  return {
+    getItem: (key: string) => store[key] || null,
+    setItem: (key: string, value: string) => {
+      store[key] = value.toString();
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      store = {};
+    },
+  };
+})();
+
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+});
+
+describe('i18n store', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('should initialize with default language (English)', () => {
+    let currentLanguage = '';
+    const unsubscribe = i18n.subscribe((config) => {
+      currentLanguage = config.currentLanguage;
+    });
+
+    expect(currentLanguage).toBe('en');
+    unsubscribe();
+  });
+
+  it('should have multiple languages available', () => {
+    let languages = [];
+    const unsubscribe = i18n.subscribe((config) => {
+      languages = config.availableLanguages.map((l) => l.code);
+    });
+
+    expect(languages).toContain('en');
+    expect(languages).toContain('fr');
+    expect(languages).toContain('es');
+    expect(languages).toContain('de');
+    expect(languages).toContain('ja');
+    expect(languages.length).toBe(5);
+    unsubscribe();
+  });
+
+  it('should mark English as default language', () => {
+    let defaultLanguage = '';
+    const unsubscribe = i18n.subscribe((config) => {
+      defaultLanguage = config.defaultLanguage;
+    });
+
+    expect(defaultLanguage).toBe('en');
+    unsubscribe();
+  });
+
+  it('should allow changing language', () => {
+    let currentLanguage = '';
+    const unsubscribe = i18n.subscribe((config) => {
+      currentLanguage = config.currentLanguage;
+    });
+
+    i18n.setLanguage('fr');
+    expect(currentLanguage).toBe('fr');
+
+    i18n.setLanguage('es');
+    expect(currentLanguage).toBe('es');
+
+    unsubscribe();
+  });
+
+  it('should persist language preference to localStorage', () => {
+    i18n.setLanguage('fr');
+    expect(localStorage.getItem('docs-language')).toBe('fr');
+
+    i18n.setLanguage('ja');
+    expect(localStorage.getItem('docs-language')).toBe('ja');
+  });
+
+  it('should update document lang attribute on language change', () => {
+    i18n.setLanguage('fr');
+    expect(document.documentElement.lang).toBe('fr');
+
+    i18n.setLanguage('es');
+    expect(document.documentElement.lang).toBe('es');
+  });
+
+  it('should ignore setting invalid language', () => {
+    let currentLanguage = '';
+    const unsubscribe = i18n.subscribe((config) => {
+      currentLanguage = config.currentLanguage;
+    });
+
+    const initialLanguage = currentLanguage;
+    i18n.setLanguage('zh' as any);
+    expect(currentLanguage).toBe(initialLanguage);
+
+    unsubscribe();
+  });
+
+  it('should allow adding new languages', () => {
+    let languages = [];
+    const unsubscribe = i18n.subscribe((config) => {
+      languages = config.availableLanguages.map((l) => l.code);
+    });
+
+    i18n.addLanguage({
+      code: 'pt',
+      label: 'Português',
+      nativeLabel: 'Português',
+      direction: 'ltr',
+    });
+
+    expect(languages).toContain('pt');
+    unsubscribe();
+  });
+
+  it('should allow removing languages', () => {
+    let languages = [];
+    const unsubscribe = i18n.subscribe((config) => {
+      languages = config.availableLanguages.map((l) => l.code);
+    });
+
+    const initialCount = languages.length;
+    i18n.removeLanguage('fr');
+
+    expect(languages.length).toBe(initialCount - 1);
+    expect(languages).not.toContain('fr');
+    unsubscribe();
+  });
+
+  it('should retrieve language metadata', () => {
+    // Re-add French if it was removed by previous test
+    i18n.addLanguage({
+      code: 'fr',
+      label: 'Français',
+      nativeLabel: 'Français',
+      direction: 'ltr',
+    });
+
+    const metadata = i18n.getLanguageMetadata('fr');
+    expect(metadata).toBeDefined();
+    expect(metadata?.code).toBe('fr');
+    expect(metadata?.label).toBe('Français');
+    expect(metadata?.direction).toBe('ltr');
+  });
+
+  it('should have correct language labels', () => {
+    // Ensure French is available
+    i18n.addLanguage({
+      code: 'fr',
+      label: 'Français',
+      nativeLabel: 'Français',
+      direction: 'ltr',
+    });
+
+    let languages = [];
+    const unsubscribe = i18n.subscribe((config) => {
+      languages = config.availableLanguages;
+    });
+
+    const french = languages.find((l) => l.code === 'fr');
+    expect(french?.label).toBe('Français');
+    expect(french?.nativeLabel).toBe('Français');
+
+    const spanish = languages.find((l) => l.code === 'es');
+    expect(spanish?.label).toBe('Español');
+
+    unsubscribe();
+  });
+});