@alliance-droid/svelte-docs-system 0.0.1

package/src/lib/configParser.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect } from 'vitest';
+import { parseConfigFile, parseFrontmatter } from './configParser';
+
+describe('Config Parser - JSON', () => {
+  it('should parse valid JSON config', () => {
+    const content = JSON.stringify({
+      name: 'My Docs',
+      docsRoute: '/docs',
+    });
+
+    const result = parseConfigFile(content, 'config.json');
+    expect(result.source).toBe('json');
+    expect(result.config.name).toBe('My Docs');
+    expect(result.config.docsRoute).toBe('/docs');
+  });
+
+  it('should detect JSON by file extension', () => {
+    const content = '{ "name": "test" }';
+    const result = parseConfigFile(content, 'config.json');
+    expect(result.source).toBe('json');
+  });
+
+  it('should handle invalid JSON gracefully', () => {
+    const content = '{ invalid json }';
+    const result = parseConfigFile(content, 'config.json');
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('Invalid JSON');
+  });
+
+  it('should handle empty JSON object', () => {
+    const content = '{}';
+    const result = parseConfigFile(content, 'config.json');
+    expect(result.source).toBe('json');
+    expect(result.config).toEqual({});
+  });
+});
+
+describe('Config Parser - YAML', () => {
+  it('should parse valid YAML config', () => {
+    const content = `
+name: My Docs
+docsRoute: /docs
+enableSearch: true
+`.trim();
+
+    const result = parseConfigFile(content, 'config.yaml');
+    expect(result.source).toBe('yaml');
+    expect(result.config.name).toBe('My Docs');
+    expect(result.config.docsRoute).toBe('/docs');
+    expect(result.config.enableSearch).toBe(true);
+  });
+
+  it('should detect YAML by file extension', () => {
+    const content = 'name: test';
+    const result = parseConfigFile(content, 'config.yml');
+    expect(result.source).toBe('yaml');
+  });
+
+  it('should parse YAML with nested objects', () => {
+    const content = `
+name: My Docs
+theme:
+  primary: "#ff0000"
+  secondary: "#00ff00"
+`.trim();
+
+    const result = parseConfigFile(content, 'config.yaml');
+    expect(result.config.theme?.primary).toBe('#ff0000');
+    expect(result.config.theme?.secondary).toBe('#00ff00');
+  });
+
+  it('should parse YAML boolean values', () => {
+    const content = `
+enableSearch: true
+darkMode: false
+breadcrumbs: true
+`.trim();
+
+    const result = parseConfigFile(content, 'config.yaml');
+    expect(result.config.enableSearch).toBe(true);
+    expect(result.config.darkMode).toBe(false);
+    expect(result.config.breadcrumbs).toBe(true);
+  });
+
+  it('should parse YAML with comments', () => {
+    const content = `
+name: My Docs
+docsRoute: /docs
+`.trim();
+
+    const result = parseConfigFile(content, 'config.yaml');
+    expect(result.config.name).toBe('My Docs');
+    expect(result.config.docsRoute).toBe('/docs');
+  });
+});
+
+describe('Frontmatter Parser', () => {
+  it('should parse JSON frontmatter', () => {
+    const content = `---
+{
+  "title": "My Page",
+  "author": "John Doe"
+}
+---
+# Page Content
+
+This is the body.`;
+
+    const result = parseFrontmatter(content);
+    expect(result.frontmatter?.title).toBe('My Page');
+    expect(result.frontmatter?.author).toBe('John Doe');
+    expect(result.body).toContain('# Page Content');
+  });
+
+  it('should parse YAML frontmatter', () => {
+    const content = `---
+title: My Page
+author: John Doe
+date: 2024-01-01
+---
+# Page Content
+
+This is the body.`;
+
+    const result = parseFrontmatter(content);
+    expect(result.frontmatter?.title).toBe('My Page');
+    expect(result.frontmatter?.author).toBe('John Doe');
+    expect(result.body).toContain('# Page Content');
+  });
+
+  it('should handle missing frontmatter', () => {
+    const content = `# Page Content
+
+This is the body.`;
+
+    const result = parseFrontmatter(content);
+    expect(result.frontmatter).toBeNull();
+    expect(result.body).toBe(content);
+  });
+
+  it('should extract body correctly', () => {
+    const content = `---
+title: Test
+---
+# Heading
+
+Content here.`;
+
+    const result = parseFrontmatter(content);
+    expect(result.body).toBe('# Heading\n\nContent here.');
+  });
+
+  it('should handle empty content after frontmatter', () => {
+    const content = `---
+title: Test
+---
+Content`;
+
+    const result = parseFrontmatter(content);
+    expect(result.body).toBe('Content');
+    expect(result.frontmatter?.title).toBe('Test');
+  });
+
+  it('should handle invalid frontmatter gracefully', () => {
+    const content = `---
+title: Test
+author: John
+---
+Content`;
+
+    const result = parseFrontmatter(content);
+    // Should parse YAML successfully if it's valid YAML
+    expect(result.frontmatter?.title).toBe('Test');
+    expect(result.body).toBe('Content');
+  });
+
+  it('should preserve multi-line content in body', () => {
+    const content = `---
+title: Test
+---
+# Heading
+
+- Item 1
+- Item 2
+
+Paragraph 1
+
+Paragraph 2`;
+
+    const result = parseFrontmatter(content);
+    expect(result.body).toContain('- Item 1');
+    expect(result.body).toContain('Paragraph 2');
+  });
+});
+
+describe('File Format Detection', () => {
+  it('should detect JSON by content starting with {', () => {
+    const result = parseConfigFile('{ "test": true }', 'unknown');
+    expect(result.source).toBe('json');
+  });
+
+  it('should detect JSON by content starting with [', () => {
+    const result = parseConfigFile('[]', 'unknown');
+    expect(result.source).toBe('json');
+  });
+
+  it('should default to YAML for unknown format', () => {
+    const result = parseConfigFile('name: test', 'unknown');
+    expect(result.source).toBe('yaml');
+  });
+
+  it('should prefer file extension over content detection', () => {
+    const jsonContent = '{ "valid": "json" }';
+    const result = parseConfigFile(jsonContent, 'config.json');
+    expect(result.source).toBe('json');
+  });
+});

