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

package/dist/themeCustomization.js

@@ -0,0 +1,188 @@
+/**
+ * Theme customization system
+ * Generates CSS variables from theme configuration
+ */
+/**
+ * Generate CSS custom properties (variables) from theme config
+ * These can be injected into the document or stylesheet
+ */
+export function generateCSSVariables(theme) {
+    const vars = {};
+    // Color variables
+    if (theme.primary)
+        vars['--color-primary'] = theme.primary;
+    if (theme.secondary)
+        vars['--color-secondary'] = theme.secondary;
+    if (theme.textLight)
+        vars['--color-text-light'] = theme.textLight;
+    if (theme.textDark)
+        vars['--color-text-dark'] = theme.textDark;
+    if (theme.bgLight)
+        vars['--color-bg-light'] = theme.bgLight;
+    if (theme.bgDark)
+        vars['--color-bg-dark'] = theme.bgDark;
+    if (theme.sidebarBg)
+        vars['--color-sidebar-bg'] = theme.sidebarBg;
+    if (theme.navbarBg)
+        vars['--color-navbar-bg'] = theme.navbarBg;
+    if (theme.codeBg)
+        vars['--color-code-bg'] = theme.codeBg;
+    // Font variables
+    if (theme.fontFamily)
+        vars['--font-family-body'] = theme.fontFamily;
+    if (theme.headingFont)
+        vars['--font-family-heading'] = theme.headingFont;
+    return vars;
+}
+/**
+ * Apply CSS variables to the document root
+ */
+export function applyCSSVariables(vars) {
+    if (typeof window === 'undefined') {
+        return; // Skip in SSR
+    }
+    const root = document.documentElement;
+    Object.entries(vars).forEach(([key, value]) => {
+        root.style.setProperty(key, value);
+    });
+}
+/**
+ * Create a stylesheet string from CSS variables
+ * Useful for injecting into <style> tags
+ */
+export function createCSSVariablesStylesheet(vars) {
+    const entries = Object.entries(vars)
+        .map(([key, value]) => `  ${key}: ${value};`)
+        .join('\n');
+    return `:root {\n${entries}\n}`;
+}
+/**
+ * Parse a color value and validate it
+ */
+export function parseColor(color) {
+    if (!color || typeof color !== 'string') {
+        return { valid: false, error: 'Color must be a non-empty string' };
+    }
+    const trimmed = color.trim();
+    // Hex colors
+    if (/^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?([0-9a-fA-F]{2})?$/.test(trimmed)) {
+        return { valid: true, value: trimmed };
+    }
+    // RGB/RGBA
+    if (/^rgba?\s*\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}(\s*,\s*[\d.]+)?\s*\)$/.test(trimmed)) {
+        return { valid: true, value: trimmed };
+    }
+    // Named colors (basic list)
+    const namedColors = [
+        'red',
+        'blue',
+        'green',
+        'white',
+        'black',
+        'gray',
+        'grey',
+        'transparent',
+        'currentColor',
+    ];
+    if (namedColors.includes(trimmed.toLowerCase())) {
+        return { valid: true, value: trimmed };
+    }
+    // CSS custom property
+    if (/^var\s*\(\s*--[a-zA-Z0-9-]+\s*\)$/.test(trimmed)) {
+        return { valid: true, value: trimmed };
+    }
+    return { valid: false, error: `Invalid color format: ${color}` };
+}
+/**
+ * Validate theme configuration
+ */
+export function validateTheme(theme) {
+    const errors = [];
+    if (!theme || typeof theme !== 'object') {
+        return { valid: false, errors: ['Theme must be an object'] };
+    }
+    // Validate colors
+    const colorFields = ['primary', 'secondary', 'textLight', 'textDark', 'bgLight', 'bgDark', 'sidebarBg', 'navbarBg', 'codeBg'];
+    colorFields.forEach((field) => {
+        if (theme[field] !== undefined) {
+            const validation = parseColor(theme[field]);
+            if (!validation.valid) {
+                errors.push(`${field}: ${validation.error}`);
+            }
+        }
+    });
+    // Validate fonts
+    if (theme.fontFamily !== undefined && typeof theme.fontFamily !== 'string') {
+        errors.push('fontFamily must be a string');
+    }
+    if (theme.headingFont !== undefined && typeof theme.headingFont !== 'string') {
+        errors.push('headingFont must be a string');
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Merge theme configs, with priority to the first argument
+ */
+export function mergeThemes(primary, secondary) {
+    return {
+        ...secondary,
+        ...primary,
+    };
+}
+export function getThemeTemplate(template = 'default') {
+    const templates = {
+        default: {
+            primary: '#0066cc',
+            secondary: '#ff6b6b',
+            textLight: '#333333',
+            textDark: '#f0f0f0',
+            bgLight: '#ffffff',
+            bgDark: '#1a1a1a',
+            sidebarBg: '#f5f5f5',
+            navbarBg: '#ffffff',
+            codeBg: '#f4f4f4',
+            fontFamily: 'system-ui, -apple-system, sans-serif',
+            headingFont: 'system-ui, -apple-system, sans-serif',
+        },
+        dark: {
+            primary: '#4da6ff',
+            secondary: '#ff9999',
+            textLight: '#e0e0e0',
+            textDark: '#1a1a1a',
+            bgLight: '#1a1a1a',
+            bgDark: '#0d0d0d',
+            sidebarBg: '#262626',
+            navbarBg: '#1a1a1a',
+            codeBg: '#2d2d2d',
+            fontFamily: 'system-ui, -apple-system, sans-serif',
+            headingFont: 'system-ui, -apple-system, sans-serif',
+        },
+        minimal: {
+            primary: '#000000',
+            secondary: '#666666',
+            textLight: '#333333',
+            textDark: '#cccccc',
+            bgLight: '#ffffff',
+            bgDark: '#181818',
+            sidebarBg: '#fafafa',
+            navbarBg: '#ffffff',
+            codeBg: '#eeeeee',
+            fontFamily: 'Georgia, serif',
+            headingFont: 'Georgia, serif',
+        },
+        colorful: {
+            primary: '#ff006e',
+            secondary: '#00d9ff',
+            textLight: '#2d3142',
+            textDark: '#e0e0e0',
+            bgLight: '#fafafa',
+            bgDark: '#0d1b2a',
+            sidebarBg: '#f0f3ff',
+            navbarBg: '#ffffff',
+            codeBg: '#f5f5f5',
+            fontFamily: 'system-ui, -apple-system, sans-serif',
+            headingFont: '"Segoe UI", Tahoma, sans-serif',
+        },
+    };
+    return templates[template] || templates.default;
+}

package/dist/utils/highlight.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Highlight search terms in text
+ * Returns HTML with highlighted terms wrapped in <mark> tags
+ */
+export declare function highlightSearchTerms(text: string, searchQuery: string): string;
+/**
+ * Truncate text to a maximum length and ensure it ends at a word boundary
+ */
+export declare function truncateText(text: string, maxLength?: number): string;
+/**
+ * Extract excerpt around search terms
+ */
+export declare function extractExcerpt(text: string, searchQuery: string, maxLength?: number): string;

package/dist/utils/highlight.js

@@ -0,0 +1,83 @@
+/**
+ * Highlight search terms in text
+ * Returns HTML with highlighted terms wrapped in <mark> tags
+ */
+export function highlightSearchTerms(text, searchQuery) {
+    if (!text || !searchQuery.trim()) {
+        return text;
+    }
+    // Split search query into individual terms and escape special regex characters
+    const terms = searchQuery
+        .trim()
+        .split(/\s+/)
+        .filter((term) => term.length > 0)
+        .map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    if (terms.length === 0) {
+        return text;
+    }
+    // Create a regex that matches any of the terms (case-insensitive)
+    const regex = new RegExp(`\\b(${terms.join('|')})\\b`, 'gi');
+    // Replace matches with highlighted version
+    return text.replace(regex, '<span class="search-highlight">$1</span>');
+}
+/**
+ * Truncate text to a maximum length and ensure it ends at a word boundary
+ */
+export function truncateText(text, maxLength = 150) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    // Truncate and find the last space
+    const truncated = text.substring(0, maxLength);
+    const lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace > maxLength * 0.7) {
+        // If the last space is relatively close to the end, use it
+        return truncated.substring(0, lastSpace) + '...';
+    }
+    // Otherwise just truncate and add ellipsis
+    return truncated + '...';
+}
+/**
+ * Extract excerpt around search terms
+ */
+export function extractExcerpt(text, searchQuery, maxLength = 200) {
+    if (!text || !searchQuery.trim()) {
+        return truncateText(text, maxLength);
+    }
+    const searchTerms = searchQuery
+        .trim()
+        .split(/\s+/)
+        .filter((term) => term.length > 0)
+        .map((term) => term.toLowerCase());
+    // Find the position of the first search term in the text
+    let earliestIndex = text.length;
+    for (const term of searchTerms) {
+        const index = text.toLowerCase().indexOf(term);
+        if (index !== -1 && index < earliestIndex) {
+            earliestIndex = index;
+        }
+    }
+    // Extract context around the search term
+    let startIndex = Math.max(0, earliestIndex - 50);
+    let endIndex = Math.min(text.length, startIndex + maxLength);
+    // Adjust if we're too close to the end
+    if (endIndex === text.length && startIndex > 0) {
+        startIndex = Math.max(0, endIndex - maxLength);
+    }
+    let excerpt = text.substring(startIndex, endIndex);
+    // Remove partial words at the beginning
+    if (startIndex > 0) {
+        const firstSpace = excerpt.indexOf(' ');
+        if (firstSpace !== -1 && firstSpace < 20) {
+            excerpt = excerpt.substring(firstSpace + 1);
+        }
+    }
+    // Add ellipsis if needed
+    if (startIndex > 0) {
+        excerpt = '...' + excerpt;
+    }
+    if (endIndex < text.length) {
+        excerpt = excerpt + '...';
+    }
+    return excerpt;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export { renderMarkdown, renderMarkdownSync, renderMarkdownWithState, createLoadingResult, extractMetadata, getExcerpt, type MarkdownMetadata, type MarkdownResult, type MarkdownLoadingResult } from './markdown.js';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export { renderMarkdown, renderMarkdownSync, renderMarkdownWithState, createLoadingResult, extractMetadata, getExcerpt } from './markdown.js';

package/dist/utils/markdown.d.ts

@@ -0,0 +1,40 @@
+export interface MarkdownMetadata {
+    title?: string;
+    description?: string;
+    author?: string;
+    date?: string;
+    order?: number;
+    [key: string]: any;
+}
+export interface MarkdownResult {
+    html: string;
+    metadata: MarkdownMetadata;
+}
+export interface MarkdownLoadingResult extends MarkdownResult {
+    loading: boolean;
+    error?: string;
+}
+/**
+ * Create a loading result
+ */
+export declare function createLoadingResult(): MarkdownLoadingResult;
+/**
+ * Render markdown synchronously (browser-safe)
+ */
+export declare function renderMarkdownSync(content: unknown): MarkdownResult;
+/**
+ * Render markdown (async version, browser-safe)
+ */
+export declare function renderMarkdown(content: unknown): MarkdownResult;
+/**
+ * Render markdown with loading state
+ */
+export declare function renderMarkdownWithState(content: unknown): MarkdownLoadingResult;
+/**
+ * Extract metadata from markdown content
+ */
+export declare function extractMetadata(content: string): MarkdownMetadata;
+/**
+ * Get excerpt from markdown content
+ */
+export declare function getExcerpt(content: string, wordLimit?: number): string;

package/dist/utils/markdown.js

@@ -0,0 +1,165 @@
+import { marked } from 'marked';
+/**
+ * Browser-safe frontmatter parser (no Buffer dependency)
+ */
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return { data: {}, content };
+    }
+    const frontmatterStr = match[1];
+    const markdownContent = match[2];
+    // Parse YAML-like frontmatter (simple key: value pairs)
+    const data = {};
+    const lines = frontmatterStr.split('\n');
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.slice(0, colonIndex).trim();
+            let value = line.slice(colonIndex + 1).trim();
+            // Remove quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            // Parse numbers
+            if (/^\d+$/.test(value)) {
+                value = parseInt(value, 10);
+            }
+            else if (/^\d+\.\d+$/.test(value)) {
+                value = parseFloat(value);
+            }
+            // Parse booleans
+            if (value === 'true')
+                value = true;
+            if (value === 'false')
+                value = false;
+            data[key] = value;
+        }
+    }
+    return { data, content: markdownContent };
+}
+/**
+ * Create a custom renderer that escapes raw HTML
+ */
+function createSafeRenderer() {
+    const renderer = new marked.Renderer();
+    renderer.html = function (token) {
+        const html = token.text;
+        const escaped = html
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+        return `<p>${escaped}</p>\n`;
+    };
+    return renderer;
+}
+const markedOptions = {
+    breaks: true,
+    gfm: true,
+    async: false,
+    renderer: createSafeRenderer()
+};
+/**
+ * Validate content input
+ */
+function validateContent(content) {
+    if (content === undefined || content === null) {
+        throw new Error('Content is undefined or null');
+    }
+    if (typeof content !== 'string') {
+        throw new Error(`Content must be a string, received ${typeof content}`);
+    }
+    return content;
+}
+/**
+ * Create a loading result
+ */
+export function createLoadingResult() {
+    return {
+        html: '',
+        metadata: {},
+        loading: true
+    };
+}
+/**
+ * Render markdown synchronously (browser-safe)
+ */
+export function renderMarkdownSync(content) {
+    try {
+        const validContent = validateContent(content);
+        if (validContent.trim().length === 0) {
+            return { html: '', metadata: {} };
+        }
+        const { data, content: markdownContent } = parseFrontmatter(validContent);
+        const html = marked.parse(markdownContent, markedOptions);
+        return {
+            html: html || '',
+            metadata: data
+        };
+    }
+    catch (error) {
+        console.error('Error rendering markdown:', error);
+        return {
+            html: `<p class="markdown-error">Error: ${error instanceof Error ? error.message : 'Unknown error'}</p>`,
+            metadata: {}
+        };
+    }
+}
+/**
+ * Render markdown (async version, browser-safe)
+ */
+export function renderMarkdown(content) {
+    return renderMarkdownSync(content);
+}
+/**
+ * Render markdown with loading state
+ */
+export function renderMarkdownWithState(content) {
+    const result = renderMarkdownSync(content);
+    return { ...result, loading: false };
+}
+/**
+ * Extract metadata from markdown content
+ */
+export function extractMetadata(content) {
+    try {
+        const { data } = parseFrontmatter(content);
+        return data;
+    }
+    catch (error) {
+        console.error('Error extracting metadata:', error);
+        return {};
+    }
+}
+/**
+ * Get excerpt from markdown content
+ */
+export function getExcerpt(content, wordLimit = 150) {
+    try {
+        if (!content || content.trim().length === 0) {
+            return '';
+        }
+        const { content: markdownContent } = parseFrontmatter(content);
+        const text = markdownContent
+            .replace(/#{1,6}\s/g, '')
+            .replace(/[*_]{1,2}(.*?)[*_]{1,2}/g, '$1')
+            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+            .replace(/`([^`]+)`/g, '$1')
+            .replace(/^>\s/gm, '')
+            .trim();
+        const words = text.split(/\s+/).filter(word => word.length > 0);
+        if (words.length === 0) {
+            return '';
+        }
+        const excerpt = words.slice(0, wordLimit).join(' ');
+        return excerpt.length < text.length ? excerpt + '...' : excerpt;
+    }
+    catch (error) {
+        console.error('Error extracting excerpt:', error);
+        return '';
+    }
+}

package/package.json

@@ -1,44 +1,66 @@
 {
 	"name": "@alliance-droid/svelte-docs-system",
-	"version": "0.0.2",
+	"version": "0.1.1",
 	"type": "module",
-	"bin": {
-		"svelte-docs-init": "./bin/init.js"
+	"description": "Drop-in documentation system for SvelteKit - just add markdown files",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./plugin": {
+			"types": "./dist/plugin.d.ts",
+			"default": "./dist/plugin.js"
+		}
 	},
+	"svelte": "./dist/index.js",
+	"files": [
+		"dist",
+		"!dist/**/*.test.*"
+	],
 	"scripts": {
 		"dev": "vite dev",
-		"build": "vite build && pagefind",
+		"build": "vite build && npm run package",
+		"package": "svelte-kit sync && svelte-package -o dist",
 		"preview": "vite preview",
 		"prepare": "svelte-kit sync || echo ''",
+		"prepublishOnly": "npm run package",
 		"test": "vitest",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json"
+	},
+	"peerDependencies": {
+		"svelte": "^5.0.0",
+		"@sveltejs/kit": "^2.0.0"
+	},
+	"dependencies": {
+		"gray-matter": "^4.0.3",
+		"marked": "^17.0.1"
 	},
 	"devDependencies": {
 		"@sveltejs/adapter-auto": "^7.0.0",
-		"@sveltejs/adapter-static": "^3.0.10",
-		"@sveltejs/adapter-vercel": "^6.3.1",
 		"@sveltejs/kit": "^2.50.1",
+		"@sveltejs/package": "^2.3.10",
 		"@sveltejs/vite-plugin-svelte": "^6.2.4",
-		"@testing-library/svelte": "^5.3.1",
-		"@testing-library/user-event": "^14.6.1",
-		"autoprefixer": "^10.4.24",
-		"happy-dom": "^20.5.0",
-		"jsdom": "^28.0.0",
-		"pagefind": "^1.4.0",
-		"postcss": "^8.5.6",
+		"@types/node": "^22.15.29",
 		"svelte": "^5.48.2",
 		"svelte-check": "^4.3.5",
-		"tailwindcss": "^4.1.18",
 		"typescript": "^5.9.3",
 		"vite": "^7.3.1",
 		"vitest": "^4.0.18"
 	},
-	"dependencies": {
-		"@fortawesome/fontawesome-free": "^7.1.0",
-		"gray-matter": "^4.0.3",
-		"marked": "^17.0.1",
-		"resize-observer-polyfill": "^1.5.1",
-		"svelte-component-library": "^0.2.1"
-	}
+	"keywords": [
+		"svelte",
+		"sveltekit",
+		"documentation",
+		"markdown",
+		"docs"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/alliance-droid/svelte-docs-system"
+	},
+	"license": "MIT"
 }