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

package/dist/stores/i18n.d.ts

@@ -0,0 +1,20 @@
+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;
+}
+export declare const i18n: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<I18nConfig>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    setLanguage: (language: Language) => void;
+    addLanguage: (metadata: LanguageMetadata) => void;
+    removeLanguage: (language: Language) => void;
+    getLanguageMetadata: (language: Language) => LanguageMetadata | undefined;
+};

package/dist/stores/i18n.js

@@ -0,0 +1,119 @@
+import { writable } from 'svelte/store';
+function createI18nStore() {
+    // Default language configuration
+    const defaultConfig = {
+        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 = () => {
+        if (typeof window === 'undefined') {
+            return defaultConfig.defaultLanguage;
+        }
+        try {
+            // Check localStorage for stored language preference
+            const stored = localStorage?.getItem?.('docs-language');
+            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);
+            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({
+        ...defaultConfig,
+        currentLanguage: getInitialLanguage(),
+    });
+    return {
+        subscribe,
+        setLanguage: (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) => {
+            update((config) => ({
+                ...config,
+                availableLanguages: [
+                    ...config.availableLanguages.filter((l) => l.code !== metadata.code),
+                    metadata,
+                ],
+            }));
+        },
+        removeLanguage: (language) => {
+            update((config) => ({
+                ...config,
+                availableLanguages: config.availableLanguages.filter((l) => l.code !== language),
+            }));
+        },
+        getLanguageMetadata: (language) => {
+            let metadata;
+            const unsubscribe = subscribe((config) => {
+                metadata = config.availableLanguages.find((l) => l.code === language);
+            });
+            unsubscribe();
+            return metadata;
+        },
+    };
+}
+export const i18n = createI18nStore();

package/dist/stores/nav.d.ts

@@ -0,0 +1,20 @@
+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[];
+}
+export declare const nav: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<NavConfig>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    setNav: (config: NavConfig) => void;
+    updateNav: (fn: (nav: NavConfig) => NavConfig) => void;
+};
+export declare const sidebarOpen: import("svelte/store").Writable<boolean>;

package/dist/stores/nav.js

@@ -0,0 +1,15 @@
+import { writable } from 'svelte/store';
+function createNavStore() {
+    const { subscribe, set, update } = writable({
+        title: 'Documentation',
+        sections: [],
+    });
+    return {
+        subscribe,
+        setNav: (config) => set(config),
+        updateNav: (fn) => update(fn),
+    };
+}
+export const nav = createNavStore();
+// Store for mobile sidebar visibility
+export const sidebarOpen = writable(false);

package/dist/stores/search.d.ts

@@ -0,0 +1,49 @@
+import { 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;
+}
+/**
+ * Initialize Pagefind when the client loads
+ */
+export declare function initPagefind(): Promise<void>;
+/**
+ * Perform a search query
+ */
+export declare function performSearch(query: string, filters?: SearchFilters): Promise<SearchResult[]>;
+/**
+ * Get reactive search results
+ */
+export declare const results: Readable<SearchResult[]>;
+/**
+ * Get reactive search query
+ */
+export declare const query: Writable<string>;
+/**
+ * Get reactive loading state
+ */
+export declare const loading: Writable<boolean>;
+/**
+ * Computed derived store for result count
+ */
+export declare const resultCount: Readable<number>;
+/**
+ * Clear search results and query
+ */
+export declare function clearSearch(): void;
+/**
+ * Update search query and perform search
+ */
+export declare function updateSearch(newQuery: string, filters?: SearchFilters): Promise<SearchResult[]>;
+/**
+ * Subscribe to search query changes with debouncing
+ */
+export declare function subscribeToSearch(callback: (query: string) => Promise<void>, delayMs?: number): () => void;
+export {};

package/dist/stores/search.js

