stylpp 1.0.0

package/src/compiler/generator.js

@@ -0,0 +1,157 @@
+/**
+ * STYL++ CSS Generator
+ * Converts the transformed AST into valid CSS output
+ * Supports minification, source maps, and vendor prefixes
+ */
+
+class StylppGenerator {
+  constructor(options = {}) {
+    this.options = {
+      minify: false,
+      sourceMap: false,
+      vendorPrefix: true,
+      ...options
+    };
+    this.css = '';
+    this.sourceMap = { version: 3, sources: [], mappings: '' };
+  }
+
+  /**
+   * Generate CSS from AST
+   * @param {Object} ast - Transformed AST
+   * @returns {string} CSS code
+   */
+  generate(ast) {
+    this.css = '';
+    this.generateRules(ast.rules, 0);
+
+    if (this.options.minify) {
+      this.css = this.minifyCSS(this.css);
+    }
+
+    return this.css;
+  }
+
+  /**
+   * Generate rules recursively
+   * @param {Array} rules - Rules array
+   * @param {number} indent - Indentation level
+   */
+  generateRules(rules, indent = 0) {
+    const indentStr = this.options.minify ? '' : '  '.repeat(indent);
+    const newline = this.options.minify ? '' : '\n';
+
+    rules.forEach(rule => {
+      if (rule.type === 'rule') {
+        this.css += `${indentStr}${rule.selector} {${newline}`;
+
+        // Add declarations
+        if (rule.declarations && rule.declarations.length > 0) {
+          rule.declarations.forEach(decl => {
+            const property = this.normalizeProperty(decl.property);
+            const value = this.normalizeValue(decl.value);
+            this.css += `${indentStr}  ${property}: ${value};${newline}`;
+
+            // Add vendor prefixes if needed
+            if (this.options.vendorPrefix) {
+              const prefixed = this.getVendorPrefixes(property, value);
+              prefixed.forEach(p => {
+                this.css += `${indentStr}  ${p.property}: ${p.value};${newline}`;
+              });
+            }
+          });
+        }
+
+        // Add nested rules
+        if (rule.rules && rule.rules.length > 0) {
+          this.generateRules(rule.rules, indent + 1);
+        }
+
+        this.css += `${indentStr}}${newline}`;
+      }
+    });
+  }
+
+  /**
+   * Normalize CSS property names (handle hyphenation)
+   * @param {string} property - Property name
+   * @returns {string} Normalized property
+   */
+  normalizeProperty(property) {
+    // Convert camelCase to kebab-case
+    return property.replace(/([A-Z])/g, '-$1').toLowerCase();
+  }
+
+  /**
+   * Normalize CSS values
+   * @param {string} value - Property value
+   * @returns {string} Normalized value
+   */
+  normalizeValue(value) {
+    // Remove extra whitespace
+    value = value.replace(/\s+/g, ' ').trim();
+
+    // Ensure calc() is properly formatted
+    if (value.includes('calc(')) {
+      value = value.replace(/calc\(\s+/g, 'calc(').replace(/\s+\)/g, ')');
+    }
+
+    return value;
+  }
+
+  /**
+   * Get vendor prefixes for a property
+   * @param {string} property - CSS property
+   * @param {string} value - CSS value
+   * @returns {Array} Vendor-prefixed versions
+   */
+  getVendorPrefixes(property, value) {
+    const prefixes = [];
+    const prefixMap = {
+      'transform': ['-webkit-transform', '-moz-transform', '-o-transform'],
+      'transition': ['-webkit-transition', '-moz-transition', '-o-transition'],
+      'box-shadow': ['-webkit-box-shadow'],
+      'border-radius': ['-webkit-border-radius'],
+      'gradient': ['-webkit-linear-gradient', '-moz-linear-gradient'],
+      'appearance': ['-webkit-appearance', '-moz-appearance'],
+      'user-select': ['-webkit-user-select', '-moz-user-select', '-ms-user-select']
+    };
+
+    Object.keys(prefixMap).forEach(key => {
+      if (property.includes(key)) {
+        prefixMap[key].forEach(prefixed => {
+          prefixes.push({ property: prefixed, value: value });
+        });
+      }
+    });
+
+    return prefixes;
+  }
+
+  /**
+   * Minify CSS
+   * @param {string} css - CSS code
+   * @returns {string} Minified CSS
+   */
+  minifyCSS(css) {
+    return css
+      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove comments
+      .replace(/\s+{/g, '{') // Remove spaces before {
+      .replace(/\s+}/g, '}') // Remove spaces before }
+      .replace(/;\s+/g, ';') // Remove spaces after ;
+      .replace(/:\s+/g, ':') // Remove spaces after :
+      .replace(/,\s+/g, ',') // Remove spaces after ,
+      .replace(/\n/g, '') // Remove newlines
+      .trim();
+  }
+
+  /**
+   * Generate source map
+   * @returns {Object} Source map object
+   */
+  generateSourceMap() {
+    return this.sourceMap;
+  }
+}
+
+module.exports = StylppGenerator;

