scss-variable-extractor 1.1.0 → 1.4.0

package/src/angular-parser.js

@@ -0,0 +1,381 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parses angular.json to extract project configuration
+ * @param {string} angularJsonPath - Path to angular.json file
+ * @returns {Object} - Parsed Angular configuration
+ */
+function parseAngularJson(angularJsonPath = null) {
+  // Find angular.json
+  const possiblePaths = [
+    angularJsonPath,
+    'angular.json',
+    path.join(process.cwd(), 'angular.json')
+  ].filter(Boolean);
+
+  let angularJsonFile = null;
+  for (const filePath of possiblePaths) {
+    if (fs.existsSync(filePath)) {
+      angularJsonFile = filePath;
+      break;
+    }
+  }
+
+  if (!angularJsonFile) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(angularJsonFile, 'utf8');
+    const angularJson = JSON.parse(content);
+    
+    return {
+      raw: angularJson,
+      projects: extractProjects(angularJson),
+      defaultProject: angularJson.defaultProject || null,
+      version: angularJson.version || 1,
+      cli: angularJson.cli || {},
+      schematics: angularJson.schematics || {}
+    };
+  } catch (error) {
+    console.warn(`Warning: Could not parse angular.json: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Extracts project information from angular.json
+ * @param {Object} angularJson - Parsed angular.json
+ * @returns {Array} - Array of project configurations
+ */
+function extractProjects(angularJson) {
+  const projects = [];
+  
+  if (!angularJson.projects) {
+    return projects;
+  }
+
+  Object.entries(angularJson.projects).forEach(([name, config]) => {
+    const projectInfo = {
+      name,
+      type: config.projectType || 'application',
+      root: config.root || '',
+      sourceRoot: config.sourceRoot || path.join(config.root || '', 'src'),
+      prefix: config.prefix || 'app',
+      stylePreprocessor: getStylePreprocessor(config),
+      styleExt: getStyleExtension(config),
+      inlineStyle: getInlineStyle(config),
+      inlineTemplate: getInlineTemplate(config),
+      architect: config.architect || {},
+      schematics: config.schematics || {}
+    };
+
+    projects.push(projectInfo);
+  });
+
+  return projects;
+}
+
+/**
+ * Gets the style preprocessor from project config
+ * @param {Object} projectConfig - Project configuration
+ * @returns {string} - Style preprocessor (scss, sass, less, css)
+ */
+function getStylePreprocessor(projectConfig) {
+  // Check schematics first
+  if (projectConfig.schematics) {
+    const componentSchematics = 
+      projectConfig.schematics['@schematics/angular:component'] ||
+      projectConfig.schematics['@angular/material:component'] ||
+      {};
+    
+    if (componentSchematics.style) {
+      return componentSchematics.style;
+    }
+    
+    if (componentSchematics.styleext) {
+      return componentSchematics.styleext;
+    }
+  }
+
+  // Check architect build options
+  if (projectConfig.architect && projectConfig.architect.build) {
+    const buildOptions = projectConfig.architect.build.options || {};
+    
+    if (buildOptions.stylePreprocessorOptions) {
+      // Try to infer from includePaths or other indicators
+      const styles = buildOptions.styles || [];
+      for (const style of styles) {
+        const styleStr = typeof style === 'string' ? style : style.input || '';
+        if (styleStr.endsWith('.scss')) return 'scss';
+        if (styleStr.endsWith('.sass')) return 'sass';
+        if (styleStr.endsWith('.less')) return 'less';
+      }
+    }
+    
+    // Check styles array
+    const styles = buildOptions.styles || [];
+    for (const style of styles) {
+      const styleStr = typeof style === 'string' ? style : style.input || '';
+      if (styleStr.endsWith('.scss')) return 'scss';
+      if (styleStr.endsWith('.sass')) return 'sass';
+      if (styleStr.endsWith('.less')) return 'less';
+    }
+  }
+
+  return 'scss'; // Default
+}
+
+/**
+ * Gets the style file extension
+ * @param {Object} projectConfig - Project configuration
+ * @returns {string} - File extension
+ */
+function getStyleExtension(projectConfig) {
+  const preprocessor = getStylePreprocessor(projectConfig);
+  return preprocessor === 'css' ? 'css' : preprocessor;
+}
+
+/**
+ * Gets the inline style preference
+ * @param {Object} projectConfig - Project configuration
+ * @returns {boolean} - Whether to use inline styles
+ */
+function getInlineStyle(projectConfig) {
+  if (projectConfig.schematics) {
+    const componentSchematics = 
+      projectConfig.schematics['@schematics/angular:component'] ||
+      projectConfig.schematics['@angular/material:component'] ||
+      {};
+    
+    return componentSchematics.inlineStyle === true;
+  }
+  return false;
+}
+
+/**
+ * Gets the inline template preference
+ * @param {Object} projectConfig - Project configuration
+ * @returns {boolean} - Whether to use inline templates
+ */
+function getInlineTemplate(projectConfig) {
+  if (projectConfig.schematics) {
+    const componentSchematics = 
+      projectConfig.schematics['@schematics/angular:component'] ||
+      projectConfig.schematics['@angular/material:component'] ||
+      {};
+    
+    return componentSchematics.inlineTemplate === true;
+  }
+  return false;
+}
+
+/**
+ * Gets project by name
+ * @param {Object} angularConfig - Parsed Angular configuration
+ * @param {string} projectName - Project name
+ * @returns {Object|null} - Project configuration
+ */
+function getProject(angularConfig, projectName) {
+  if (!angularConfig || !angularConfig.projects) {
+    return null;
+  }
+  
+  return angularConfig.projects.find(p => p.name === projectName) || null;
+}
+
+/**
+ * Gets the default project
+ * @param {Object} angularConfig - Parsed Angular configuration
+ * @returns {Object|null} - Default project configuration
+ */
+function getDefaultProject(angularConfig) {
+  if (!angularConfig) {
+    return null;
+  }
+  
+  if (angularConfig.defaultProject) {
+    const project = getProject(angularConfig, angularConfig.defaultProject);
+    if (project) return project;
+  }
+  
+  // Return first project if no default specified
+  return angularConfig.projects && angularConfig.projects.length > 0 
+    ? angularConfig.projects[0] 
+    : null;
+}
+
+/**
+ * Detects the source directory for a project
+ * @param {Object} angularConfig - Parsed Angular configuration
+ * @param {string} projectName - Project name (optional)
+ * @returns {string|null} - Source directory path
+ */
+function detectSourceDirectory(angularConfig, projectName = null) {
+  if (!angularConfig) {
+    return null;
+  }
+  
+  let project;
+  if (projectName) {
+    project = getProject(angularConfig, projectName);
+  } else {
+    project = getDefaultProject(angularConfig);
+  }
+  
+  if (!project) {
+    return null;
+  }
+  
+  return project.sourceRoot || path.join(project.root || '', 'src');
+}
+
+/**
+ * Gets global style files from angular.json
+ * @param {Object} angularConfig - Parsed Angular configuration
+ * @param {string} projectName - Project name (optional)
+ * @returns {Array<string>} - Array of global style file paths
+ */
+function getGlobalStyleFiles(angularConfig, projectName = null) {
+  if (!angularConfig) {
+    return [];
+  }
+  
+  let project;
+  if (projectName) {
+    project = getProject(angularConfig, projectName);
+  } else {
+    project = getDefaultProject(angularConfig);
+  }
+  
+  if (!project || !project.architect || !project.architect.build) {
+    return [];
+  }
+  
+  const buildOptions = project.architect.build.options || {};
+  const styles = buildOptions.styles || [];
+  
+  return styles.map(style => {
+    if (typeof style === 'string') {
+      return style;
+    }
+    return style.input || '';
+  }).filter(Boolean);
+}
+
+/**
+ * Generates enhanced configuration based on angular.json
+ * @param {string} angularJsonPath - Path to angular.json
+ * @param {Object} baseConfig - Base configuration
+ * @param {string} projectName - Project name (optional)
+ * @returns {Object} - Enhanced configuration
+ */
+function enhanceConfigFromAngularJson(angularJsonPath, baseConfig = {}, projectName = null) {
+  const angularConfig = parseAngularJson(angularJsonPath);
+  
+  if (!angularConfig) {
+    return baseConfig;
+  }
+  
+  let project;
+  if (projectName) {
+    project = getProject(angularConfig, projectName);
+  } else {
+    project = getDefaultProject(angularConfig);
+  }
+  
+  if (!project) {
+    return baseConfig;
+  }
+  
+  const enhanced = { ...baseConfig };
+  
+  // Set source directory if not already set
+  if (!enhanced.src) {
+    enhanced.src = detectSourceDirectory(angularConfig, projectName);
+  }
+  
+  // Set output based on global styles
+  if (!enhanced.output) {
+    const globalStyles = getGlobalStyleFiles(angularConfig, projectName);
+    if (globalStyles.length > 0) {
+      // Find scss/sass file in global styles
+      const scssFile = globalStyles.find(s => s.endsWith('.scss') || s.endsWith('.sass'));
+      if (scssFile) {
+        // Extract directory and create variables file path
+        const dir = path.dirname(scssFile);
+        enhanced.output = path.join(dir, '_variables.scss');
+      }
+    }
+  }
+  
+  // Add Angular-specific metadata
+  enhanced.angular = {
+    project: project.name,
+    prefix: project.prefix,
+    stylePreprocessor: project.stylePreprocessor,
+    styleExt: project.styleExt,
+    inlineStyle: project.inlineStyle,
+    sourceRoot: project.sourceRoot,
+    root: project.root
+  };
+  
+  // Adjust ignore patterns based on Angular structure
+  const angularIgnorePatterns = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/.angular/**',
+    '**/out-tsc/**',
+    '**/_variables.scss',
+    '**/styles.scss', // Don't refactor main styles.scss
+    '**/theme.scss'   // Don't refactor theme files
+  ];
+  
+  if (!enhanced.ignore || enhanced.ignore.length === 0) {
+    enhanced.ignore = angularIgnorePatterns;
+  } else {
+    // Merge ignore patterns
+    enhanced.ignore = [...new Set([...enhanced.ignore, ...angularIgnorePatterns])];
+  }
+  
+  return enhanced;
+}
+
+/**
+ * Validates that a path is within an Angular project
+ * @param {Object} angularConfig - Parsed Angular configuration
+ * @param {string} targetPath - Path to validate
+ * @returns {Object|null} - Project info if path is valid, null otherwise
+ */
+function findProjectForPath(angularConfig, targetPath) {
+  if (!angularConfig || !angularConfig.projects) {
+    return null;
+  }
+  
+  const normalizedTarget = path.normalize(targetPath);
+  
+  for (const project of angularConfig.projects) {
+    const projectRoot = path.normalize(project.root || '');
+    const sourceRoot = path.normalize(project.sourceRoot || '');
+    
+    if (normalizedTarget.startsWith(projectRoot) || normalizedTarget.startsWith(sourceRoot)) {
+      return project;
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  parseAngularJson,
+  extractProjects,
+  getProject,
+  getDefaultProject,
+  detectSourceDirectory,
+  getGlobalStyleFiles,
+  enhanceConfigFromAngularJson,
+  findProjectForPath,
+  getStylePreprocessor,
+  getStyleExtension
+};