@teambit/dependencies 1.0.227 → 1.0.229

package/dist/dependencies-cmd.d.ts

@@ -0,0 +1,169 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { DependenciesMain } from './dependencies.main.runtime';
+type GetDependenciesFlags = {
+    tree: boolean;
+    scope?: boolean;
+};
+export type SetDependenciesFlags = {
+    dev?: boolean;
+    optional?: boolean;
+    peer?: boolean;
+};
+export type RemoveDependenciesFlags = SetDependenciesFlags;
+export declare class DependenciesGetCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([id]: [string], { tree, scope }: GetDependenciesFlags): Promise<any>;
+}
+export declare class DependenciesDebugCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([id]: [string]): Promise<string>;
+}
+export declare class DependenciesSetCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([pattern, packages]: [string, string[]], setDepsFlags: SetDependenciesFlags): Promise<string>;
+}
+export declare class DependenciesRemoveCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([pattern, packages]: [string, string[]], removeDepsFlags: RemoveDependenciesFlags): Promise<string>;
+}
+export declare class DependenciesUnsetCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([pattern, packages]: [string, string[]], removeDepsFlags: RemoveDependenciesFlags): Promise<string>;
+}
+export declare class DependenciesResetCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([pattern]: [string]): Promise<string>;
+}
+export declare class DependenciesEjectCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([pattern]: [string]): Promise<string>;
+}
+export declare class DependenciesBlameCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([compName, depName]: [string, string]): Promise<string>;
+}
+type DependenciesUsageCmdOptions = {
+    depth?: number;
+};
+export declare class DependenciesUsageCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: CommandOptions;
+    constructor(deps: DependenciesMain);
+    report([depName]: [string], options: DependenciesUsageCmdOptions): Promise<string>;
+}
+export declare class WhyCmd extends DependenciesUsageCmd {
+    name: string;
+}
+export declare class DependenciesCmd implements Command {
+    name: string;
+    alias: string;
+    description: string;
+    options: never[];
+    group: string;
+    commands: Command[];
+    helpUrl: string;
+    report([unrecognizedSubcommand]: [string]): Promise<string>;
+}
+export declare class SetPeerCmd implements Command {
+    private deps;
+    name: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    group: string;
+    description: string;
+    alias: string;
+    options: never[];
+    constructor(deps: DependenciesMain);
+    report([componentId, range]: [string, string]): Promise<string>;
+}
+export {};

package/dist/dependencies-loader/apply-overrides.d.ts

