@teambit/workspace-config-files 1.0.106 → 1.0.108

package/config-writer-entry.ts

@@ -0,0 +1,146 @@
+import { Environment, ExecutionContext } from '@teambit/envs';
+import { EnvMapValue } from './workspace-config-files.main.runtime';
+import { WrittenConfigFile } from './writers';
+
+export type ConfigFile = {
+  /**
+   * Name of the config file.
+   * supports also using `{hash}` in the name, which will be replaced by the hash of the config file.
+   */
+  name: string;
+  /**
+   * Content of the config file.
+   * I.E the content of the tsconfig.json file.
+   */
+  content: string;
+  /**
+   * Hash of the config file.
+   */
+  hash?: string;
+};
+
+export type ExtendingConfigFileAdditionalProp = {
+  /**
+   * the config file that this config file extends.
+   */
+  extendingTarget: WrittenConfigFile;
+
+  /**
+   * When replacing the config file name with the actual path of the config file, use absolute paths.
+   */
+  useAbsPaths?: boolean;
+};
+
+export type ExtendingConfigFile = ConfigFile & ExtendingConfigFileAdditionalProp;
+
+export type PostProcessExtendingConfigFilesArgs = {
+  workspaceDir: string;
+  configsRootDir: string;
+  extendingConfigFile: ExtendingConfigFile;
+  /**
+   * Paths that the file will be written to.
+   */
+  paths: string[];
+  envMapValue: EnvMapValue;
+  /**
+   * This is a flag for backward compatibility
+   * We used to return string from the post process, so old versions of bit only knows to handle string results
+   * while in new version we support getting array of objects
+   * we need to know if bit the user is using support the new format or not
+   */
+  supportSpecificPathChange?: boolean;
+};
+
+export type GenerateExtendingConfigFilesArgs = {
+  workspaceDir: string;
+  configsRootDir: string;
+  writtenConfigFiles: WrittenConfigFile[];
+  envMapValue: EnvMapValue;
+};
+
+export type PostProcessExtendingConfigFilesOneFile = {
+  path: string;
+  content: string;
+};
+
+export type MergeConfigFilesFunc = (configFile: ConfigFile, configFile2: ConfigFile) => string;
+export interface ConfigWriterEntry {
+  /**
+   * Id is used for few things:
+   * 1. merge/post process different configs files (from different envs) together.
+   * 2. filter the config writer by the cli when using --writers flag.
+   */
+  id: string;
+
+  /**
+   * Name of the config writer.
+   * used for outputs and logging.
+   */
+  name: string;
+
+  /**
+   * Get's the component env and return the config file content
+   * for example the eslint config to tsconfig.
+   * This also enable to return a hash of the config file, which will be used to determine if
+   * 2 config files are the same.
+   * If the hash is not provided, the content will be used as the hash.
+   * This enables the specific config type to ignore specific fields when calculating the
+   * hash in order to ignore theses fields when determining if 2 config files are the same.
+   * The calc function also get the target directory of the config file (calculated by this aspect) as sometime there
+   * is a need to change the config file content based on the target directory.
+   * for example, change the includes/excludes paths to be relative to the target directory.
+   * The calc can return undefined if the config file is not relevant for the component. or not supported by the subscriber.
+   * for example if the component uses babel to compile, then tsconfig is not relevant.
+   * @param env
+   */
+  calcConfigFiles(executionContext: ExecutionContext, env: Environment, dir: string): ConfigFile[] | undefined;
+
+  /**
+   * Provide a function that knows how to merge 2 config files together.
+   * This is used when 2 different envs generate the same config file hash.
+   * sometime we want to merge the 2 config files together.
+   * @param configFile
+   * @param configFile2
+   */
+  mergeConfigFiles?: MergeConfigFilesFunc;
+
+  /**
+   * This will be used to generate an extending file content.
+   * For example, the tsconfig.json file will extend the real tsconfig.{hash}.json file (that were coming from the env).
+   * That way we can avoid writing the same config file multiple times.
+   * It also reduces the risk of the user manually change the config file and then the changes will be lost.
+   * This function support returning a file with content with a dsl using `{}` to replace the config file name.
+   * for example:
+   * content = `{
+   *   "extends": {configFile.name},
+   * }`
+   */
+  generateExtendingFile(args: GenerateExtendingConfigFilesArgs): ExtendingConfigFile | undefined;
+
+  /**
+   * This enables the writer to do some post processing after the extending config files were calculated and deduped.
+   * this is important in case when we need to change a config file / extending config file after it was calculated
+   * based on all the environments in the ws
+   * or based on other config files that were written.
+   * @param args
+   */
+  postProcessExtendingConfigFiles?(
+    args: PostProcessExtendingConfigFilesArgs
+  ): Promise<string | Array<PostProcessExtendingConfigFilesOneFile> | undefined>;
+
+  /**
+   * Find all the files that are relevant for the config type.
+   * This is used to clean / delete these files
+   * This should return an array of glob patterns (that will passed to the globby/minimatch library)
+   * @param dir
+   */
+  patterns: string[];
+
+  /**
+   * A function to determine if a file was generated by bit.
+   * This is useful to check if the config file was generated by bit to prevent delete user's file.
+   * @param filePath
+   * @returns
+   */
+  isBitGenerated?: (filePath: string) => boolean;
+}

