@zenithbuild/core 0.6.3 → 1.2.0

package/cli/utils/content.ts

@@ -1,112 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { marked } from 'marked';
-
-export interface ContentItem {
-    id?: string | number;
-    slug?: string | null;
-    collection?: string | null;
-    content?: string | null;
-    [key: string]: any | null;
-}
-
-/**
- * Load all content from the content directory
- */
-export function loadContent(contentDir: string): Record<string, ContentItem[]> {
-    if (!fs.existsSync(contentDir)) {
-        return {};
-    }
-
-    const collections: Record<string, ContentItem[]> = {};
-    const files = getAllFiles(contentDir);
-
-    for (const filePath of files) {
-        const ext = path.extname(filePath).toLowerCase();
-        const relativePath = path.relative(contentDir, filePath);
-        const collection = relativePath.split(path.sep)[0];
-        if (!collection) continue;
-
-        const slug = relativePath.replace(/\.(md|mdx|json)$/, '').replace(/\\/g, '/');
-        const id = slug;
-
-        const rawContent = fs.readFileSync(filePath, 'utf-8');
-
-        if (!collections[collection]) {
-            collections[collection] = [];
-        }
-
-        if (ext === '.json') {
-            try {
-                const data = JSON.parse(rawContent);
-                collections[collection].push({
-                    id,
-                    slug,
-                    collection,
-                    content: '',
-                    ...data
-                });
-            } catch (e) {
-                console.error(`Error parsing JSON file ${filePath}:`, e);
-            }
-        } else if (ext === '.md' || ext === '.mdx') {
-            const { metadata, content } = parseMarkdown(rawContent);
-            collections[collection].push({
-                id,
-                slug,
-                collection,
-                content,
-                ...metadata
-            });
-        }
-    }
-
-    return collections;
-}
-
-function getAllFiles(dir: string, fileList: string[] = []): string[] {
-    const files = fs.readdirSync(dir);
-    files.forEach((file: string) => {
-        const name = path.join(dir, file);
-        if (fs.statSync(name).isDirectory()) {
-            getAllFiles(name, fileList);
-        } else {
-            fileList.push(name);
-        }
-    });
-    return fileList;
-}
-
-function parseMarkdown(content: string): { metadata: Record<string, any>, content: string } {
-    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-
-    if (!match) {
-        return { metadata: {}, content: content.trim() };
-    }
-
-    const [, yamlStr, body] = match;
-    const metadata: Record<string, any> = {};
-
-    if (yamlStr) {
-        yamlStr.split('\n').forEach(line => {
-            const [key, ...values] = line.split(':');
-            if (key && values.length > 0) {
-                const value = values.join(':').trim();
-                // Basic type conversion
-                if (value === 'true') metadata[key.trim()] = true;
-                else if (value === 'false') metadata[key.trim()] = false;
-                else if (!isNaN(Number(value))) metadata[key.trim()] = Number(value);
-                else if (value.startsWith('[') && value.endsWith(']')) {
-                    metadata[key.trim()] = value.slice(1, -1).split(',').map(v => v.trim().replace(/^['"]|['"]$/g, ''));
-                }
-                else metadata[key.trim()] = value.replace(/^['"]|['"]$/g, '');
-            }
-        });
-    }
-
-    return {
-        metadata,
-        content: marked.parse((body || '').trim()) as string
-    };
-}

package/router/manifest.ts

@@ -1,314 +0,0 @@
-/**
- * Zenith Route Manifest Generator
- * 
- * Scans pages/ directory at build time and generates a route manifest
- * with proper scoring for deterministic route matching.
- */
-
-import fs from "fs"
-import path from "path"
-import {
-  type RouteDefinition,
-  type ParsedSegment,
-  SegmentType
-} from "./types"
-
-/**
- * Scoring constants for route ranking
- * Higher scores = higher priority
- */
-const SEGMENT_SCORES = {
-  [SegmentType.STATIC]: 10,
-  [SegmentType.DYNAMIC]: 5,
-  [SegmentType.CATCH_ALL]: 1,
-  [SegmentType.OPTIONAL_CATCH_ALL]: 0
-} as const
-
-/**
- * Discover all .zen files in the pages directory
- */
-export function discoverPages(pagesDir: string): string[] {
-  const pages: string[] = []
-  
-  function walk(dir: string): void {
-    if (!fs.existsSync(dir)) return
-    
-    const entries = fs.readdirSync(dir, { withFileTypes: true })
-    
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name)
-      
-      if (entry.isDirectory()) {
-        walk(fullPath)
-      } else if (entry.isFile() && entry.name.endsWith(".zen")) {
-        pages.push(fullPath)
-      }
-    }
-  }
-  
-  walk(pagesDir)
-  return pages
-}
-
-/**
- * Convert a file path to a route path
- * 
- * Examples:
- *   pages/index.zen       → /
- *   pages/about.zen       → /about
- *   pages/blog/index.zen  → /blog
- *   pages/blog/[id].zen   → /blog/:id
- *   pages/posts/[...slug].zen → /posts/*slug
- *   pages/[[...all]].zen  → /*all (optional)
- */
-export function filePathToRoutePath(filePath: string, pagesDir: string): string {
-  // Get relative path from pages directory
-  const relativePath = path.relative(pagesDir, filePath)
-  
-  // Remove .zen extension
-  const withoutExt = relativePath.replace(/\.zen$/, "")
-  
-  // Split into segments
-  const segments = withoutExt.split(path.sep)
-  
-  // Transform segments
-  const routeSegments: string[] = []
-  
-  for (const segment of segments) {
-    // Handle index files (they represent the directory root)
-    if (segment === "index") {
-      continue
-    }
-    
-    // Handle optional catch-all: [[...param]]
-    const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.(\w+)\]\]$/)
-    if (optionalCatchAllMatch) {
-      routeSegments.push(`*${optionalCatchAllMatch[1]}?`)
-      continue
-    }
-    
-    // Handle required catch-all: [...param]
-    const catchAllMatch = segment.match(/^\[\.\.\.(\w+)\]$/)
-    if (catchAllMatch) {
-      routeSegments.push(`*${catchAllMatch[1]}`)
-      continue
-    }
-    
-    // Handle dynamic segment: [param]
-    const dynamicMatch = segment.match(/^\[(\w+)\]$/)
-    if (dynamicMatch) {
-      routeSegments.push(`:${dynamicMatch[1]}`)
-      continue
-    }
-    
-    // Static segment
-    routeSegments.push(segment)
-  }
-  
-  // Build route path
-  const routePath = "/" + routeSegments.join("/")
-  
-  // Normalize trailing slashes
-  return routePath === "/" ? "/" : routePath.replace(/\/$/, "")
-}
-
-/**
- * Parse a route path into segments with type information
- */
-export function parseRouteSegments(routePath: string): ParsedSegment[] {
-  if (routePath === "/") {
-    return []
-  }
-  
-  const segments = routePath.slice(1).split("/")
-  const parsed: ParsedSegment[] = []
-  
-  for (const segment of segments) {
-    // Optional catch-all: *param?
-    if (segment.startsWith("*") && segment.endsWith("?")) {
-      parsed.push({
-        type: SegmentType.OPTIONAL_CATCH_ALL,
-        paramName: segment.slice(1, -1),
-        raw: segment
-      })
-      continue
-    }
-    
-    // Required catch-all: *param
-    if (segment.startsWith("*")) {
-      parsed.push({
-        type: SegmentType.CATCH_ALL,
-        paramName: segment.slice(1),
-        raw: segment
-      })
-      continue
-    }
-    
-    // Dynamic: :param
-    if (segment.startsWith(":")) {
-      parsed.push({
-        type: SegmentType.DYNAMIC,
-        paramName: segment.slice(1),
-        raw: segment
-      })
-      continue
-    }
-    
-    // Static
-    parsed.push({
-      type: SegmentType.STATIC,
-      raw: segment
-    })
-  }
-  
-  return parsed
-}
-
-/**
- * Calculate route score based on segments
- * Higher scores = higher priority for matching
- */
-export function calculateRouteScore(segments: ParsedSegment[]): number {
-  if (segments.length === 0) {
-    // Root route gets a high score
-    return 100
-  }
-  
-  let score = 0
-  
-  for (const segment of segments) {
-    score += SEGMENT_SCORES[segment.type]
-  }
-  
-  // Bonus for having more static segments (specificity)
-  const staticCount = segments.filter(s => s.type === SegmentType.STATIC).length
-  score += staticCount * 2
-  
-  return score
-}
-
-/**
- * Extract parameter names from parsed segments
- */
-export function extractParamNames(segments: ParsedSegment[]): string[] {
-  return segments
-    .filter(s => s.paramName !== undefined)
-    .map(s => s.paramName!)
-}
-
-/**
- * Convert route path to regex pattern
- * 
- * Examples:
- *   /about         → /^\/about\/?$/
- *   /blog/:id      → /^\/blog\/([^/]+)\/?$/
- *   /posts/*slug   → /^\/posts\/(.+)\/?$/
- *   /              → /^\/$/
- *   /*all?         → /^(?:\/(.*))?$/  (optional catch-all)
- */
-export function routePathToRegex(routePath: string): RegExp {
-  if (routePath === "/") {
-    return /^\/$/
-  }
-  
-  const segments = routePath.slice(1).split("/")
-  const regexParts: string[] = []
-  
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]
-    if (!segment) continue
-    
-    // Optional catch-all: *param?
-    if (segment.startsWith("*") && segment.endsWith("?")) {
-      // Optional catch-all - matches zero or more path segments
-      // Should only be at the end
-      regexParts.push("(?:\\/(.*))?")
-      continue
-    }
-    
-    // Required catch-all: *param
-    if (segment.startsWith("*")) {
-      // Required catch-all - matches one or more path segments
-      regexParts.push("\\/(.+)")
-      continue
-    }
-    
-    // Dynamic: :param
-    if (segment.startsWith(":")) {
-      regexParts.push("\\/([^/]+)")
-      continue
-    }
-    
-    // Static segment - escape special regex characters
-    const escaped = segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-    regexParts.push(`\\/${escaped}`)
-  }
-  
-  // Build final regex with optional trailing slash
-  const pattern = `^${regexParts.join("")}\\/?$`
-  return new RegExp(pattern)
-}
-
-/**
- * Generate a route definition from a file path
- */
-export function generateRouteDefinition(
-  filePath: string,
-  pagesDir: string
-): RouteDefinition {
-  const routePath = filePathToRoutePath(filePath, pagesDir)
-  const segments = parseRouteSegments(routePath)
-  const paramNames = extractParamNames(segments)
-  const score = calculateRouteScore(segments)
-  
-  return {
-    path: routePath,
-    segments,
-    paramNames,
-    score,
-    filePath
-  }
-}
-
-/**
- * Generate route manifest from pages directory
- * Returns route definitions sorted by score (highest first)
- */
-export function generateRouteManifest(pagesDir: string): RouteDefinition[] {
-  const pages = discoverPages(pagesDir)
-  
-  const definitions = pages.map(filePath => 
-    generateRouteDefinition(filePath, pagesDir)
-  )
-  
-  // Sort by score descending (highest priority first)
-  definitions.sort((a, b) => b.score - a.score)
-  
-  return definitions
-}
-
-/**
- * Generate the route manifest as JavaScript code for runtime
- */
-export function generateRouteManifestCode(definitions: RouteDefinition[]): string {
-  const routeEntries = definitions.map(def => {
-    const regex = routePathToRegex(def.path)
-    
-    return `  {
-    path: ${JSON.stringify(def.path)},
-    regex: ${regex.toString()},
-    paramNames: ${JSON.stringify(def.paramNames)},
-    score: ${def.score},
-    filePath: ${JSON.stringify(def.filePath)}
-  }`
-  })
-  
-  return `// Auto-generated route manifest
-// Do not edit directly
-
-export const routeManifest = [
-${routeEntries.join(",\n")}
-];
-`
-}
-

