@wireweave/core 1.0.0-beta.20260107130839 → 1.0.0-beta.20260107133417

package/src/parser/index.ts

@@ -1,214 +0,0 @@
-/**
- * Parser module for wireweave
- *
- * Provides parse function to convert wireframe DSL to AST
- */
-
-import type { WireframeDocument, SourceLocation } from '../ast/types';
-// @ts-expect-error - generated parser has no type declarations
-import { parse as peggyParse } from './generated-parser.js';
-
-/**
- * Parse options
- */
-export interface ParseOptions {
-  /** Starting rule (defaults to 'Document') */
-  startRule?: string;
-  /** Include source location in error messages */
-  includeLocation?: boolean;
-}
-
-/**
- * Expected token description from Peggy
- */
-export interface ExpectedToken {
-  type: string;
-  description?: string;
-  text?: string;
-}
-
-/**
- * Parse error with location information
- */
-export interface ParseError extends Error {
-  name: 'ParseError';
-  message: string;
-  location: SourceLocation;
-  expected: ExpectedToken[];
-  found: string | null;
-}
-
-/**
- * Peggy error structure
- */
-interface PeggyError {
-  message: string;
-  location: SourceLocation;
-  expected: ExpectedToken[];
-  found: string | null;
-}
-
-/**
- * Parse result for tryParse
- */
-export interface ParseResult {
-  success: boolean;
-  document: WireframeDocument | null;
-  errors: ParseErrorInfo[];
-}
-
-/**
- * Simplified error info
- */
-export interface ParseErrorInfo {
-  message: string;
-  location: {
-    line: number;
-    column: number;
-    offset?: number;
-  } | null;
-  expected?: string[];
-  found?: string | null;
-}
-
-/**
- * Parse wireframe DSL source code into AST
- *
- * @param source - wireweave source code
- * @param options - Parse options
- * @returns Parsed AST document
- * @throws {ParseError} When source contains syntax errors
- */
-export function parse(source: string, options?: ParseOptions): WireframeDocument {
-  try {
-    return peggyParse(source, options) as WireframeDocument;
-  } catch (error: unknown) {
-    throw enhanceError(error);
-  }
-}
-
-/**
- * Parse wireframe DSL with error recovery
- *
- * @param source - wireweave source code
- * @param options - Parse options
- * @returns Parse result with AST or errors
- */
-export function tryParse(source: string, options?: ParseOptions): ParseResult {
-  try {
-    const document = parse(source, options);
-    return { success: true, document, errors: [] };
-  } catch (error) {
-    const parseError = error as ParseError;
-    return {
-      success: false,
-      document: null,
-      errors: [
-        {
-          message: parseError.message,
-          location: parseError.location
-            ? {
-                line: parseError.location.start.line,
-                column: parseError.location.start.column,
-                offset: parseError.location.start.offset,
-              }
-            : null,
-          expected: parseError.expected?.map((e) => e.description || e.text || String(e)),
-          found: parseError.found,
-        },
-      ],
-    };
-  }
-}
-
-/**
- * Enhance Peggy error with better formatting
- */
-function enhanceError(error: unknown): ParseError {
-  if (error && typeof error === 'object' && 'location' in error) {
-    const pegError = error as PeggyError;
-    const enhanced = new Error(formatErrorMessage(pegError)) as ParseError;
-    enhanced.name = 'ParseError';
-    enhanced.location = pegError.location;
-    enhanced.expected = pegError.expected || [];
-    enhanced.found = pegError.found;
-    return enhanced;
-  }
-
-  // Re-throw non-Peggy errors
-  throw error;
-}
-
-/**
- * Format error message for better readability
- */
-function formatErrorMessage(error: PeggyError): string {
-  const { location, expected, found } = error;
-  const line = location?.start?.line ?? '?';
-  const column = location?.start?.column ?? '?';
-
-  // Format expected tokens
-  let expectedDesc = 'something';
-  if (expected && expected.length > 0) {
-    const descriptions = expected
-      .map((e) => e.description || e.text || String(e))
-      .filter((d, i, arr) => arr.indexOf(d) === i) // unique
-      .slice(0, 5); // limit to 5
-
-    if (descriptions.length === 1) {
-      expectedDesc = descriptions[0];
-    } else if (descriptions.length === 2) {
-      expectedDesc = `${descriptions[0]} or ${descriptions[1]}`;
-    } else {
-      const last = descriptions.pop();
-      expectedDesc = `${descriptions.join(', ')}, or ${last}`;
-    }
-
-    if (expected.length > 5) {
-      expectedDesc += ` (and ${expected.length - 5} more)`;
-    }
-  }
-
-  // Format found token
-  const foundDesc = found === null ? 'end of input' : `"${escapeString(found)}"`;
-
-  return `Syntax error at line ${line}, column ${column}: Expected ${expectedDesc} but found ${foundDesc}`;
-}
-
-/**
- * Escape special characters in string for display
- */
-function escapeString(str: string): string {
-  return str
-    .replace(/\\/g, '\\\\')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t')
-    .replace(/"/g, '\\"');
-}
-
-/**
- * Validate source code without throwing
- *
- * @param source - wireweave source code
- * @returns true if valid, false otherwise
- */
-export function isValid(source: string): boolean {
-  try {
-    parse(source);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get syntax errors from source code
- *
- * @param source - wireweave source code
- * @returns Array of error info, empty if valid
- */
-export function getErrors(source: string): ParseErrorInfo[] {
-  const result = tryParse(source);
-  return result.errors;
-}

package/src/renderer/html/base.ts

@@ -1,186 +0,0 @@
-/**
- * Base HTML Renderer for wireweave
- *
- * Provides abstract base class for HTML rendering with theme support
- */
-
-import type { WireframeDocument, AnyNode } from '../../ast/types';
-import type { RenderOptions, RenderResult, RenderContext, ThemeConfig } from '../types';
-import { defaultTheme, darkTheme } from '../types';
-import { generateStyles } from '../styles';
-
-/**
- * Default render options
- */
-const DEFAULT_OPTIONS: Required<RenderOptions> = {
-  theme: 'light',
-  scale: 1,
-  includeStyles: true,
-  minify: false,
-  classPrefix: 'wf',
-};
-
-/**
- * Abstract base renderer class
- *
- * Provides core infrastructure for HTML rendering:
- * - Theme management
- * - Indentation and formatting
- * - Depth tracking for nested elements
- */
-export abstract class BaseRenderer {
-  protected context: RenderContext;
-
-  constructor(options: RenderOptions = {}) {
-    const resolvedOptions: Required<RenderOptions> = {
-      ...DEFAULT_OPTIONS,
-      ...options,
-    };
-
-    this.context = {
-      options: resolvedOptions,
-      theme: this.buildTheme(resolvedOptions),
-      depth: 0,
-    };
-  }
-
-  /**
-   * Build theme configuration based on options
-   */
-  protected buildTheme(options: Required<RenderOptions>): ThemeConfig {
-    return options.theme === 'dark' ? { ...darkTheme } : { ...defaultTheme };
-  }
-
-  /**
-   * Render a wireframe document to HTML and CSS
-   */
-  render(document: WireframeDocument): RenderResult {
-    const html = this.renderDocument(document);
-    const css = this.context.options.includeStyles
-      ? generateStyles(this.context.theme, this.context.options.classPrefix)
-      : '';
-
-    return {
-      html: this.context.options.minify ? this.minifyHtml(html) : html,
-      css: this.context.options.minify ? this.minifyCss(css) : css,
-    };
-  }
-
-  /**
-   * Render a complete wireframe document
-   */
-  protected renderDocument(document: WireframeDocument): string {
-    const pages = document.children
-      .map((page) => this.renderPage(page))
-      .join(this.context.options.minify ? '' : '\n');
-
-    return pages;
-  }
-
-  /**
-   * Render a page node (to be implemented by subclasses)
-   */
-  protected abstract renderPage(node: AnyNode): string;
-
-  /**
-   * Render any AST node (to be implemented by subclasses)
-   */
-  protected abstract renderNode(node: AnyNode): string;
-
-  /**
-   * Get the CSS class prefix
-   */
-  protected get prefix(): string {
-    return this.context.options.classPrefix;
-  }
-
-  /**
-   * Add indentation based on current depth
-   */
-  protected indent(content: string): string {
-    if (this.context.options.minify) {
-      return content;
-    }
-
-    const spaces = '  '.repeat(this.context.depth);
-    return content
-      .split('\n')
-      .map((line) => (line.trim() ? spaces + line : line))
-      .join('\n');
-  }
-
-  /**
-   * Execute a function with increased depth
-   */
-  protected withDepth<T>(fn: () => T): T {
-    this.context.depth++;
-    const result = fn();
-    this.context.depth--;
-    return result;
-  }
-
-  /**
-   * Escape HTML special characters
-   */
-  protected escapeHtml(text: string): string {
-    const escapeMap: Record<string, string> = {
-      '&': '&amp;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      "'": '&#39;',
-    };
-
-    return text.replace(/[&<>"']/g, (char) => escapeMap[char] || char);
-  }
-
-  /**
-   * Build a CSS class string from an array of class names
-   */
-  protected buildClassString(classes: (string | undefined | false)[]): string {
-    return classes.filter(Boolean).join(' ');
-  }
-
-  /**
-   * Build HTML attributes string
-   */
-  protected buildAttrsString(attrs: Record<string, string | undefined | boolean>): string {
-    const parts: string[] = [];
-
-    for (const [key, value] of Object.entries(attrs)) {
-      if (value === undefined || value === false) {
-        continue;
-      }
-
-      if (value === true) {
-        parts.push(key);
-      } else {
-        parts.push(`${key}="${this.escapeHtml(value)}"`);
-      }
-    }
-
-    return parts.length > 0 ? ' ' + parts.join(' ') : '';
-  }
-
-  /**
-   * Simple HTML minification
-   */
-  private minifyHtml(html: string): string {
-    return html
-      .replace(/\n\s*/g, '')
-      .replace(/>\s+</g, '><')
-      .trim();
-  }
-
-  /**
-   * Simple CSS minification
-   */
-  private minifyCss(css: string): string {
-    return css
-      .replace(/\/\*[\s\S]*?\*\//g, '')
-      .replace(/\s+/g, ' ')
-      .replace(/\s*([{}:;,])\s*/g, '$1')
-      .replace(/;}/g, '}')
-      .trim();
-  }
-}