@atlaspack/cli 2.14.17-dev-compiled-hash-e5f8a1735.0 → 2.15.0

package/lib/compareCompiledCommand.js

@@ -1,378 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeCompareCompiledCommand = makeCompareCompiledCommand;
-function _fs() {
-  const data = require("@atlaspack/fs");
-  _fs = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = _interopRequireDefault(require("@atlaspack/logger"));
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _commander() {
-  const data = _interopRequireDefault(require("commander"));
-  _commander = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-var _normalizeOptions = require("./normalizeOptions");
-var _applyOptions = require("./applyOptions");
-var _options = require("./options");
-var _handleUncaughtException = require("./handleUncaughtException");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function makeCompareCompiledCommand() {
-  const compareCompiled = new (_commander().default.Command)('compare-compiled-css [input...]').description('Compare Atlaspack and Parcel Compiled CSS transformers').option('--fixtures-path <path>', 'Path to fixtures directory', _path().default.join(process.cwd(), 'crates/atlassian-swc-compiled-css/tests/fixtures')).option('--config-path <path>', 'Path to .compiledcssrc config file', './.compiledcssrc').option('--output-dir <path>', 'Directory to write comparison results', './comparison-results').option('--fixture-glob <pattern>', 'Glob pattern for fixture files', '**/in.jsx').action(async (args, opts, command) => {
-    try {
-      await runCompareCompiled(args, opts, command);
-    } catch (err) {
-      (0, _handleUncaughtException.handleUncaughtException)(err);
-    }
-  });
-  (0, _applyOptions.applyOptions)(compareCompiled, _options.commonOptions);
-  return compareCompiled;
-}
-async function runCompareCompiled(args, opts, command) {
-  const fs = new (_fs().NodeFS)();
-  Object.assign(command, opts);
-  const options = await (0, _normalizeOptions.normalizeOptions)(command, fs);
-
-  // Load configuration
-  const configPath = _path().default.resolve(opts.configPath || './.compiledcssrc');
-  let config = {};
-  try {
-    const configContent = await fs.readFile(configPath);
-    config = JSON.parse(configContent);
-    _logger().default.info({
-      message: `Loaded config from ${configPath}`,
-      origin: '@atlaspack/cli'
-    });
-  } catch (err) {
-    _logger().default.warn({
-      message: `Could not load config from ${configPath}, using default config`,
-      origin: '@atlaspack/cli'
-    });
-  }
-
-  // Find fixture files
-  const fixturesPath = _path().default.resolve(opts.fixturesPath || _path().default.join(process.cwd(), 'crates/atlassian-swc-compiled-css/tests/fixtures'));
-  const fixtureGlob = opts.fixtureGlob || '**/in.jsx';
-  const fixtureFiles = await findFixtureFiles(fs, fixturesPath, fixtureGlob);
-  _logger().default.info({
-    message: `Found ${fixtureFiles.length} fixture files in ${fixturesPath}`,
-    origin: '@atlaspack/cli'
-  });
-  if (fixtureFiles.length === 0) {
-    _logger().default.warn({
-      message: `No fixture files found matching pattern ${fixtureGlob} in ${fixturesPath}`,
-      origin: '@atlaspack/cli'
-    });
-    return;
-  }
-
-  // Create output directory
-  const outputDir = _path().default.resolve(opts.outputDir || './comparison-results');
-  try {
-    await fs.mkdirp(outputDir);
-  } catch (err) {
-    // Directory might already exist
-  }
-
-  // Initialize Atlaspack
-  const Atlaspack = require('@atlaspack/core').default;
-  const atlaspack = new Atlaspack({
-    entries: ['.'],
-    defaultConfig: require.resolve('@atlaspack/config-default', {
-      paths: [fs.cwd(), __dirname]
-    }),
-    shouldPatchConsole: false,
-    shouldBuildLazily: false,
-    ...options,
-    mode: 'development',
-    env: {
-      NODE_ENV: 'development'
-    }
-  });
-
-  // For now, we'll focus on comparing Atlaspack output with expected output from fixtures
-  // TODO: Add @compiled/parcel-transformer comparison when dependencies are resolved
-
-  const results = [];
-  let successCount = 0;
-  let errorCount = 0;
-
-  // Process each fixture
-  for (const fixtureFile of fixtureFiles) {
-    const relativePath = _path().default.relative(fixturesPath, fixtureFile);
-    const fixtureName = _path().default.dirname(relativePath);
-    _logger().default.info({
-      message: `Processing fixture: ${fixtureName}`,
-      origin: '@atlaspack/cli'
-    });
-    try {
-      // Transform with Atlaspack
-      const atlaspackResult = await transformWithAtlaspack(atlaspack, fixtureFile, config);
-
-      // Load expected output from fixture directory
-      const expectedResult = await loadExpectedResult(fs, fixtureFile);
-
-      // Compare results
-      const match = compareResults(atlaspackResult, expectedResult);
-      const result = {
-        fixture: fixtureName,
-        atlaspack: atlaspackResult,
-        parcel: expectedResult,
-        match
-      };
-      results.push(result);
-      if (match) {
-        successCount++;
-        _logger().default.info({
-          message: `✓ ${fixtureName}: Results match`,
-          origin: '@atlaspack/cli'
-        });
-      } else {
-        errorCount++;
-        _logger().default.warn({
-          message: `✗ ${fixtureName}: Results differ`,
-          origin: '@atlaspack/cli'
-        });
-      }
-
-      // Write individual result files
-      await writeResultFiles(fs, outputDir, fixtureName, result);
-    } catch (err) {
-      errorCount++;
-      const result = {
-        fixture: fixtureName,
-        atlaspack: null,
-        parcel: null,
-        match: false,
-        error: err.message
-      };
-      results.push(result);
-      _logger().default.error({
-        message: `✗ ${fixtureName}: Error processing fixture: ${err.message}`,
-        origin: '@atlaspack/cli'
-      });
-    }
-  }
-
-  // Write summary report
-  await writeSummaryReport(fs, outputDir, results);
-
-  // Log final summary
-  _logger().default.info({
-    message: `\n=== Comparison Summary ===\n` + `Total fixtures: ${results.length}\n` + `Matches: ${successCount}\n` + `Mismatches: ${errorCount}\n` + `Results written to: ${outputDir}`,
-    origin: '@atlaspack/cli'
-  });
-  process.exit(errorCount > 0 ? 1 : 0);
-}
-async function transformWithAtlaspack(atlaspack, filePath, config) {
-  try {
-    var _mainAsset$getMapBuff;
-    const assets = await atlaspack.unstable_transform({
-      filePath,
-      env: {
-        NODE_ENV: 'development',
-        context: 'browser'
-      },
-      config
-    });
-    const mainAsset = assets[0];
-    if (!mainAsset) {
-      throw new Error('No assets returned from transformation');
-    }
-    return {
-      code: await mainAsset.getCode(),
-      map: await ((_mainAsset$getMapBuff = mainAsset.getMapBuffer()) === null || _mainAsset$getMapBuff === void 0 ? void 0 : _mainAsset$getMapBuff.toString()),
-      styleRules: mainAsset.meta.styleRules,
-      assets: assets.map(asset => ({
-        type: asset.type,
-        code: asset.getCode(),
-        meta: asset.meta
-      }))
-    };
-  } catch (err) {
-    throw new Error(`Atlaspack transform failed: ${err.message}`);
-  }
-}
-async function findFixtureFiles(fs, fixturesPath, pattern) {
-  try {
-    const files = [];
-    async function walkDir(dir) {
-      const entries = await fs.readdir(dir);
-      for (const entry of entries) {
-        const fullPath = _path().default.join(dir, entry);
-        const stat = await fs.stat(fullPath);
-        if (stat.isDirectory()) {
-          await walkDir(fullPath);
-        } else if (entry === 'in.jsx' || entry === 'in.js' || entry === 'in.ts' || entry === 'in.tsx') {
-          files.push(fullPath);
-        }
-      }
-    }
-    await walkDir(fixturesPath);
-    return files;
-  } catch (err) {
-    throw new Error(`Failed to find fixture files: ${err.message}`);
-  }
-}
-async function loadExpectedResult(fs, fixtureFile) {
-  const fixtureDir = _path().default.dirname(fixtureFile);
-
-  // Try to load expected output files (out.js, actual.js, etc.)
-  const expectedFiles = ['out.js', 'actual.js', 'expected.js'];
-  for (const expectedFile of expectedFiles) {
-    const expectedPath = _path().default.join(fixtureDir, expectedFile);
-    try {
-      const content = await fs.readFile(expectedPath, 'utf8');
-
-      // Also try to load style rules if available
-      let styleRules = null;
-      try {
-        const styleRulesPath = _path().default.join(fixtureDir, 'style-rules.json');
-        const styleRulesContent = await fs.readFile(styleRulesPath, 'utf8');
-        styleRules = JSON.parse(styleRulesContent);
-      } catch {
-        // Style rules file might not exist
-      }
-      return {
-        code: content,
-        styleRules,
-        assets: []
-      };
-    } catch {
-      // Try next expected file
-      continue;
-    }
-  }
-  return null;
-}
-function compareResults(atlaspack, parcel) {
-  if (!atlaspack && !parcel) return true;
-  if (!atlaspack || !parcel) return false;
-
-  // Normalize and compare code output
-  const normalizeCode = code => {
-    return code.replace(/\s+/g, ' ') // Normalize whitespace
-    .replace(/;+/g, ';') // Normalize semicolons
-    .trim();
-  };
-  const atlaspackCode = normalizeCode(atlaspack.code);
-  const parcelCode = normalizeCode(parcel.code);
-  return atlaspackCode === parcelCode;
-}
-async function writeResultFiles(fs, outputDir, fixtureName, result) {
-  const fixtureDir = _path().default.join(outputDir, fixtureName);
-  await fs.mkdirp(fixtureDir);
-
-  // Write Atlaspack result
-  if (result.atlaspack) {
-    await fs.writeFile(_path().default.join(fixtureDir, 'atlaspack.js'), result.atlaspack.code);
-    if (result.atlaspack.styleRules) {
-      await fs.writeFile(_path().default.join(fixtureDir, 'atlaspack.style-rules.json'), JSON.stringify(result.atlaspack.styleRules, null, 2));
-    }
-  }
-
-  // Write Expected result (from fixtures)
-  if (result.parcel) {
-    await fs.writeFile(_path().default.join(fixtureDir, 'expected.js'), result.parcel.code);
-  }
-
-  // Write comparison result
-  const comparisonInfo = {
-    fixture: result.fixture,
-    match: result.match,
-    error: result.error,
-    hasAtlaspack: !!result.atlaspack,
-    hasExpected: !!result.parcel,
-    timestamp: new Date().toISOString()
-  };
-  await fs.writeFile(_path().default.join(fixtureDir, 'comparison.json'), JSON.stringify(comparisonInfo, null, 2));
-
-  // Write diff if results don't match
-  if (result.atlaspack && result.parcel && !result.match) {
-    const diff = createSimpleDiff(result.atlaspack.code, result.parcel.code);
-    await fs.writeFile(_path().default.join(fixtureDir, 'diff.txt'), diff);
-  }
-}
-function createSimpleDiff(atlaspack, parcel) {
-  const atlaspackLines = atlaspack.split('\n');
-  const parcelLines = parcel.split('\n');
-  let diff = '--- Atlaspack Output\n+++ Parcel Output\n\n';
-  const maxLines = Math.max(atlaspackLines.length, parcelLines.length);
-  for (let i = 0; i < maxLines; i++) {
-    const atlaspackLine = atlaspackLines[i] || '';
-    const parcelLine = parcelLines[i] || '';
-    if (atlaspackLine !== parcelLine) {
-      if (atlaspackLine) {
-        diff += `- ${atlaspackLine}\n`;
-      }
-      if (parcelLine) {
-        diff += `+ ${parcelLine}\n`;
-      }
-    } else if (atlaspackLine) {
-      diff += `  ${atlaspackLine}\n`;
-    }
-  }
-  return diff;
-}
-async function writeSummaryReport(fs, outputDir, results) {
-  const summary = {
-    timestamp: new Date().toISOString(),
-    total: results.length,
-    matches: results.filter(r => r.match).length,
-    mismatches: results.filter(r => !r.match).length,
-    errors: results.filter(r => r.error).length,
-    results: results.map(r => ({
-      fixture: r.fixture,
-      match: r.match,
-      error: r.error,
-      hasAtlaspack: !!r.atlaspack,
-      hasExpected: !!r.parcel
-    }))
-  };
-  await fs.writeFile(_path().default.join(outputDir, 'summary.json'), JSON.stringify(summary, null, 2));
-
-  // Create markdown report
-  let markdown = `# Compiled CSS Transformer Comparison Report\n\n`;
-  markdown += `**Generated:** ${summary.timestamp}\n\n`;
-  markdown += `## Summary\n\n`;
-  markdown += `- **Total Fixtures:** ${summary.total}\n`;
-  markdown += `- **Matches:** ${summary.matches}\n`;
-  markdown += `- **Mismatches:** ${summary.mismatches}\n`;
-  markdown += `- **Errors:** ${summary.errors}\n\n`;
-  if (summary.mismatches > 0 || summary.errors > 0) {
-    markdown += `## Issues\n\n`;
-    for (const result of results) {
-      if (!result.match || result.error) {
-        markdown += `### ${result.fixture}\n\n`;
-        if (result.error) {
-          markdown += `**Error:** ${result.error}\n\n`;
-        } else {
-          markdown += `**Status:** Outputs differ\n`;
-          markdown += `**Atlaspack:** ${result.atlaspack ? 'Success' : 'Failed'}\n`;
-          markdown += `**Expected:** ${result.parcel ? 'Found' : 'Missing'}\n\n`;
-        }
-      }
-    }
-  }
-  await fs.writeFile(_path().default.join(outputDir, 'report.md'), markdown);
-}

package/lib/types/compareCompiledCommand.d.ts

@@ -1,2 +0,0 @@
-import commander from 'commander';
-export declare function makeCompareCompiledCommand(): commander.Command;