@alliance-droid/svelte-docs-system 0.0.1

package/src/lib/stores/i18n.ts

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,162 @@
+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.ts

@@ -0,0 +1,59 @@
+import { writable } from 'svelte/store';
+
+type Theme = 'light' | 'dark';
+
+function createThemeStore() {
+  // Check localStorage or system preference on initialization
+  const getInitialTheme = (): Theme => {
+    if (typeof window === 'undefined') {
+      return 'light'; // SSR default
+    }
+
+    // Check localStorage
+    const stored = localStorage.getItem('theme') as Theme | null;
+    if (stored) {
+      return stored;
+    }
+
+    // Check system preference
+    if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+      return 'dark';
+    }
+
+    return 'light';
+  };
+
+  const { subscribe, set, update } = writable<Theme>(getInitialTheme());
+
+  return {
+    subscribe,
+    set: (theme: Theme) => {
+      if (typeof window !== 'undefined') {
+        localStorage.setItem('theme', theme);
+        // Apply theme to document
+        if (theme === 'dark') {
+          document.documentElement.classList.add('dark');
+        } else {
+          document.documentElement.classList.remove('dark');
+        }
+      }
+      set(theme);
+    },
+    toggle: () => {
+      update((theme) => {
+        const newTheme = theme === 'dark' ? 'light' : 'dark';
+        if (typeof window !== 'undefined') {
+          localStorage.setItem('theme', newTheme);
+          if (newTheme === 'dark') {
+            document.documentElement.classList.add('dark');
+          } else {
+            document.documentElement.classList.remove('dark');
+          }
+        }
+        return newTheme;
+      });
+    },
+  };
+}
+
+export const theme = createThemeStore();

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

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { version } from './version';
+
+// 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('version store', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('should initialize with default version', () => {
+    let currentVersion = '';
+    const unsubscribe = version.subscribe((config) => {
+      currentVersion = config.current;
+    });
+
+    expect(currentVersion).toBe('2.0');
+    unsubscribe();
+  });
+
+  it('should have multiple versions available', () => {
+    let versions = [];
+    const unsubscribe = version.subscribe((config) => {
+      versions = config.availableVersions.map((v) => v.version);
+    });
+
+    expect(versions).toContain('2.0');
+    expect(versions).toContain('1.5');
+    expect(versions).toContain('1.0');
+    expect(versions.length).toBe(3);
+    unsubscribe();
+  });
+
+  it('should mark v2.0 as latest', () => {
+    let latestVersion = null;
+    const unsubscribe = version.subscribe((config) => {
+      const latest = config.availableVersions.find((v) => v.isLatest);
+      latestVersion = latest?.version;
+    });
+
+    expect(latestVersion).toBe('2.0');
+    unsubscribe();
+  });
+
+  it('should allow changing version', () => {
+    let currentVersion = '';
+    const unsubscribe = version.subscribe((config) => {
+      currentVersion = config.current;
+    });
+
+    version.setVersion('1.5');
+    expect(currentVersion).toBe('1.5');
+
+    version.setVersion('1.0');
+    expect(currentVersion).toBe('1.0');
+
+    unsubscribe();
+  });
+
+  it('should persist version preference to localStorage', () => {
+    version.setVersion('1.5');
+    expect(localStorage.getItem('docs-version')).toBe('1.5');
+
+    version.setVersion('1.0');
+    expect(localStorage.getItem('docs-version')).toBe('1.0');
+  });
+
+  it('should ignore setting invalid version', () => {
+    let currentVersion = '';
+    const unsubscribe = version.subscribe((config) => {
+      currentVersion = config.current;
+    });
+
+    const initialVersion = currentVersion;
+    version.setVersion('99.0');
+    expect(currentVersion).toBe(initialVersion);
+
+    unsubscribe();
+  });
+
+  it('should allow adding new versions', () => {
+    let versions = [];
+    const unsubscribe = version.subscribe((config) => {
+      versions = config.availableVersions.map((v) => v.version);
+    });
+
+    version.addVersion({
+      version: '3.0',
+      label: 'v3.0',
+      isLatest: false,
+      status: 'beta',
+    });
+
+    expect(versions).toContain('3.0');
+    unsubscribe();
+  });
+
+  it('should allow removing versions', () => {
+    let versions = [];
+    const unsubscribe = version.subscribe((config) => {
+      versions = config.availableVersions.map((v) => v.version);
+    });
+
+    const initialCount = versions.length;
+    version.removeVersion('1.0');
+
+    expect(versions.length).toBe(initialCount - 1);
+    expect(versions).not.toContain('1.0');
+    unsubscribe();
+  });
+
+  it('should retrieve version metadata', () => {
+    const metadata = version.getVersionMetadata('2.0');
+    expect(metadata).toBeDefined();
+    expect(metadata?.version).toBe('2.0');
+    expect(metadata?.isLatest).toBe(true);
+    expect(metadata?.status).toBe('stable');
+  });
+});