@alliance-droid/svelte-docs-system 0.0.2 → 0.1.0

package/src/lib/stores/i18n.ts

@@ -1,143 +0,0 @@
-import { writable } from 'svelte/store';
-
-export type Language = 'en' | 'fr' | 'es' | 'de' | 'ja';
-
-export interface LanguageMetadata {
-  code: Language;
-  label: string;
-  nativeLabel: string;
-  direction: 'ltr' | 'rtl';
-  isDefault?: boolean;
-}
-
-export interface I18nConfig {
-  currentLanguage: Language;
-  availableLanguages: LanguageMetadata[];
-  defaultLanguage: Language;
-}
-
-function createI18nStore() {
-  // Default language configuration
-  const defaultConfig: I18nConfig = {
-    currentLanguage: 'en',
-    defaultLanguage: 'en',
-    availableLanguages: [
-      {
-        code: 'en',
-        label: 'English',
-        nativeLabel: 'English',
-        direction: 'ltr',
-        isDefault: true,
-      },
-      {
-        code: 'fr',
-        label: 'Français',
-        nativeLabel: 'Français',
-        direction: 'ltr',
-      },
-      {
-        code: 'es',
-        label: 'Español',
-        nativeLabel: 'Español',
-        direction: 'ltr',
-      },
-      {
-        code: 'de',
-        label: 'Deutsch',
-        nativeLabel: 'Deutsch',
-        direction: 'ltr',
-      },
-      {
-        code: 'ja',
-        label: '日本語',
-        nativeLabel: '日本語',
-        direction: 'ltr',
-      },
-    ],
-  };
-
-  const getInitialLanguage = (): Language => {
-    if (typeof window === 'undefined') {
-      return defaultConfig.defaultLanguage;
-    }
-
-    try {
-      // Check localStorage for stored language preference
-      const stored = localStorage?.getItem?.('docs-language') as Language | null;
-      if (stored && defaultConfig.availableLanguages.some((l) => l.code === stored)) {
-        return stored;
-      }
-
-      // Check browser language preference
-      const browserLang = navigator?.language?.split('-')[0].toLowerCase();
-      const matchedLang = defaultConfig.availableLanguages.find(
-        (l) => l.code === (browserLang as Language)
-      );
-      if (matchedLang) {
-        return matchedLang.code;
-      }
-    } catch (e) {
-      // localStorage or navigator may not be available in some environments
-    }
-
-    return defaultConfig.defaultLanguage;
-  };
-
-  const { subscribe, set, update } = writable<I18nConfig>({
-    ...defaultConfig,
-    currentLanguage: getInitialLanguage(),
-  });
-
-  return {
-    subscribe,
-    setLanguage: (language: Language) => {
-      update((config) => {
-        if (config.availableLanguages.some((l) => l.code === language)) {
-          if (typeof window !== 'undefined') {
-            try {
-              localStorage?.setItem?.('docs-language', language);
-            } catch (e) {
-              // localStorage may not be available
-            }
-            // Update document lang attribute
-            if (document?.documentElement) {
-              document.documentElement.lang = language;
-              // Update document dir attribute
-              const metadata = config.availableLanguages.find((l) => l.code === language);
-              if (metadata) {
-                document.documentElement.dir = metadata.direction;
-              }
-            }
-          }
-          return { ...config, currentLanguage: language };
-        }
-        return config;
-      });
-    },
-    addLanguage: (metadata: LanguageMetadata) => {
-      update((config) => ({
-        ...config,
-        availableLanguages: [
-          ...config.availableLanguages.filter((l) => l.code !== metadata.code),
-          metadata,
-        ],
-      }));
-    },
-    removeLanguage: (language: Language) => {
-      update((config) => ({
-        ...config,
-        availableLanguages: config.availableLanguages.filter((l) => l.code !== language),
-      }));
-    },
-    getLanguageMetadata: (language: Language): LanguageMetadata | undefined => {
-      let metadata: LanguageMetadata | undefined;
-      const unsubscribe = subscribe((config) => {
-        metadata = config.availableLanguages.find((l) => l.code === language);
-      });
-      unsubscribe();
-      return metadata;
-    },
-  };
-}
-
-export const i18n = createI18nStore();