@@ -0,0 +1,101 @@
+import { ComponentID } from '@teambit/component-id';
+import { IssuesList } from '@teambit/component-issues';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { Workspace } from '@teambit/workspace';
+import { Dependency } from '@teambit/legacy/dist/consumer/component/dependencies';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import OverridesDependencies from './overrides-dependencies';
+import { DependenciesData } from './dependencies-data';
+import { DebugDependencies } from './auto-detect-deps';
+export type AllDependencies = {
+    dependencies: Dependency[];
+    devDependencies: Dependency[];
+    peerDependencies: Dependency[];
+};
+export type AllPackagesDependencies = {
+    packageDependencies: Record<string, string>;
+    devPackageDependencies: Record<string, string>;
+    peerPackageDependencies: Record<string, string>;
+};
+export declare class ApplyOverrides {
+    private component;
+    private depsResolver;
+    private workspace?;
+    componentId: ComponentID;
+    componentFromModel: Component;
+    allDependencies: AllDependencies;
+    allPackagesDependencies: AllPackagesDependencies;
+    /**
+     * This will store a copy of the package deps before removal
+     * in order to apply auto detected rules that are running after the removal
+     */
+    originAllPackagesDependencies: AllPackagesDependencies;
+    issues: IssuesList;
+    coreAspects: string[];
+    processedFiles: string[];
+    overridesDependencies: OverridesDependencies;
+    debugDependenciesData: DebugDependencies;
+    autoDetectOverrides: Record<string, any> | undefined;
+    constructor(component: Component, depsResolver: DependencyResolverMain, workspace?: Workspace | undefined);
+    get consumer(): Consumer | undefined;
+    getDependenciesData(): Promise<{
+        dependenciesData: DependenciesData;
+        overridesDependencies: OverridesDependencies;
+        autoDetectOverrides?: Record<string, any>;
+    }>;
+    /**
+     * Given the tree of file dependencies from the driver, find the components of these files.
+     * Each dependency file has a path, use bit.map to search for the component name by that path.
+     * If the component is found, add it to "this.allDependencies.dependencies". Otherwise, add it to "this.issues.untrackedDependencies".
+     *
+     * For the found components, add their sourceRelativePath and destinationRelativePath, they are being used for
+     * generating links upon import:
+     * sourceRelativePath - location of the link file.
+     * destinationRelativePath - destination written inside the link file.
+     *
+     * When a dependency is found in a regular (implementation) file, it goes to `dependencies`. If
+     * it found on a test file, it goes to `devDependencies`.
+     * Similarly, when a package is found in a regular file, it goes to `packageDependencies`. When
+     * if found in a test file, it goes to `devPackageDependencies`.
+     * An exception for the above is when a package is required in a regular or test file but is also
+     * mentioned in the `package.json` file as a peerDependency, in that case, the package is added
+     * to `peerPackageDependencies` and removed from other places. Unless this package is overridden
+     * and marked as ignored in the consumer or component config file.
+     */
+    private populateDependencies;
+    private removeIgnoredComponentsByOverrides;
+    private loadAutoDetectOverrides;
+    private cloneAllPackagesDependencies;
+    private removeIgnoredPackagesByOverrides;
+    private _resolvePackageData;
+    private _getComponentIdToAdd;
+    getDependenciesToAddManually(packageJson: Record<string, any> | null | undefined, existingDependencies: AllDependencies): {
+        components: Record<string, any>;
+        packages: Record<string, any>;
+    } | undefined;
+    private manuallyAddDependencies;
+    /**
+     * Remove the dependencies which appear both in dev and regular deps from the dev
+     * Because if a dependency is both dev dependency and regular dependency it should be treated as regular one
+     * Apply for both packages and components dependencies
+     */
+    private removeDevAndEnvDepsIfTheyAlsoRegulars;
+    private applyPeersFromComponentModel;
+    private applyPackageJson;
+    private applyWorkspacePolicy;
+    /**
+     * It removes the @teambit/legacy dependency from the dependencies/devDeps and adds it as a peer dependency with ^.
+     */
+    private makeLegacyAsPeer;
+    private applyAutoDetectOverridesOnComponent;
+    private applyAutoDetectedPeersFromEnvOnEnvItSelf;
+    /**
+     * returns `package.json` of the component when it's imported, or `package.json` of the workspace
+     * when it's authored.
+     */
+    private _getPackageJson;
+    private _getPackageJsonFromComponentModel;
+    private setLegacyInsideHarmonyIssue;
+    private _pkgFieldMapping;
+}

package/dist/dependencies-loader/auto-detect-deps.d.ts

