@teambit/install 0.0.0-019dfe796cb827647fea4f5ea377789618005504

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

@@ -0,0 +1,248 @@
+import type { CompilerMain } from '@teambit/compiler';
+import type { CLIMain } from '@teambit/cli';
+import type { Workspace } from '@teambit/workspace';
+import type { GenerateResult, GeneratorMain } from '@teambit/generator';
+import type { ApplicationMain } from '@teambit/application';
+import type { VariantsMain } from '@teambit/variants';
+import type { Component } from '@teambit/component';
+import { ComponentMap } from '@teambit/component';
+import type { Harmony, SlotRegistry } from '@teambit/harmony';
+import { type DependenciesGraph } from '@teambit/objects';
+import type { CodemodResult, NodeModulesLinksResult } from '@teambit/workspace.modules.node-modules-linker';
+import type { EnvsMain } from '@teambit/envs';
+import type { IpcEventsMain } from '@teambit/ipc-events';
+import type { WorkspaceDependencyLifecycleType, DependencyResolverMain, LinkingOptions, LinkResults, WorkspacePolicy } from '@teambit/dependency-resolver';
+import type { WorkspaceConfigFilesMain } from '@teambit/workspace-config-files';
+import type { Logger, LoggerMain } from '@teambit/logger';
+import type { IssuesMain } from '@teambit/issues';
+import type { AspectLoaderMain } from '@teambit/aspect-loader';
+import type { BundlerMain } from '@teambit/bundler';
+import type { UiMain } from '@teambit/ui';
+export type WorkspaceLinkOptions = LinkingOptions & {
+    rootPolicy?: WorkspacePolicy;
+    linkToBitRoots?: boolean;
+    includePeers?: boolean;
+};
+export type WorkspaceLinkResults = {
+    legacyLinkResults?: NodeModulesLinksResult[];
+    legacyLinkCodemodResults?: CodemodResult[];
+} & LinkResults;
+export type WorkspaceInstallOptions = {
+    addMissingDeps?: boolean;
+    skipUnavailable?: boolean;
+    addMissingPeers?: boolean;
+    lifecycleType?: WorkspaceDependencyLifecycleType;
+    dedupe?: boolean;
+    import?: boolean;
+    showExternalPackageManagerPrompt?: boolean;
+    copyPeerToRuntimeOnRoot?: boolean;
+    copyPeerToRuntimeOnComponents?: boolean;
+    updateExisting?: boolean;
+    skipIfExisting?: boolean;
+    savePrefix?: string;
+    compile?: boolean;
+    includeOptionalDeps?: boolean;
+    updateAll?: boolean;
+    recurringInstall?: boolean;
+    optimizeReportForNonTerminal?: boolean;
+    lockfileOnly?: boolean;
+    writeConfigFiles?: boolean;
+    skipPrune?: boolean;
+    dependenciesGraph?: DependenciesGraph;
+};
+export type ModulesInstallOptions = Omit<WorkspaceInstallOptions, 'updateExisting' | 'lifecycleType' | 'import'>;
+type PreLink = (linkOpts?: WorkspaceLinkOptions) => Promise<void>;
+type PreInstall = (installOpts?: WorkspaceInstallOptions) => Promise<void>;
+type PostInstall = () => Promise<void>;
+type PreLinkSlot = SlotRegistry<PreLink>;
+type PreInstallSlot = SlotRegistry<PreInstall>;
+type PostInstallSlot = SlotRegistry<PostInstall>;
+export declare class InstallMain {
+    private dependencyResolver;
+    private logger;
+    private workspace;
+    private variants;
+    private compiler;
+    private envs;
+    private wsConfigFiles;
+    private aspectLoader;
+    private app;
+    private generator;
+    private preLinkSlot;
+    private preInstallSlot;
+    private postInstallSlot;
+    private ipcEvents;
+    private harmony;
+    private visitedAspects;
+    private oldNonLoadedEnvs;
+    constructor(dependencyResolver: DependencyResolverMain, logger: Logger, workspace: Workspace, variants: VariantsMain, compiler: CompilerMain, envs: EnvsMain, wsConfigFiles: WorkspaceConfigFilesMain, aspectLoader: AspectLoaderMain, app: ApplicationMain, generator: GeneratorMain, preLinkSlot: PreLinkSlot, preInstallSlot: PreInstallSlot, postInstallSlot: PostInstallSlot, ipcEvents: IpcEventsMain, harmony: Harmony);
+    /**
+     * Install dependencies for all components in the workspace
+     *
+     * @returns
+     * @memberof Workspace
+     */
+    install(packages?: string[], options?: WorkspaceInstallOptions): Promise<ComponentMap<string>>;
+    registerPreLink(fn: PreLink): void;
+    registerPreInstall(fn: PreInstall): void;
+    registerPostInstall(fn: PostInstall): void;
+    onComponentCreate(generateResults: GenerateResult[], installOptions?: Partial<WorkspaceInstallOptions>): Promise<void>;
+    private _addPackages;
+    private _installModules;
+    private shouldClearCacheOnInstall;
+    /**
+     * This function is very important to fix some issues that might happen during the installation process.
+     * The case is the following:
+     * during/before the installation process we load some envs from their bit.env files
+     * this contains code like:
+     * protected tsconfigPath = require.resolve('./config/tsconfig.json');
+     * protected eslintConfigPath = require.resolve('./config/eslintrc.cjs');
+     * When we load that file, we calculated the resolved path, and it's stored in the env
+     * object instance.
+     * then later on during the install we move the env to another location (like bit roots)
+     * which points to a .pnpm folder with some peers, that changed during the install
+     * then when we take this env object and call write ws config for example
+     * or compile
+     * we use that resolved path to calculate the final tsconfig
+     * however that file is no longer exists which result in an error
+     * This function will check if an env folder doesn't exist anymore, and will re-load it
+     * from its new location.
+     * This usually happen when we have install running in the middle of the process followed
+     * by other bit ops.
+     * examples:
+     * bit new - which might run few installs then other ops.
+     * bit switch - which might run few installs then other ops, and potentially change the
+     * peer deps during the install.
+     * bit server (vscode plugin) - which keep the process always live, so any install ops
+     * that change the location, will cause the vscode plugin/bit server to crash later.
+     * @returns
+     */
+    private reloadMovedEnvs;
+    private reloadRegisteredEnvs;
+    private reloadNonLoadedEnvs;
+    private reloadEnvs;
+    private reloadAspects;
+    private reloadOneAspectsGroup;
+    /**
+     * This function groups the components to aspects to load into groups.
+     * The order of the groups is important, the first group should be loaded first.
+     * The order inside the group is not important.
+     * The groups are:
+     * 1. aspects definitions without components (this should be an empty group, if it's not, we should check why).
+     * 2. aspects which are not in the workspace but in the scope / node modules.
+     * 3. envs of aspects (which are also aspects)
+     * 4. other aspects (the rest)
+     * @param aspects
+     * @returns
+     */
+    private groupAspectsToLoad;
+    private regroupEnvsIdsFromTheList;
+    private _getComponentsManifestsAndRootPolicy;
+    /**
+     * The function `tryWriteConfigFiles` attempts to write workspace config files, and if it fails, it logs an error
+     * message.
+     * @returns If the condition `!shouldWrite` is true, then nothing is being returned. Otherwise, if the `writeConfigFiles`
+     * function is successfully executed, nothing is being returned. If an error occurs during the execution of
+     * `writeConfigFiles`, an error message is being returned.
+     */
+    private tryWriteConfigFiles;
+    private addConfiguredAspectsToWorkspacePolicy;
+    private addConfiguredGeneratorEnvsToWorkspacePolicy;
+    private _addMissingPackagesToRootPolicy;
+    private _getMissingPackagesWithoutRootDeps;
+    private _getAllMissingPackages;
+    private _getComponentsManifests;
+    setOldNonLoadedEnvs(): string[];
+    /**
+     * This function returns a list of old non-loaded environments names.
+     * @returns an array of strings called `oldNonLoadedEnvs`. This array contains the names of environment variables that
+     * failed to load as extensions and are also don't have an env.jsonc file.
+     * If this list is not empty, then the user might need to run another install to make sure all dependencies resolved
+     * correctly
+     */
+    getOldNonLoadedEnvs(): string[];
+    private _updateRootDirs;
+    private _getRootManifests;
+    private _getEnvManifests;
+    private _getEnvDependencies;
+    /**
+     * Return the package name of the env with its version.
+     * (only if the env is not a core env and is not in the workspace)
+     * @param envId
+     * @returns
+     */
+    private _getEnvPackage;
+    private _getAppManifests;
+    private _getAllUsedEnvIds;
+    /**
+     * Updates out-of-date dependencies in the workspace.
+     *
+     * @param options.all {Boolean} updates all outdated dependencies without showing a prompt.
+     */
+    updateDependencies(options: {
+        forceVersionBump?: 'major' | 'minor' | 'patch' | 'compatible';
+        patterns?: string[];
+        all: boolean;
+    }): Promise<ComponentMap<string> | null>;
+    addDuplicateComponentAndPackageIssue(components: Component[]): Promise<void>;
+    private _updateComponentsConfig;
+    private _updateVariantsPolicies;
+    /**
+     * Uninstall the specified packages from dependencies.
+     *
+     * @param {string[]} the list of packages that should be removed from dependencies.
+     */
+    uninstallDependencies(packages: string[]): Promise<ComponentMap<string>>;
+    /**
+     * This function returns all the locations of the external links that should be created inside node_modules.
+     * This information may then be passed to the package manager, which will create the links on its own.
+     */
+    calculateLinks(options?: WorkspaceLinkOptions): Promise<{
+        linkResults: WorkspaceLinkResults;
+        linkedRootDeps: Record<string, string>;
+    }>;
+    linkCodemods(compDirMap: ComponentMap<string>, options?: {
+        rewire?: boolean;
+    }): Promise<{
+        linksResults: NodeModulesLinksResult[];
+        codemodResults: any;
+    }>;
+    link(options?: WorkspaceLinkOptions): Promise<WorkspaceLinkResults>;
+    private _linkAllComponentsToBitRoots;
+    private getRootComponentDirByRootId;
+    /**
+     * Generate a filter to pass to the installer
+     * This will filter deps which are come from remotes which defined in scope.json
+     * those components comes from local remotes, usually doesn't have a package in a registry
+     * so no reason to try to install them (it will fail)
+     */
+    private generateFilterFnForDepsFromLocalRemote;
+    private getComponentsDirectory;
+    private onRootAspectAddedSubscriber;
+    private onAspectsResolveSubscriber;
+    onComponentChange(component: Component): Promise<void>;
+    static slots: (((registerFn: () => string) => SlotRegistry<PreLinkSlot>) | ((registerFn: () => string) => SlotRegistry<PreInstallSlot>))[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static provider([dependencyResolver, workspace, loggerExt, variants, cli, compiler, issues, envs, app, ipcEvents, generator, wsConfigFiles, aspectLoader, bundler, ui,]: [
+        DependencyResolverMain,
+        Workspace,
+        LoggerMain,
+        VariantsMain,
+        CLIMain,
+        CompilerMain,
+        IssuesMain,
+        EnvsMain,
+        ApplicationMain,
+        IpcEventsMain,
+        GeneratorMain,
+        WorkspaceConfigFilesMain,
+        AspectLoaderMain,
+        BundlerMain,
+        UiMain
+    ], _: any, [preLinkSlot, preInstallSlot, postInstallSlot]: [PreLinkSlot, PreInstallSlot, PostInstallSlot], harmony: Harmony): Promise<InstallMain>;
+    private handleExternalPackageManagerPrompt;
+    private disableExternalPackageManagerMode;
+    private removePostInstallScript;
+}
+export default InstallMain;