@zenithbuild/plugins 0.3.5 → 0.3.6

package/content/hooks/useZenOrder.ts

@@ -172,90 +172,78 @@ export function createZenOrder(rawSections: any[]): ZenOrderReturn {
     // Process and sort sections
     const sections = processRawSections(rawSections);
 
-    // Initialize state
-    let state: ZenOrderState = {
-        sections,
-        selectedSection: sections[0] || null,
-        selectedDoc: sections[0]?.items[0] || null
-    };
-
-    // Actions
-    const selectSection = (section: Section): void => {
-        state.selectedSection = section;
-        state.selectedDoc = section.items[0] || null;
-    };
-
-    const selectDoc = (doc: DocItem): void => {
-        state.selectedDoc = doc;
-        // Also update selected section if doc is from a different section
-        const docSection = sections.find(s => s.slug === doc.sectionSlug);
-        if (docSection && state.selectedSection?.slug !== doc.sectionSlug) {
-            state.selectedSection = docSection;
+    // React to selection changes by updating the returned object's properties
+    const actions: ZenOrderActions = {
+        selectSection: (section: Section): void => {
+            instance.selectedSection = section;
+            instance.selectedDoc = section.items[0] || null;
+        },
+
+        selectDoc: (doc: DocItem): void => {
+            instance.selectedDoc = doc;
+            const docSection = sections.find(s => s.slug === doc.sectionSlug);
+            if (docSection) {
+                instance.selectedSection = docSection;
+            }
+        },
+
+        getSectionBySlug: (sectionSlug: string): Section | null => {
+            return sections.find(s => s.slug === sectionSlug) || null;
+        },
+
+        getDocBySlug: (sectionSlug: string, docSlug: string): DocItem | null => {
+            const section = sections.find(s => s.slug === sectionSlug);
+            if (!section) return null;
+            return section.items.find(d => d.slug === docSlug) || null;
+        },
+
+        getNextDoc: (currentDoc: DocItem): DocItem | null => {
+            const currentSection = sections.find(s => s.slug === currentDoc.sectionSlug);
+            if (!currentSection) return null;
+
+            const currentIndex = currentSection.items.findIndex(d => d.slug === currentDoc.slug);
+
+            if (currentIndex < currentSection.items.length - 1) {
+                return currentSection.items[currentIndex + 1];
+            }
+
+            const sectionIndex = sections.findIndex(s => s.slug === currentSection.slug);
+            if (sectionIndex < sections.length - 1) {
+                const nextSection = sections[sectionIndex + 1];
+                return nextSection.items[0] || null;
+            }
+
+            return null;
+        },
+
+        getPrevDoc: (currentDoc: DocItem): DocItem | null => {
+            const currentSection = sections.find(s => s.slug === currentDoc.sectionSlug);
+            if (!currentSection) return null;
+
+            const currentIndex = currentSection.items.findIndex(d => d.slug === currentDoc.slug);
+
+            if (currentIndex > 0) {
+                return currentSection.items[currentIndex - 1];
+            }
+
+            const sectionIndex = sections.findIndex(s => s.slug === currentSection.slug);
+            if (sectionIndex > 0) {
+                const prevSection = sections[sectionIndex - 1];
+                return prevSection.items[prevSection.items.length - 1] || null;
+            }
+
+            return null;
         }
     };
 
-    const getSectionBySlug = (sectionSlug: string): Section | null => {
-        return sections.find(s => s.slug === sectionSlug) || null;
-    };
-
-    const getDocBySlug = (sectionSlug: string, docSlug: string): DocItem | null => {
-        const section = getSectionBySlug(sectionSlug);
-        if (!section) return null;
-        return section.items.find(d => d.slug === docSlug) || null;
-    };
-
-    const getNextDoc = (currentDoc: DocItem): DocItem | null => {
-        const currentSection = sections.find(s => s.slug === currentDoc.sectionSlug);
-        if (!currentSection) return null;
-
-        const currentIndex = currentSection.items.findIndex(d => d.slug === currentDoc.slug);
-
-        // Try next doc in same section
-        if (currentIndex < currentSection.items.length - 1) {
-            return currentSection.items[currentIndex + 1];
-        }
-
-        // Try first doc of next section
-        const sectionIndex = sections.findIndex(s => s.slug === currentSection.slug);
-        if (sectionIndex < sections.length - 1) {
-            const nextSection = sections[sectionIndex + 1];
-            return nextSection.items[0] || null;
-        }
-
-        return null;
-    };
-
-    const getPrevDoc = (currentDoc: DocItem): DocItem | null => {
-        const currentSection = sections.find(s => s.slug === currentDoc.sectionSlug);
-        if (!currentSection) return null;
-
-        const currentIndex = currentSection.items.findIndex(d => d.slug === currentDoc.slug);
-
-        // Try previous doc in same section
-        if (currentIndex > 0) {
-            return currentSection.items[currentIndex - 1];
-        }
-
-        // Try last doc of previous section
-        const sectionIndex = sections.findIndex(s => s.slug === currentSection.slug);
-        if (sectionIndex > 0) {
-            const prevSection = sections[sectionIndex - 1];
-            return prevSection.items[prevSection.items.length - 1] || null;
-        }
-
-        return null;
-    };
-
-    return {
-        ...state,
+    const instance: ZenOrderReturn = {
         sections,
-        selectSection,
-        selectDoc,
-        getNextDoc,
-        getPrevDoc,
-        getDocBySlug,
-        getSectionBySlug
+        selectedSection: sections[0] || null,
+        selectedDoc: sections[0]?.items[0] || null,
+        ...actions
     };
+
+    return instance;
 }
 
 /**

package/content/index.ts

@@ -107,11 +107,14 @@ export default function content(options: ContentPluginOptions = {}): ZenithPlugi
     name: 'zenith-content',
     config: options,
     setup(ctx: PluginContext) {
+      console.log('[zenith:content] setup() starting...');
       let collections: Record<string, ContentItem[]> = {};
 
       if (options.sources && Object.keys(options.sources).length > 0) {
         // Use new sources configuration
+        console.log('[zenith:content] Loading from sources...');
         collections = loadFromSources(options.sources, ctx.projectRoot);
+        console.log('[zenith:content] loadFromSources completed');
       } else if (options.contentDir) {
         // Legacy: single content directory
         const contentPath = path.resolve(ctx.projectRoot, options.contentDir);
@@ -131,10 +134,12 @@ export default function content(options: ContentPluginOptions = {}): ZenithPlugi
 
       // Pass to runtime using generic namespaced data store
       const allItems = Object.values(collections).flat();
+      console.log('[zenith:content] Setting plugin data, items:', allItems.length);
       ctx.setPluginData('content', allItems);
 
       // Update legacy storage
       allContent = allItems;
+      console.log('[zenith:content] setup() completed');
     },
 
     /**

package/content/loader.ts

@@ -4,15 +4,19 @@ import type { ContentItem, ContentSourceConfig } from './types';
 import { compileMarkdown, vnodesToHtml } from './markdown';
 
 export function loadContent(contentDir: string): ContentItem[] {
+    console.log(`[zenith:content:loadContent] Starting for: ${contentDir}`);
     if (!fs.existsSync(contentDir)) {
         console.warn(`Content directory ${contentDir} does not exist.`);
         return [];
     }
 
     const items: ContentItem[] = [];
+    console.log('[zenith:content:loadContent] Getting all files...');
     const files = getAllFiles(contentDir);
+    console.log(`[zenith:content:loadContent] Found ${files.length} files`);
 
     for (const filePath of files) {
+        console.log(`[zenith:content:loadContent] Processing file: ${path.basename(filePath)}`);
         const ext = path.extname(filePath).toLowerCase();
         const relativePath = path.relative(contentDir, filePath);
         const collection = relativePath.split(path.sep)[0];
@@ -40,10 +44,14 @@ export function loadContent(contentDir: string): ContentItem[] {
                 console.error(`Error parsing JSON file ${filePath}:`, e);
             }
         } else if (ext === '.md' || ext === '.mdx') {
+            console.log(`[zenith:content:loadContent] Parsing markdown: ${path.basename(filePath)}`);
             const { metadata, content: markdownBody } = parseMarkdown(rawContent);
+            console.log(`[zenith:content:loadContent] Compiling markdown...`);
             // Compile markdown to VNodes then to HTML for rendering
             const vnodes = compileMarkdown(markdownBody);
+            console.log(`[zenith:content:loadContent] Converting vnodes to HTML...`);
             const compiledContent = vnodesToHtml(vnodes);
+            console.log(`[zenith:content:loadContent] Done with: ${path.basename(filePath)}`);
             items.push({
                 id,
                 slug,
@@ -53,7 +61,7 @@ export function loadContent(contentDir: string): ContentItem[] {
             });
         }
     }
-
+    console.log(`[zenith:content:loadContent] Finished, returning ${items.length} items`);
     return items;
 }
 
@@ -65,27 +73,34 @@ export function loadFromSources(
     sources: Record<string, ContentSourceConfig>,
     projectRoot: string
 ): Record<string, ContentItem[]> {
+    console.log('[zenith:content:loader] loadFromSources called, sources:', Object.keys(sources));
     const collections: Record<string, ContentItem[]> = {};
 
     for (const [collectionName, config] of Object.entries(sources)) {
+        console.log(`[zenith:content:loader] Processing collection: ${collectionName}`);
         const rootPath = path.resolve(projectRoot, config.root);
+        console.log(`[zenith:content:loader] Root path: ${rootPath}`);
 
         if (!fs.existsSync(rootPath)) {
             console.warn(`[zenith:content] Source root "${rootPath}" does not exist for collection "${collectionName}"`);
             continue;
         }
+        console.log('[zenith:content:loader] Root path exists, scanning folders...');
 
         // Get folders to scan
         let foldersToScan: string[] = [];
 
         if (config.include && config.include.length > 0) {
             // Explicit include list
+            console.log('[zenith:content:loader] Using explicit include list:', config.include);
             foldersToScan = config.include;
         } else {
             // Scan all subdirectories if no include specified
             try {
+                console.log('[zenith:content:loader] Reading subdirectories...');
                 foldersToScan = fs.readdirSync(rootPath)
                     .filter(f => fs.statSync(path.join(rootPath, f)).isDirectory());
+                console.log('[zenith:content:loader] Found subdirectories:', foldersToScan);
             } catch {
                 // If root is itself the content folder
                 foldersToScan = ['.'];
@@ -95,10 +110,12 @@ export function loadFromSources(
         // Apply excludes
         const exclude = config.exclude || [];
         foldersToScan = foldersToScan.filter(f => !exclude.includes(f));
+        console.log('[zenith:content:loader] Folders after exclude filter:', foldersToScan);
 
         // Load content from each folder
         const items: ContentItem[] = [];
         for (const folder of foldersToScan) {
+            console.log(`[zenith:content:loader] Processing folder: ${folder}`);
             const folderPath = folder === '.' ? rootPath : path.join(rootPath, folder);
 
             if (!fs.existsSync(folderPath)) {
@@ -106,7 +123,9 @@ export function loadFromSources(
                 continue;
             }
 
+            console.log(`[zenith:content:loader] Calling loadContent for: ${folderPath}`);
             const folderItems = loadContent(folderPath);
+            console.log(`[zenith:content:loader] loadContent returned ${folderItems.length} items`);
 
             // Override collection name to match the configured name
             items.push(...folderItems.map(item => ({

package/content/markdown.ts

@@ -109,8 +109,16 @@ export function compileMarkdown(markdown: string): VNode[] {
         const line = lines[i];
         const trimmed = line.trim();
 
-        // Skip empty lines
-        if (trimmed === '') {
+        // Raw HTML: if a line starts with < and ends with > (simplified detection)
+        if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+            // We'll treat this as a raw HTML block. 
+            // VNode doesn't have a 'raw' type, so we'll use a special tag 'div' 
+            // but we need a way to signal it shouldn't be escaped.
+            // Since our system uses innerHTML for the final injection, 
+            // we can just put the raw HTML in the children for now?
+            // Wait, vnodesToHtml will escape children if they are strings.
+            // Let's use a special tag 'zen-raw-html' that vnodesToHtml handles.
+            nodes.push(h('zen-raw-html', { html: trimmed }, []));
             i++;
             continue;
         }
@@ -185,6 +193,12 @@ export function compileMarkdown(markdown: string): VNode[] {
             continue;
         }
 
+        // Skip empty lines explicitly to prevent infinite loop
+        if (trimmed === '') {
+            i++;
+            continue;
+        }
+
         // Paragraph: collect consecutive non-empty lines
         const paraLines: string[] = [];
         while (i < lines.length && lines[i].trim() !== '' &&
@@ -219,6 +233,10 @@ export function vnodesToHtml(nodes: VNode[]): string {
 
         const { tag, props, children } = node;
 
+        if (tag === 'zen-raw-html') {
+            return props.html || '';
+        }
+
         // Self-closing tags
         if (tag === 'hr' || tag === 'br') {
             const attrs = Object.entries(props)

package/content/query.ts

@@ -97,4 +97,70 @@ export class ZenCollection {
         const results = await this.get();
         return results.length;
     }
+
+    /**
+     * Group items by folder (first segment of slug).
+     * Returns an object with a groupByFolder method that can be chained.
+     */
+    groupByFolder(): { get: () => Array<{ id: string; title: string; items: ContentItem[] }> } {
+        const self = this;
+        return {
+            get(): Array<{ id: string; title: string; items: ContentItem[] }> {
+                let results = [...self.collectionItems];
+
+                // 1. Filter
+                for (const filter of self.filters) {
+                    results = results.filter(filter);
+                }
+
+                // 2. Sort
+                if (self.sortField) {
+                    results.sort((a, b) => {
+                        const valA = a[self.sortField!];
+                        const valB = b[self.sortField!];
+
+                        if (valA < valB) return self.sortOrder === 'asc' ? -1 : 1;
+                        if (valA > valB) return self.sortOrder === 'asc' ? 1 : -1;
+                        return 0;
+                    });
+                }
+
+                // 3. Limit
+                if (self.limitCount !== null) {
+                    results = results.slice(0, self.limitCount);
+                }
+
+                // Group by folder (first segment of slug)
+                const groups = new Map<string, ContentItem[]>();
+                for (const item of results) {
+                    const slug = String(item.slug || item.id || '');
+                    const parts = slug.split('/');
+                    const folder = parts.length > 1 ? parts[0] : 'default';
+
+                    if (!groups.has(folder)) {
+                        groups.set(folder, []);
+                    }
+                    groups.get(folder)!.push(item);
+                }
+
+                // Convert to array of sections
+                const sections: Array<{ id: string; title: string; items: ContentItem[] }> = [];
+                for (const [folder, items] of groups) {
+                    // Generate title from folder name
+                    const title = folder
+                        .split('-')
+                        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                        .join(' ');
+
+                    sections.push({
+                        id: folder,
+                        title,
+                        items
+                    });
+                }
+
+                return sections;
+            }
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/plugins",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Plugin system for Zenith framework",
   "type": "module",
   "main": "content/index.ts",
@@ -33,4 +33,4 @@
   "devDependencies": {
     "@types/node": "^25.0.6"
   }
-}
+}