@@ -0,0 +1,164 @@
+import { ComponentID } from '@teambit/component-id';
+import { IssuesList } from '@teambit/component-issues';
+import Consumer from '@teambit/legacy/dist/consumer/consumer';
+import { PathOsBased } from '@teambit/legacy/dist/utils/path';
+import ComponentMap from '@teambit/legacy/dist/consumer/bit-map/component-map';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { DependenciesTree } from '@teambit/legacy/dist/consumer/component/dependencies/files-dependency-builder/types/dependency-tree-type';
+import { DevFilesMain } from '@teambit/dev-files';
+import { Workspace } from '@teambit/workspace';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { DependencyDetector } from '@teambit/legacy/dist/consumer/component/dependencies/files-dependency-builder/detector-hook';
+import { DependenciesData } from './dependencies-data';
+import { AllDependencies, AllPackagesDependencies } from './apply-overrides';
+export type FileType = {
+    isTestFile: boolean;
+};
+export type DebugDependencies = {
+    components: DebugComponentsDependency[];
+    unidentifiedPackages?: string[];
+};
+export type DebugComponentsDependency = {
+    id: ComponentID;
+    importSource?: string;
+    dependencyPackageJsonPath?: string;
+    dependentPackageJsonPath?: string;
+    versionResolvedFrom?: 'DependencyPkgJson' | 'DependentPkgJson' | 'BitMap' | 'Model' | 'MergeConfig' | string;
+    version?: string;
+    componentIdResolvedFrom?: 'DependencyPkgJson' | 'DependencyPath';
+    packageName?: string;
+};
+export declare class AutoDetectDeps {
+    private component;
+    private workspace;
+    private devFiles;
+    private depsResolver;
+    private aspectLoader;
+    componentId: ComponentID;
+    componentMap: ComponentMap;
+    componentFromModel: Component;
+    consumerPath: PathOsBased;
+    tree: DependenciesTree;
+    allDependencies: AllDependencies;
+    allPackagesDependencies: AllPackagesDependencies;
+    issues: IssuesList;
+    coreAspects: string[];
+    processedFiles: string[];
+    debugDependenciesData: DebugDependencies;
+    autoDetectConfigMerge: Record<string, any>;
+    constructor(component: Component, workspace: Workspace, devFiles: DevFilesMain, depsResolver: DependencyResolverMain, aspectLoader: AspectLoaderMain);
+    get consumer(): Consumer;
+    private setTree;
+    /**
+     * Resolve components and packages dependencies for a component.
+     * This method should NOT have any side-effect on the component. the DependenciesLoader class is
+     * responsible for saving this data on the component object.
+     *
+     * The process is as follows:
+     * 1) Use the language driver to parse the component files and find for each file its dependencies.
+     * 2) The results we get from the driver per file tells us what are the files and packages that depend on our file.
+     * and also whether there are missing packages and files.
+     * 3) Using the information from the driver, we go over each one of the dependencies files and find its counterpart
+     * component. The way how we find it, is by using the bit.map file which has a mapping between the component name and
+     * the file paths.
+     * 4) If we find a component to the file dependency, we add it to component.dependencies. Otherwise, it's added to
+     * component.issues.untrackedDependencies
+     * 5) Similarly, when we find the packages dependencies, they are added to component.packageDependencies. Otherwise,
+     * they're added to component.issues.missingPackagesDependenciesOnFs
+     * 6) In case the driver found a file dependency that is not on the file-system, we add that file to
+     * component.issues.missingDependenciesOnFs
+     */
+    getDependenciesData(cacheResolvedDependencies: Record<string, any>, cacheProjectAst: Record<string, any> | undefined): Promise<{
+        dependenciesData: DependenciesData;
+        debugDependenciesData: DebugDependencies;
+    }>;
+    getEnvDetectors(): Promise<DependencyDetector[] | null>;
+    /**
+     * Given the tree of file dependencies from the driver, find the components of these files.
+     * Each dependency file has a path, use bit.map to search for the component name by that path.
+     * If the component is found, add it to "this.allDependencies.dependencies". Otherwise, add it to "this.issues.untrackedDependencies".
+     *
+     * For the found components, add their sourceRelativePath and destinationRelativePath, they are being used for
+     * generating links upon import:
+     * sourceRelativePath - location of the link file.
+     * destinationRelativePath - destination written inside the link file.
+     *
+     * When a dependency is found in a regular (implementation) file, it goes to `dependencies`. If
+     * it found on a test file, it goes to `devDependencies`.
+     * Similarly, when a package is found in a regular file, it goes to `packageDependencies`. When
+     * if found in a test file, it goes to `devPackageDependencies`.
+     * An exception for the above is when a package is required in a regular or test file but is also
+     * mentioned in the `package.json` file as a peerDependency, in that case, the package is added
+     * to `peerPackageDependencies` and removed from other places. Unless this package is overridden
+     * and marked as ignored in the consumer or component config file.
+     */
+    private populateDependencies;
+    private throwForNonExistFile;
+    private getComponentIdByResolvedPackageData;
+    /**
+     * this happens when using relative paths between components, which is allowed on Legacy only.
+     * on Harmony, during the execution of this function, it recognizes the use of relative-paths, enter
+     * it to the "issues", then, later, it shows a warning on bit-status and block tagging.
+     */
+    private getComponentIdByDepFile;
+    private processDepFiles;
+    private processOneDepFile;
+    /**
+     * process require/import of Bit components where the require statement is not a relative path
+     * but a module path, such as `require('@bit/bit.envs/compiler/babel');`
+     */
+    private processComponents;
+    private isPkgInWorkspacePolicies;
+    private addImportNonMainIssueIfNeeded;
+    private processPackages;
+    private processMissing;
+    private processErrors;
+    /**
+     * when a user uses core-extensions these core-extensions should not be dependencies.
+     * here, we filter them out from all places they could entered as dependencies.
+     * an exception is when running this method on bit-core-extensions themselves (dogfooding), in
+     * which case we recognizes that the current originFile is a core-extension and avoid filtering.
+     */
+    private processCoreAspects;
+    /**
+     * ** LEGACY ONLY **
+     * This is related to a legacy feature "custom-module-resolution". the code was removed, only the debug is still there, just in case.
+     *
+     * ** OLD COMMENT **
+     * currently the only unidentified packages being process are the ones coming from custom-modules-resolution.
+     * assuming the author used custom-resolution, which enable using non-relative import syntax,
+     * for example, requiring the file 'src/utils/is-string' from anywhere as require('utils/is-string');
+     * now, when the component is imported, the driver recognizes 'utils/is-string' as a package,
+     * because it's not relative.
+     * the goal here is to use the 'package' the driver found and match it with one of the
+     * dependencies from the model. In the example above, we might find in the model, a dependency
+     * is-string with importSource of 'utils/is-string'.
+     * Once a match is found, copy the relativePaths from the model.
+     *
+     * keep in mind that this custom-modules-resolution supported on legacy components only.
+     * as such, no need to find the packageName to pass to _pushToDependenciesIfNotExist method.
+     */
+    private processUnidentifiedPackages;
+    private _pushToDependenciesIfNotExist;
+    private pushToDependenciesArray;
+    private getExistingDependency;
+    private getExistingDepRelativePaths;
+    private getDiffSpecifiers;
+    /**
+     * when requiring packages in typescript, sometimes there are the types packages with the same
+     * name, which the user probably wants as well. for example, requiring `foo` package, will also
+     * add `@types/foo` to the devDependencies if it has been found in the user `package.json` file.
+     *
+     * ideally this should be in bit-javascript. however, the decision where to put these `@types`
+     * packages (dependencies/devDependencies) is done here according to the user `package.json`
+     * and can't be done there because the `Tree` we get from bit-javascript doesn't have this
+     * distinction.
+     */
+    private _addTypesPackagesForTypeScript;
+    private _pushToUntrackDependenciesIssues;
+    private _pushToRelativeComponentsAuthoredIssues;
+    private _pushToMissingDependenciesOnFs;
+    private _pushToMissingPackagesDependenciesIssues;
+}
+export declare function getValidVersion(version: string | undefined): string | null;

