@zenithbuild/plugins 0.3.2

package/content/markdown.ts

@@ -0,0 +1,244 @@
+/**
+ * Markdown to Zenith Render Nodes Compiler
+ * 
+ * Converts markdown content to Zenith-compatible VNodes at build/load time.
+ * This ensures markdown is fully compiled before reaching the frontend.
+ * 
+ * Supported syntax:
+ * - Headings (#, ##, ###, ####, #####, ######)
+ * - Paragraphs
+ * - Bold (**text** or __text__)
+ * - Italic (*text* or _text_)
+ * - Inline code (`code`)
+ * - Code blocks (```language\ncode\n```)
+ * - Links ([text](url))
+ * - Horizontal rules (---, ***, ___)
+ * - Lists (- item, * item, 1. item)
+ * - Blockquotes (> text)
+ */
+
+/**
+ * VNode - Virtual DOM node structure compatible with Zenith runtime
+ */
+export interface VNode {
+    tag: string;
+    props: Record<string, string | null>;
+    children: (VNode | string)[];
+}
+
+/**
+ * Create a VNode element
+ */
+function h(tag: string, props: Record<string, string | null> = {}, children: (VNode | string)[] = []): VNode {
+    return { tag, props, children };
+}
+
+/**
+ * Escape HTML entities in text
+ */
+function escapeText(text: string): string {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+
+/**
+ * Parse inline markdown (bold, italic, code, links)
+ */
+function parseInline(text: string): (VNode | string)[] {
+    const result: (VNode | string)[] = [];
+    let remaining = text;
+
+    while (remaining.length > 0) {
+        // Bold: **text** or __text__
+        let match = remaining.match(/^(\*\*|__)(.+?)\1/);
+        if (match) {
+            result.push(h('strong', {}, [match[2]]));
+            remaining = remaining.slice(match[0].length);
+            continue;
+        }
+
+        // Italic: *text* or _text_ (but not ** or __)
+        match = remaining.match(/^(\*|_)(?!\1)(.+?)\1(?!\1)/);
+        if (match) {
+            result.push(h('em', {}, [match[2]]));
+            remaining = remaining.slice(match[0].length);
+            continue;
+        }
+
+        // Inline code: `code`
+        match = remaining.match(/^`([^`]+)`/);
+        if (match) {
+            result.push(h('code', {}, [match[1]]));
+            remaining = remaining.slice(match[0].length);
+            continue;
+        }
+
+        // Links: [text](url)
+        match = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+        if (match) {
+            result.push(h('a', { href: match[2] }, [match[1]]));
+            remaining = remaining.slice(match[0].length);
+            continue;
+        }
+
+        // Find next special character or consume until end
+        const nextSpecial = remaining.slice(1).search(/[\*_`\[]/);
+        if (nextSpecial === -1) {
+            result.push(remaining);
+            break;
+        } else {
+            result.push(remaining.slice(0, nextSpecial + 1));
+            remaining = remaining.slice(nextSpecial + 1);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Compile markdown string to VNode array
+ */
+export function compileMarkdown(markdown: string): VNode[] {
+    const nodes: VNode[] = [];
+    const lines = markdown.split('\n');
+    let i = 0;
+
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+
+        // Skip empty lines
+        if (trimmed === '') {
+            i++;
+            continue;
+        }
+
+        // Code blocks: ```language\ncode\n```
+        if (trimmed.startsWith('```')) {
+            const lang = trimmed.slice(3).trim() || null;
+            const codeLines: string[] = [];
+            i++;
+            while (i < lines.length && !lines[i].trim().startsWith('```')) {
+                codeLines.push(lines[i]);
+                i++;
+            }
+            i++; // Skip closing ```
+
+            const codeContent = codeLines.join('\n');
+            const codeNode = h('code', lang ? { class: `language-${lang}` } : {}, [codeContent]);
+            nodes.push(h('pre', {}, [codeNode]));
+            continue;
+        }
+
+        // Headings: # to ######
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const text = headingMatch[2];
+            nodes.push(h(`h${level}`, {}, parseInline(text)));
+            i++;
+            continue;
+        }
+
+        // Horizontal rules: ---, ***, ___
+        if (/^([-*_])\1{2,}$/.test(trimmed)) {
+            nodes.push(h('hr', {}, []));
+            i++;
+            continue;
+        }
+
+        // Blockquotes: > text
+        if (trimmed.startsWith('>')) {
+            const quoteLines: string[] = [];
+            while (i < lines.length && lines[i].trim().startsWith('>')) {
+                quoteLines.push(lines[i].trim().slice(1).trim());
+                i++;
+            }
+            const quoteContent = quoteLines.join(' ');
+            nodes.push(h('blockquote', {}, parseInline(quoteContent)));
+            continue;
+        }
+
+        // Unordered lists: - item, * item
+        if (/^[-*]\s+/.test(trimmed)) {
+            const listItems: VNode[] = [];
+            while (i < lines.length && /^[-*]\s+/.test(lines[i].trim())) {
+                const itemText = lines[i].trim().replace(/^[-*]\s+/, '');
+                listItems.push(h('li', {}, parseInline(itemText)));
+                i++;
+            }
+            nodes.push(h('ul', {}, listItems));
+            continue;
+        }
+
+        // Ordered lists: 1. item
+        if (/^\d+\.\s+/.test(trimmed)) {
+            const listItems: VNode[] = [];
+            while (i < lines.length && /^\d+\.\s+/.test(lines[i].trim())) {
+                const itemText = lines[i].trim().replace(/^\d+\.\s+/, '');
+                listItems.push(h('li', {}, parseInline(itemText)));
+                i++;
+            }
+            nodes.push(h('ol', {}, listItems));
+            continue;
+        }
+
+        // Paragraph: collect consecutive non-empty lines
+        const paraLines: string[] = [];
+        while (i < lines.length && lines[i].trim() !== '' &&
+            !lines[i].trim().startsWith('#') &&
+            !lines[i].trim().startsWith('```') &&
+            !lines[i].trim().startsWith('>') &&
+            !/^[-*]\s+/.test(lines[i].trim()) &&
+            !/^\d+\.\s+/.test(lines[i].trim()) &&
+            !/^([-*_])\1{2,}$/.test(lines[i].trim())) {
+            paraLines.push(lines[i].trim());
+            i++;
+        }
+
+        if (paraLines.length > 0) {
+            const paraText = paraLines.join(' ');
+            nodes.push(h('p', {}, parseInline(paraText)));
+        }
+    }
+
+    return nodes;
+}
+
+/**
+ * Convert VNode tree to HTML string for rendering in innerHTML
+ * This is used as an intermediate step for browser rendering
+ */
+export function vnodesToHtml(nodes: VNode[]): string {
+    function renderNode(node: VNode | string): string {
+        if (typeof node === 'string') {
+            return escapeText(node);
+        }
+
+        const { tag, props, children } = node;
+
+        // Self-closing tags
+        if (tag === 'hr' || tag === 'br') {
+            const attrs = Object.entries(props)
+                .filter(([_, v]) => v !== null)
+                .map(([k, v]) => `${k}="${v}"`)
+                .join(' ');
+            return attrs ? `<${tag} ${attrs} />` : `<${tag} />`;
+        }
+
+        const attrs = Object.entries(props)
+            .filter(([_, v]) => v !== null)
+            .map(([k, v]) => `${k}="${v}"`)
+            .join(' ');
+
+        const childrenHtml = children.map(renderNode).join('');
+
+        return attrs
+            ? `<${tag} ${attrs}>${childrenHtml}</${tag}>`
+            : `<${tag}>${childrenHtml}</${tag}>`;
+    }
+
+    return nodes.map(renderNode).join('\n');
+}

