@teambit/dependencies 1.0.82 → 1.0.83

package/dependencies-loader/dependencies-data.ts

@@ -0,0 +1,47 @@
+import { IssuesList } from '@teambit/component-issues';
+import { Dependency } from '@teambit/legacy/dist/consumer/component/dependencies';
+import { ManuallyChangedDependencies } from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { AllDependencies, AllPackagesDependencies } from './apply-overrides';
+
+export type OverridesDependenciesData = {
+  manuallyRemovedDependencies: ManuallyChangedDependencies;
+  manuallyAddedDependencies: ManuallyChangedDependencies;
+  missingPackageDependencies: string[];
+};
+
+export class DependenciesData {
+  constructor(
+    public allDependencies: AllDependencies,
+    public allPackagesDependencies: AllPackagesDependencies,
+    public issues: IssuesList,
+    public coreAspects: string[]
+  ) {}
+
+  serialize(): string {
+    const { issues, allDependencies, ...rest } = this;
+    return JSON.stringify({
+      ...rest,
+      issues: issues.serialize(),
+      allDependencies: {
+        dependencies: allDependencies.dependencies.map((dep) => dep.serialize()),
+        devDependencies: allDependencies.devDependencies.map((dep) => dep.serialize()),
+      },
+      // for backward compatibility. version < 1.5.1 expected this to be saved in the fs cache.
+      overridesDependencies: {
+        manuallyRemovedDependencies: {},
+        manuallyAddedDependencies: {},
+        missingPackageDependencies: [],
+      },
+    });
+  }
+
+  static deserialize(data: string): DependenciesData {
+    const dataParsed = JSON.parse(data);
+    const dependencies = dataParsed.allDependencies.dependencies.map((dep) => Dependency.deserialize(dep));
+    const devDependencies = dataParsed.allDependencies.devDependencies.map((dep) => Dependency.deserialize(dep));
+    const issuesList = IssuesList.deserialize(dataParsed.issues);
+    const allDependencies = { dependencies, devDependencies };
+    const coreAspects = dataParsed.coreAspects;
+    return new DependenciesData(allDependencies, dataParsed.allPackagesDependencies, issuesList, coreAspects);
+  }
+}

package/dependencies-loader/dependencies-loader.ts