package/dist/dependencies-loader/dependencies-data.d.ts

@@ -0,0 +1,17 @@
+import { IssuesList } from '@teambit/component-issues';
+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 declare class DependenciesData {
+    allDependencies: AllDependencies;
+    allPackagesDependencies: AllPackagesDependencies;
+    issues: IssuesList;
+    coreAspects: string[];
+    constructor(allDependencies: AllDependencies, allPackagesDependencies: AllPackagesDependencies, issues: IssuesList, coreAspects: string[]);
+    serialize(): string;
+    static deserialize(data: string): DependenciesData;
+}

package/dist/dependencies-loader/dependencies-loader.d.ts

@@ -0,0 +1,28 @@
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { DependencyLoaderOpts } from '@teambit/legacy/dist/consumer/component/component-loader';
+import { Workspace } from '@teambit/workspace';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { DevFilesMain } from '@teambit/dev-files';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { DependenciesData } from './dependencies-data';
+import { DebugDependencies } from './auto-detect-deps';
+import OverridesDependencies from './overrides-dependencies';
+export declare class DependenciesLoader {
+    private component;
+    private depsResolver;
+    private devFiles;
+    private aspectLoader;
+    private idStr;
+    constructor(component: Component, depsResolver: DependencyResolverMain, devFiles: DevFilesMain, aspectLoader: AspectLoaderMain);
+    load(workspace: Workspace, opts: DependencyLoaderOpts): Promise<{
+        dependenciesData: DependenciesData;
+        overridesDependencies: OverridesDependencies;
+        debugDependenciesData: DebugDependencies;
+    }>;
+    loadFromScope(dependenciesData: Partial<DependenciesData>): Promise<void>;
+    private getDependenciesData;
+    private getDependenciesDataFromCacheIfPossible;
+    private shouldSaveInCache;
+    private setDependenciesDataOnComponent;
+    private pushToDependencyResolverExtension;
+}

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

