@atlaspack/reporter-conditional-manifest 2.14.1-dev.131 → 2.14.1-dev.134

package/lib/ConditionalManifestReporter.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.manifestHashes = exports.default = void 0;
+exports.report = report;
+exports.updateManifest = void 0;
 function _path() {
   const data = require("path");
   _path = function () {
@@ -11,6 +13,13 @@ function _path() {
   };
   return data;
 }
+function _crypto() {
+  const data = _interopRequireDefault(require("crypto"));
+  _crypto = function () {
+    return data;
+  };
+  return data;
+}
 function _plugin() {
   const data = require("@atlaspack/plugin");
   _plugin = function () {
@@ -19,6 +28,29 @@ function _plugin() {
   return data;
 }
 var _Config = require("./Config");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const manifestHashes = exports.manifestHashes = new Map();
+const updateManifest = async (outputFS, logger, conditionalManifestFilename, conditionalManifest) => {
+  const hash = _crypto().default.createHash('sha1').update(conditionalManifest).digest('hex');
+  if (manifestHashes.get(conditionalManifestFilename) !== hash) {
+    manifestHashes.set(conditionalManifestFilename, hash);
+    await outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
+    await outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+      mode: 0o666
+    });
+    logger.info({
+      message: `Wrote conditional manifest to ${conditionalManifestFilename}`
+    });
+  }
+};
+exports.updateManifest = updateManifest;
 async function report({
   event,
   options,
@@ -52,13 +84,17 @@ async function report({
       const conditionalManifest = JSON.stringify(
       // If there's no content, send an empty manifest so we can still map from it safely
       manifest[target.name] ?? {}, null, 2);
-      await options.outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
-      await options.outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
-        mode: 0o666
-      });
-      logger.info({
-        message: 'Wrote conditional manifest to ' + conditionalManifestFilename
-      });
+      if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingReporterDuplicateFix')) {
+        await updateManifest(options.outputFS, logger, conditionalManifestFilename, conditionalManifest);
+      } else {
+        await options.outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
+        await options.outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+          mode: 0o666
+        });
+        logger.info({
+          message: 'Wrote conditional manifest to ' + conditionalManifestFilename
+        });
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/reporter-conditional-manifest",
-  "version": "2.14.1-dev.131+14d6b0e5a",
+  "version": "2.14.1-dev.134+e072f4b10",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -15,9 +15,10 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/plugin": "2.14.1-dev.131+14d6b0e5a",
+    "@atlaspack/feature-flags": "2.14.1-dev.134+e072f4b10",
+    "@atlaspack/plugin": "2.14.1-dev.134+e072f4b10",
     "nullthrows": "^1.1.1"
   },
   "type": "commonjs",
-  "gitHead": "14d6b0e5abcf5554c4979b6492e3e635b8f458c7"
+  "gitHead": "e072f4b100a13d97c544324004819ee51cdac4a8"
 }

package/src/ConditionalManifestReporter.js

@@ -1,5 +1,6 @@
 // @flow strict-local
 import {relative, join, dirname} from 'path';