package/src/compiler/index.js

@@ -0,0 +1,119 @@
+/**
+ * STYL++ Main Compiler
+ * Orchestrates parsing, transformation, and code generation
+ */
+
+const StylppParser = require('./parser');
+const StylppTransformer = require('./transformer');
+const StylppGenerator = require('./generator');
+
+class StylppCompiler {
+  constructor(options = {}) {
+    this.options = {
+      minify: false,
+      sourceMap: false,
+      vendorPrefix: true,
+      ...options
+    };
+    
+    this.parser = new StylppParser();
+    this.transformer = new StylppTransformer();
+    this.generator = new StylppGenerator(this.options);
+  }
+
+  /**
+   * Compile STYL++ code to CSS
+   * @param {string} code - STYL++ source code
+   * @param {string} filename - Source filename (for error reporting)
+   * @returns {Object} Compilation result
+   */
+  compile(code, filename = 'input.stylpp') {
+    try {
+      // Phase 1: Parse
+      const ast = this.parser.parse(code);
+
+      if (this.parser.errors.length > 0) {
+        return {
+          success: false,
+          css: '',
+          ast: null,
+          errors: this.parser.errors,
+          filename
+        };
+      }
+
+      // Phase 2: Transform
+      const transformedAst = this.transformer.transform(ast);
+
+      if (this.transformer.errors.length > 0) {
+        return {
+          success: false,
+          css: '',
+          ast: ast,
+          transformedAst: null,
+          errors: this.transformer.errors,
+          filename
+        };
+      }
+
+      // Phase 3: Generate
+      const css = this.generator.generate(transformedAst);
+
+      // Optional: Generate source map
+      let sourceMap = null;
+      if (this.options.sourceMap) {
+        sourceMap = this.generator.generateSourceMap();
+      }
+
+      return {
+        success: true,
+        css: css,
+        ast: ast,
+        transformedAst: transformedAst,
+        sourceMap: sourceMap,
+        errors: [],
+        filename
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        css: '',
+        ast: null,
+        transformedAst: null,
+        errors: [{
+          type: 'CompileError',
+          message: error.message,
+          stack: error.stack,
+          filename
+        }],
+        filename
+      };
+    }
+  }
+
+  /**
+   * Check if code is valid without compiling
+   * @param {string} code - STYL++ source code
+   * @returns {Object} Validation result
+   */
+  validate(code) {
+    try {
+      const ast = this.parser.parse(code);
+      return {
+        valid: true,
+        errors: []
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [{
+          message: error.message,
+          line: error.line
+        }]
+      };
+    }
+  }
+}
+
+module.exports = StylppCompiler;

package/src/compiler/parser.js