@@ -0,0 +1,6 @@
+import { Workspace } from '@teambit/workspace';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import OverridesDependencies from './overrides-dependencies';
+import { DebugComponentsDependency } from './auto-detect-deps';
+export declare function updateDependenciesVersions(depsResolver: DependencyResolverMain, workspace: Workspace, component: Component, overridesDependencies: OverridesDependencies, autoDetectOverrides?: Record<string, any>, debugDependencies?: DebugComponentsDependency[], updateExtensionsVersions?: boolean): void;

package/dist/dependencies-loader/index.d.ts

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

package/dist/dependencies-loader/overrides-dependencies.d.ts

@@ -0,0 +1,17 @@
+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);
+    shouldIgnorePackage(packageName: string, fileType: FileType): boolean;
+    shouldIgnorePackageByType(packageName: string, field: string): boolean;
+    shouldIgnorePeerPackage(packageName: string): boolean;
+    getDependenciesToAddManually(): Record<string, any> | undefined;
+    _manuallyAddPackage(field: string, dependency: string, dependencyValue: string, packageJson: Record<string, any> | null | undefined): Record<string, any> | null | undefined;
+    _addManuallyRemovedDep(field: string, value: string): void;
+    _addManuallyAddedDep(field: string, value: string): void;
+}

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

@@ -0,0 +1 @@
+export declare function packageToDefinetlyTyped(pkgName: string): string;

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

@@ -0,0 +1 @@
+export {};

package/dist/dependencies.aspect.d.ts

@@ -0,0 +1,2 @@
+import { Aspect } from '@teambit/harmony';
+export declare const DependenciesAspect: Aspect;

package/dist/dependencies.main.runtime.d.ts