package/config-writer-list.ts

@@ -0,0 +1,84 @@
+import { EnvContext, EnvHandler } from '@teambit/envs';
+import { findIndex } from 'lodash';
+import { ConfigWriterEntry } from './config-writer-entry';
+
+export type ConfigWriterHandler = {
+  handler: EnvHandler<ConfigWriterEntry>;
+  name: string;
+};
+
+/**
+ * create and maintain config writer list for component dev environments.
+ */
+export class ConfigWriterList {
+  constructor(private _writers: ConfigWriterHandler[]) {}
+
+  /**
+   * list all congig writer handlers in the list.
+   */
+  get writers() {
+    return this._writers;
+  }
+
+  private initiateWriters(writers: ConfigWriterHandler[], context: EnvContext): ConfigWriterEntry[] {
+    return writers.map((task) => {
+      return task.handler(context);
+    });
+  }
+
+  /**
+   * add writers to the list.
+   */
+  add(writers: ConfigWriterHandler[]) {
+    this._writers = this._writers.concat(writers);
+    return this;
+  }
+
+  /**
+   * remove writers from the list.
+   */
+  remove(writerNames: string[]) {
+    this._writers = this._writers.filter((writer) => {
+      return !writerNames.includes(writer.name);
+    });
+    return this;
+  }
+
+  /**
+   * replace writers in the list.
+   */
+  replace(writers: ConfigWriterHandler[]) {
+    writers.forEach((writer) => {
+      // Find Writer index using _.findIndex
+      const matchIndex = findIndex(this._writers, (origWriter) => {
+        return origWriter.name === writer.name;
+      });
+      if (matchIndex !== -1) {
+        // Replace Writer at index using native splice
+        this._writers.splice(matchIndex, 1, writer);
+      }
+    });
+    return this;
+  }
+
+  /**
+   * return a new list with the writers from the args added.
+   * @param pipeline
+   * @returns
+   */
+  concat(writerList: ConfigWriterList) {
+    return new ConfigWriterList(this._writers.concat(writerList.writers));
+  }
+
+  /**
+   * compute the list.
+   */
+  compute(context: EnvContext): ConfigWriterEntry[] {
+    const writerEntries = this.initiateWriters(this._writers, context);
+    return writerEntries;
+  }
+
+  static from(writersHandlers: ConfigWriterHandler[]): ConfigWriterList {
+    return new ConfigWriterList(writersHandlers);
+  }
+}