@@ -0,0 +1,127 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { writable, derived } from 'svelte/store';
+// Main search query store
+const searchQuery = writable('');
+// Search results store
+const searchResults = writable([]);
+// Loading state store
+const isSearching = writable(false);
+// Pagefind index reference
+let pagefindIndex = null;
+/**
+ * Initialize Pagefind when the client loads
+ */
+export async function initPagefind() {
+    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.pagefind) {
+            pagefindIndex = window.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(__rewriteRelativeImportExtension(/* @vite-ignore */ pagefindPath, true));
+        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, filters) {
+    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 = results.results
+            .slice(0, limit)
+            .map((result) => ({
+            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 = 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 = derived(searchResults, ($results) => $results.length);
+/**
+ * Clear search results and query
+ */
+export function clearSearch() {
+    searchQuery.set('');
+    searchResults.set([]);
+}
+/**
+ * Update search query and perform search
+ */
+export async function updateSearch(newQuery, filters) {
+    searchQuery.set(newQuery);
+    return performSearch(newQuery, filters);
+}
+/**
+ * Subscribe to search query changes with debouncing
+ */
+export function subscribeToSearch(callback, delayMs = 300) {
+    let timeout;
+    const unsubscribe = searchQuery.subscribe((query) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => callback(query), delayMs);
+    });
+    return () => {
+        clearTimeout(timeout);
+        unsubscribe();
+    };
+}

package/dist/stores/theme.d.ts

@@ -0,0 +1,7 @@
+type Theme = 'light' | 'dark';
+export declare const theme: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<Theme>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    set: (theme: Theme) => void;
+    toggle: () => void;
+};
+export {};

package/dist/stores/theme.js

@@ -0,0 +1,152 @@
+import { writable } from 'svelte/store';
+/**
+ * Detects if this app is embedded in a parent app by checking if window.parent exists
+ * and is different from the current window.
+ */
+function isEmbedded() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        return window.parent !== window && window.parent !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Attempts to detect the parent app's theme by checking the parent window's
+ * document.documentElement classList for the 'dark' class.
+ */
+function getParentTheme() {
+    if (!isEmbedded())
+        return null;
+    try {
+        // Try to access parent's document to check for dark class
+        if (window.parent &&
+            window.parent.document &&
+            window.parent.document.documentElement) {
+            const hasDarkClass = window.parent.document.documentElement.classList.contains('dark');
+            return hasDarkClass ? 'dark' : 'light';
+        }
+    }
+    catch (e) {
+        // Cross-origin or other access errors - fall back to other methods
+        console.debug('Unable to detect parent theme via document inspection:', e);
+    }
+    return null;
+}
+function createThemeStore() {
+    /**
+     * Initializes theme by:
+     * 1. Checking if embedded in parent app and inheriting parent's theme
+     * 2. Falling back to localStorage preference
+     * 3. Falling back to system preference
+     * 4. Defaulting to 'light'
+     */
+    const getInitialTheme = () => {
+        if (typeof window === 'undefined') {
+            return 'light'; // SSR default
+        }
+        // Priority 1: Check parent app theme if embedded
+        const parentTheme = getParentTheme();
+        if (parentTheme) {
+            return parentTheme;
+        }
+        // Priority 2: Check localStorage (user preference in standalone mode)
+        try {
+            const stored = localStorage?.getItem?.('theme');
+            if (stored) {
+                return stored;
+            }
+        }
+        catch (e) {
+            // localStorage may not be available in some environments
+        }
+        // Priority 3: Check system preference
+        if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+            return 'dark';
+        }
+        return 'light';
+    };
+    const { subscribe, set, update } = writable(getInitialTheme());
+    // Set up listener for parent theme changes when embedded
+    if (typeof window !== 'undefined' && isEmbedded()) {
+        try {
+            const observer = new MutationObserver((mutations) => {
+                mutations.forEach((mutation) => {
+                    if (mutation.type === 'attributes' &&
+                        mutation.attributeName === 'class' &&
+                        mutation.target === window.parent?.document?.documentElement) {
+                        // Parent's dark class changed, update our theme
+                        const parentTheme = getParentTheme();
+                        if (parentTheme) {
+                            const currentTheme = parentTheme;
+                            applyTheme(currentTheme);
+                            set(currentTheme);
+                        }
+                    }
+                });
+            });
+            // Watch for class changes on parent's documentElement
+            if (window.parent?.document?.documentElement) {
+                observer.observe(window.parent.document.documentElement, {
+                    attributes: true,
+                    attributeFilter: ['class'],
+                });
+            }
+        }
+        catch (e) {
+            console.debug('Could not set up parent theme listener (may be cross-origin):', e);
+        }
+    }
+    /**
+     * Applies theme to the document by adding/removing the 'dark' class
+     */
+    const applyTheme = (theme) => {
+        if (typeof window === 'undefined')
+            return;
+        if (theme === 'dark') {
+            document.documentElement.classList.add('dark');
+        }
+        else {
+            document.documentElement.classList.remove('dark');
+        }
+    };
+    return {
+        subscribe,
+        set: (theme) => {
+            if (typeof window !== 'undefined') {
+                // Only save to localStorage if not embedded (standalone mode)
+                if (!isEmbedded()) {
+                    try {
+                        localStorage?.setItem?.('theme', theme);
+                    }
+                    catch (e) {
+                        // localStorage may not be available
+                    }
+                }
+                applyTheme(theme);
+            }
+            set(theme);
+        },
+        toggle: () => {
+            update((theme) => {
+                const newTheme = theme === 'dark' ? 'light' : 'dark';
+                if (typeof window !== 'undefined') {
+                    // Only save to localStorage if not embedded (standalone mode)
+                    if (!isEmbedded()) {
+                        try {
+                            localStorage?.setItem?.('theme', newTheme);
+                        }
+                        catch (e) {
+                            // localStorage may not be available
+                        }
+                    }
+                    applyTheme(newTheme);
+                }
+                return newTheme;
+            });
+        },
+    };
+}
+export const theme = createThemeStore();