package/content/query.ts

@@ -0,0 +1,100 @@
+import type { ContentItem, SortOrder, Enhancer } from './types';
+import { applyEnhancers } from './enhancers';
+
+export class ZenCollection {
+    private collectionItems: ContentItem[];
+    private filters: ((item: ContentItem) => boolean)[] = [];
+    private sortField: string | null = null;
+    private sortOrder: SortOrder = 'desc';
+    private limitCount: number | null = null;
+    private selectedFields: string[] | null = null;
+    private enhancers: Enhancer[] = [];
+
+    constructor(items: ContentItem[]) {
+        this.collectionItems = [...items];
+    }
+
+    where(fn: (item: ContentItem) => boolean): this {
+        this.filters.push(fn);
+        return this;
+    }
+
+    sortBy(field: string, order: SortOrder = 'desc'): this {
+        this.sortField = field;
+        this.sortOrder = order;
+        return this;
+    }
+
+    limit(n: number): this {
+        this.limitCount = n;
+        return this;
+    }
+
+    fields(fields: string[]): this {
+        this.selectedFields = fields;
+        return this;
+    }
+
+    enhanceWith(enhancer: Enhancer): this {
+        this.enhancers.push(enhancer);
+        return this;
+    }
+
+    async get(): Promise<ContentItem[]> {
+        let results = [...this.collectionItems];
+
+        // 1. Filter
+        for (const filter of this.filters) {
+            results = results.filter(filter);
+        }
+
+        // 2. Sort
+        if (this.sortField) {
+            results.sort((a, b) => {
+                const valA = a[this.sortField!];
+                const valB = b[this.sortField!];
+
+                if (valA < valB) return this.sortOrder === 'asc' ? -1 : 1;
+                if (valA > valB) return this.sortOrder === 'asc' ? 1 : -1;
+                return 0;
+            });
+        }
+
+        // 3. Limit
+        if (this.limitCount !== null) {
+            results = results.slice(0, this.limitCount);
+        }
+
+        // 4. Enhance
+        if (this.enhancers.length > 0) {
+            results = await Promise.all(results.map(item => applyEnhancers(item, this.enhancers)));
+        }
+
+        // 5. Select Fields
+        if (this.selectedFields) {
+            results = results.map(item => {
+                const newItem: any = {};
+                this.selectedFields!.forEach(f => {
+                    newItem[f] = item[f];
+                });
+                return newItem as ContentItem;
+            });
+        }
+
+        return results;
+    }
+
+    async all(): Promise<ContentItem[]> {
+        return this.get();
+    }
+
+    async first(): Promise<ContentItem | null> {
+        const results = await this.limit(1).get();
+        return results.length > 0 ? results[0] : null;
+    }
+
+    async count(): Promise<number> {
+        const results = await this.get();
+        return results.length;
+    }
+}