package/dedup-paths.spec.ts

@@ -0,0 +1,349 @@
+import { DedupedPaths, dedupePaths } from './dedup-paths';
+import { ExtendingConfigFilesMap } from './writers';
+
+const envCompsDirsMap = {
+  'teambit.harmony/node': {
+    id: 'teambit.harmony/node',
+    paths: [
+      'react/apps/react-app-types',
+      'compilation/babel-compiler',
+      'compilation/compiler-task',
+      'mdx/compilers/mdx-compiler',
+      'mdx/compilers/mdx-multi-compiler',
+      'compilation/compilers/multi-compiler',
+      'defender/eslint-linter',
+      'mdx/generator/mdx-starters',
+      'mdx/generator/mdx-templates',
+      'react/generator/react-starters',
+      'react/generator/react-templates',
+      'defender/jest-tester',
+      'react/jest/react-jest',
+      'defender/linter-task',
+      'defender/mocha-tester',
+      'compilation/modules/babel-file-transpiler',
+      'defender/prettier-formatter',
+      'preview/react-preview',
+      'defender/tester-task',
+      'typescript/typescript-compiler',
+      'webpack/webpack-bundler',
+      'webpack/webpack-dev-server',
+      'react/webpack/react-webpack',
+    ],
+  },
+  'teambit.react/react-env@0.0.44': {
+    id: 'teambit.react/react-env@0.0.44',
+    paths: ['test-new-envs-app/apps/test-app', 'test-new-env/ui/button2'],
+  },
+  'teambit.react/react': {
+    id: 'teambit.react/react',
+    paths: ['docs/docs-template', 'react/mounter'],
+  },
+  'teambit.envs/env': {
+    id: 'teambit.envs/env',
+    paths: [
+      'react/examples/my-react-env',
+      'mdx/mdx-env',
+      'node/node',
+      'node/node-env-extension',
+      'react/react-env',
+      'react/react-env-extension',
+    ],
+  },
+  'teambit.mdx/mdx-env@0.0.6': {
+    id: 'teambit.mdx/mdx-env@0.0.6',
+    paths: ['test-new-env/mdx/content-comp'],
+  },
+  'teambit.node/node@0.0.16': {
+    id: 'teambit.node/node@0.0.16',
+    paths: ['test-new-env/node/node-comp1', 'test-new-env/node/node-comp2'],
+  },
+  'teambit.react/examples/my-react-env@0.0.39': {
+    id: 'teambit.react/examples/my-react-env@0.0.39',
+    paths: ['test-new-env/ui/button'],
+  },
+};
+
+const tsExtendingConfigFilesMap: ExtendingConfigFilesMap = {
+  '816b7f584991ff21a7682ef8a4229ebf312c457f': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-typescript-config\n' +
+        '\n' +
+        '{\n' +
+        '  "extends": "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.4957ea3122e57ea3302aadd885eed84127d9c54b.json"\n' +
+        '}',
+      name: 'tsconfig.json',
+      extendingTarget: {
+        hash: '4957ea3122e57ea3302aadd885eed84127d9c54b',
+        content: 'does not matter',
+        name: 'tsconfig.bit.4957ea3122e57ea3302aadd885eed84127d9c54b.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.4957ea3122e57ea3302aadd885eed84127d9c54b.json',
+      },
+
+      hash: '816b7f584991ff21a7682ef8a4229ebf312c457f',
+    },
+    envIds: ['teambit.harmony/node', 'teambit.react/react'],
+  },
+  '00330a9c547353867d519c34f47e17ddc9f161d1': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-typescript-config\n' +
+        '\n' +
+        '{\n' +
+        '  "extends": "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.17b99a1071b1d2d86ed04ebce68903b82403f278.json"\n' +
+        '}',
+      name: 'tsconfig.json',
+      extendingTarget: {
+        hash: '17b99a1071b1d2d86ed04ebce68903b82403f278',
+        content: 'does not matter',
+        name: 'tsconfig.bit.17b99a1071b1d2d86ed04ebce68903b82403f278.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.17b99a1071b1d2d86ed04ebce68903b82403f278.json',
+      },
+      hash: '00330a9c547353867d519c34f47e17ddc9f161d1',
+    },
+    envIds: ['teambit.react/react-env@0.0.44', 'teambit.react/examples/my-react-env@0.0.39'],
+  },
+  '3c5960bcad98570b98834a5c37f47dd4729dbef0': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-typescript-config\n' +
+        '\n' +
+        '{\n' +
+        '  "extends": "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.dab521d0914afe64de248743e05a169cf9b4b50c.json"\n' +
+        '}',
+      name: 'tsconfig.json',
+      extendingTarget: {
+        hash: 'dab521d0914afe64de248743e05a169cf9b4b50c',
+        content: 'does not matter',
+        name: 'tsconfig.bit.dab521d0914afe64de248743e05a169cf9b4b50c.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/tsconfig.bit.dab521d0914afe64de248743e05a169cf9b4b50c.json',
+      },
+      hash: '3c5960bcad98570b98834a5c37f47dd4729dbef0',
+    },
+    envIds: ['teambit.node/node@0.0.16'],
+  },
+};
+
+const tsExpectedDedupedPaths: DedupedPaths = [
+  {
+    fileHash: '00330a9c547353867d519c34f47e17ddc9f161d1',
+    paths: ['test-new-envs-app', 'test-new-env/ui'],
+  },
+  {
+    fileHash: '3c5960bcad98570b98834a5c37f47dd4729dbef0',
+    paths: ['test-new-env/node'],
+  },
+  {
+    fileHash: '816b7f584991ff21a7682ef8a4229ebf312c457f',
+    paths: ['.'],
+  },
+];
+
+const eslintExtendingConfigFilesMap: ExtendingConfigFilesMap = {
+  '8810839e74a9c41694bb5a2a8587dcae71dc389d': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-eslint-config\n' +
+        '{\n' +
+        '  "extends": [\n' +
+        '    "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.be8facfbdcf1db685d5020f8612d8c2c3ac2eb7c.json"\n' +
+        '  ]\n' +
+        '}',
+      name: '.eslintrc.json',
+      extendingTarget: {
+        hash: 'be8facfbdcf1db685d5020f8612d8c2c3ac2eb7c',
+        content: 'does not matter',
+        name: '.eslintrc.bit.be8facfbdcf1db685d5020f8612d8c2c3ac2eb7c.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.be8facfbdcf1db685d5020f8612d8c2c3ac2eb7c.json',
+      },
+      hash: '8810839e74a9c41694bb5a2a8587dcae71dc389d',
+    },
+    envIds: ['teambit.harmony/node', 'teambit.react/react', 'teambit.envs/env'],
+  },
+  ff6ea265e6f21ce25f7985570beef37dd957d0dc: {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-eslint-config\n' +
+        '{\n' +
+        '  "extends": [\n' +
+        '    "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.e5ca5528c64e0442b05b949fea42cdda4243d840.json"\n' +
+        '  ]\n' +
+        '}',
+      name: '.eslintrc.json',
+      extendingTarget: {
+        hash: 'e5ca5528c64e0442b05b949fea42cdda4243d840',
+        content: 'does not matter',
+        name: '.eslintrc.bit.e5ca5528c64e0442b05b949fea42cdda4243d840.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.e5ca5528c64e0442b05b949fea42cdda4243d840.json',
+      },
+      hash: 'ff6ea265e6f21ce25f7985570beef37dd957d0dc',
+    },
+    envIds: ['teambit.react/react-env@0.0.44'],
+  },
+  '91021f2c973a2940c70b75447639e4ea2a799955': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-eslint-config\n' +
+        '{\n' +
+        '  "extends": [\n' +
+        '    "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.7f229bf5ab41e8bfe61916de6c68f9c14c76f23e.json"\n' +
+        '  ]\n' +
+        '}',
+      name: '.eslintrc.json',
+      extendingTarget: {
+        hash: '7f229bf5ab41e8bfe61916de6c68f9c14c76f23e',
+        content: 'does not matter',
+        name: '.eslintrc.bit.7f229bf5ab41e8bfe61916de6c68f9c14c76f23e.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.7f229bf5ab41e8bfe61916de6c68f9c14c76f23e.json',
+      },
+      hash: '91021f2c973a2940c70b75447639e4ea2a799955',
+    },
+    envIds: ['teambit.mdx/mdx-env@0.0.6', 'teambit.react/examples/my-react-env@0.0.39'],
+  },
+  f1743b227e588db0c59d4a43171653e6c4262816: {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-eslint-config\n' +
+        '{\n' +
+        '  "extends": [\n' +
+        '    "/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.c503f7386e2a637d91c74f7df90d8fafe79c4378.json"\n' +
+        '  ]\n' +
+        '}',
+      name: '.eslintrc.json',
+      extendingTarget: {
+        hash: 'c503f7386e2a637d91c74f7df90d8fafe79c4378',
+        content: 'does not matter',
+        name: '.eslintrc.bit.c503f7386e2a637d91c74f7df90d8fafe79c4378.json',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.eslintrc.bit.c503f7386e2a637d91c74f7df90d8fafe79c4378.json',
+      },
+      hash: 'f1743b227e588db0c59d4a43171653e6c4262816',
+    },
+    envIds: ['teambit.node/node@0.0.16'],
+  },
+};
+
+const eslintExpectedDedupedPaths: DedupedPaths = [
+  {
+    fileHash: 'ff6ea265e6f21ce25f7985570beef37dd957d0dc',
+    paths: ['test-new-envs-app', 'test-new-env/ui/button2'],
+  },
+  {
+    fileHash: '91021f2c973a2940c70b75447639e4ea2a799955',
+    paths: ['test-new-env/mdx', 'test-new-env/ui/button'],
+  },
+  {
+    fileHash: 'f1743b227e588db0c59d4a43171653e6c4262816',
+    paths: ['test-new-env/node'],
+  },
+  {
+    fileHash: '8810839e74a9c41694bb5a2a8587dcae71dc389d',
+    paths: ['.'],
+  },
+];
+
+const prettierExtendingConfigFilesMap: ExtendingConfigFilesMap = {
+  '082f546b2555ea89e7063b20de47c039d387fc74': {
+    extendingConfigFile: {
+      useAbsPaths: false,
+      content:
+        '// bit-generated-prettier-config\n' +
+        'module.exports = {\n' +
+        "  ...require('/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.prettierrc.bit.e4882af8861bcf5b0147891d8b70b40a10428881.cjs')\n" +
+        '}',
+      name: '.prettierrc.cjs',
+      extendingTarget: {
+        hash: 'e4882af8861bcf5b0147891d8b70b40a10428881',
+        content: 'does not matter',
+        name: '.prettierrc.bit.e4882af8861bcf5b0147891d8b70b40a10428881.cjs',
+        filePath:
+          '/Users/giladshoham/dev/temp/new-react-18-config-files/node_modules/.cache/.prettierrc.bit.e4882af8861bcf5b0147891d8b70b40a10428881.cjs',
+      },
+      hash: '082f546b2555ea89e7063b20de47c039d387fc74',
+    },
+    envIds: [
+      'teambit.harmony/node',
+      'teambit.react/react-env@0.0.44',
+      'teambit.react/react',
+      'teambit.envs/env',
+      'teambit.mdx/mdx-env@0.0.6',
+      'teambit.node/node@0.0.16',
+      'teambit.react/examples/my-react-env@0.0.39',
+    ],
+  },
+};
+
+const prettierExpectedDedupedPaths: DedupedPaths = [
+  {
+    fileHash: '082f546b2555ea89e7063b20de47c039d387fc74',
+    paths: ['.'],
+  },
+];
+
+describe('Workspace Config files - dedupe paths', function () {
+  describe('dedupePaths', () => {
+    describe('ts example', () => {
+      let result: DedupedPaths;
+      beforeAll(async () => {
+        // @ts-ignore (we don't really care about the env itself here)
+        result = dedupePaths(tsExtendingConfigFilesMap, envCompsDirsMap);
+      });
+
+      it('should reduce files to minimum necessary', async () => {
+        expect(result.length).toEqual(tsExpectedDedupedPaths.length);
+      });
+
+      it('should place files in correct folders', async () => {
+        // @ts-ignore
+        expect(result).toMatchObject(tsExpectedDedupedPaths);
+      });
+    });
+
+    describe('eslint example', () => {
+      let result: DedupedPaths;
+      beforeAll(async () => {
+        // @ts-ignore (we don't really care about the env itself here)
+        result = dedupePaths(eslintExtendingConfigFilesMap, envCompsDirsMap);
+      });
+
+      it('should reduce files to minimum necessary', async () => {
+        expect(result.length).toEqual(eslintExpectedDedupedPaths.length);
+      });
+
+      it('should place files in correct folders', async () => {
+        // @ts-ignore
+        expect(result).toMatchObject(eslintExpectedDedupedPaths);
+      });
+    });
+
+    describe('prettier example', () => {
+      let result: DedupedPaths;
+      beforeAll(async () => {
+        // @ts-ignore (we don't really care about the env itself here)
+        result = dedupePaths(prettierExtendingConfigFilesMap, envCompsDirsMap);
+      });
+
+      it('should reduce files to minimum necessary', async () => {
+        expect(result.length).toEqual(prettierExpectedDedupedPaths.length);
+      });
+
+      it('should place files in correct folders', async () => {
+        // @ts-ignore
+        expect(result).toMatchObject(prettierExpectedDedupedPaths);
+      });
+    });
+  });
+});