+import crypto from 'crypto';
 import {Reporter} from '@atlaspack/plugin';
 import type {
   Async,
@@ -7,10 +8,40 @@ import type {
   PluginOptions,
   PluginTracer,
   ReporterEvent,
+  FileSystem,
+  FilePath,
 } from '@atlaspack/types-internal';
 import {getConfig} from './Config';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-async function report({
+export const manifestHashes: Map<FilePath, string> = new Map();
+
+export const updateManifest = async (
+  outputFS: FileSystem,
+  logger: PluginLogger,
+  conditionalManifestFilename: FilePath,
+  conditionalManifest: string,
+) => {
+  const hash = crypto
+    .createHash('sha1')
+    .update(conditionalManifest)
+    .digest('hex');
+
+  if (manifestHashes.get(conditionalManifestFilename) !== hash) {
+    manifestHashes.set(conditionalManifestFilename, hash);
+
+    await outputFS.mkdirp(dirname(conditionalManifestFilename));
+    await outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+      mode: 0o666,
+    });
+
+    logger.info({
+      message: `Wrote conditional manifest to ${conditionalManifestFilename}`,
+    });
+  }
+};
+
+export async function report({
   event,
   options,
   logger,
@@ -59,17 +90,26 @@ async function report({
         2,
       );
 
-      await options.outputFS.mkdirp(dirname(conditionalManifestFilename));
+      if (getFeatureFlag('conditionalBundlingReporterDuplicateFix')) {
+        await updateManifest(
+          options.outputFS,
+          logger,
+          conditionalManifestFilename,
+          conditionalManifest,
+        );
+      } else {
+        await options.outputFS.mkdirp(dirname(conditionalManifestFilename));
+        await options.outputFS.writeFile(
+          conditionalManifestFilename,
+          conditionalManifest,
+          {mode: 0o666},
+        );
 
-      await options.outputFS.writeFile(
-        conditionalManifestFilename,
-        conditionalManifest,
-        {mode: 0o666},
-      );
-
-      logger.info({
-        message: 'Wrote conditional manifest to ' + conditionalManifestFilename,
-      });
+        logger.info({
+          message:
+            'Wrote conditional manifest to ' + conditionalManifestFilename,
+        });
+      }
     }
   }
 }

package/test/ConditionalManifestReporter.test.js

@@ -0,0 +1,114 @@
+// @flow strict-local
+import {
+  manifestHashes,
+  updateManifest,
+} from '../src/ConditionalManifestReporter';
+import sinon from 'sinon';
+import assert from 'assert';
+
+let createMockOverlayFS = () => ({
+  // Mock filesystem methods
+  writeFile: sinon.stub(),
+  readFile: sinon.stub(),
+  exists: sinon.stub(),
+  chdir: sinon.stub(),
+  copyFile: sinon.stub(),
+  createReadStream: sinon.stub(),
+  createWriteStream: sinon.stub(),
+  cwd: sinon.stub(),
+  existsSync: sinon.stub(),
+  findAncestorFile: sinon.stub(),
+  findFirstFile: sinon.stub(),
+  findNodeModule: sinon.stub(),
+  getEventsSince: sinon.stub(),
+  mkdirp: sinon.stub(),
+  ncp: sinon.stub(),
+  readFileSync: sinon.stub(),
+  readdir: sinon.stub(),
+  readdirSync: sinon.stub(),
+  realpath: sinon.stub(),
+  realpathSync: sinon.stub(),
+  rimraf: sinon.stub(),
+  stat: sinon.stub(),
+  statSync: sinon.stub(),
+  symlink: sinon.stub(),
+  unlink: sinon.stub(),
+  watch: sinon.stub(),
+  writeSnapshot: sinon.stub(),
+});
+
+let createMockLogger = () => ({
+  // Mock logger methods
+  warn: sinon.stub(),
+  info: sinon.stub(),
+  verbose: sinon.stub(),
+  error: sinon.stub(),
+  log: sinon.stub(),
+});
+
+describe('ConditionalManifestReporter', function () {
+  beforeEach(() => {
+    manifestHashes.clear();
+  });
+
+  it('should write the manifest to file', async function () {
+    let logger = createMockLogger();
+    let overlayFS = createMockOverlayFS();
+
+    const conditionalManifestFilename =
+      '/project-root/dist/conditional-manifest.json';
+    const conditionalManifest = JSON.stringify({test: 'manifest'});
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    // Verify that writeFile was called with the correct arguments
+    assert(
+      overlayFS.writeFile.calledWith(
+        conditionalManifestFilename,
+        conditionalManifest,
+        {mode: 0o666},
+      ),
+    );
+
+    // Verify that logger.info was called with the correct message
+    assert(
+      logger.info.calledWith({
+        message: `Wrote conditional manifest to ${conditionalManifestFilename}`,
+      }),
+    );
+  });
+
+  it('should not write the manifest if it has not changed', async function () {
+    let logger = createMockLogger();
+    let overlayFS = createMockOverlayFS();
+
+    let conditionalManifestFilename =
+      '/project-root/dist/conditional-manifest.json';
+    let conditionalManifest = JSON.stringify({test: 'manifest'});
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    // Verify that writeFile was called once
+    assert(overlayFS.writeFile.calledOnce);
+
+    // Verify that logger.info was called with the correct message
+    assert(logger.info.calledOnce);
+  });
+});