package/router/navigation/ZenLink.zen

@@ -1,231 +0,0 @@
-<script>
-// Props extend HTMLAnchorElement properties + custom ZenLink attributes
-// Standard anchor attributes: href, target, rel, download, hreflang, type, ping, referrerPolicy, etc.
-// Custom ZenLink attributes: preload, exact, onClick
-type Props = {
-  // Standard HTMLAnchorElement attributes
-  href?: string
-  target?: '_blank' | '_self' | '_parent' | '_top' | string
-  rel?: string
-  download?: string | boolean
-  hreflang?: string
-  type?: string
-  ping?: string
-  referrerPolicy?: string
-  class?: string
-  id?: string
-  title?: string
-  ariaLabel?: string
-  role?: string
-  tabIndex?: number | string
-  // Custom ZenLink attributes
-  preload?: boolean
-  exact?: boolean
-  onClick?: (event?: MouseEvent) => void | boolean
-}
-
-/**
- * Handle link click - prevents default and uses SPA navigation
- * Respects target="_blank" and other standard anchor behaviors
- */
-function handleClick(event, el) {
-  // Ensure attributes are set from props
-  if (el) {
-    ensureAttributes(el)
-  }
-  
-  // Get target from the element attribute (more reliable than prop)
-  const linkTarget = el ? el.getAttribute('target') : (typeof target !== 'undefined' ? target : null)
-  
-  // If target is _blank, _parent, or _top, let browser handle it (opens in new tab/window)
-  if (linkTarget === '_blank' || linkTarget === '_parent' || linkTarget === '_top') {
-    // Let browser handle standard navigation
-    return
-  }
-  
-  // Allow modifier keys for native behavior (Cmd/Ctrl+click, etc.)
-  if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
-    return
-  }
-  
-  // Get href from element or prop
-  const linkHref = el ? el.getAttribute('href') : (typeof href !== 'undefined' ? href : null)
-  if (!linkHref) return
-  
-  // Check if external URL (http://, https://, //, mailto:, tel:, etc.)
-  if (linkHref.startsWith('http://') || 
-      linkHref.startsWith('https://') || 
-      linkHref.startsWith('//') ||
-      linkHref.startsWith('mailto:') ||
-      linkHref.startsWith('tel:') ||
-      linkHref.startsWith('javascript:')) {
-    // External/special link - open in new tab if target not specified
-    if (!linkTarget) {
-      el?.setAttribute('target', '_blank')
-      el?.setAttribute('rel', 'noopener noreferrer')
-    }
-    // Let browser handle it
-    return
-  }
-  
-  // Prevent default navigation for internal SPA links
-  event.preventDefault()
-  event.stopPropagation()
-  
-  // Call onClick prop if provided
-  if (typeof onClick === 'function') {
-    const result = onClick(event)
-    // If onClick returns false, cancel navigation
-    if (result === false) {
-      return
-    }
-  }
-  
-  // Normalize path for comparison
-  const normalizedHref = linkHref === '' ? '/' : linkHref
-  const currentPath = window.location.pathname === '' ? '/' : window.location.pathname
-  
-  // Only navigate if path is different (idempotent navigation)
-  if (normalizedHref !== currentPath) {
-    console.log('[ZenLink] Navigating to:', linkHref)
-    // Navigate using SPA router
-    if (window.__zenith_router && window.__zenith_router.navigate) {
-      console.log('[ZenLink] Using router.navigate')
-      window.__zenith_router.navigate(linkHref)
-    } else {
-      console.log('[ZenLink] Using fallback history API')
-      // Fallback to history API
-      window.history.pushState(null, '', linkHref)
-      window.dispatchEvent(new PopStateEvent('popstate'))
-    }
-  } else {
-    console.log('[ZenLink] Already on route:', linkHref, '- skipping navigation')
-  }
-}
-
-/**
- * Handle mouse enter for preloading
- */
-function handleMouseEnter(event, el) {
-  // Ensure attributes are set
-  if (el) {
-    ensureAttributes(el)
-  }
-  
-  const shouldPreload = typeof preload !== 'undefined' ? preload : false
-  console.log('[ZenLink] handleMouseEnter called, preload:', shouldPreload)
-  if (!shouldPreload) {
-    console.log('[ZenLink] Preload disabled, returning early')
-    return
-  }
-  
-  const linkHref = el ? el.getAttribute('href') : (typeof href !== 'undefined' ? href : null)
-  if (!linkHref) {
-    return
-  }
-  
-  // Skip external URLs
-  if (linkHref.startsWith('http://') || linkHref.startsWith('https://') || linkHref.startsWith('//')) {
-    return
-  }
-  
-  console.log('[ZenLink] Prefetch triggered on hover:', linkHref)
-  
-  // Prefetch the route
-  if (window.__zenith_router && window.__zenith_router.prefetch) {
-    console.log('[ZenLink] Calling router.prefetch for:', linkHref)
-    window.__zenith_router.prefetch(linkHref).then(() => {
-      console.log('[ZenLink] Prefetch complete for:', linkHref)
-    }).catch((error) => {
-      console.warn('[ZenLink] Prefetch failed for:', linkHref, error)
-    })
-  } else {
-    console.warn('[ZenLink] Router prefetch not available')
-  }
-}
-
-// Apply attributes on mount
-if (typeof zenOnMount !== 'undefined') {
-  zenOnMount(() => {
-    setTimeout(() => {
-      // Find all ZenLink anchor elements and apply attributes
-      document.querySelectorAll('a[data-zen-component="Zenlink"]').forEach(el => {
-        ensureAttributes(el)
-      })
-    }, 0)
-  })
-}
-
-/**
- * Apply standard anchor attributes from props to the element
- * Called when the element is clicked to ensure attributes are set
- */
-function ensureAttributes(el) {
-  if (!el) return
-  
-  // Set attributes from props (only if they exist and aren't already set)
-  const attrs = {
-    target: typeof target !== 'undefined' ? target : null,
-    rel: typeof rel !== 'undefined' ? rel : null,
-    download: typeof download !== 'undefined' ? download : null,
-    hreflang: typeof hreflang !== 'undefined' ? hreflang : null,
-    type: typeof type !== 'undefined' ? type : null,
-    ping: typeof ping !== 'undefined' ? ping : null,
-    referrerPolicy: typeof referrerPolicy !== 'undefined' ? referrerPolicy : null,
-    id: typeof id !== 'undefined' ? id : null,
-    title: typeof title !== 'undefined' ? title : null,
-    ariaLabel: typeof ariaLabel !== 'undefined' ? ariaLabel : null,
-    role: typeof role !== 'undefined' ? role : null,
-    tabIndex: typeof tabIndex !== 'undefined' ? tabIndex : null
-  }
-  
-  // Map to HTML attribute names
-  const htmlAttrs = {
-    target: 'target',
-    rel: 'rel',
-    download: 'download',
-    hreflang: 'hreflang',
-    type: 'type',
-    ping: 'ping',
-    referrerPolicy: 'referrerpolicy',
-    id: 'id',
-    title: 'title',
-    ariaLabel: 'aria-label',
-    role: 'role',
-    tabIndex: 'tabindex'
-  }
-  
-  // Set attributes that have values
-  for (const [prop, value] of Object.entries(attrs)) {
-    if (value !== null && value !== undefined && value !== '') {
-      const htmlAttr = htmlAttrs[prop]
-      if (htmlAttr && !el.hasAttribute(htmlAttr)) {
-        el.setAttribute(htmlAttr, String(value))
-      }
-    }
-  }
-}
-
-</script>
-
-<style>
-.zen-link {
-  color: inherit;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.zen-link:hover {
-  text-decoration: underline;
-}
-</style>
-
-<a 
-  href="{ href }"
-  class="zen-link { class }"
-  onclick="handleClick"
-  onmouseenter="handleMouseEnter"
-  style="cursor: pointer;"
->
-  <slot />
-</a>