package/src/lib/stores/nav.ts

@@ -1,36 +0,0 @@
-import { writable } from 'svelte/store';
-
-export interface NavItem {
-  label: string;
-  href?: string;
-  children?: NavItem[];
-  icon?: string;
-}
-
-export interface NavConfig {
-  title: string;
-  sections: NavSection[];
-}
-
-export interface NavSection {
-  title: string;
-  items: NavItem[];
-}
-
-function createNavStore() {
-  const { subscribe, set, update } = writable<NavConfig>({
-    title: 'Documentation',
-    sections: [],
-  });
-
-  return {
-    subscribe,
-    setNav: (config: NavConfig) => set(config),
-    updateNav: (fn: (nav: NavConfig) => NavConfig) => update(fn),
-  };
-}
-
-export const nav = createNavStore();
-
-// Store for mobile sidebar visibility
-export const sidebarOpen = writable(false);

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

@@ -1,140 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-	query,
-	results,
-	loading,
-	resultCount,
-	initPagefind,
-	updateSearch,
-	clearSearch,
-	performSearch,
-	subscribeToSearch
-} from './search';
-
-describe('Search Store', () => {
-	beforeEach(() => {
-		clearSearch();
-	});
-
-	describe('query store', () => {
-		it('should initialize with empty string', () => {
-			let currentQuery = '';
-			query.subscribe((q) => {
-				currentQuery = q;
-			});
-			expect(currentQuery).toBe('');
-		});
-	});
-
-	describe('results store', () => {
-		it('should initialize with empty array', () => {
-			let currentResults: any[] = [];
-			results.subscribe((r) => {
-				currentResults = r;
-			});
-			expect(currentResults).toEqual([]);
-		});
-	});
-
-	describe('loading store', () => {
-		it('should initialize as false', () => {
-			let isLoading = false;
-			loading.subscribe((l) => {
-				isLoading = l;
-			});
-			expect(isLoading).toBe(false);
-		});
-	});
-
-	describe('resultCount store', () => {
-		it('should initialize with 0', () => {
-			let count = 0;
-			resultCount.subscribe((c) => {
-				count = c;
-			});
-			expect(count).toBe(0);
-		});
-	});
-
-	describe('clearSearch', () => {
-		it('should clear query and results', async () => {
-			query.set('test query');
-			let queries: string[] = [];
-			let resultsList: any[] = [];
-
-			const unsubscribeQuery = query.subscribe((q) => {
-				queries.push(q);
-			});
-
-			const unsubscribeResults = results.subscribe((r) => {
-				resultsList.push(r);
-			});
-
-			clearSearch();
-
-			// Allow time for updates
-			await new Promise((resolve) => setTimeout(resolve, 10));
-			
-			expect(queries[queries.length - 1]).toBe('');
-			expect(resultsList[resultsList.length - 1]).toEqual([]);
-			unsubscribeQuery();
-			unsubscribeResults();
-		});
-	});
-
-	describe('updateSearch', () => {
-		it('should update query store', async () => {
-			let currentQuery = '';
-			const unsubscribe = query.subscribe((q) => {
-				currentQuery = q;
-			});
-
-			// Note: This will fail without Pagefind initialized,
-			// but we're testing the store behavior
-			try {
-				await updateSearch('test');
-			} catch {
-				// Expected to fail without Pagefind
-			}
-
-			expect(currentQuery).toBe('test');
-			unsubscribe();
-		});
-	});
-
-	describe('subscribeToSearch', () => {
-		it('should unsubscribe properly', () => {
-			const mockCallback = vi.fn();
-			const unsubscribe = subscribeToSearch(mockCallback, 100);
-
-			query.set('test');
-
-			// Unsubscribe immediately
-			unsubscribe();
-
-			// Query should still update but callback should not be called
-			// (because we unsubscribed)
-			expect(mockCallback).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('Search results type', () => {
-		it('should have correct result properties', () => {
-			const mockResult = {
-				id: 'test-1',
-				url: '/test',
-				title: 'Test Title',
-				content: 'Test content',
-				excerpt: 'Test excerpt',
-				meta: { category: 'test' }
-			};
-
-			expect(mockResult.id).toBe('test-1');
-			expect(mockResult.url).toBe('/test');
-			expect(mockResult.title).toBe('Test Title');
-			expect(mockResult.content).toBe('Test content');
-			expect(mockResult.excerpt).toBe('Test excerpt');
-			expect(mockResult.meta).toEqual({ category: 'test' });
-		});
-	});
-});

package/src/lib/stores/search.ts

@@ -1,162 +0,0 @@
-import { writable, derived, type Writable, type Readable } from 'svelte/store';
-
-export interface SearchResult {
-	id: string;
-	url: string;
-	title: string;
-	content: string;
-	excerpt?: string;
-	meta?: Record<string, unknown>;
-}
-
-interface SearchFilters {
-	limit?: number;
-}
-
-// Main search query store
-const searchQuery: Writable<string> = writable('');
-
-// Search results store
-const searchResults: Writable<SearchResult[]> = writable([]);
-
-// Loading state store
-const isSearching: Writable<boolean> = writable(false);
-
-// Pagefind index reference
-let pagefindIndex: any = null;
-
-/**
- * Initialize Pagefind when the client loads
- */
-export async function initPagefind(): Promise<void> {
-	if (typeof window === 'undefined') {
-		console.warn('Pagefind can only be initialized on the client side');
-		return;
-	}
-
-	try {
-		// Check if pagefind is already available globally (from build output)
-		if ((window as any).pagefind) {
-			pagefindIndex = (window as any).pagefind;
-			console.log('Pagefind initialized successfully (from global)');
-			return;
-		}
-
-		// Dynamically import Pagefind from the build output
-		// Use string concatenation to prevent Vite from resolving this at build time
-		const pagefindPath = '/' + 'pagefind' + '/' + 'pagefind.js';
-		const pagefind = await import(/* @vite-ignore */ pagefindPath);
-		pagefindIndex = pagefind;
-		console.log('Pagefind initialized successfully (from dynamic import)');
-	} catch (error) {
-		console.error('Failed to initialize Pagefind:', error);
-		console.warn(
-			'Search functionality will not work. Make sure to run `npm run build` to generate search index.'
-		);
-	}
-}
-
-/**
- * Perform a search query
- */
-export async function performSearch(query: string, filters?: SearchFilters): Promise<SearchResult[]> {
-	if (!query.trim()) {
-		searchResults.set([]);
-		return [];
-	}
-
-	if (!pagefindIndex) {
-		console.warn('Pagefind not yet initialized');
-		return [];
-	}
-
-	isSearching.set(true);
-
-	try {
-		const results = await pagefindIndex.search(query);
-		const limit = filters?.limit || 20;
-
-		// Convert Pagefind results to our SearchResult format
-		const formattedResults: SearchResult[] = results.results
-			.slice(0, limit)
-			.map((result: any) => ({
-				id: result.id,
-				url: result.url,
-				title: result.meta?.title || 'Untitled',
-				content: result.meta?.content || '',
-				excerpt: result.excerpt || '',
-				meta: result.meta || {}
-			}));
-
-		searchResults.set(formattedResults);
-		return formattedResults;
-	} catch (error) {
-		console.error('Search error:', error);
-		searchResults.set([]);
-		return [];
-	} finally {
-		isSearching.set(false);
-	}
-}
-
-/**
- * Get reactive search results
- */
-export const results: Readable<SearchResult[]> = derived(
-	searchResults,
-	($results) => $results
-);
-
-/**
- * Get reactive search query
- */
-export const query = searchQuery;
-
-/**
- * Get reactive loading state
- */
-export const loading = isSearching;
-
-/**
- * Computed derived store for result count
- */
-export const resultCount: Readable<number> = derived(
-	searchResults,
-	($results) => $results.length
-);
-
-/**
- * Clear search results and query
- */
-export function clearSearch(): void {
-	searchQuery.set('');
-	searchResults.set([]);
-}
-
-/**
- * Update search query and perform search
- */
-export async function updateSearch(newQuery: string, filters?: SearchFilters): Promise<SearchResult[]> {
-	searchQuery.set(newQuery);
-	return performSearch(newQuery, filters);
-}
-
-/**
- * Subscribe to search query changes with debouncing
- */
-export function subscribeToSearch(
-	callback: (query: string) => Promise<void>,
-	delayMs: number = 300
-): () => void {
-	let timeout: ReturnType<typeof setTimeout>;
-
-	const unsubscribe = searchQuery.subscribe((query) => {
-		clearTimeout(timeout);
-		timeout = setTimeout(() => callback(query), delayMs);
-	});
-
-	return () => {
-		clearTimeout(timeout);
-		unsubscribe();
-	};
-}

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

@@ -1,117 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { theme } from './theme';
-
-// 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,
-  writable: true,
-});
-
-describe('Theme Store', () => {
-  let unsubscribe: () => void;
-  let currentTheme: 'light' | 'dark' | null = null;
-
-  beforeEach(() => {
-    // Clear localStorage
-    localStorage.clear();
-    currentTheme = null;
-
-    // Subscribe to theme changes
-    unsubscribe = theme.subscribe((t) => {
-      currentTheme = t;
-    });
-  });
-
-  afterEach(() => {
-    if (unsubscribe) {
-      unsubscribe();
-    }
-    localStorage.clear();
-    // Remove dark class from document
-    document.documentElement.classList.remove('dark');
-  });
-
-  describe('Theme initialization', () => {
-    it('should default to light theme', () => {
-      expect(currentTheme).toBe('light');
-    });
-
-    it('should respect localStorage preference in standalone mode', () => {
-      // Verify that when we set a theme, it's saved to localStorage
-      theme.set('dark');
-      expect(localStorage.getItem('theme')).toBe('dark');
-      
-      // Verify that the store reflects the saved value
-      expect(currentTheme).toBe('dark');
-    });
-  });
-
-  describe('Theme set', () => {
-    it('should set theme and apply dark class to document', () => {
-      theme.set('dark');
-      expect(currentTheme).toBe('dark');
-      expect(document.documentElement.classList.contains('dark')).toBe(true);
-    });
-
-    it('should set theme and remove dark class from document', () => {
-      document.documentElement.classList.add('dark');
-      theme.set('light');
-      expect(currentTheme).toBe('light');
-      expect(document.documentElement.classList.contains('dark')).toBe(false);
-    });
-
-    it('should save theme to localStorage in standalone mode', () => {
-      theme.set('dark');
-      const stored = localStorage.getItem('theme');
-      expect(stored).toBe('dark');
-    });
-  });
-
-  describe('Theme toggle', () => {
-    it('should toggle from light to dark', () => {
-      theme.set('light');
-      theme.toggle();
-      expect(currentTheme).toBe('dark');
-      expect(document.documentElement.classList.contains('dark')).toBe(true);
-    });
-
-    it('should toggle from dark to light', () => {
-      theme.set('dark');
-      theme.toggle();
-      expect(currentTheme).toBe('light');
-      expect(document.documentElement.classList.contains('dark')).toBe(false);
-    });
-
-    it('should persist toggled theme to localStorage', () => {
-      theme.set('light');
-      theme.toggle();
-      expect(localStorage.getItem('theme')).toBe('dark');
-    });
-  });
-
-  describe('Parent theme detection', () => {
-    it('should detect parent theme when embedded', () => {
-      // This test would require mocking window.parent
-      // In a real scenario, window.parent would be set up in the parent app
-      // For now, we skip this test in unit tests and rely on integration tests
-      expect(true).toBe(true);
-    });
-  });
-});