@atlaspack/reporter-conditional-manifest 2.12.1-dev.3520 → 2.12.1-dev.3565

package/lib/ConditionalManifestReporter.js

@@ -18,42 +18,48 @@ function _plugin() {
   };
   return data;
 }
-var _default = exports.default = new (_plugin().Reporter)({
-  async report({
-    event,
-    options,
-    logger
-  }) {
-    if (event.type === 'buildSuccess') {
-      const bundles = event.bundleGraph.getConditionalBundleMapping();
-
-      // Replace bundles with file paths
-      const mapBundles = bundles => bundles.map(bundle => (0, _path().relative)(bundle.target.distDir, bundle.filePath));
-      const manifest = {};
-      for (const [bundle, conditions] of bundles.entries()) {
-        const bundleInfo = {};
-        for (const [key, cond] of conditions) {
-          bundleInfo[key] = {
-            ifTrueBundles: mapBundles(cond.ifTrueBundles).reverse(),
-            ifFalseBundles: mapBundles(cond.ifFalseBundles).reverse()
-          };
-        }
-        manifest[bundle.target.name] ??= {};
-        manifest[bundle.target.name][(0, _path().relative)(bundle.target.distDir, bundle.filePath)] = bundleInfo;
-      }
+var _Config = require("./Config");
+async function report({
+  event,
+  options,
+  logger
+}) {
+  if (event.type === 'buildSuccess') {
+    const bundles = event.bundleGraph.getConditionalBundleMapping();
 
-      // Error if there are multiple targets in the build
-      const targets = new Set(event.bundleGraph.getBundles().map(bundle => bundle.target));
-      for (const target of targets) {
-        const conditionalManifestFilename = (0, _path().join)(target.distDir, 'conditional-manifest.json');
-        const conditionalManifest = JSON.stringify(manifest[target.name], null, 2);
-        await options.outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
-          mode: 0o666
-        });
-        logger.info({
-          message: 'Wrote conditional manifest to ' + conditionalManifestFilename
-        });
+    // Replace bundles with file paths
+    const mapBundles = bundles => bundles.map(bundle => (0, _path().relative)(bundle.target.distDir, bundle.filePath));
+    const manifest = {};
+    for (const [bundle, conditions] of bundles.entries()) {
+      const bundleInfo = {};
+      for (const [key, cond] of conditions) {
+        bundleInfo[key] = {
+          // Reverse bundles so we load children bundles first
+          ifTrueBundles: mapBundles(cond.ifTrueBundles).reverse(),
+          ifFalseBundles: mapBundles(cond.ifFalseBundles).reverse()
+        };
       }
+      manifest[bundle.target.name] ??= {};
+      manifest[bundle.target.name][(0, _path().relative)(bundle.target.distDir, bundle.filePath)] = bundleInfo;
+    }
+    const targets = new Set(event.bundleGraph.getBundles().map(bundle => bundle.target));
+    const {
+      filename
+    } = await (0, _Config.getConfig)(options);
+    for (const target of targets) {
+      const conditionalManifestFilename = (0, _path().join)(target.distDir, filename);
+      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.writeFile(conditionalManifestFilename, conditionalManifest, {
+        mode: 0o666
+      });
+      logger.info({
+        message: 'Wrote conditional manifest to ' + conditionalManifestFilename
+      });
     }
   }
+}
+var _default = exports.default = new (_plugin().Reporter)({
+  report
 });

package/lib/Config.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfig = getConfig;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+async function getConfig({
+  env,
+  inputFS,
+  projectRoot
+}) {
+  const packageJson = JSON.parse(await inputFS.readFile((0, _path().join)(projectRoot, 'package.json'), 'utf8'));
+  const config = packageJson['@atlaspack/reporter-conditional-manifest'] ?? {};
+  for (const [key, value] of Object.entries(config)) {
+    // Replace values in the format of ${VARIABLE} with their corresponding env
+    if (typeof value === 'string') {
+      config[key] = value.replace(/\${([^}]+)}/g, (_, v) => env[v] ?? '');
+    }
+  }
+  const {
+    filename
+  } = config;
+  return {
+    filename: filename ?? 'conditional-manifest.json'
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/reporter-conditional-manifest",
-  "version": "2.12.1-dev.3520+8a5346e28",
+  "version": "2.12.1-dev.3565+b31bc6b33",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -12,12 +12,12 @@
   "main": "lib/ConditionalManifestReporter.js",
   "source": "src/ConditionalManifestReporter.js",
   "engines": {
-    "node": ">= 16.0.0",
-    "parcel": "^2.12.1-dev.3520+8a5346e28"
+    "atlaspack": "^2.12.1-dev.3565+b31bc6b33",
+    "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/plugin": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/plugin": "2.12.1-dev.3565+b31bc6b33",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "8a5346e28c1bb3b9cd40f1c4e77c66dd6666f1e4"
+  "gitHead": "b31bc6b33de40c158b9f4d8ff177238be0de409d"
 }

package/src/ConditionalManifestReporter.js

@@ -1,62 +1,75 @@
 // @flow strict-local
 import {relative, join} from 'path';
 import {Reporter} from '@atlaspack/plugin';
+import type {
+  Async,
+  PluginLogger,
+  PluginOptions,
+  PluginTracer,
+  ReporterEvent,
+} from '@atlaspack/types-internal';
+import {getConfig} from './Config';
 
-export default (new Reporter({
-  async report({event, options, logger}) {
-    if (event.type === 'buildSuccess') {
-      const bundles = event.bundleGraph.getConditionalBundleMapping();
-
-      // Replace bundles with file paths
-      const mapBundles = (bundles) =>
-        bundles.map((bundle) =>
-          relative(bundle.target.distDir, bundle.filePath),
-        );
-
-      const manifest = {};
-      for (const [bundle, conditions] of bundles.entries()) {
-        const bundleInfo = {};
-        for (const [key, cond] of conditions) {
-          bundleInfo[key] = {
-            ifTrueBundles: mapBundles(cond.ifTrueBundles).reverse(),
-            ifFalseBundles: mapBundles(cond.ifFalseBundles).reverse(),
-          };
-        }
-
-        manifest[bundle.target.name] ??= {};
-        manifest[bundle.target.name][
-          relative(bundle.target.distDir, bundle.filePath)
-        ] = bundleInfo;
+async function report({
+  event,
+  options,
+  logger,
+}: {|
+  event: ReporterEvent,
+  options: PluginOptions,
+  logger: PluginLogger,
+  tracer: PluginTracer,
+|}): Async<void> {
+  if (event.type === 'buildSuccess') {
+    const bundles = event.bundleGraph.getConditionalBundleMapping();
+
+    // Replace bundles with file paths
+    const mapBundles = (bundles) =>
+      bundles.map((bundle) => relative(bundle.target.distDir, bundle.filePath));
+
+    const manifest = {};
+    for (const [bundle, conditions] of bundles.entries()) {
+      const bundleInfo = {};
+      for (const [key, cond] of conditions) {
+        bundleInfo[key] = {
+          // Reverse bundles so we load children bundles first
+          ifTrueBundles: mapBundles(cond.ifTrueBundles).reverse(),
+          ifFalseBundles: mapBundles(cond.ifFalseBundles).reverse(),
+        };
       }
 
-      // Error if there are multiple targets in the build
-      const targets = new Set(
-        event.bundleGraph.getBundles().map((bundle) => bundle.target),
+      manifest[bundle.target.name] ??= {};
+      manifest[bundle.target.name][
+        relative(bundle.target.distDir, bundle.filePath)
+      ] = bundleInfo;
+    }
+
+    const targets = new Set(
+      event.bundleGraph.getBundles().map((bundle) => bundle.target),
+    );
+
+    const {filename} = await getConfig(options);
+
+    for (const target of targets) {
+      const conditionalManifestFilename = join(target.distDir, filename);
+      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,
       );
 
-      for (const target of targets) {
-        const conditionalManifestFilename = join(
-          target.distDir,
-          'conditional-manifest.json',
-        );
-
-        const conditionalManifest = JSON.stringify(
-          manifest[target.name],
-          null,
-          2,
-        );
-
-        await options.outputFS.writeFile(
-          conditionalManifestFilename,
-          conditionalManifest,
-          {mode: 0o666},
-        );
-
-        logger.info({
-          message:
-            'Wrote conditional manifest to ' + conditionalManifestFilename,
-        });
-      }
+      await options.outputFS.writeFile(
+        conditionalManifestFilename,
+        conditionalManifest,
+        {mode: 0o666},
+      );
+
+      logger.info({
+        message: 'Wrote conditional manifest to ' + conditionalManifestFilename,
+      });
     }
-  },
-}): Reporter);
+  }
+}
+
+export default (new Reporter({report}): Reporter);

package/src/Config.js

@@ -0,0 +1,31 @@
+// @flow strict-local
+import {join} from 'path';
+import type {PluginOptions} from '@atlaspack/types-internal';
+
+type Config = {|
+  filename: string,
+|};
+
+export async function getConfig({
+  env,
+  inputFS,
+  projectRoot,
+}: PluginOptions): Promise<Config> {
+  const packageJson = JSON.parse(
+    await inputFS.readFile(join(projectRoot, 'package.json'), 'utf8'),
+  );
+
+  const config = packageJson['@atlaspack/reporter-conditional-manifest'] ?? {};
+  for (const [key, value] of Object.entries(config)) {
+    // Replace values in the format of ${VARIABLE} with their corresponding env
+    if (typeof value === 'string') {
+      config[key] = value.replace(/\${([^}]+)}/g, (_, v) => env[v] ?? '');
+    }
+  }
+
+  const {filename} = config;
+
+  return {
+    filename: filename ?? 'conditional-manifest.json',
+  };
+}

package/test/Config.test.js

@@ -0,0 +1,67 @@
+// @flow strict-local
+import type {PluginOptions, EnvMap} from '@atlaspack/types-internal';
+
+import {NodePackageManager} from '@atlaspack/package-manager';
+import {getConfig} from '../src/Config';
+import {overlayFS, fsFixture} from '@atlaspack/test-utils';
+import assert from 'assert';
+import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+
+function getPluginOptions({env}: {env?: EnvMap, ...}): PluginOptions {
+  return {
+    mode: 'development',
+    parcelVersion: 'version',
+    serveOptions: false,
+    shouldBuildLazily: false,
+    shouldAutoInstall: false,
+    logLevel: 'info',
+    cacheDir: '.parcel-cache/',
+    packageManager: new NodePackageManager(overlayFS, '/'),
+    instanceId: 'instance-id',
+    featureFlags: DEFAULT_FEATURE_FLAGS,
+    detailedReport: undefined,
+    hmrOptions: undefined,
+    inputFS: overlayFS,
+    outputFS: overlayFS,
+    projectRoot: '/project-root',
+    env: env ?? {},
+  };
+}
+
+describe('ConditionalManifestReporter', function () {
+  it('should load filename from config', async function () {
+    const pluginOptions = getPluginOptions({});
+    overlayFS.mkdirp(pluginOptions.projectRoot);
+
+    await fsFixture(overlayFS, pluginOptions.projectRoot)`
+      package.json:
+        {
+          "@atlaspack/reporter-conditional-manifest": {
+            "filename": "../some-other-dir/conditional.json"
+          }
+        }
+    `;
+
+    const {filename} = await getConfig(pluginOptions);
+
+    assert.equal(filename, '../some-other-dir/conditional.json');
+  });
+
+  it('should load filename from config with env vars', async function () {
+    const pluginOptions = getPluginOptions({env: {USER: 'some-user'}});
+    overlayFS.mkdirp(pluginOptions.projectRoot);
+
+    await fsFixture(overlayFS, pluginOptions.projectRoot)`
+      package.json:
+        {
+          "@atlaspack/reporter-conditional-manifest": {
+            "filename": "../\${USER}/conditional.json"
+          }
+        }
+    `;
+
+    const {filename} = await getConfig(pluginOptions);
+
+    assert.equal(filename, '../some-user/conditional.json');
+  });
+});