@teambit/dependency-resolver 1.0.106 → 1.0.108

package/dist/types.d.ts

@@ -2,15 +2,15 @@ import { ComponentConfig, ComponentFS } from '@teambit/component';
 import { PathLinux } from '@teambit/legacy/dist/utils/path';
 import { ComponentManifest } from './manifest/component-manifest';
 import { PackageName } from './dependencies';
-export declare type RegistryName = string;
-export declare type Registry = {
+export type RegistryName = string;
+export type Registry = {
     uri: string;
     alwaysAuth: boolean;
     authHeaderValue?: string;
     originalAuthType: string;
     originalAuthValue: string;
 };
-export declare type RegistriesMap = Record<RegistryName, Registry>;
+export type RegistriesMap = Record<RegistryName, Registry>;
 export interface RawComponentState {
     filesystem: ComponentFS;
     config: ComponentConfig;
@@ -20,7 +20,7 @@ export interface RawComponentState {
  * For example, `import foo from './bar' `, "foo" is the import-specifier and is default.
  * Conversely, `import { foo } from './bar' `, here, "foo" is non-default.
  */
-export declare type Specifier = {
+export type Specifier = {
     isDefault: boolean;
     name: string;
 };
@@ -29,7 +29,7 @@ export declare type Specifier = {
  * For example, a component might have a dependency: "import { foo } from './bar' ", when a link is generated, we use
  * the import-specifier name, which is "foo" to generate the link correctly.
  */
-export declare type ImportSpecifier = {
+export type ImportSpecifier = {
     mainFile: Specifier;
 };
 /**
@@ -42,7 +42,7 @@ export declare type ImportSpecifier = {
  * In this example, the component "foo" has one dependency "utils" with two RelativePaths.
  * one for utils/is-string.js file and the second for utils/is-array.js file
  */
-export declare type RelativePath = {
+export type RelativePath = {
     sourceRelativePath: PathLinux;
     destinationRelativePath: PathLinux;
     importSpecifiers?: ImportSpecifier[];
@@ -57,6 +57,6 @@ interface FileDependencyDefinition {
     relativePaths?: RelativePath[];
     isType?: boolean;
 }
-export declare type FileDependenciesDefinition = FileDependencyDefinition[];
-export declare type ComponentsManifestsMap = Map<PackageName, ComponentManifest>;
+export type FileDependenciesDefinition = FileDependencyDefinition[];
+export type ComponentsManifestsMap = Map<PackageName, ComponentManifest>;
 export {};

package/extend-with-components-from-dir.ts

@@ -0,0 +1,29 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Currently, the same capsule directory is used multiple times during installation.
+ * The issue is that the state between installations is not preserved,
+ * so the node_modules directory gets broken on each sunseqent install.
+ * This function is for finding all components in the root of the capsule and reading their manifests.
+ * This way the package manager will have all the necessary information to keep the node_modules directory
+ * in the correct state.
+ */
+export async function extendWithComponentsFromDir(rootDir: string, manifestsByPaths) {
+  const files = await fs.readdir(rootDir, { withFileTypes: true });
+  const newManifestsByPaths = { ...manifestsByPaths };
+  await Promise.all(
+    files
+      .filter((file) => file.isDirectory() && file.name !== 'node_modules')
+      .map((dir) => path.join(rootDir, dir.name))
+      .filter((dirPath) => !manifestsByPaths[dirPath])
+      .map(async (dirPath) => {
+        try {
+          newManifestsByPaths[dirPath] = await fs.readJson(path.join(dirPath, 'package.json'));
+        } catch (err: any) {
+          if (err.code !== 'ENOENT') throw err;
+        }
+      })
+  );
+  return newManifestsByPaths;
+}

package/get-all-policy-pkgs.spec.ts

@@ -0,0 +1,82 @@
+import { ComponentID } from '@teambit/component';
+import { getAllPolicyPkgs } from './get-all-policy-pkgs';
+import { WorkspacePolicy } from './policy';
+
+describe('getAllPolicyPkgs()', () => {
+  it('should read the version from a version object', () => {
+    const outdatedPkgs = getAllPolicyPkgs({
+      rootPolicy: new WorkspacePolicy([]),
+      variantPoliciesByPatterns: {
+        comp: {
+          dependencies: {
+            foo: {
+              version: '1',
+              resolveFromEnv: true,
+            },
+          },
+          devDependencies: {},
+          peerDependencies: {},
+        },
+      },
+      componentPolicies: [],
+      componentModelVersions: [],
+    });
+    // @ts-ignore
+    expect(outdatedPkgs).toStrictEqual([
+      {
+        currentRange: '1',
+        name: 'foo',
+        source: 'variants',
+        targetField: 'dependencies',
+        variantPattern: 'comp',
+      },
+    ]);
+  });
+  it('should deduplicate dependencies that are present in root policies', () => {
+    const outdatedPkgs = getAllPolicyPkgs({
+      rootPolicy: new WorkspacePolicy([
+        {
+          dependencyId: 'foo',
+          lifecycleType: 'runtime',
+          value: { version: '1' },
+        },
+      ]),
+      variantPoliciesByPatterns: {},
+      componentPolicies: [],
+      componentModelVersions: [
+        {
+          name: 'foo',
+          version: '2',
+          lifecycleType: 'runtime',
+          componentId: ComponentID.fromString('scope/comp1'),
+          isAuto: true,
+        },
+        {
+          name: 'bar',
+          version: '2',
+          lifecycleType: 'runtime',
+          componentId: ComponentID.fromString('scope/comp1'),
+          isAuto: true,
+        },
+      ],
+    });
+    // @ts-ignore
+    expect(outdatedPkgs).toStrictEqual([
+      {
+        currentRange: '1',
+        name: 'foo',
+        source: 'rootPolicy',
+        targetField: 'dependencies',
+        variantPattern: null,
+      },
+      {
+        componentId: ComponentID.fromString('scope/comp1'),
+        currentRange: '2',
+        isAuto: true,
+        name: 'bar',
+        source: 'component-model',
+        targetField: 'dependencies',
+      },
+    ]);
+  });
+});

package/get-all-policy-pkgs.ts

@@ -0,0 +1,126 @@
+import { ComponentID } from '@teambit/component-id';
+import { ManifestDependenciesKeysNames } from './manifest';
+import { VariantPolicyConfigObject, VariantPolicyEntryValue, WorkspacePolicy } from './policy';
+import { DependencyLifecycleType } from './dependencies/dependency';
+import { KEY_NAME_BY_LIFECYCLE_TYPE } from './dependencies';
+
+export type CurrentPkgSource =
+  // the variants section of "workspace.jsonc"
+  | 'variants'
+  // these are dependencies set via "bit deps set" or "component.json"
+  | 'component'
+  // these are dependencies from the dependencies policy in "workspace.jsonc"
+  | 'rootPolicy'
+  // these are dependencies stored in the component object (snapped/tagged version)
+  | 'component-model';
+
+type CurrentPkg = {
+  name: string;
+  currentRange: string;
+  source: CurrentPkgSource;
+  variantPattern?: string | null;
+  componentId?: ComponentID;
+  isAuto?: boolean;
+
+  targetField: ManifestDependenciesKeysNames;
+};
+
+export type OutdatedPkg = CurrentPkg & {
+  latestRange: string;
+};
+
+export type ComponentModelVersion = {
+  name: string;
+  version: string;
+  componentId: ComponentID;
+  lifecycleType: DependencyLifecycleType;
+  isAuto: boolean;
+};
+
+/**
+ * Get packages from root policy, variants, and component config files (component.json files).
+ */
+export function getAllPolicyPkgs({
+  rootPolicy,
+  variantPoliciesByPatterns,
+  componentPolicies,
+  componentModelVersions,
+}: {
+  rootPolicy: WorkspacePolicy;
+  variantPoliciesByPatterns: Record<string, VariantPolicyConfigObject>;
+  componentPolicies: Array<{ componentId: ComponentID; policy: any }>;
+  componentModelVersions: ComponentModelVersion[];
+}): CurrentPkg[] {
+  const pkgsFromPolicies = getPkgsFromRootPolicy(rootPolicy);
+  const pkgsNamesFromPolicies = new Set(pkgsFromPolicies.map(({ name }) => name));
+  return [
+    ...pkgsFromPolicies,
+    ...getPkgsFromVariants(variantPoliciesByPatterns),
+    ...getPkgsFromComponents(componentPolicies),
+    ...componentModelVersions
+      .filter(({ name }) => !pkgsNamesFromPolicies.has(name))
+      .map((componentDep) => ({
+        name: componentDep.name,
+        currentRange: componentDep.version,
+        source: 'component-model' as const,
+        isAuto: componentDep.isAuto,
+        componentId: componentDep.componentId,
+        targetField: KEY_NAME_BY_LIFECYCLE_TYPE[componentDep.lifecycleType] as ManifestDependenciesKeysNames,
+      })),
+  ];
+}
+
+function getPkgsFromRootPolicy(rootPolicy: WorkspacePolicy): CurrentPkg[] {
+  return rootPolicy.entries.map((entry) => ({
+    name: entry.dependencyId,
+    currentRange: entry.value.version,
+    source: 'rootPolicy',
+    variantPattern: null as string | null,
+    targetField: KEY_NAME_BY_LIFECYCLE_TYPE[entry.lifecycleType] as ManifestDependenciesKeysNames,
+  }));
+}
+
+function getPkgsFromVariants(variantPoliciesByPatterns: Record<string, VariantPolicyConfigObject>): CurrentPkg[] {
+  return Object.entries(variantPoliciesByPatterns)
+    .filter(([, variant]) => variant != null)
+    .map(([variantPattern, variant]) => {
+      return readAllDependenciesFromPolicyObject({ source: 'variants', variantPattern }, variant);
+    })
+    .flat();
+}
+
+function getPkgsFromComponents(
+  componentPolicies: Array<{ componentId: ComponentID; policy: VariantPolicyConfigObject }>
+): CurrentPkg[] {
+  return componentPolicies
+    .map(({ componentId, policy }) => {
+      return readAllDependenciesFromPolicyObject({ source: 'component', componentId }, policy);
+    })
+    .flat();
+}
+
+function readAllDependenciesFromPolicyObject(
+  context: Pick<CurrentPkg, 'source' | 'componentId' | 'variantPattern'>,
+  policy: VariantPolicyConfigObject
+): CurrentPkg[] {
+  if (!policy) return [];
+  const pkgs: CurrentPkg[] = [];
+  for (const targetField of [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+  ] as ManifestDependenciesKeysNames[]) {
+    for (const [name, currentRange] of Object.entries(policy[targetField] ?? {})) {
+      if (currentRange !== '-') {
+        pkgs.push({
+          ...context,
+          name,
+          currentRange:
+            typeof currentRange === 'string' ? currentRange : (currentRange as VariantPolicyEntryValue).version,
+          targetField,
+        });
+      }
+    }
+  }
+  return pkgs;
+}

package/index.ts

@@ -0,0 +1,70 @@
+import { DependencyResolverAspect } from './dependency-resolver.aspect';
+
+export type { UpdatedComponent } from './apply-updates';
+export type { RawComponentState, ComponentsManifestsMap, RegistriesMap } from './types';
+export { WorkspaceManifest, ComponentManifest } from './manifest';
+export type { CreateFromComponentsOptions, ManifestDependenciesObject } from './manifest';
+export { Registries, Registry } from './registry';
+export type {
+  InstallationContext,
+  PackageImportMethod,
+  PackageManager,
+  PackageManagerInstallOptions,
+  PackageManagerResolveRemoteVersionOptions,
+  ResolvedPackageVersion,
+} from './package-manager';
+export type {
+  DependencyResolverMain,
+  DependencyResolverWorkspaceConfig,
+  DependencyResolverVariantConfig,
+  MergedOutdatedPkg,
+  NodeLinker,
+} from './dependency-resolver.main.runtime';
+export { NPM_REGISTRY, BIT_CLOUD_REGISTRY } from './dependency-resolver.main.runtime';
+export type {
+  ProxyConfig as PackageManagerProxyConfig,
+  NetworkConfig as PackageManagerNetworkConfig,
+} from './dependency-resolver.main.runtime';
+export { DependencyList, BaseDependency, ComponentDependency, KEY_NAME_BY_LIFECYCLE_TYPE } from './dependencies';
+export type {
+  DependencyLifecycleType,
+  WorkspaceDependencyLifecycleType,
+  DependencyFactory,
+  SerializedDependency,
+  Dependency,
+  SemverVersion,
+  DependenciesManifest,
+} from './dependencies';
+export { WorkspacePolicy, VariantPolicy, EnvPolicy } from './policy';
+export type {
+  WorkspacePolicyEntry,
+  WorkspacePolicyConfigObject,
+  VariantPolicyConfigObject,
+  Policy,
+  PolicySemver,
+  PolicyConfigKeys,
+  PolicyConfigKeysNames,
+  PolicyEntry,
+  SerializedVariantPolicy,
+  WorkspacePolicyConfigKeysNames,
+  EnvPolicyConfigObject,
+} from './policy';
+export { DependencyLinker } from './dependency-linker';
+export type {
+  CoreAspectLinkResult,
+  LinkDetail,
+  LinkResults,
+  LinkingOptions,
+  DepsLinkedToEnvResult,
+  NestedNMDepsLinksResult,
+  LinkToDirResult,
+} from './dependency-linker';
+export { DependencyInstaller } from './dependency-installer';
+export type { GetComponentManifestsOptions, InstallOptions, InstallArgs } from './dependency-installer';
+export type { DependencyDetector, FileContext } from './dependency-detector';
+export type { DependencySource, VariantPolicyEntry } from './policy/variant-policy/variant-policy';
+export type { OutdatedPkg } from './get-all-policy-pkgs';
+export { extendWithComponentsFromDir } from './extend-with-components-from-dir';
+export { isRange } from './manifest/deduping/hoist-dependencies';
+export type { DependencyEnv } from './dependency-env';
+export { DependencyResolverAspect as default, DependencyResolverAspect };

package/package-manager-legacy.ts

@@ -0,0 +1,137 @@
+/* eslint-disable no-empty */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Capsule } from '@teambit/isolator';
+import { Logger } from '@teambit/logger';
+import { pipeOutput } from '@teambit/legacy/dist/utils/child_process';
+import createSymlinkOrCopy from '@teambit/legacy/dist/utils/fs/create-symlink-or-copy';
+import { EventEmitter } from 'events';
+import execa from 'execa';
+import fs from 'fs-extra';
+import mapSeries from 'p-map-series';
+import path, { join } from 'path';
+
+export default class PackageManager {
+  private emitter = new EventEmitter();
+  constructor(readonly packageManagerName: string, readonly logger: Logger) {}
+
+  get name() {
+    return this.packageManagerName;
+  }
+  async checkIfFileExistsInCapsule(capsule: Capsule, file: string) {
+    const pathToFile = join(capsule.wrkDir, file);
+    try {
+      await capsule.fs.promises.access(pathToFile);
+      return true;
+    } catch (e: any) {}
+    return false;
+  }
+
+  async removeLockFilesInCapsule(capsule: Capsule) {
+    async function safeUnlink(toRemove: string) {
+      try {
+        await capsule.fs.promises.unlink(join(capsule.wrkDir, toRemove));
+      } catch (e: any) {}
+    }
+    await safeUnlink('yarn.lock');
+    await safeUnlink('package-lock.json');
+  }
+  async capsulesInstall(capsules: Capsule[], opts: {} = {}) {
+    const packageManager = this.packageManagerName;
+    const longProcessLogger = this.logger.createLongProcessLogger('installing capsules', capsules.length);
+    if (packageManager === 'npm' || packageManager === 'yarn' || packageManager === 'pnpm') {
+      // Don't run them in parallel (Promise.all), the package-manager doesn't handle it well.
+      await mapSeries(capsules, async (capsule) => {
+        const componentId = capsule.component.id.toString();
+        longProcessLogger.logProgress(componentId);
+        // TODO: remove this hack once harmony supports ownExtensionName
+        const execOptions = { cwd: capsule.wrkDir };
+        const getExecCall = () => {
+          switch (packageManager) {
+            case 'npm':
+              return execa('npm', ['install', '--no-package-lock'], execOptions);
+            case 'yarn':
+              return execa('yarn', [], execOptions);
+            case 'pnpm':
+              return execa('pnpm', ['install'], execOptions);
+            default:
+              throw new Error(`unsupported package manager ${packageManager}`);
+          }
+        };
+        const installProc = getExecCall();
+        this.logger.info(`${componentId}, ${packageManager === 'npm' ? '$ npm install --no-package-lock' : '$ yarn'}`); // TODO: better
+        installProc.stdout!.on('data', (d) => this.logger.info(`${componentId}, ${d.toString()}`));
+        installProc.stderr!.on('data', (d) => this.logger.warn(`${componentId}, ${d.toString()}`));
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        installProc.on('error', (e) => {
+          console.log('error:', e); // eslint-disable-line no-console
+          this.logger.error(`${componentId}, ${e}`);
+        });
+        await installProc;
+        linkBitLegacyInCapsule(capsule);
+      });
+    } else {
+      throw new Error(`unsupported package manager ${packageManager}`);
+    }
+    longProcessLogger.end();
+    return null;
+  }
+
+  async runInstallInFolder(folder: string, opts: {} = {}): Promise<void> {
+    const packageManager = this.packageManagerName;
+    if (packageManager === 'yarn') {
+      const child = execa('yarn', [], { cwd: folder, stdio: 'pipe' });
+      pipeOutput(child);
+      await child;
+      return;
+    }
+    if (packageManager === 'npm') {
+      const child = execa('npm', ['install'], { cwd: folder, stdio: 'pipe' });
+      this.logger.info(`${folder} $ npm install`);
+      await new Promise((resolve, reject) => {
+        // @ts-ignore
+        child.stdout.on('data', (d) => this.logger.info(`${folder} ${d.toString()}`));
+        // @ts-ignore
+        child.stderr.on('data', (d) => this.logger.warn(`${folder} ${d.toString()}`));
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        child.on('error', (e) => {
+          reject(e);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        child.on('close', (exitStatus) => {
+          if (exitStatus) {
+            reject(new Error(`${folder}`));
+          } else {
+            resolve(null);
+          }
+        });
+      });
+      return;
+    }
+    throw new Error(`unsupported package manager ${packageManager}`);
+  }
+}
+
+function linkBitLegacyInCapsule(capsule) {
+  const bitLegacyPath = path.join(capsule.wrkDir, './node_modules/@teambit/legacy');
+  const getLocalBitLegacyPath = () => {
+    const pathOutsideNodeModules = path.join(__dirname, '../..');
+    if (pathOutsideNodeModules.endsWith(`${path.sep}dist`)) {
+      return pathOutsideNodeModules;
+    }
+    throw new Error('unable to link @teambit/legacy to the capsule, the location of @teambit/legacy is unknown');
+  };
+  const localBitLegacyPath = getLocalBitLegacyPath();
+  // if there are no deps, sometimes the node_modules folder is not created
+  // and we need it in order to perform the linking
+  try {
+    capsule.fs.mkdirSync('node_modules');
+  } catch (e: any) {
+    // fail silently - we only need to create it if it doesn't already exist
+  }
+  // we use fs directly here rather than the capsule.fs because there are some edge cases
+  // that the capusle fs does not deal with well (eg. identifying and deleting
+  // a symlink rather than the what the symlink links to)
+  fs.removeSync(bitLegacyPath);
+  createSymlinkOrCopy(localBitLegacyPath, bitLegacyPath);
+}

package/package-manager.ts

@@ -0,0 +1,174 @@
+import { PeerDependencyIssuesByProjects } from '@pnpm/core';
+import { PeerDependencyRules, ProjectManifest } from '@pnpm/types';
+import { ComponentMap } from '@teambit/component';
+import { Registries } from './registry';
+import { DepsFilterFn } from './manifest';
+import { NetworkConfig, ProxyConfig } from './dependency-resolver.main.runtime';
+
+export { PeerDependencyIssuesByProjects };
+
+export type PackageImportMethod = 'auto' | 'hardlink' | 'copy' | 'clone';
+
+export type PackageManagerInstallOptions = {
+  cacheRootDir?: string;
+  /**
+   * decide whether to dedup dependencies.
+   */
+  dedupe?: boolean;
+
+  copyPeerToRuntimeOnRoot?: boolean;
+
+  copyPeerToRuntimeOnComponents?: boolean;
+
+  excludeLinksFromLockfile?: boolean;
+
+  installPeersFromEnvs?: boolean;
+
+  dependencyFilterFn?: DepsFilterFn;
+
+  overrides?: Record<string, string>;
+
+  lockfileOnly?: boolean;
+
+  nodeLinker?: 'hoisted' | 'isolated';
+
+  packageManagerConfigRootDir?: string;
+
+  packageImportMethod?: PackageImportMethod;
+
+  rootComponents?: boolean;
+
+  rootComponentsForCapsules?: boolean;
+
+  useNesting?: boolean;
+
+  keepExistingModulesDir?: boolean;
+
+  sideEffectsCache?: boolean;
+
+  engineStrict?: boolean;
+
+  nodeVersion?: string;
+
+  peerDependencyRules?: PeerDependencyRules;
+
+  includeOptionalDeps?: boolean;
+
+  updateAll?: boolean;
+
+  hidePackageManagerOutput?: boolean;
+
+  pruneNodeModules?: boolean;
+
+  hasRootComponents?: boolean;
+
+  neverBuiltDependencies?: string[];
+
+  preferOffline?: boolean;
+
+  nmSelfReferences?: boolean;
+
+  /**
+   * e.g. when running `bit install` through the web or the IDE, not from the CLI.
+   */
+  optimizeReportForNonTerminal?: boolean;
+
+  /**
+   * Sets the frequency of updating the progress output in milliseconds.
+   * E.g., if this is set to 1000, then the progress will be updated every second.
+   */
+  throttleProgress?: number;
+
+  hideProgressPrefix?: boolean;
+
+  hideLifecycleOutput?: boolean;
+
+  /**
+   * Do installation using lockfile only. Ignore the component manifests.
+   */
+  ignorePackageManifest?: boolean;
+
+  /**
+   * When enabled, installation by the package manager will be skipped
+   * but all the options will be calculated and the rebuild function will be returned.
+   * We use this option for a performance optimization in Ripple CI.
+   */
+  dryRun?: boolean;
+
+  dedupeInjectedDeps?: boolean;
+};
+
+export type PackageManagerGetPeerDependencyIssuesOptions = PackageManagerInstallOptions;
+
+export type ResolvedPackageVersion = {
+  packageName: string;
+  version: string | null;
+  wantedRange?: string;
+  isSemver: boolean;
+  resolvedVia?: string;
+};
+
+export type PackageManagerResolveRemoteVersionOptions = {
+  rootDir: string;
+  cacheRootDir?: string;
+  packageManagerConfigRootDir?: string;
+  // fetchToCache?: boolean;
+  // update?: boolean;
+};
+
+export interface InstallationContext {
+  rootDir: string;
+  manifests: Record<string, ProjectManifest>;
+  componentDirectoryMap: ComponentMap<string>;
+}
+
+export interface PackageManager {
+  /**
+   * Name of the package manager
+   */
+  name: string;
+  /**
+   * install dependencies
+   * @param componentDirectoryMap
+   */
+  install(
+    context: InstallationContext,
+    options: PackageManagerInstallOptions
+  ): Promise<{ dependenciesChanged: boolean }>;
+
+  pruneModules?(rootDir: string): Promise<void>;
+
+  resolveRemoteVersion(
+    packageName: string,
+    options: PackageManagerResolveRemoteVersionOptions
+  ): Promise<ResolvedPackageVersion>;
+
+  getPeerDependencyIssues?(
+    rootDir: string,
+    manifests: Record<string, ProjectManifest>,
+    options: PackageManagerGetPeerDependencyIssuesOptions
+  ): Promise<PeerDependencyIssuesByProjects>;
+
+  getInjectedDirs?(rootDir: string, componentDir: string, packageName: string): Promise<string[]>;
+
+  getRegistries?(): Promise<Registries>;
+
+  getProxyConfig?(): Promise<ProxyConfig>;
+
+  getNetworkConfig?(): Promise<NetworkConfig>;
+
+  /**
+   * Specify if the package manager can be run with deduping on existing worksapce (which already contains root dependencies)
+   * again, with a different context.
+   * If the package manager is not capable of doing so, we want to disable the deduping.
+   */
+  supportsDedupingOnExistingRoot?: () => boolean;
+
+  /**
+   * Returns "dependencies" entries for ".bit_roots".
+   * These entries tell the package manager from where to the local components should be installed.
+   */
+  getWorkspaceDepsOfBitRoots(manifests: ProjectManifest[]): Record<string, string>;
+
+  findUsages?(depName: string, opts: { lockfileDir: string; depth?: number }): Promise<string>;
+}