@@ -0,0 +1,210 @@
+/**
+ * STYL++ Parser
+ * Converts STYL++ source code into an Abstract Syntax Tree (AST)
+ * Handles semicolon-based indentation and property-value parsing
+ */
+
+class StylppParser {
+  constructor(options = {}) {
+    this.options = options;
+    this.errors = [];
+  }
+
+  /**
+   * Parse STYL++ code and return AST
+   * @param {string} code - STYL++ source code
+   * @returns {Object} AST
+   */
+  parse(code) {
+    const lines = code.split('\n');
+    const ast = {
+      type: 'stylesheet',
+      rules: [],
+      variables: {}
+    };
+
+    let currentIndent = 0;
+    const stack = [];
+
+    for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+      const line = lines[lineNumber];
+      const trimmed = line.trim();
+
+      // Skip empty lines
+      if (!trimmed) continue;
+
+      // Skip comment lines (start with ; at beginning)
+      if (trimmed.startsWith(';') && !trimmed.match(/^\s*;\s*\w+/)) continue;
+
+      // Count leading semicolons for indentation
+      const indentMatch = line.match(/^(;*)/);
+      const indentLevel = indentMatch ? indentMatch[0].length : 0;
+      const content = line.substring(indentLevel).trim();
+
+      // Skip empty content
+      if (!content) continue;
+
+      // Handle variables section
+      if (content === 'variables;' || content === 'variables') {
+        const variablesSection = this.parseVariablesSection(lines, lineNumber + 1);
+        ast.variables = variablesSection.variables;
+        lineNumber = variablesSection.endLine;
+        continue;
+      }
+
+      // Handle property-value pairs
+      if (content.endsWith(';') && indentLevel > 0) {
+        const propValue = this.parseProperty(content);
+        if (propValue && stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          if (!parent.declarations) parent.declarations = [];
+          parent.declarations.push(propValue);
+        }
+        continue;
+      }
+
+      // Handle rules/selectors
+      const selector = content.replace(/;$/, '');
+      const newRule = {
+        type: 'rule',
+        selector: selector,
+        declarations: [],
+        rules: []
+      };
+
+      // Manage indentation stack
+      if (indentLevel > currentIndent) {
+        // Nested rule
+        if (stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent.rules.push(newRule);
+        }
+        stack.push(newRule);
+      } else if (indentLevel < currentIndent) {
+        // Pop stack until we reach the right level
+        const popCount = (currentIndent - indentLevel);
+        for (let i = 0; i < popCount; i++) {
+          stack.pop();
+        }
+        if (stack.length > 0) {
+          const parent = stack[stack.length - 1];
+          parent.rules.push(newRule);
+        } else {
+          ast.rules.push(newRule);
+        }
+        stack.push(newRule);
+      } else {
+        // Same level
+        if (stack.length > 0) {
+          stack.pop();
+          if (stack.length > 0) {
+            const parent = stack[stack.length - 1];
+            parent.rules.push(newRule);
+          } else {
+            ast.rules.push(newRule);
+          }
+        } else {
+          ast.rules.push(newRule);
+        }
+        stack.push(newRule);
+      }
+
+      currentIndent = indentLevel;
+    }
+
+    return ast;
+  }
+
+  /**
+   * Parse variables section
+   * @param {Array} lines - All code lines
+   * @param {number} startLine - Starting line number
+   * @returns {Object} Variables and end line
+   */
+  parseVariablesSection(lines, startLine) {
+    const variables = {};
+    let endLine = startLine;
+
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      if (!trimmed || trimmed.startsWith(';')) continue;
+
+      // Check if we've exited the variables section
+      const leadingSemicolons = line.match(/^(;*)/)[0].length;
+      if (leadingSemicolons === 0 && trimmed && !trimmed.match(/^\w+\s+/)) {
+        break;
+      }
+
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 2) {
+        const name = parts[0];
+        const value = parts.slice(1).join(' ').replace(/;$/, '');
+        variables[name] = value;
+        endLine = i;
+      } else {
+        break;
+      }
+    }
+
+    return { variables, endLine };
+  }
+
+  /**
+   * Parse a property-value pair
+   * @param {string} content - Property-value string (e.g., "background white;")
+   * @returns {Object} Declaration object
+   */
+  parseProperty(content) {
+    // Remove trailing semicolon
+    const cleaned = content.replace(/;$/, '').trim();
+    
+    // Split by first space to separate property from value
+    const spaceIndex = cleaned.indexOf(' ');
+    if (spaceIndex === -1) return null;
+
+    const property = cleaned.substring(0, spaceIndex);
+    const value = cleaned.substring(spaceIndex + 1);
+
+    return {
+      type: 'declaration',
+      property: property,
+      value: value
+    };
+  }
+
+  /**
+   * Parse for loop syntax: for i in 1 to 5;
+   * @param {string} content - For loop declaration
+   * @returns {Object} Loop object or null
+   */
+  parseForLoop(content) {
+    const match = content.match(/for\s+(\w+)\s+in\s+([\d\w]+)\s+to\s+([\d\w]+)/);
+    if (!match) return null;
+
+    return {
+      type: 'for-loop',
+      variable: match[1],
+      from: parseInt(match[2]),
+      to: parseInt(match[3])
+    };
+  }
+
+  /**
+   * Parse if/conditional syntax: if condition;
+   * @param {string} content - If statement
+   * @returns {Object} Conditional object or null
+   */
+  parseConditional(content) {
+    const match = content.match(/@(\w+)/);
+    if (!match) return null;
+
+    return {
+      type: 'conditional',
+      condition: match[1]
+    };
+  }
+}
+
+module.exports = StylppParser;