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

package/dist/components/Sidebar.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { NavSection } from '../stores/nav';
+type $$ComponentProps = {
+    sections?: NavSection[];
+    currentPath?: string;
+    onNavigate?: (path: string) => void;
+};
+declare const Sidebar: import("svelte").Component<$$ComponentProps, {}, "">;
+type Sidebar = ReturnType<typeof Sidebar>;
+export default Sidebar;

package/dist/components/Tabs.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tabs component for switching between content panels
+ * Usage:
+ * <Tabs items={[{label: 'Tab 1', content: 'Content 1'}]} />
+ */
+interface TabItem {
+    label: string;
+    content?: string;
+}
+interface Props {
+    items: TabItem[];
+    defaultIndex?: number;
+}
+declare const Tabs: import("svelte").Component<Props, {}, "">;
+type Tabs = ReturnType<typeof Tabs>;
+export default Tabs;

package/dist/config.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Configuration schema and types for the documentation system
+ */
+export interface ThemeConfig {
+    /** Primary color (hex, rgb, or CSS color name) */
+    primary?: string;
+    /** Secondary color */
+    secondary?: string;
+    /** Text color for light mode */
+    textLight?: string;
+    /** Text color for dark mode */
+    textDark?: string;
+    /** Background color for light mode */
+    bgLight?: string;
+    /** Background color for dark mode */
+    bgDark?: string;
+    /** Font family for body text */
+    fontFamily?: string;
+    /** Font family for headings */
+    headingFont?: string;
+    /** Sidebar background color */
+    sidebarBg?: string;
+    /** Navbar background color */
+    navbarBg?: string;
+    /** Code block background color */
+    codeBg?: string;
+}
+export interface NavItem {
+    label: string;
+    href?: string;
+    children?: NavItem[];
+    icon?: string;
+}
+export interface NavSection {
+    title: string;
+    items: NavItem[];
+}
+export interface NavigationConfig {
+    title?: string;
+    logo?: string;
+    sections?: NavSection[];
+    /** Auto-generate navigation from folder structure */
+    autoGenerate?: boolean;
+    /** Exclude paths from auto-generation */
+    excludePaths?: string[];
+}
+export interface ConfigOptions {
+    /** Name of the documentation project */
+    name?: string;
+    /** Mount point for docs (e.g., /docs, /help, /guides) */
+    docsRoute?: string;
+    /** Path to docs folder relative to project root */
+    docsFolderPath?: string;
+    /** Base URL path for links */
+    basePath?: string;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+    /** Navigation configuration */
+    navigation?: NavigationConfig;
+    /** Enable search functionality */
+    enableSearch?: boolean;
+    /** Custom CSS file path */
+    customCss?: string;
+    /** Layout template name (default, minimal, full-width) */
+    layout?: 'default' | 'minimal' | 'full-width';
+    /** Enable dark mode toggle */
+    darkMode?: boolean;
+    /** Default theme (light or dark) */
+    defaultTheme?: 'light' | 'dark';
+    /** Enable breadcrumbs */
+    breadcrumbs?: boolean;
+    /** Enable prev/next navigation */
+    prevNext?: boolean;
+    /** Site title for header */
+    siteTitle?: string;
+    /** Site description for meta tags */
+    siteDescription?: string;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: ConfigOptions;
+/**
+ * Validates a configuration object
+ */
+export declare function validateConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Merges user config with defaults
+ */
+export declare function mergeConfig(userConfig: ConfigOptions, defaults?: ConfigOptions): ConfigOptions;

package/dist/config.js

@@ -0,0 +1,89 @@
+/**
+ * Configuration schema and types for the documentation system
+ */
+/**
+ * Default configuration values
+ */
+export const DEFAULT_CONFIG = {
+    name: 'Documentation',
+    docsRoute: '/docs',
+    docsFolderPath: './docs',
+    basePath: '/docs',
+    enableSearch: true,
+    layout: 'default',
+    darkMode: true,
+    defaultTheme: 'light',
+    breadcrumbs: true,
+    prevNext: true,
+    theme: {
+        primary: '#0066cc',
+        secondary: '#ff6b6b',
+        fontFamily: 'system-ui, -apple-system, sans-serif',
+        headingFont: 'system-ui, -apple-system, sans-serif',
+    },
+    navigation: {
+        autoGenerate: true,
+    },
+};
+/**
+ * Validates a configuration object
+ */
+export function validateConfig(config) {
+    const errors = [];
+    if (typeof config !== 'object' || config === null) {
+        errors.push('Configuration must be an object');
+        return { valid: false, errors };
+    }
+    const cfg = config;
+    // Validate docsRoute
+    if (cfg.docsRoute !== undefined) {
+        if (typeof cfg.docsRoute !== 'string') {
+            errors.push('docsRoute must be a string');
+        }
+        else if (!cfg.docsRoute.startsWith('/')) {
+            errors.push('docsRoute must start with /');
+        }
+    }
+    // Validate layout
+    if (cfg.layout !== undefined) {
+        if (!['default', 'minimal', 'full-width'].includes(cfg.layout)) {
+            errors.push('layout must be one of: default, minimal, full-width');
+        }
+    }
+    // Validate defaultTheme
+    if (cfg.defaultTheme !== undefined) {
+        if (!['light', 'dark'].includes(cfg.defaultTheme)) {
+            errors.push('defaultTheme must be either light or dark');
+        }
+    }
+    // Validate theme config
+    if (cfg.theme !== undefined) {
+        if (typeof cfg.theme !== 'object' || cfg.theme === null) {
+            errors.push('theme must be an object');
+        }
+    }
+    // Validate navigation config
+    if (cfg.navigation !== undefined) {
+        if (typeof cfg.navigation !== 'object' || cfg.navigation === null) {
+            errors.push('navigation must be an object');
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Merges user config with defaults
+ */
+export function mergeConfig(userConfig, defaults = DEFAULT_CONFIG) {
+    return {
+        ...defaults,
+        ...userConfig,
+        theme: {
+            ...defaults.theme,
+            ...(userConfig.theme || {}),
+        },
+        navigation: {
+            ...defaults.navigation,
+            ...(userConfig.navigation || {}),
+        },
+    };
+}

package/dist/configLoader.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Configuration loader and manager
+ * Loads, validates, and manages the docs system configuration
+ */
+import type { ConfigOptions } from './config';
+export interface ConfigLoadResult {
+    success: boolean;
+    config: ConfigOptions;
+    errors: string[];
+    warnings: string[];
+    source: 'default' | 'loaded' | 'merged';
+}
+/**
+ * Load configuration from a file
+ */
+export declare function loadConfiguration(configPath?: string): Promise<ConfigLoadResult>;
+export declare function getConfiguration(configPath?: string): Promise<ConfigOptions>;
+/**
+ * Clear configuration cache (useful for testing or reloading)
+ */
+export declare function clearConfigCache(): void;
+/**
+ * Parse frontmatter from markdown content and merge with config
+ */
+export declare function parseMarkdownFrontmatter(content: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+    errors: string[];
+};
+/**
+ * Validate a custom config object
+ */
+export declare function validateCustomConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create a configuration from minimal user input
+ */
+export declare function createMinimalConfig(options?: Partial<ConfigOptions>): ConfigOptions;
+/**
+ * Export configuration as JSON
+ */
+export declare function exportConfigAsJSON(config: ConfigOptions): string;
+/**
+ * Export configuration as YAML
+ */
+export declare function exportConfigAsYAML(config: ConfigOptions): string;

package/dist/configLoader.js

@@ -0,0 +1,187 @@
+/**
+ * Configuration loader and manager
+ * Loads, validates, and manages the docs system configuration
+ */
+import { DEFAULT_CONFIG, mergeConfig, validateConfig } from './config';
+import { parseConfigFile, loadConfigFile, parseFrontmatter } from './configParser';
+import { createRouteConfig, validateRoute } from './routing';
+import { validateTheme } from './themeCustomization';
+import { validateNavigation } from './navigationBuilder';
+/**
+ * Load configuration from a file
+ */
+export async function loadConfiguration(configPath = '/docs/_config.json') {
+    const errors = [];
+    const warnings = [];
+    let userConfig = {};
+    // Try to load the config file
+    const result = await loadConfigFile(configPath);
+    if (result.errors.length > 0 && !configPath.includes('_config')) {
+        // If it's not a standard config file, it might not exist - that's ok
+        errors.push(...result.errors);
+    }
+    else if (result.errors.length > 0) {
+        // For standard config file, log errors but continue with defaults
+        warnings.push(...result.errors);
+    }
+    else {
+        userConfig = result.config;
+    }
+    // Validate the loaded config
+    const validation = validateConfig(userConfig);
+    if (!validation.valid) {
+        warnings.push(...validation.errors);
+    }
+    // Validate sub-configs
+    if (userConfig.theme) {
+        const themeValidation = validateTheme(userConfig.theme);
+        if (!themeValidation.valid) {
+            warnings.push(`Theme validation errors: ${themeValidation.errors.join(', ')}`);
+        }
+    }
+    if (userConfig.navigation) {
+        const navValidation = validateNavigation(userConfig.navigation);
+        if (!navValidation.valid) {
+            warnings.push(`Navigation validation errors: ${navValidation.errors.join(', ')}`);
+        }
+    }
+    // Validate route
+    if (userConfig.docsRoute && !validateRoute(userConfig.docsRoute)) {
+        errors.push(`Invalid docsRoute: ${userConfig.docsRoute}`);
+    }
+    // Merge with defaults
+    const finalConfig = mergeConfig(userConfig, DEFAULT_CONFIG);
+    // Validate final config
+    const finalValidation = validateConfig(finalConfig);
+    if (!finalValidation.valid) {
+        errors.push(...finalValidation.errors);
+    }
+    const success = errors.length === 0;
+    return {
+        success,
+        config: finalConfig,
+        errors,
+        warnings,
+        source: success ? 'loaded' : warnings.length > 0 ? 'merged' : 'default',
+    };
+}
+/**
+ * Load and cache configuration (for browser environment)
+ */
+let cachedConfig = null;
+let configLoadPromise = null;
+export async function getConfiguration(configPath = '/docs/_config.json') {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    if (!configLoadPromise) {
+        configLoadPromise = loadConfiguration(configPath);
+    }
+    const result = await configLoadPromise;
+    cachedConfig = result.config;
+    return result.config;
+}
+/**
+ * Clear configuration cache (useful for testing or reloading)
+ */
+export function clearConfigCache() {
+    cachedConfig = null;
+    configLoadPromise = null;
+}
+/**
+ * Parse frontmatter from markdown content and merge with config
+ */
+export function parseMarkdownFrontmatter(content) {
+    const result = parseFrontmatter(content);
+    if (result.error) {
+        return {
+            frontmatter: {},
+            body: result.body,
+            errors: [result.error],
+        };
+    }
+    return {
+        frontmatter: result.frontmatter || {},
+        body: result.body,
+        errors: [],
+    };
+}
+/**
+ * Validate a custom config object
+ */
+export function validateCustomConfig(config) {
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+        return validation;
+    }
+    const cfg = config;
+    const errors = [];
+    // Additional validations
+    if (cfg.theme) {
+        const themeValidation = validateTheme(cfg.theme);
+        if (!themeValidation.valid) {
+            errors.push(`Theme: ${themeValidation.errors.join(', ')}`);
+        }
+    }
+    if (cfg.navigation) {
+        const navValidation = validateNavigation(cfg.navigation);
+        if (!navValidation.valid) {
+            errors.push(`Navigation: ${navValidation.errors.join(', ')}`);
+        }
+    }
+    if (cfg.docsRoute && !validateRoute(cfg.docsRoute)) {
+        errors.push(`Invalid docsRoute: ${cfg.docsRoute}`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Create a configuration from minimal user input
+ */
+export function createMinimalConfig(options = {}) {
+    return mergeConfig(options, DEFAULT_CONFIG);
+}
+/**
+ * Export configuration as JSON
+ */
+export function exportConfigAsJSON(config) {
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Export configuration as YAML
+ */
+export function exportConfigAsYAML(config) {
+    const lines = [];
+    function addValue(key, value, indent = 0) {
+        const indentStr = '  '.repeat(indent);
+        if (value === null || value === undefined) {
+            return;
+        }
+        if (typeof value === 'string') {
+            lines.push(`${indentStr}${key}: ${value}`);
+        }
+        else if (typeof value === 'boolean' || typeof value === 'number') {
+            lines.push(`${indentStr}${key}: ${value}`);
+        }
+        else if (Array.isArray(value)) {
+            lines.push(`${indentStr}${key}:`);
+            value.forEach((item, idx) => {
+                if (typeof item === 'object') {
+                    addValue(`- `, item, indent + 1);
+                }
+                else {
+                    lines.push(`${indentStr}  - ${item}`);
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            lines.push(`${indentStr}${key}:`);
+            Object.entries(value).forEach(([k, v]) => {
+                addValue(k, v, indent + 1);
+            });
+        }
+    }
+    Object.entries(config).forEach(([key, value]) => {
+        addValue(key, value);
+    });
+    return lines.join('\n');
+}

package/dist/configParser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Config file parser supporting JSON and YAML formats
+ */
+import type { ConfigOptions } from './config';
+export interface ParseResult {
+    config: ConfigOptions;
+    errors: string[];
+    source: 'json' | 'yaml' | 'unknown';
+}
+/**
+ * Parse frontmatter from markdown content
+ * Supports both JSON and YAML frontmatter
+ */
+export declare function parseFrontmatter(content: string): {
+    frontmatter: Record<string, unknown> | null;
+    body: string;
+    error?: string;
+};
+/**
+ * Parse config file content (JSON or YAML)
+ */
+export declare function parseConfigFile(content: string, filename?: string): ParseResult;
+/**
+ * Load and parse a config file from a file path (browser-safe)
+ * In a browser environment, use fetch; in Node, use fs
+ */
+export declare function loadConfigFile(filePath: string): Promise<ParseResult>;

package/dist/configParser.js

@@ -0,0 +1,208 @@
+/**
+ * Config file parser supporting JSON and YAML formats
+ */
+import { validateConfig } from './config';
+/**
+ * Parse JSON config file
+ */
+function parseJSON(content) {
+    try {
+        return { data: JSON.parse(content) };
+    }
+    catch (err) {
+        return {
+            data: null,
+            error: `Invalid JSON: ${err instanceof Error ? err.message : 'Unknown error'}`,
+        };
+    }
+}
+/**
+ * Parse YAML config file (simplified parser)
+ * Handles basic YAML key-value pairs and nested objects
+ */
+function parseYAML(content) {
+    try {
+        const result = {};
+        const lines = content.split('\n');
+        let currentObject = null;
+        let currentKey = null;
+        let indentStack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Skip empty lines and comments
+            if (!line.trim() || line.trim().startsWith('#')) {
+                continue;
+            }
+            // Calculate indentation
+            const indent = line.length - line.trimLeft().length;
+            const trimmedLine = line.trim();
+            // Pop stack if we've decreased indentation
+            while (indentStack.length > 0 && indentStack[indentStack.length - 1].indent >= indent) {
+                indentStack.pop();
+            }
+            // Parse key: value
+            if (trimmedLine.includes(':')) {
+                const [key, ...valueParts] = trimmedLine.split(':');
+                const trimmedKey = key.trim();
+                const value = valueParts.join(':').trim();
+                // Determine parent object
+                const parent = indentStack.length > 0 ? indentStack[indentStack.length - 1].obj : result;
+                // Parse value
+                let parsedValue = value;
+                if (value === '') {
+                    // Empty value - next items might be children
+                    parsedValue = {};
+                    indentStack.push({ indent, key: trimmedKey, obj: parsedValue });
+                }
+                else if (value === 'true') {
+                    parsedValue = true;
+                }
+                else if (value === 'false') {
+                    parsedValue = false;
+                }
+                else if (/^\d+$/.test(value)) {
+                    parsedValue = parseInt(value, 10);
+                }
+                else if (/^\d+\.\d+$/.test(value)) {
+                    parsedValue = parseFloat(value);
+                }
+                else if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                    parsedValue = value.slice(1, -1);
+                }
+                else if (value.startsWith('[') && value.endsWith(']')) {
+                    try {
+                        parsedValue = JSON.parse(value);
+                    }
+                    catch {
+                        parsedValue = value;
+                    }
+                }
+                else if (value.startsWith('{') && value.endsWith('}')) {
+                    try {
+                        parsedValue = JSON.parse(value);
+                    }
+                    catch {
+                        parsedValue = value;
+                    }
+                }
+                parent[trimmedKey] = parsedValue;
+                currentKey = trimmedKey;
+            }
+        }
+        return { data: result };
+    }
+    catch (err) {
+        return {
+            data: null,
+            error: `Invalid YAML: ${err instanceof Error ? err.message : 'Unknown error'}`,
+        };
+    }
+}
+/**
+ * Parse frontmatter from markdown content
+ * Supports both JSON and YAML frontmatter
+ */
+export function parseFrontmatter(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+        return { frontmatter: null, body: content };
+    }
+    const frontmatterContent = frontmatterMatch[1];
+    const body = frontmatterMatch[2];
+    // Try JSON first
+    let parsed = parseJSON(frontmatterContent);
+    // If JSON fails, try YAML
+    if (parsed.error) {
+        parsed = parseYAML(frontmatterContent);
+    }
+    if (parsed.error) {
+        return {
+            frontmatter: null,
+            body: content,
+            error: `Failed to parse frontmatter: ${parsed.error}`,
+        };
+    }
+    return {
+        frontmatter: parsed.data,
+        body,
+    };
+}
+/**
+ * Detect file format from content or filename
+ */
+function detectFormat(content, filename) {
+    // Check filename extension
+    if (filename.endsWith('.json'))
+        return 'json';
+    if (filename.endsWith('.yaml') || filename.endsWith('.yml'))
+        return 'yaml';
+    // Try to detect by content
+    const trimmed = content.trim();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return 'json';
+    }
+    return 'yaml';
+}
+/**
+ * Parse config file content (JSON or YAML)
+ */
+export function parseConfigFile(content, filename = 'config.json') {
+    const format = detectFormat(content, filename);
+    let parsed;
+    if (format === 'json') {
+        parsed = parseJSON(content);
+    }
+    else {
+        parsed = parseYAML(content);
+    }
+    if (parsed.error) {
+        return {
+            config: {},
+            errors: [parsed.error],
+            source: format,
+        };
+    }
+    const validation = validateConfig(parsed.data);
+    return {
+        config: parsed.data || {},
+        errors: validation.errors,
+        source: format,
+    };
+}
+/**
+ * Load and parse a config file from a file path (browser-safe)
+ * In a browser environment, use fetch; in Node, use fs
+ */
+export async function loadConfigFile(filePath) {
+    try {
+        let content;
+        if (typeof window !== 'undefined') {
+            // Browser environment - use fetch
+            const response = await fetch(filePath);
+            if (!response.ok) {
+                return {
+                    config: {},
+                    errors: [`Failed to load config file: ${response.statusText}`],
+                    source: 'unknown',
+                };
+            }
+            content = await response.text();
+        }
+        else {
+            // Node environment - would need fs module
+            return {
+                config: {},
+                errors: ['Cannot load config file in this environment'],
+                source: 'unknown',
+            };
+        }
+        return parseConfigFile(content, filePath);
+    }
+    catch (err) {
+        return {
+            config: {},
+            errors: [`Error loading config file: ${err instanceof Error ? err.message : 'Unknown error'}`],
+            source: 'unknown',
+        };
+    }
+}