@luna_ui/luna 0.11.0 → 0.17.0

package/src/css-optimizer/pattern.ts

@@ -1,171 +0,0 @@
-/**
- * Frequent pattern mining for CSS classes
- */
-
-import type { ClassUsage, MergePattern } from "./types.js";
-
-/**
- * Find frequent patterns (sets of classes that often appear together)
- * Uses a greedy enumeration approach for small pattern sizes
- */
-export function findFrequentPatterns(
-  usages: ClassUsage[],
-  minFrequency: number,
-  maxSize: number
-): MergePattern[] {
-  // Count all class set patterns
-  const patternCounts = new Map<string, number>();
-
-  for (const usage of usages) {
-    const classes = [...usage.classes].sort();
-    const n = classes.length;
-
-    // Count pairs (size 2)
-    for (let i = 0; i < n; i++) {
-      for (let j = i + 1; j < n; j++) {
-        const key = `${classes[i]}|${classes[j]}`;
-        patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
-      }
-    }
-
-    // Count triples (size 3)
-    if (maxSize >= 3) {
-      for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-          for (let k = j + 1; k < n; k++) {
-            const key = `${classes[i]}|${classes[j]}|${classes[k]}`;
-            patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
-          }
-        }
-      }
-    }
-
-    // Count quadruples (size 4)
-    if (maxSize >= 4) {
-      for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-          for (let k = j + 1; k < n; k++) {
-            for (let l = k + 1; l < n; l++) {
-              const key = `${classes[i]}|${classes[j]}|${classes[k]}|${classes[l]}`;
-              patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
-            }
-          }
-        }
-      }
-    }
-
-    // Count quintuples (size 5)
-    if (maxSize >= 5) {
-      for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-          for (let k = j + 1; k < n; k++) {
-            for (let l = k + 1; l < n; l++) {
-              for (let m = l + 1; m < n; m++) {
-                const key = `${classes[i]}|${classes[j]}|${classes[k]}|${classes[l]}|${classes[m]}`;
-                patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Filter by min frequency and create patterns
-  const patterns: MergePattern[] = [];
-
-  for (const [key, frequency] of patternCounts) {
-    if (frequency >= minFrequency) {
-      const originalClasses = key.split("|");
-      const classCount = originalClasses.length;
-
-      // Estimate savings:
-      // HTML: each class is ~6 chars + space, merged saves (n-1) * 7 * frequency
-      // CSS: each rule is ~25 bytes, merged saves (n-1) * 25
-      const htmlSavings = (classCount - 1) * 7 * frequency;
-      const cssSavings = (classCount - 1) * 25;
-      const bytesSaved = htmlSavings + cssSavings;
-
-      patterns.push({
-        originalClasses,
-        mergedClass: "", // Will be set during merge
-        declarations: [], // Will be set during merge
-        frequency,
-        bytesSaved,
-      });
-    }
-  }
-
-  // Sort by bytes saved descending
-  patterns.sort((a, b) => b.bytesSaved - a.bytesSaved);
-
-  // Remove subsumed patterns
-  return removeSubsumedPatterns(patterns);
-}
-
-/**
- * Remove patterns that are subsets of larger patterns with similar frequency
- * This prevents double-counting savings
- */
-export function removeSubsumedPatterns(patterns: MergePattern[]): MergePattern[] {
-  const result: MergePattern[] = [];
-
-  for (let i = 0; i < patterns.length; i++) {
-    const pattern = patterns[i];
-    let isDominated = false;
-
-    for (let j = 0; j < patterns.length; j++) {
-      if (i === j) continue;
-
-      const other = patterns[j];
-      // Check if other is a superset with similar or higher frequency (80% threshold)
-      if (
-        other.originalClasses.length > pattern.originalClasses.length &&
-        other.frequency >= pattern.frequency * 0.8
-      ) {
-        const patternSet = new Set(pattern.originalClasses);
-        const otherSet = new Set(other.originalClasses);
-
-        // Check if pattern is subset of other
-        let isSubset = true;
-        for (const cls of patternSet) {
-          if (!otherSet.has(cls)) {
-            isSubset = false;
-            break;
-          }
-        }
-
-        if (isSubset) {
-          isDominated = true;
-          break;
-        }
-      }
-    }
-
-    if (!isDominated) {
-      result.push(pattern);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Group usages by their exact class set
- * Returns a map from sorted class key to array of usages
- */
-export function groupByClassSet(
-  usages: ClassUsage[]
-): Map<string, ClassUsage[]> {
-  const groups = new Map<string, ClassUsage[]>();
-
-  for (const usage of usages) {
-    const key = [...usage.classes].sort().join("|");
-    if (!groups.has(key)) {
-      groups.set(key, []);
-    }
-    groups.get(key)!.push(usage);
-  }
-
-  return groups;
-}

package/src/css-optimizer/transformers.ts

@@ -1,301 +0,0 @@
-/**
- * CSS Co-occurrence Optimizer - Transformers
- *
- * Pluggable output transformation strategies for different formats.
- * Each transformer applies merge maps to source content.
- */
-
-/**
- * Transformer interface - implement this for custom output formats
- */
-export interface ClassTransformer {
-  /** Transformer name for debugging */
-  name: string;
-
-  /**
-   * Transform content by applying merge map
-   * @param content - Source content to transform
-   * @param mergeMap - Mapping from "class1 class2" to "merged_class"
-   * @param options - Transformer-specific options
-   */
-  transform(
-    content: string,
-    mergeMap: Map<string, string>,
-    options?: TransformerOptions
-  ): string;
-}
-
-/**
- * Common transformer options
- */
-export interface TransformerOptions {
-  /** Class prefix for identifying mergeable classes (default: "_") */
-  classPrefix?: string;
-}
-
-/**
- * HTML Transformer
- *
- * Transforms HTML by replacing class="" attribute values with merged classes.
- */
-export class HtmlTransformer implements ClassTransformer {
-  name = "html";
-
-  private pattern = /class\s*=\s*"([^"]+)"/g;
-
-  transform(
-    content: string,
-    mergeMap: Map<string, string>,
-    options: TransformerOptions = {}
-  ): string {
-    if (mergeMap.size === 0) {
-      return content;
-    }
-
-    const { classPrefix = "_" } = options;
-
-    // Sort merge keys by length descending (longer patterns first)
-    const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
-
-    return content.replace(this.pattern, (match, classValue) => {
-      const classes = classValue.trim().split(/\s+/);
-      const prefixedClasses = classes.filter((c: string) => c.startsWith(classPrefix));
-      const otherClasses = classes.filter((c: string) => !c.startsWith(classPrefix));
-
-      // Sort for consistent matching
-      prefixedClasses.sort();
-
-      let result = [...prefixedClasses];
-      const merged: string[] = [];
-
-      // Apply each merge pattern
-      for (const key of sortedKeys) {
-        const patternClasses = key.split(" ");
-        const mergedClass = mergeMap.get(key)!;
-
-        // Check if all pattern classes are present
-        let allPresent = true;
-        for (const cls of patternClasses) {
-          if (!result.includes(cls)) {
-            allPresent = false;
-            break;
-          }
-        }
-
-        if (allPresent) {
-          result = result.filter((c) => !patternClasses.includes(c));
-          merged.push(mergedClass);
-        }
-      }
-
-      const finalClasses = [...merged, ...result, ...otherClasses].join(" ");
-      return `class="${finalClasses}"`;
-    });
-  }
-}
-
-/**
- * JSX Transformer
- *
- * Transforms JSX/TSX by replacing className attribute values.
- */
-export class JsxTransformer implements ClassTransformer {
-  name = "jsx";
-
-  private stringPattern = /className\s*=\s*"([^"]+)"/g;
-
-  transform(
-    content: string,
-    mergeMap: Map<string, string>,
-    options: TransformerOptions = {}
-  ): string {
-    if (mergeMap.size === 0) {
-      return content;
-    }
-
-    const { classPrefix = "_" } = options;
-    const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
-
-    return content.replace(this.stringPattern, (match, classValue) => {
-      const classes = classValue.trim().split(/\s+/);
-      const prefixedClasses = classes.filter((c: string) => c.startsWith(classPrefix));
-      const otherClasses = classes.filter((c: string) => !c.startsWith(classPrefix));
-
-      prefixedClasses.sort();
-
-      let result = [...prefixedClasses];
-      const merged: string[] = [];
-
-      for (const key of sortedKeys) {
-        const patternClasses = key.split(" ");
-        const mergedClass = mergeMap.get(key)!;
-
-        let allPresent = true;
-        for (const cls of patternClasses) {
-          if (!result.includes(cls)) {
-            allPresent = false;
-            break;
-          }
-        }
-
-        if (allPresent) {
-          result = result.filter((c) => !patternClasses.includes(c));
-          merged.push(mergedClass);
-        }
-      }
-
-      const finalClasses = [...merged, ...result, ...otherClasses].join(" ");
-      return `className="${finalClasses}"`;
-    });
-  }
-}
-
-/**
- * Svelte Transformer
- *
- * Transforms Svelte templates by replacing class attribute values.
- * Preserves dynamic {expression} syntax.
- */
-export class SvelteTransformer implements ClassTransformer {
-  name = "svelte";
-
-  private pattern = /class\s*=\s*"([^"]+)"/g;
-
-  transform(
-    content: string,
-    mergeMap: Map<string, string>,
-    options: TransformerOptions = {}
-  ): string {
-    if (mergeMap.size === 0) {
-      return content;
-    }
-
-    const { classPrefix = "_" } = options;
-    const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
-
-    return content.replace(this.pattern, (match, classValue) => {
-      // Preserve dynamic expressions
-      const expressions: string[] = [];
-      const cleanValue = classValue.replace(/\{[^}]+\}/g, (expr: string) => {
-        expressions.push(expr);
-        return `__EXPR_${expressions.length - 1}__`;
-      });
-
-      const classes = cleanValue.trim().split(/\s+/);
-      const prefixedClasses = classes.filter(
-        (c: string) => c.startsWith(classPrefix) && !c.startsWith("__EXPR_")
-      );
-      const otherClasses = classes.filter(
-        (c: string) => !c.startsWith(classPrefix) || c.startsWith("__EXPR_")
-      );
-
-      prefixedClasses.sort();
-
-      let result = [...prefixedClasses];
-      const merged: string[] = [];
-
-      for (const key of sortedKeys) {
-        const patternClasses = key.split(" ");
-        const mergedClass = mergeMap.get(key)!;
-
-        let allPresent = true;
-        for (const cls of patternClasses) {
-          if (!result.includes(cls)) {
-            allPresent = false;
-            break;
-          }
-        }
-
-        if (allPresent) {
-          result = result.filter((c) => !patternClasses.includes(c));
-          merged.push(mergedClass);
-        }
-      }
-
-      let finalClasses = [...merged, ...result, ...otherClasses].join(" ");
-
-      // Restore expressions
-      expressions.forEach((expr, i) => {
-        finalClasses = finalClasses.replace(`__EXPR_${i}__`, expr);
-      });
-
-      return `class="${finalClasses}"`;
-    });
-  }
-}
-
-/**
- * Multi-format transformer
- *
- * Automatically selects the appropriate transformer based on content or file type.
- */
-export class MultiTransformer implements ClassTransformer {
-  name = "multi";
-
-  private transformers: Map<string, ClassTransformer>;
-
-  constructor() {
-    this.transformers = new Map<string, ClassTransformer>([
-      ["html", new HtmlTransformer()],
-      ["jsx", new JsxTransformer()],
-      ["tsx", new JsxTransformer()],
-      ["svelte", new SvelteTransformer()],
-    ]);
-  }
-
-  /**
-   * Register a custom transformer for a file extension
-   */
-  register(extension: string, transformer: ClassTransformer): void {
-    this.transformers.set(extension, transformer);
-  }
-
-  transform(
-    content: string,
-    mergeMap: Map<string, string>,
-    options?: TransformerOptions
-  ): string {
-    // Default to HTML transformer
-    const htmlTransformer = this.transformers.get("html")!;
-    return htmlTransformer.transform(content, mergeMap, options);
-  }
-
-  /**
-   * Transform with explicit file type
-   */
-  transformWithType(
-    content: string,
-    mergeMap: Map<string, string>,
-    fileType: string,
-    options?: TransformerOptions
-  ): string {
-    const transformer =
-      this.transformers.get(fileType) || this.transformers.get("html")!;
-    return transformer.transform(content, mergeMap, options);
-  }
-
-  /**
-   * Transform multiple files
-   */
-  transformFiles(
-    files: Array<{ content: string; path: string }>,
-    mergeMap: Map<string, string>,
-    options?: TransformerOptions
-  ): Array<{ content: string; path: string }> {
-    return files.map((file) => {
-      const ext = file.path.split(".").pop() || "html";
-      const transformer =
-        this.transformers.get(ext) || this.transformers.get("html")!;
-      return {
-        path: file.path,
-        content: transformer.transform(file.content, mergeMap, options),
-      };
-    });
-  }
-}
-
-// Default transformers
-export const htmlTransformer = new HtmlTransformer();
-export const jsxTransformer = new JsxTransformer();
-export const svelteTransformer = new SvelteTransformer();
-export const multiTransformer = new MultiTransformer();

