metamask-extension/development/build/manifest.js

const { promises: fs } = require('fs');
const path = require('path');
const { merge, cloneDeep } = require('lodash');

const baseManifest = require('../../app/manifest/_base.json');

const { createTask, composeSeries } = require('./task');

module.exports = createManifestTasks;

const scriptsToExcludeFromBackgroundDevBuild = {
  'bg-libs.js': true,
};

function createManifestTasks({ browserPlatforms }) {
  // merge base manifest with per-platform manifests
  const prepPlatforms = async () => {
    return Promise.all(
      browserPlatforms.map(async (platform) => {
        const platformModifications = await readJson(
          path.join(
            __dirname,
            '..',
            '..',
            'app',
            'manifest',
            `${platform}.json`,
          ),
        );
        const result = merge(cloneDeep(baseManifest), platformModifications);
        const dir = path.join('.', 'dist', platform);
        await fs.mkdir(dir, { recursive: true });
        await writeJson(result, path.join(dir, 'manifest.json'));
      }),
    );
  };

  // dev: remove bg-libs, add chromereload, add perms
  const envDev = createTaskForModifyManifestForEnvironment((manifest) => {
    const scripts = manifest.background.scripts.filter(
      (scriptName) => !scriptsToExcludeFromBackgroundDevBuild[scriptName],
    );
    scripts.push('chromereload.js');
    manifest.background = {
      ...manifest.background,
      scripts,
    };
    manifest.permissions = [...manifest.permissions, 'webRequestBlocking'];
  });

  // testDev: remove bg-libs, add perms
  const envTestDev = createTaskForModifyManifestForEnvironment((manifest) => {
    const scripts = manifest.background.scripts.filter(
      (scriptName) => !scriptsToExcludeFromBackgroundDevBuild[scriptName],
    );
    scripts.push('chromereload.js');
    manifest.background = {
      ...manifest.background,
      scripts,
    };
    manifest.permissions = [
      ...manifest.permissions,
      'webRequestBlocking',
      'http://localhost/*',
    ];
  });

  // test: add permissions
  const envTest = createTaskForModifyManifestForEnvironment((manifest) => {
    manifest.permissions = [
      ...manifest.permissions,
      'webRequestBlocking',
      'http://localhost/*',
    ];
  });

  // high level manifest tasks
  const dev = createTask('manifest:dev', composeSeries(prepPlatforms, envDev));

  const testDev = createTask(
    'manifest:testDev',
    composeSeries(prepPlatforms, envTestDev),
  );

  const test = createTask(
    'manifest:test',
    composeSeries(prepPlatforms, envTest),
  );

  const prod = createTask('manifest:prod', prepPlatforms);

  return { prod, dev, testDev, test };

  // helper for modifying each platform's manifest.json in place
  function createTaskForModifyManifestForEnvironment(transformFn) {
    return () => {
      return Promise.all(
        browserPlatforms.map(async (platform) => {
          const manifestPath = path.join(
            '.',
            'dist',
            platform,
            'manifest.json',
          );
          const manifest = await readJson(manifestPath);
          transformFn(manifest);
          await writeJson(manifest, manifestPath);
        }),
      );
    };
  }
}

// helper for reading and deserializing json from fs
async function readJson(file) {
  return JSON.parse(await fs.readFile(file, 'utf8'));
}

// helper for serializing and writing json to fs
async function writeJson(obj, file) {
  return fs.writeFile(file, JSON.stringify(obj, null, 2));
}