package/content/schema.ts

@@ -0,0 +1,30 @@
+import type { ContentSchema } from './types';
+
+const schemaRegistry = new Map<string, ContentSchema>();
+
+export function defineSchema(name: string, schema: ContentSchema) {
+    schemaRegistry.set(name, schema);
+}
+
+export function getSchema(name: string): ContentSchema | undefined {
+    return schemaRegistry.get(name);
+}
+
+export function validateItem(collection: string, item: any): boolean {
+    const schema = getSchema(collection);
+    if (!schema) return true; // No schema, no validation (or permissive)
+
+    // Basic validation logic
+    for (const [key, type] of Object.entries(schema)) {
+        const value = item[key];
+        if (value === undefined) continue; // Optional by default?
+
+        if (type === 'string' && typeof value !== 'string') return false;
+        if (type === 'number' && typeof value !== 'number') return false;
+        if (type === 'boolean' && typeof value !== 'boolean') return false;
+        if (type === 'string[]' && (!Array.isArray(value) || !value.every(v => typeof v === 'string'))) return false;
+        // ... more types
+    }
+
+    return true;
+}

package/content/types.ts

@@ -0,0 +1,53 @@
+export interface ContentItem {
+  id?: string | number;
+  slug?: string | null;
+  collection?: string | null;
+  content?: string | null;
+  [key: string]: any | null;
+}
+
+/**
+ * Configuration for a content source
+ */
+export interface ContentSourceConfig {
+  /** Root directory relative to project root (e.g., "../zenith-docs" or "content") */
+  root: string;
+  /** Folders to include from the root (e.g., ["documentation"]). Defaults to all. */
+  include?: string[];
+  /** Folders to exclude from the root (e.g., ["changelog"]) */
+  exclude?: string[];
+}
+
+/**
+ * Options for the content plugin factory function
+ */
+export interface ContentPluginOptions {
+  /** Named content sources mapped to their configuration */
+  sources?: Record<string, ContentSourceConfig>;
+  /** Legacy: Single content directory (deprecated, use sources instead) */
+  contentDir?: string;
+}
+
+export type ContentSchema = Record<string, 'string' | 'number' | 'boolean' | 'string[]' | 'date'>;
+
+export interface PluginOptions {
+  contentDir?: string; // Default: 'content'
+}
+
+export type SortOrder = 'asc' | 'desc';
+
+export type EnhancerFn = (item: ContentItem) => ContentItem | Promise<ContentItem>;
+export type Enhancer = string | EnhancerFn;
+
+export interface PluginContext {
+  options: PluginOptions;
+  // Add other context methods if known, for now minimal
+  [key: string]: any;
+}
+
+export interface ZenithPlugin {
+  name: string;
+  template?: string;
+  options?: PluginOptions;
+  setup: (ctx: PluginContext) => void | Promise<void>;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@zenithbuild/plugins",
+  "version": "0.3.2",
+  "description": "Plugin system for Zenith framework",
+  "type": "module",
+  "main": "content/index.ts",
+  "scripts": {
+    "dev": "bun dev",
+    "build": "bun build",
+    "start": "bun run build && bun run dev",
+    "release": "bun run scripts/release.ts",
+    "release:dry": "bun run scripts/release.ts --dry-run",
+    "release:patch": "bun run scripts/release.ts --bump=patch",
+    "release:minor": "bun run scripts/release.ts --bump=minor",
+    "release:major": "bun run scripts/release.ts --bump=major"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:zenithbuild/zenith-plugins.git"
+  },
+  "keywords": [
+    "zenith",
+    "plugins",
+    "framework"
+  ],
+  "author": "Zenith Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false,
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^25.0.6"
+  }
+}