@@ -0,0 +1,174 @@
+import R from 'ramda';
+import path from 'path';
+import { uniq } from 'lodash';
+import { IssuesClasses } from '@teambit/component-issues';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import logger from '@teambit/legacy/dist/logger/logger';
+import { getLastModifiedComponentTimestampMs } from '@teambit/legacy/dist/utils/fs/last-modified';
+import { ExtensionDataEntry } from '@teambit/legacy/dist/consumer/config';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { DependencyLoaderOpts } from '@teambit/legacy/dist/consumer/component/component-loader';
+import { COMPONENT_CONFIG_FILE_NAME } from '@teambit/legacy/dist/constants';
+import { Workspace } from '@teambit/workspace';
+import DependencyResolverAspect, { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { DevFilesMain } from '@teambit/dev-files';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { DependenciesData } from './dependencies-data';
+import { updateDependenciesVersions } from './dependencies-versions-resolver';
+import { AutoDetectDeps, DebugDependencies } from './auto-detect-deps';
+import OverridesDependencies from './overrides-dependencies';
+import { ApplyOverrides } from './apply-overrides';
+
+export class DependenciesLoader {
+  private idStr: string;
+  private consumer: Consumer;
+  constructor(
+    private component: Component,
+    private workspace: Workspace,
+    private depsResolver: DependencyResolverMain,
+    private devFiles: DevFilesMain,
+    private aspectLoader: AspectLoaderMain,
+    private opts: DependencyLoaderOpts
+  ) {
+    this.consumer = this.workspace.consumer;
+    this.idStr = this.component.id.toString();
+  }
+  async load() {
+    const { dependenciesData, debugDependenciesData } = await this.getDependenciesData();
+    const applyOverrides = new ApplyOverrides(this.component, this.depsResolver, this.workspace);
+    applyOverrides.allDependencies = dependenciesData.allDependencies;
+    applyOverrides.allPackagesDependencies = dependenciesData.allPackagesDependencies;
+    if (debugDependenciesData) {
+      // if it's coming from the cache, it's empty
+      applyOverrides.debugDependenciesData = debugDependenciesData;
+    }
+    applyOverrides.issues = dependenciesData.issues;
+    const results = await applyOverrides.getDependenciesData();
+    this.setDependenciesDataOnComponent(results.dependenciesData, results.overridesDependencies);
+    updateDependenciesVersions(
+      this.depsResolver,
+      this.workspace,
+      this.component,
+      results.overridesDependencies,
+      results.autoDetectOverrides,
+      applyOverrides.debugDependenciesData.components
+    );
+
+    return {
+      dependenciesData: results.dependenciesData,
+      overridesDependencies: results.overridesDependencies,
+      debugDependenciesData: applyOverrides.debugDependenciesData,
+    };
+  }
+
+  private async getDependenciesData(): Promise<{
+    dependenciesData: DependenciesData;
+    debugDependenciesData?: DebugDependencies;
+  }> {
+    const depsDataFromCache = await this.getDependenciesDataFromCacheIfPossible();
+    if (depsDataFromCache) {
+      return { dependenciesData: depsDataFromCache };
+    }
+
+    const autoDetectDeps = new AutoDetectDeps(
+      this.component,
+      this.workspace,
+      this.devFiles,
+      this.depsResolver,
+      this.aspectLoader
+    );
+    const results = await autoDetectDeps.getDependenciesData(
+      this.opts.cacheResolvedDependencies,
+      this.opts.cacheProjectAst
+    );
+    if (this.shouldSaveInCache(results.dependenciesData)) {
+      await this.consumer.componentFsCache.saveDependenciesDataInCache(
+        this.idStr,
+        results.dependenciesData.serialize()
+      );
+    }
+
+    return results;
+  }
+
+  private async getDependenciesDataFromCacheIfPossible(): Promise<DependenciesData | null> {
+    if (!this.opts.useDependenciesCache) {
+      return null;
+    }
+    const cacheData = await this.consumer.componentFsCache.getDependenciesDataFromCache(this.idStr);
+    if (!cacheData) {
+      return null; // probably the first time, so it wasn't entered to the cache yet.
+    }
+    const rootDir = this.component.componentMap?.getComponentDir();
+    if (!rootDir) {
+      // could happen on legacy only and when there is no trackDir, in which case, we can't
+      // determine whether or not a component file has been deleted, as a result, we are unable
+      // to invalidate the cache in such a case.
+      return null;
+    }
+    const filesPaths = this.component.files.map((f) => f.path);
+    const componentConfigPath = path.join(this.consumer.getPath(), rootDir, COMPONENT_CONFIG_FILE_NAME);
+    filesPaths.push(componentConfigPath);
+    const lastModifiedComponent = await getLastModifiedComponentTimestampMs(rootDir, filesPaths);
+    const wasModifiedAfterCache = lastModifiedComponent > cacheData.timestamp;
+    if (wasModifiedAfterCache) {
+      return null; // cache is invalid.
+    }
+    logger.debug(`dependencies-loader, getting the dependencies data for ${this.idStr} from the cache`);
+    return DependenciesData.deserialize(cacheData.data);
+  }
+
+  private shouldSaveInCache(dependenciesData: DependenciesData) {
+    if (!dependenciesData.issues) return true;
+    return !dependenciesData.issues.shouldBlockSavingInCache();
+  }
+
+  private setDependenciesDataOnComponent(
+    dependenciesData: DependenciesData,
+    overridesDependencies: OverridesDependencies
+  ) {
+    this.component.setDependencies(dependenciesData.allDependencies.dependencies);
+    this.component.setDevDependencies(dependenciesData.allDependencies.devDependencies);
+    this.component.packageDependencies = dependenciesData.allPackagesDependencies.packageDependencies ?? {};
+    this.component.devPackageDependencies = dependenciesData.allPackagesDependencies.devPackageDependencies ?? {};
+    this.component.peerPackageDependencies = dependenciesData.allPackagesDependencies.peerPackageDependencies ?? {};
+    const missingFromOverrides = overridesDependencies.missingPackageDependencies;
+    if (!R.isEmpty(missingFromOverrides)) {
+      dependenciesData.issues.getOrCreate(IssuesClasses.MissingManuallyConfiguredPackages).data =
+        uniq(missingFromOverrides);
+    }
+    if (!dependenciesData.issues.isEmpty()) this.component.issues = dependenciesData.issues;
+    this.component.manuallyRemovedDependencies = overridesDependencies.manuallyRemovedDependencies;
+    this.component.manuallyAddedDependencies = overridesDependencies.manuallyAddedDependencies;
+    if (dependenciesData.coreAspects.length) {
+      this.pushToDependencyResolverExtension('coreAspects', dependenciesData.coreAspects, 'set');
+    }
+  }
+
+  private pushToDependencyResolverExtension(dataField: string, data: any, operation: 'add' | 'set' = 'add') {
+    const depResolverAspectName = DependencyResolverAspect.id;
+    let extExistOnComponent = true;
+    let ext = this.component.extensions.findCoreExtension(depResolverAspectName);
+    if (!ext) {
+      extExistOnComponent = false;
+      // Create new deps resolver extension entry to add to the component with data only
+      ext = new ExtensionDataEntry(undefined, undefined, depResolverAspectName, undefined, {});
+    }
+
+    if (!ext.data[dataField]) ext.data[dataField] = [];
+    if (operation === 'add') {
+      const existing = ext.data[dataField].find((c) => c.packageName === data.packageName);
+      if (existing) {
+        existing.componentId = data.componentId;
+      } else {
+        ext.data[dataField].push(data);
+      }
+    }
+    if (operation === 'set') {
+      ext.data[dataField] = data;
+    }
+    if (!extExistOnComponent) {
+      this.component.extensions.push(ext);
+    }
+  }
+}

package/dependencies-loader/dependencies-versions-resolver.ts

@@ -0,0 +1,160 @@
+import R from 'ramda';
+import { ComponentID } from '@teambit/component-id';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import { Workspace } from '@teambit/workspace';
+import logger from '@teambit/legacy/dist/logger/logger';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { ExtensionDataEntry, ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
+import Dependencies from '@teambit/legacy/dist/consumer/component/dependencies/dependencies';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { DEPENDENCIES_FIELDS } from '@teambit/legacy/dist/constants';
+import Dependency from '@teambit/legacy/dist/consumer/component/dependencies/dependency';
+import OverridesDependencies from './overrides-dependencies';
+import { DebugComponentsDependency, getValidVersion } from './auto-detect-deps';
+
+export function updateDependenciesVersions(
+  depsResolver: DependencyResolverMain,
+  workspace: Workspace,
+  component: Component,
+  overridesDependencies: OverridesDependencies,
+  autoDetectOverrides?: Record<string, any>,
+  debugDependencies?: DebugComponentsDependency[]
+) {
+  const consumer: Consumer = workspace.consumer;
+  const autoDetectConfigMerge = workspace.getAutoDetectConfigMerge(component.id) || {};
+
+  updateDependencies(component.dependencies);
+  updateDependencies(component.devDependencies);
+  updateExtensions(component.extensions);
+
+  /**
+   * the `pkg` can be missing only in two scenarios:
+   * 1: the dependency is using relative-paths, not the module path. (which bit-status shows an error and suggests
+   * running bit link --rewire).
+   * 2: this gets called for extension-id.
+   */
+  function resolveVersion(id: ComponentID, pkg?: string): string | undefined {
+    const idFromBitMap = getIdFromBitMap(id);
+    const idFromComponentConfig = getIdFromComponentConfig(id);
+    const getFromComponentConfig = () => idFromComponentConfig;
+    const getFromBitMap = () => idFromBitMap || null;
+    // later, change this to return the version from the overrides.
+    const getFromOverrides = () => (pkg && isPkgInOverrides(pkg) ? id : null);
+    const debugDep = debugDependencies?.find((dep) => dep.id.isEqualWithoutVersion(id));
+    // the id we get from the auto-detect is coming from the package.json of the dependency.
+    const getFromDepPackageJson = () => (id.hasVersion() ? id : null);
+    // In case it's resolved from the node_modules, and it's also in the ws policy or variants,
+    // use the resolved version from the node_modules / package folder
+    const getFromDepPackageJsonDueToWorkspacePolicy = () =>
+      pkg && id.hasVersion() && isPkgInWorkspacePolicies(pkg) ? id : null;
+    // merge config here is only auto-detected ones. their priority is less then the ws policy
+    // otherwise, imagine you merge a lane, you don't like the dependency you got from the other lane, you run
+    // bit-install to change it, but it won't do anything.
+    const getFromMergeConfig = () => (pkg ? resolveFromMergeConfig(id, pkg) : null);
+    const getFromDepPackageJsonDueToAutoDetectOverrides = () => (pkg && isPkgInAutoDetectOverrides(pkg) ? id : null);
+    // If there is a version in the node_modules/package folder, but it's not in the ws policy,
+    // prefer the version from the model over the version from the node_modules
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const getFromModel = () => getIdFromModelDeps(component.componentFromModel!, id);
+
+    const strategies = [
+      getFromComponentConfig,
+      getFromOverrides,
+      getFromBitMap,
+      getFromDepPackageJsonDueToWorkspacePolicy,
+      getFromMergeConfig,
+      getFromDepPackageJsonDueToAutoDetectOverrides,
+      getFromModel,
+      getFromDepPackageJson,
+    ];
+
+    for (const strategy of strategies) {
+      const strategyId = strategy();
+      if (strategyId) {
+        logger.debug(
+          `found dependency version ${strategyId.version} for ${id.toString()} in strategy ${strategy.name}`
+        );
+        if (debugDep) {
+          debugDep.versionResolvedFrom = strategy.name.replace('getFrom', '');
+          debugDep.version = strategyId.version;
+        }
+
+        return strategyId.version;
+      }
+    }
+    return undefined;
+  }
+
+  function updateDependency(dependency: Dependency) {
+    const { id, packageName } = dependency;
+    const resolvedVersion = resolveVersion(id, packageName);
+    if (resolvedVersion) {
+      dependency.id = dependency.id.changeVersion(resolvedVersion);
+    }
+  }
+  function updateDependencies(dependencies: Dependencies) {
+    dependencies.get().forEach(updateDependency);
+  }
+
+  function updateExtension(extension: ExtensionDataEntry) {
+    if (extension.extensionId) {
+      const resolvedVersion = resolveVersion(extension.extensionId);
+      if (resolvedVersion) {
+        extension.extensionId = extension.extensionId.changeVersion(resolvedVersion);
+      }
+    }
+  }
+  function updateExtensions(extensions: ExtensionDataList) {
+    extensions.forEach(updateExtension);
+  }
+
+  function getIdFromModelDeps(componentFromModel: Component, componentId: ComponentID): ComponentID | null {
+    if (!componentFromModel) return null;
+    const dependency = componentFromModel.getAllDependenciesIds().searchWithoutVersion(componentId);
+    if (!dependency) return null;
+    return dependency;
+  }
+
+  function getIdFromBitMap(componentId: ComponentID): ComponentID | null | undefined {
+    const existingIds = consumer.bitmapIdsFromCurrentLane.filterWithoutVersion(componentId);
+    return existingIds.length === 1 ? existingIds[0] : undefined;
+  }
+
+  function getIdFromComponentConfig(componentId: ComponentID): ComponentID | undefined {
+    const dependencies = component.overrides.getComponentDependenciesWithVersion();
+    if (R.isEmpty(dependencies)) return undefined;
+    const dependency = Object.keys(dependencies).find((idStr) => componentId.toStringWithoutVersion() === idStr);
+    if (!dependency) return undefined;
+    return componentId.changeVersion(dependencies[dependency]);
+  }
+
+  function isPkgInOverrides(pkgName: string): boolean {
+    const dependencies = overridesDependencies.getDependenciesToAddManually();
+    if (!dependencies) return false;
+    const allDeps = Object.values(dependencies)
+      .map((obj) => Object.keys(obj))
+      .flat();
+    return allDeps.includes(pkgName);
+  }
+
+  function isPkgInAutoDetectOverrides(pkgName: string): boolean {
+    return DEPENDENCIES_FIELDS.some(
+      (depField) => autoDetectOverrides?.[depField] && autoDetectOverrides[depField][pkgName]
+    );
+  }
+
+  function isPkgInWorkspacePolicies(pkgName: string) {
+    return depsResolver.getWorkspacePolicyManifest().dependencies?.[pkgName];
+  }
+
+  function resolveFromMergeConfig(id: ComponentID, pkgName: string) {
+    let foundVersion: string | undefined | null;
+    DEPENDENCIES_FIELDS.forEach((field) => {
+      if (autoDetectConfigMerge[field]?.[pkgName]) {
+        foundVersion = autoDetectConfigMerge[field]?.[pkgName];
+        foundVersion = foundVersion ? getValidVersion(foundVersion) : null;
+      }
+    });
+    return foundVersion ? id.changeVersion(foundVersion) : undefined;
+  }
+}

package/dependencies-loader/index.ts

@@ -0,0 +1,2 @@
+export { DependenciesLoader } from './dependencies-loader';
+export { ApplyOverrides } from './apply-overrides';

package/dependencies-loader/overrides-dependencies.ts

@@ -0,0 +1,115 @@
+import {
+  DEPENDENCIES_FIELDS,
+  MANUALLY_ADD_DEPENDENCY,
+  MANUALLY_REMOVE_DEPENDENCY,
+} from '@teambit/legacy/dist/constants';
+import logger from '@teambit/legacy/dist/logger/logger';
+import Component, { ManuallyChangedDependencies } from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { FileType } from './auto-detect-deps';
+
+export default class OverridesDependencies {
+  component: Component;
+  componentFromModel: Component | null | undefined;
+  manuallyRemovedDependencies: ManuallyChangedDependencies;
+  manuallyAddedDependencies: ManuallyChangedDependencies;
+  missingPackageDependencies: string[];
+  constructor(component: Component) {
+    this.component = component;
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    this.componentFromModel = this.component.componentFromModel;
+    this.manuallyRemovedDependencies = {};
+    this.manuallyAddedDependencies = {};
+    this.missingPackageDependencies = [];
+  }
+
+  shouldIgnorePackage(packageName: string, fileType: FileType): boolean {
+    const field = fileType.isTestFile ? 'devDependencies' : 'dependencies';
+    return this.shouldIgnorePackageByType(packageName, field);
+  }
+
+  shouldIgnorePackageByType(packageName: string, field: string): boolean {
+    const shouldIgnorePackage = (packages: string[]) => {
+      return packages.some((pkg) => pkg === packageName);
+    };
+    const ignoreField = this.component.overrides.getIgnoredPackages(field);
+    const ignore = shouldIgnorePackage(ignoreField);
+    if (ignore) {
+      this._addManuallyRemovedDep(field, packageName);
+    }
+    return ignore;
+  }
+
+  shouldIgnorePeerPackage(packageName: string): boolean {
+    const shouldIgnorePackage = (packages: string[]) => {
+      return packages.some((pkg) => pkg === packageName);
+    };
+    const field = 'peerDependencies';
+    const ignorePeer = this.component.overrides.getIgnoredPackages(field);
+    const ignore = shouldIgnorePackage(ignorePeer);
+    if (ignore) {
+      this._addManuallyRemovedDep(field, packageName);
+    }
+    return ignore;
+  }
+
+  getDependenciesToAddManually(): Record<string, any> | undefined {
+    const overrides = this.component.overrides.componentOverridesData;
+    if (!overrides) return undefined;
+    const packages = {};
+    DEPENDENCIES_FIELDS.forEach((depField) => {
+      if (!overrides[depField]) return;
+      Object.keys(overrides[depField]).forEach((dependency) => {
+        const dependencyValue = overrides[depField][dependency];
+        if (dependencyValue === MANUALLY_REMOVE_DEPENDENCY) return;
+        (packages[depField] ||= {})[dependency] = dependencyValue;
+      });
+    });
+    return packages;
+  }
+
+  _manuallyAddPackage(
+    field: string,
+    dependency: string,
+    dependencyValue: string,
+    packageJson: Record<string, any> | null | undefined
+  ): Record<string, any> | null | undefined {
+    const packageVersionToAdd = (): string | null | undefined => {
+      if (dependencyValue !== MANUALLY_ADD_DEPENDENCY) {
+        return dependencyValue;
+      }
+      if (!packageJson) return null;
+      for (const depField of DEPENDENCIES_FIELDS) {
+        if (packageJson[depField]) {
+          const found = Object.keys(packageJson[depField]).find((pkg) => pkg === dependency);
+          if (found) return packageJson[depField][dependency];
+        }
+      }
+      return null;
+    };
+    const versionToAdd = packageVersionToAdd();
+    if (!versionToAdd) {
+      logger.debug(`unable to manually add the dependency "${dependency}" into "${this.component.id.toString()}".
+it's not an existing component, nor existing package (in a package.json)`);
+      this.missingPackageDependencies.push(dependency);
+      return undefined;
+    }
+    const packageStr = `${dependency}@${versionToAdd}`;
+    this._addManuallyAddedDep(field, packageStr);
+
+    return { [dependency]: versionToAdd };
+  }
+
+  _addManuallyRemovedDep(field: string, value: string) {
+    this.manuallyRemovedDependencies[field]
+      ? this.manuallyRemovedDependencies[field].push(value)
+      : (this.manuallyRemovedDependencies[field] = [value]);
+  }
+
+  _addManuallyAddedDep(field: string, value: string) {
+    if (this.manuallyAddedDependencies?.[field]?.includes(value)) return;
+
+    this.manuallyAddedDependencies[field]
+      ? this.manuallyAddedDependencies[field].push(value)
+      : (this.manuallyAddedDependencies[field] = [value]);
+  }
+}

package/dependencies-loader/package-to-definetly-typed.spec.ts

@@ -0,0 +1,53 @@
+import { expect } from 'chai';
+import { packageToDefinetlyTyped } from './package-to-definetly-typed';
+
+const scenarios = new Map([
+  ['@testing-library/jest-dom', '@types/testing-library__jest-dom'],
+  ['chai', '@types/chai'],
+  ['mocha', '@types/mocha'],
+
+  ['classnames', '@types/classnames'],
+  ['cors', '@types/cors'],
+  ['cross-spawn', '@types/cross-spawn'],
+  ['dagre', '@types/dagre'],
+  ['didyoumean', '@types/didyoumean'],
+  ['eslint', '@types/eslint'],
+  ['express', '@types/express'],
+  ['find-cache-dir', '@types/find-cache-dir'],
+  ['find-root', '@types/find-root'],
+  ['history', '@types/history'],
+  ['http-proxy-agent', '@types/http-proxy-agent'],
+  ['lodash', '@types/lodash'],
+  ['lodash.compact', '@types/lodash.compact'],
+  ['lodash.flatten', '@types/lodash.flatten'],
+  ['lodash.head', '@types/lodash.head'],
+  ['lodash.pick', '@types/lodash.pick'],
+  ['@mdx-js/react', '@types/mdx-js__react'],
+  ['memoizee', '@types/memoizee'],
+  ['mime', '@types/mime'],
+  ['mousetrap', '@types/mousetrap'],
+  ['node', '@types/node'],
+  ['puppeteer', '@types/puppeteer'],
+  ['react', '@types/react'],
+  ['react-dom', '@types/react-dom'],
+  ['react-router-dom', '@types/react-router-dom'],
+  ['react-tabs', '@types/react-tabs'],
+  ['react-tooltip', '@types/react-tooltip'],
+  ['socket.io-client', '@types/socket.io-client'],
+  ['ua-parser-js', '@types/ua-parser-js'],
+  ['url-join', '@types/url-join'],
+  ['url-parse', '@types/url-parse'],
+  ['webpack', '@types/webpack'],
+  ['webpack-dev-server', '@types/webpack-dev-server'],
+  ['webpack-merge', '@types/webpack-merge'],
+]);
+
+describe('packageToDefinetlyTyped()', () => {
+  scenarios.forEach((expected, input) => {
+    it(`should map to ${expected}`, () => {
+      const result = packageToDefinetlyTyped(input);
+
+      expect(result).to.equal(expected);
+    });
+  });
+});

package/dependencies-loader/package-to-definetly-typed.ts

@@ -0,0 +1,10 @@
+const scopedRegistryRegex = /^(@([-\w]+)\/)/;
+const scopedRegistryReplace = '$2__';
+
+// it seems definetly typed are using this:
+// `const dtsName = packageName.replace("@", "").replace("/", "__")`
+
+export function packageToDefinetlyTyped(pkgName: string) {
+  const escaped = pkgName.replace(scopedRegistryRegex, scopedRegistryReplace);
+  return `@types/${escaped}`;
+}

package/dist/dependencies-loader/README.md

@@ -0,0 +1,34 @@
+# Dependencies Cache Mechanism
+
+To improve component-loading performance, the dependencies data is cached in the filesystem.
+
+### The component's cache gets invalidated in the following scenario:
+
+1. The component-dir or sub-dirs have been changed. (modified-date of the dirs paths)
+2. One of the component files have been changed.
+3. A component config file (component.json/package.json) has modified.
+
+### The entire cache of all component dependencies is invalidated if one of the following happened:
+
+1. workspace-config file (bit.json/workspace.jsonc) has changed.
+2. package.json file has changed.
+3. node_modules-dir (only root dir, not sub-dirs) has changed. - not sure if needed.
+4. On completion of "bit link".
+5. On completion of "bit install".
+6. During 'bit tag --persist', before loading the components.
+
+### A component is not entered to the cache in the first place in the following cases:
+
+1. No root-dir/track-dir (legacy).
+2. Component has one of the following issues: missingPackagesDependenciesOnFs, untrackedDependencies.
+
+### Limitations:
+
+1. If a user deleted the dists directories of a component in node-modules, we don't know about it and bit-status won't show any error.
+2. If a user deleted a package from node-modules dir manually, we don't know about it.
+
+### Disabling the cache
+
+set the "no-fs-cache" feature.
+For one command, prefix your command with `BIT_FEATURES=no-fs-cache`.
+Or you can configure it on the machine level for all commands/workspaces: `bit config set features='no-fs-cache'`