@@ -0,0 +1,98 @@
+import { CLIMain } from '@teambit/cli';
+import { ComponentID } from '@teambit/component-id';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Workspace } from '@teambit/workspace';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import { DependencyLoaderOpts } from '@teambit/legacy/dist/consumer/component/component-loader';
+import { DevFilesMain } from '@teambit/dev-files';
+import { ComponentIdGraph, GraphMain } from '@teambit/graph';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { ScopeMain } from '@teambit/scope';
+import { DependenciesData, OverridesDependenciesData } from './dependencies-loader/dependencies-data';
+import { RemoveDependenciesFlags, SetDependenciesFlags } from './dependencies-cmd';
+import { DebugDependencies } from './dependencies-loader/auto-detect-deps';
+export type RemoveDependencyResult = {
+    id: ComponentID;
+    removedPackages: string[];
+};
+export type SetDependenciesResult = {
+    changedComps: string[];
+    addedPackages: Record<string, string>;
+};
+export type DependenciesResultsDebug = DebugDependencies & OverridesDependenciesData & {
+    coreAspects: string[];
+    sources: {
+        id: string;
+        source: string;
+    }[];
+};
+export type DependenciesResults = {
+    graph: ComponentIdGraph;
+    id: ComponentID;
+};
+export type BlameResult = {
+    snap: string;
+    tag?: string;
+    author: string;
+    date: string;
+    message: string;
+    version: string;
+};
+export declare class DependenciesMain {
+    private workspace;
+    private scope;
+    private dependencyResolver;
+    private devFiles;
+    private aspectLoader;
+    private graph;
+    constructor(workspace: Workspace, scope: ScopeMain, dependencyResolver: DependencyResolverMain, devFiles: DevFilesMain, aspectLoader: AspectLoaderMain, graph: GraphMain);
+    setPeer(componentId: string, range?: string): Promise<void>;
+    setDependency(componentPattern: string, packages: string[], options?: SetDependenciesFlags): Promise<SetDependenciesResult>;
+    removeDependency(componentPattern: string, packages: string[], options?: RemoveDependenciesFlags, removeOnlyIfExists?: boolean): Promise<RemoveDependencyResult[]>;
+    reset(componentPattern: string): Promise<ComponentID[]>;
+    eject(componentPattern: string): Promise<ComponentID[]>;
+    getDependencies(id: string, scope?: boolean): Promise<DependenciesResults>;
+    loadDependencies(component: ConsumerComponent, opts: DependencyLoaderOpts): Promise<{
+        dependenciesData: DependenciesData;
+        overridesDependencies: import("./dependencies-loader/overrides-dependencies").default;
+        debugDependenciesData: DebugDependencies;
+    }>;
+    /**
+     * load dependencies without the need for the workspace.
+     * the "auto-detect" are passed here as "dependenciesData". the "overrides", such as dependencies from the env,
+     * are calculated here.
+     * eventually all these dependencies are added to the ConsumerComponent object.
+     */
+    loadDependenciesFromScope(component: ConsumerComponent, dependenciesData: Partial<DependenciesData>): Promise<void>;
+    debugDependencies(id: string): Promise<DependenciesResultsDebug>;
+    /**
+     * helps determine what snap/tag changed a specific dependency.
+     * the results are sorted from the oldest to newest.
+     */
+    blame(compName: string, depName: string): Promise<BlameResult[]>;
+    usageDeep(depName: string, opts?: {
+        depth?: number;
+    }): Promise<string | undefined>;
+    /**
+     * @param depName either component-id-string or package-name (of the component or not component)
+     * @returns a map of component-id-string to the version of the dependency
+     */
+    usage(depName: string): Promise<{
+        [compIdStr: string]: string;
+    }>;
+    private getPackageNameAndVerResolved;
+    private splitPkgToNameAndVer;
+    static slots: never[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static provider([cli, workspace, depsResolver, devFiles, aspectLoader, scope, graph]: [
+        CLIMain,
+        Workspace,
+        DependencyResolverMain,
+        DevFilesMain,
+        AspectLoaderMain,
+        ScopeMain,
+        GraphMain
+    ]): Promise<DependenciesMain>;
+}
+export default DependenciesMain;

package/dist/dependencies.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { DependenciesAspect } from './dependencies.aspect';
+export type { DependenciesMain } from './dependencies.main.runtime';
+export default DependenciesAspect;
+export { DependenciesAspect };