package/dist/stores/version.d.ts

@@ -0,0 +1,18 @@
+export interface VersionMetadata {
+    version: string;
+    label: string;
+    isLatest: boolean;
+    releaseDate?: string;
+    status?: 'stable' | 'beta' | 'deprecated';
+}
+export interface VersionConfig {
+    current: string;
+    availableVersions: VersionMetadata[];
+}
+export declare const version: {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<VersionConfig>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    setVersion: (version: string) => void;
+    addVersion: (metadata: VersionMetadata) => void;
+    removeVersion: (version: string) => void;
+    getVersionMetadata: (version: string) => VersionMetadata | undefined;
+};

package/dist/stores/version.js

@@ -0,0 +1,93 @@
+import { writable } from 'svelte/store';
+function createVersionStore() {
+    // Default version configuration
+    const defaultConfig = {
+        current: '2.0',
+        availableVersions: [
+            {
+                version: '2.0',
+                label: 'v2.0 (Latest)',
+                isLatest: true,
+                releaseDate: '2026-02-04',
+                status: 'stable',
+            },
+            {
+                version: '1.5',
+                label: 'v1.5',
+                isLatest: false,
+                releaseDate: '2025-12-01',
+                status: 'stable',
+            },
+            {
+                version: '1.0',
+                label: 'v1.0 (Archive)',
+                isLatest: false,
+                releaseDate: '2025-10-01',
+                status: 'deprecated',
+            },
+        ],
+    };
+    const getInitialVersion = () => {
+        if (typeof window === 'undefined') {
+            return defaultConfig.current;
+        }
+        try {
+            // Check localStorage for stored version preference
+            const stored = localStorage?.getItem?.('docs-version');
+            if (stored) {
+                return stored;
+            }
+        }
+        catch (e) {
+            // localStorage may not be available in some environments
+        }
+        return defaultConfig.current;
+    };
+    const { subscribe, set, update } = writable({
+        ...defaultConfig,
+        current: getInitialVersion(),
+    });
+    return {
+        subscribe,
+        setVersion: (version) => {
+            update((config) => {
+                if (config.availableVersions.some((v) => v.version === version)) {
+                    if (typeof window !== 'undefined') {
+                        try {
+                            localStorage?.setItem?.('docs-version', version);
+                        }
+                        catch (e) {
+                            // localStorage may not be available
+                        }
+                    }
+                    return { ...config, current: version };
+                }
+                return config;
+            });
+        },
+        addVersion: (metadata) => {
+            update((config) => ({
+                ...config,
+                availableVersions: [
+                    ...config.availableVersions.filter((v) => v.version !== metadata.version),
+                    metadata,
+                ],
+            }));
+        },
+        removeVersion: (version) => {
+            update((config) => ({
+                ...config,
+                availableVersions: config.availableVersions.filter((v) => v.version !== version),
+            }));
+        },
+        getVersionMetadata: (version) => {
+            let metadata;
+            const unsubscribe = subscribe((config) => {
+                metadata = config.availableVersions.find((v) => v.version === version);
+            });
+            unsubscribe();
+            return metadata;
+        },
+    };
+}
+export const version = createVersionStore();

package/dist/themeCustomization.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Theme customization system
+ * Generates CSS variables from theme configuration
+ */
+import type { ThemeConfig } from './config';
+export interface CSSVariables {
+    [key: string]: string;
+}
+/**
+ * Generate CSS custom properties (variables) from theme config
+ * These can be injected into the document or stylesheet
+ */
+export declare function generateCSSVariables(theme: ThemeConfig): CSSVariables;
+/**
+ * Apply CSS variables to the document root
+ */
+export declare function applyCSSVariables(vars: CSSVariables): void;
+/**
+ * Create a stylesheet string from CSS variables
+ * Useful for injecting into <style> tags
+ */
+export declare function createCSSVariablesStylesheet(vars: CSSVariables): string;
+/**
+ * Parse a color value and validate it
+ */
+export declare function parseColor(color: string): {
+    valid: boolean;
+    value?: string;
+    error?: string;
+};
+/**
+ * Validate theme configuration
+ */
+export declare function validateTheme(theme: ThemeConfig): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Merge theme configs, with priority to the first argument
+ */
+export declare function mergeThemes(primary: ThemeConfig, secondary: ThemeConfig): ThemeConfig;
+/**
+ * Get a predefined theme template
+ */
+export type ThemeTemplate = 'default' | 'dark' | 'minimal' | 'colorful';
+export declare function getThemeTemplate(template?: ThemeTemplate): ThemeConfig;