package/dedup-paths.ts

@@ -0,0 +1,120 @@
+import { invertBy, uniq } from 'lodash';
+import { dirname } from 'path';
+import { PathLinuxRelative } from '@teambit/legacy/dist/utils/path';
+import { CompPathExtendingHashMap, EnvCompsDirsMap } from './workspace-config-files.main.runtime';
+import { ExtendingConfigFilesMap } from './writers';
+
+export type DedupedPaths = Array<{
+  fileHash: string;
+  paths: string[];
+}>;
+
+function getAllPossibleDirsFromPaths(paths: PathLinuxRelative[]): PathLinuxRelative[] {
+  const dirs = paths.map((p) => getAllParentsDirOfPath(p)).flat();
+  dirs.push('.'); // add the root dir
+  return uniq(dirs);
+}
+
+function getAllParentsDirOfPath(p: PathLinuxRelative): PathLinuxRelative[] {
+  const all: string[] = [];
+  let current = p;
+  while (current !== '.') {
+    all.push(current);
+    current = dirname(current);
+  }
+  return all;
+}
+
+export function buildCompPathExtendingHashMap(
+  extendingConfigFilesMap: ExtendingConfigFilesMap,
+  envCompsDirsMap: EnvCompsDirsMap
+): CompPathExtendingHashMap {
+  const map = Object.entries(extendingConfigFilesMap).reduce((acc, [hash, { envIds }]) => {
+    envIds.forEach((envId) => {
+      const envCompDirs = envCompsDirsMap[envId];
+      envCompDirs.paths.forEach((compPath) => {
+        acc[compPath] = hash;
+      });
+    });
+    return acc;
+  }, {});
+  return map;
+}
+
+/**
+ * easier to understand by an example:
+ * input:
+ * [
+ *   { fileHash: hash1, paths: [ui/button, ui/form] },
+ *   { fileHash: hash2, paths: [p/a1, p/a2] },
+ *   { fileHash: hash3, paths: [p/n1] },
+ * ]
+ *
+ * output:
+ * [
+ *   { fileHash: hash1, paths: [ui] },
+ *   { fileHash: hash2, paths: [p] },
+ *   { fileHash: hash3, paths: [p/n1] },
+ * ]
+ *
+ * the goal is to minimize the amount of files to write per env if possible.
+ * when multiple components of the same env share a root-dir, then, it's enough to write a file in that shared dir.
+ * if in a shared-dir, some components using env1 and some env2, it finds the env that has the max number of
+ * components, this env will be optimized. other components, will have the files written inside their dirs.
+ */
+export function dedupePaths(
+  extendingConfigFilesMap: ExtendingConfigFilesMap,
+  envCompsDirsMap: EnvCompsDirsMap
+): DedupedPaths {
+  const rootDir = '.';
+
+  const compPathExtendingHashMap = buildCompPathExtendingHashMap(extendingConfigFilesMap, envCompsDirsMap);
+  const allPaths = Object.keys(compPathExtendingHashMap);
+  const allPossibleDirs = getAllPossibleDirsFromPaths(allPaths);
+
+  const allPathsPerFileHash: { [path: string]: string | null } = {}; // null when parent-dir has same amount of comps per env.
+
+  const calculateBestFileForDir = (dir: string) => {
+    if (compPathExtendingHashMap[dir]) {
+      // it's the component dir, so it's the file that should be written.
+      allPathsPerFileHash[dir] = compPathExtendingHashMap[dir];
+      return;
+    }
+    const allPathsShareSameDir = dir === rootDir ? allPaths : allPaths.filter((p) => p.startsWith(`${dir}/`));
+    const countPerFileHash: { [fileHash: string]: number } = {};
+    allPathsShareSameDir.forEach((p) => {
+      const fileHash = compPathExtendingHashMap[p];
+      if (countPerFileHash[fileHash]) countPerFileHash[fileHash] += 1;
+      else countPerFileHash[fileHash] = 1;
+    });
+    const max = Math.max(...Object.values(countPerFileHash));
+    const fileHashWithMax = Object.keys(countPerFileHash).filter((fileHash) => countPerFileHash[fileHash] === max);
+    if (!fileHashWithMax.length) throw new Error(`must be at least one fileHash related to path "${dir}"`);
+    if (fileHashWithMax.length > 1) allPathsPerFileHash[dir] = null;
+    else allPathsPerFileHash[dir] = fileHashWithMax[0];
+  };
+
+  allPossibleDirs.forEach((dirPath) => {
+    calculateBestFileForDir(dirPath);
+  });
+
+  // this is the actual deduping. if found a shorter path with the same env, then no need for this path.
+  // in other words, return only the paths that their parent is null or has a different env.
+  const dedupedPathsPerFileHash = Object.keys(allPathsPerFileHash).reduce((acc, current) => {
+    if (allPathsPerFileHash[current] && allPathsPerFileHash[dirname(current)] !== allPathsPerFileHash[current]) {
+      acc[current] = allPathsPerFileHash[current];
+    }
+
+    return acc;
+  }, {});
+  // rootDir parent is always rootDir, so leave it as is.
+  if (allPathsPerFileHash[rootDir]) dedupedPathsPerFileHash[rootDir] = allPathsPerFileHash[rootDir];
+
+  const fileHashPerDedupedPaths = invertBy(dedupedPathsPerFileHash);
+
+  const dedupedPaths = Object.keys(fileHashPerDedupedPaths).map((fileHash) => ({
+    fileHash,
+    paths: fileHashPerDedupedPaths[fileHash],
+  }));
+  return dedupedPaths;
+}