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

package/lib/compareCompiledCommand.js

@@ -0,0 +1,378 @@
+"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/makeDebugCommand.js

@@ -36,6 +36,7 @@ var _normalizeOptions = require("./normalizeOptions");
 var _applyOptions = require("./applyOptions");
 var _options = require("./options");
 var _handleUncaughtException = require("./handleUncaughtException");
+var _compareCompiledCommand = require("./compareCompiledCommand");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @ts-expect-error TS2305
 
@@ -108,5 +109,6 @@ function makeDebugCommand() {
     }
   });
   (0, _applyOptions.applyOptions)(compactCache, _options.commonOptions);
+  debug.addCommand((0, _compareCompiledCommand.makeCompareCompiledCommand)());
   return debug;
 }

package/lib/types/compareCompiledCommand.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/cli",
-  "version": "2.14.15",
+  "version": "2.14.17-dev-compiled-hash-e5f8a1735.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
@@ -24,25 +24,26 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/config-default": "7.0.1",
-    "@atlaspack/core": "2.26.1",
-    "@atlaspack/diagnostic": "2.14.4",
-    "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.26.0",
-    "@atlaspack/fs": "2.15.31",
-    "@atlaspack/logger": "2.14.28",
-    "@atlaspack/package-manager": "2.14.36",
-    "@atlaspack/reporter-cli": "2.17.18",
-    "@atlaspack/reporter-dev-server": "2.14.36",
-    "@atlaspack/reporter-tracer": "2.14.36",
-    "@atlaspack/utils": "3.1.0",
+    "@atlaspack/config-default": "7.0.3-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/core": "2.26.3-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/diagnostic": "2.14.5-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/events": "2.14.5-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/feature-flags": "2.26.2-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/fs": "2.15.33-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/logger": "2.14.30-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/package-manager": "2.14.38-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/reporter-cli": "2.17.20-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/reporter-dev-server": "2.14.38-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/reporter-tracer": "2.14.38-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/utils": "3.1.2-dev-compiled-hash-e5f8a1735.0",
     "chalk": "^4.1.0",
     "commander": "^7.0.0",
     "get-port": "^4.2.0"
   },
   "devDependencies": {
+    "@atlaspack/babel-register": "2.14.5-dev-compiled-hash-e5f8a1735.0",
     "@babel/core": "^7.22.11",
-    "@atlaspack/babel-register": "2.14.4",
     "rimraf": "^5.0.5"
-  }
+  },
+  "gitHead": "e5f8a173505611c1fafafd6e7dddb2f6b483f67c"
 }