package/src/css-optimizer/types.ts

@@ -1,128 +0,0 @@
-/**
- * CSS Co-occurrence Optimizer Types
- * Standalone types for CSS class optimization based on co-occurrence analysis
- */
-
-/**
- * Represents a set of classes used together on an HTML element
- */
-export interface ClassUsage {
-  /** Array of class names used on the element */
-  classes: string[];
-  /** Source location for debugging (e.g., "file.html:42") */
-  source: string;
-}
-
-/**
- * Co-occurrence pair with frequency count
- */
-export interface CoOccurrence {
-  /** First class name (alphabetically) */
-  classA: string;
-  /** Second class name (alphabetically) */
-  classB: string;
-  /** Number of times these classes appear together */
-  frequency: number;
-}
-
-/**
- * A pattern of classes that frequently appear together
- */
-export interface MergePattern {
-  /** Original class names to merge */
-  originalClasses: string[];
-  /** New merged class name (generated) */
-  mergedClass: string;
-  /** Combined CSS declarations */
-  declarations: string[];
-  /** How many times this pattern appears in HTML */
-  frequency: number;
-  /** Estimated bytes saved by merging */
-  bytesSaved: number;
-}
-
-/**
- * Result of CSS optimization
- */
-export interface OptimizeResult {
-  /** Optimized CSS output */
-  css: string;
-  /** Mapping from original class combination to merged class */
-  mergeMap: Map<string, string>;
-  /** Patterns that were merged */
-  patterns: MergePattern[];
-  /** Optimization statistics */
-  stats: {
-    /** Number of original unique classes */
-    originalClasses: number;
-    /** Number of patterns merged */
-    mergedPatterns: number;
-    /** Estimated bytes saved */
-    estimatedBytesSaved: number;
-  };
-}
-
-/**
- * Options for CSS optimization
- */
-export interface OptimizeOptions {
-  /** Minimum frequency for a pattern to be considered (default: 2) */
-  minFrequency?: number;
-  /** Maximum pattern size to consider (default: 5) */
-  maxPatternSize?: number;
-  /** Class name prefix filter (only classes starting with this will be optimized) */
-  classPrefix?: string;
-  /** Pretty print CSS output */
-  pretty?: boolean;
-  /** Enable verbose logging */
-  verbose?: boolean;
-}
-
-/**
- * Function to generate class names from declarations
- */
-export type ClassNameGenerator = (decl: string) => string;
-
-/**
- * CSS rule with selector and declarations
- */
-export interface CssRule {
-  selector: string;
-  declarations: string;
-}
-
-// =============================================================================
-// MoonBit Static Analyzer Types
-// =============================================================================
-
-/**
- * CSS class co-occurrence detected in MoonBit source
- */
-export interface ClassCooccurrence {
-  /** CSS declarations (e.g., ["color:red", "font-size:16px"]) */
-  classes: string[];
-  /** Source file path */
-  file: string;
-  /** Line number in source */
-  line: number;
-  /** Whether this can be statically analyzed (no conditionals) */
-  isStatic: boolean;
-}
-
-/**
- * Warning from static analyzer about non-analyzable patterns
- */
-export interface AnalyzerWarning {
-  /** Warning type */
-  kind:
-    | "dynamic_conditional"
-    | "dynamic_function_call"
-    | "untraceable_variable"
-    | "dynamic_array_construction";
-  /** Source file path */
-  file: string;
-  /** Line number in source */
-  line: number;
-  /** Human-readable warning message */
-  message: string;
-}