package/src/lib/configParser.ts

@@ -0,0 +1,234 @@
+/**
+ * Config file parser supporting JSON and YAML formats
+ */
+
+import type { ConfigOptions } from './config';
+import { validateConfig } from './config';
+
+export interface ParseResult {
+  config: ConfigOptions;
+  errors: string[];
+  source: 'json' | 'yaml' | 'unknown';
+}
+
+/**
+ * Parse JSON config file
+ */
+function parseJSON(content: string): { data: unknown; error?: string } {
+  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: string): { data: unknown; error?: string } {
+  try {
+    const result: Record<string, unknown> = {};
+    const lines = content.split('\n');
+    let currentObject: Record<string, unknown> | null = null;
+    let currentKey: string | null = null;
+    let indentStack: Array<{ indent: number; key: string; obj: Record<string, unknown> }> = [];
+
+    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: unknown = value;
+
+        if (value === '') {
+          // Empty value - next items might be children
+          parsedValue = {};
+          indentStack.push({ indent, key: trimmedKey, obj: parsedValue as Record<string, unknown> });
+        } 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: string): {
+  frontmatter: Record<string, unknown> | null;
+  body: string;
+  error?: string;
+} {
+  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 as Record<string, unknown>,
+    body,
+  };
+}
+
+/**
+ * Detect file format from content or filename
+ */
+function detectFormat(content: string, filename: string): 'json' | 'yaml' {
+  // 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: string, filename: string = 'config.json'): ParseResult {
+  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 as ConfigOptions) || {},
+    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: string): Promise<ParseResult> {
+  try {
+    let content: string;
+
+    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',
+    };
+  }
+}

package/src/lib/index.ts

@@ -0,0 +1,34 @@
+// Re-export all doc components
+export { default as Callout } from './components/Callout.svelte';
+export { default as Tabs } from './components/Tabs.svelte';
+export { default as CodeBlock } from './components/CodeBlock.svelte';
+export { default as Image } from './components/Image.svelte';
+export { default as APITable } from './components/APITable.svelte';
+export { default as Breadcrumbs } from './components/Breadcrumbs.svelte';
+export { default as Search } from './components/Search.svelte';
+
+// Re-export all theme components
+export { default as DocLayout } from './components/DocLayout.svelte';
+export { default as Navbar } from './components/Navbar.svelte';
+export { default as Sidebar } from './components/Sidebar.svelte';
+export { default as Footer } from './components/Footer.svelte';
+
+// Re-export stores
+export { theme } from './stores/theme';
+export { nav, sidebarOpen } from './stores/nav';
+export { version } from './stores/version';
+export { i18n } from './stores/i18n';
+export { query, results, loading, resultCount, initPagefind, updateSearch, clearSearch, performSearch, subscribeToSearch } from './stores/search';
+export type { NavItem, NavConfig, NavSection } from './stores/nav';
+export type { VersionMetadata, VersionConfig } from './stores/version';
+export type { Language, LanguageMetadata, I18nConfig } from './stores/i18n';
+export type { SearchResult } from './stores/search';
+
+// Re-export utilities
+export {
+	renderMarkdown,
+	extractMetadata,
+	getExcerpt,
+	type MarkdownMetadata,
+	type MarkdownResult
+} from './utils';