@teambit/status 1.0.108 → 1.0.109

package/artifacts/preview/teambit_component_status-preview.js

@@ -0,0 +1 @@
+!function(e,o){"object"==typeof exports&&"object"==typeof module?module.exports=o():"function"==typeof define&&define.amd?define([],o):"object"==typeof exports?exports["teambit.component/status-preview"]=o():e["teambit.component/status-preview"]=o()}(self,(()=>(()=>{"use strict";var e={d:(o,t)=>{for(var r in t)e.o(t,r)&&!e.o(o,r)&&Object.defineProperty(o,r,{enumerable:!0,get:t[r]})},o:(e,o)=>Object.prototype.hasOwnProperty.call(e,o),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},o={};e.r(o),e.d(o,{compositions:()=>t,compositions_metadata:()=>n,overview:()=>r});const t=[],r=[],n={compositions:[]};return o})()));

package/dist/mini-status-cmd.d.ts

@@ -24,7 +24,7 @@ export declare class MiniStatusCmd implements Command {
         newComps: string[];
         compWithIssues: {
             id: string;
-            issues: (import("@teambit/component-issues/component-issue").IssueObject & {
+            issues: (import("@teambit/legacy/components/component-issues/component-issue").IssueObject & {
                 dataAsString: string;
             })[];
         }[];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/status",
-  "version": "1.0.108",
+  "version": "1.0.109",
   "homepage": "https://bit.cloud/teambit/component/status",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "status",
-    "version": "1.0.108"
+    "version": "1.0.109"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -17,21 +17,21 @@
     "@teambit/component-version": "1.0.3",
     "@teambit/harmony": "0.4.6",
     "@teambit/lane-id": "0.0.311",
-    "@teambit/cli": "0.0.840",
+    "@teambit/cli": "0.0.841",
     "@teambit/component-issues": "0.0.138",
-    "@teambit/component": "1.0.108",
-    "@teambit/insights": "1.0.108",
-    "@teambit/issues": "1.0.108",
-    "@teambit/lanes": "1.0.108",
-    "@teambit/remove": "1.0.108",
-    "@teambit/workspace": "1.0.108"
+    "@teambit/component": "1.0.109",
+    "@teambit/insights": "1.0.109",
+    "@teambit/issues": "1.0.109",
+    "@teambit/lanes": "1.0.109",
+    "@teambit/remove": "1.0.109",
+    "@teambit/workspace": "1.0.109"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
     "@types/jest": "^29.2.2",
     "@types/testing-library__jest-dom": "^5.9.5",
-    "@teambit/harmony.envs.core-aspect-env": "0.0.13"
+    "@teambit/harmony.envs.core-aspect-env": "0.0.14"
   },
   "peerDependencies": {
     "@teambit/legacy": "1.0.624"

package/index.ts

@@ -1,5 +0,0 @@
-import { StatusAspect } from './status.aspect';
-
-export type { StatusMain } from './status.main.runtime';
-export default StatusAspect;
-export { StatusAspect };

package/mini-status-cmd.ts

@@ -1,69 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { COMPONENT_PATTERN_HELP } from '@teambit/legacy/dist/constants';
-import { ComponentID } from '@teambit/component-id';
-import chalk from 'chalk';
-import { StatusMain } from './status.main.runtime';
-
-export type MiniStatusOpts = {
-  showIssues?: boolean;
-  ignoreCircularDependencies?: boolean;
-};
-
-export class MiniStatusCmd implements Command {
-  name = 'mini-status [component-pattern]';
-  description = 'EXPERIMENTAL. basic status for fast execution';
-  extendedDescription = `shows only modified/new components with code changes. for the full status, use "bit status".
-this command only checks source code changes, it doesn't check for config/aspect/dependency changes`;
-  arguments = [
-    {
-      name: 'component-pattern',
-      description: COMPONENT_PATTERN_HELP,
-    },
-  ];
-  group = 'development';
-  alias = 'ms';
-  options = [
-    ['', 'show-issues', 'show component issues (slows down the command)'],
-    [
-      'c',
-      'ignore-circular-dependencies',
-      'do not check for circular dependencies to get the results quicker (relevant when --show-issues flag is used)',
-    ],
-    ['j', 'json', 'json format'],
-  ] as CommandOptions;
-  loader = true;
-
-  constructor(private status: StatusMain) {}
-
-  async report([pattern]: [string], opts: MiniStatusOpts) {
-    const { modified, newComps, compWithIssues } = await this.status.statusMini(pattern, opts);
-    const outputSection = (title: string, ids: ComponentID[]) => {
-      const titleStr = chalk.bold(title);
-      const idsStr = ids.length ? ids.map((id) => id.toStringWithoutVersion()).join('\n') : '<none>';
-      return `${titleStr}:\n${idsStr}`;
-    };
-    const outputCompWithIssues = () => {
-      if (!opts.showIssues) return '';
-      if (!compWithIssues?.length) return '<none>';
-      const titleStr = chalk.bold('\n\ncomponent with issues');
-      const issues = compWithIssues.map((c) => `${c.id.toStringWithoutVersion()}\n  ${c.state.issues.outputForCLI()}`);
-      return `${titleStr}\n${issues}`;
-    };
-    const modifiedOutput = outputSection('modified components (files only)', modified);
-    const newOutput = outputSection('new components', newComps);
-    const compWithIssuesOutput = outputCompWithIssues();
-    return `${modifiedOutput}\n\n${newOutput}${compWithIssuesOutput}`;
-  }
-
-  async json([pattern]: [string], opts: MiniStatusOpts) {
-    const { modified, newComps, compWithIssues } = await this.status.statusMini(pattern, opts);
-    return {
-      modified: modified.map((m) => m.toStringWithoutVersion()),
-      newComps: newComps.map((m) => m.toStringWithoutVersion()),
-      compWithIssues: compWithIssues?.map((c) => ({
-        id: c.id.toStringWithoutVersion(),
-        issues: c.state.issues.toObjectIncludeDataAsString(),
-      })),
-    };
-  }
-}

package/status-cmd.ts

@@ -1,392 +0,0 @@
-import chalk from 'chalk';
-import R from 'ramda';
-import { Command, CommandOptions } from '@teambit/cli';
-import { ComponentID } from '@teambit/component-id';
-import { SnapsDistance } from '@teambit/legacy/dist/scope/component-ops/snaps-distance';
-import { IssuesList } from '@teambit/component-issues';
-import { formatBitString } from '@teambit/legacy/dist/cli/chalk-box';
-import { getInvalidComponentLabel } from '@teambit/legacy/dist/cli/templates/component-issues-template';
-import {
-  IMPORT_PENDING_MSG,
-  statusFailureMsg,
-  statusInvalidComponentsMsg,
-  statusWorkspaceIsCleanMsg,
-  BASE_DOCS_DOMAIN,
-} from '@teambit/legacy/dist/constants';
-import { compact, partition } from 'lodash';
-import { isHash } from '@teambit/component-version';
-import { StatusMain, StatusResult } from './status.main.runtime';
-
-const TROUBLESHOOTING_MESSAGE = `${chalk.yellow(
-  `learn more at about Bit component: ${BASE_DOCS_DOMAIN}reference/components/component-anatomy/`
-)}`;
-
-type StatusFlags = { strict?: boolean; verbose?: boolean; lanes?: boolean; ignoreCircularDependencies?: boolean };
-
-type StatusJsonResults = {
-  newComponents: string[];
-  modifiedComponents: string[];
-  stagedComponents: Array<{ id: string; versions: string[] }>;
-  unavailableOnMain: string[];
-  componentsWithIssues: Array<{
-    id: string;
-    issues: Array<{
-      type: string;
-      description: string;
-      data: any;
-    }>;
-  }>;
-  importPendingComponents: string[];
-  autoTagPendingComponents: string[];
-  invalidComponents: Array<{ id: string; error: Error }>;
-  locallySoftRemoved: string[];
-  remotelySoftRemoved: string[];
-  outdatedComponents: Array<{ id: string; headVersion: string; latestVersion?: string }>;
-  mergePendingComponents: string[];
-  componentsDuringMergeState: string[];
-  softTaggedComponents: string[];
-  snappedComponents: string[];
-  pendingUpdatesFromMain: Array<{
-    id: string;
-    divergeData: any;
-  }>;
-  updatesFromForked: Array<{
-    id: string;
-    divergeData: any;
-  }>;
-  currentLaneId: string;
-  forkedLaneId: string | undefined;
-  workspaceIssues: string[];
-};
-
-export class StatusCmd implements Command {
-  name = 'status';
-  description = 'present the current status of components in the workspace, including indication of detected issues';
-  group = 'development';
-  extendedDescription: string;
-  alias = 's';
-  options = [
-    ['j', 'json', 'return a json version of the component'],
-    ['', 'verbose', 'show extra data: full snap hashes for staged components, and divergence point for lanes'],
-    ['l', 'lanes', 'when on a lane, show updates from main and updates from forked lanes'],
-    ['', 'strict', 'in case issues found, exit with code 1'],
-    ['c', 'ignore-circular-dependencies', 'do not check for circular dependencies to get the results quicker'],
-  ] as CommandOptions;
-  loader = true;
-  migration = true;
-
-  constructor(private status: StatusMain) {}
-
-  async json(_args, { lanes, ignoreCircularDependencies }: StatusFlags): Promise<StatusJsonResults> {
-    const {
-      newComponents,
-      modifiedComponents,
-      stagedComponents,
-      componentsWithIssues,
-      importPendingComponents,
-      autoTagPendingComponents,
-      invalidComponents,
-      locallySoftRemoved,
-      remotelySoftRemoved,
-      outdatedComponents,
-      mergePendingComponents,
-      componentsDuringMergeState,
-      softTaggedComponents,
-      snappedComponents,
-      unavailableOnMain,
-      pendingUpdatesFromMain,
-      updatesFromForked,
-      currentLaneId,
-      forkedLaneId,
-      workspaceIssues,
-    }: StatusResult = await this.status.status({ lanes, ignoreCircularDependencies });
-    return {
-      newComponents: newComponents.map((c) => c.toStringWithoutVersion()),
-      modifiedComponents: modifiedComponents.map((c) => c.toStringWithoutVersion()),
-      stagedComponents: stagedComponents.map((c) => ({ id: c.id.toStringWithoutVersion(), versions: c.versions })),
-      unavailableOnMain: unavailableOnMain.map((c) => c.toStringWithoutVersion()),
-      componentsWithIssues: componentsWithIssues.map((c) => ({
-        id: c.id.toStringWithoutVersion(),
-        issues: c.issues?.toObjectIncludeDataAsString(),
-      })),
-      importPendingComponents: importPendingComponents.map((id) => id.toStringWithoutVersion()),
-      autoTagPendingComponents: autoTagPendingComponents.map((s) => s.toStringWithoutVersion()),
-      invalidComponents: invalidComponents.map(({ id, error }) => ({ id: id.toStringWithoutVersion(), error })),
-      locallySoftRemoved: locallySoftRemoved.map((id) => id.toStringWithoutVersion()),
-      remotelySoftRemoved: remotelySoftRemoved.map((id) => id.toStringWithoutVersion()),
-      outdatedComponents: outdatedComponents.map((c) => ({ ...c, id: c.id.toStringWithoutVersion() })),
-      mergePendingComponents: mergePendingComponents.map((c) => c.id.toStringWithoutVersion()),
-      componentsDuringMergeState: componentsDuringMergeState.map((id) => id.toStringWithoutVersion()),
-      softTaggedComponents: softTaggedComponents.map((s) => s.toStringWithoutVersion()),
-      snappedComponents: snappedComponents.map((s) => s.toStringWithoutVersion()),
-      pendingUpdatesFromMain: pendingUpdatesFromMain.map((p) => ({
-        id: p.id.toStringWithoutVersion(),
-        divergeData: p.divergeData,
-      })),
-      updatesFromForked: updatesFromForked.map((p) => ({
-        id: p.id.toStringWithoutVersion(),
-        divergeData: p.divergeData,
-      })),
-      currentLaneId: currentLaneId.toString(),
-      forkedLaneId: forkedLaneId?.toString(),
-      workspaceIssues,
-    };
-  }
-
-  // eslint-disable-next-line complexity
-  async report(_args, { strict, verbose, lanes, ignoreCircularDependencies }: StatusFlags) {
-    const {
-      newComponents,
-      modifiedComponents,
-      stagedComponents,
-      componentsWithIssues,
-      importPendingComponents,
-      autoTagPendingComponents,
-      invalidComponents,
-      locallySoftRemoved,
-      remotelySoftRemoved,
-      outdatedComponents,
-      mergePendingComponents,
-      componentsDuringMergeState,
-      softTaggedComponents,
-      snappedComponents,
-      pendingUpdatesFromMain,
-      updatesFromForked,
-      unavailableOnMain,
-      currentLaneId,
-      forkedLaneId,
-      workspaceIssues,
-    }: StatusResult = await this.status.status({ lanes, ignoreCircularDependencies });
-    // If there is problem with at least one component we want to show a link to the
-    // troubleshooting doc
-    let showTroubleshootingLink = false;
-
-    function format(id: ComponentID, showIssues = false, message?: string, localVersions?: string[]): string {
-      const idWithIssues = componentsWithIssues.find((c) => c.id.isEqual(id));
-      const softTagged = softTaggedComponents.find((softTaggedId) => softTaggedId.isEqual(id));
-
-      const messageStatusText = message || 'ok';
-      const messageStatusTextWithSoftTag = softTagged ? `${messageStatusText} (soft-tagged)` : messageStatusText;
-      const color = message ? 'yellow' : 'green';
-      const messageStatus = chalk[color](messageStatusTextWithSoftTag);
-
-      if (!showIssues && !localVersions) {
-        return `${formatBitString(id.toStringWithoutVersion())} ... ${messageStatus}`;
-      }
-      let bitFormatted = `${formatBitString(id.toStringWithoutVersion())}`;
-      if (localVersions) {
-        if (verbose) {
-          bitFormatted += `. versions: ${localVersions.join(', ')}`;
-        } else {
-          const [snaps, tags] = partition(localVersions, (version) => isHash(version));
-          const tagsStr = tags.length ? `versions: ${tags.join(', ')}` : '';
-          const snapsStr = snaps.length ? `${snaps.length} snap(s)` : '';
-          bitFormatted += `. `;
-          bitFormatted += tagsStr && snapsStr ? `${tagsStr}. and ${snapsStr}` : tagsStr || snapsStr;
-        }
-      }
-      bitFormatted += ' ... ';
-      if (showIssues && idWithIssues) {
-        showTroubleshootingLink = true;
-        return `${bitFormatted} ${chalk.red(statusFailureMsg)}${formatIssues(idWithIssues.issues)}`;
-      }
-      return `${bitFormatted}${messageStatus}`;
-    }
-
-    function formatCategory(title: string, description: string, compsOutput: string[]) {
-      if (!compsOutput.length) return '';
-      const titleOutput = chalk.underline.white(`${title} (${compsOutput.length})`);
-      const descOutput = description ? `${description}\n` : '';
-      return [titleOutput, descOutput, ...compsOutput].join('\n');
-    }
-
-    const importPendingWarning = importPendingComponents.length ? chalk.yellow(`${IMPORT_PENDING_MSG}.\n`) : '';
-
-    const splitByMissing = R.groupBy((component) => {
-      return component.includes(statusFailureMsg) ? 'missing' : 'nonMissing';
-    });
-    const { missing, nonMissing } = splitByMissing(newComponents.map((c) => format(c)));
-
-    const outdatedTitle = 'pending updates';
-    const outdatedDesc =
-      '(use "bit checkout head" to merge changes)\n(use "bit diff [component_id] [new_version]" to compare changes)\n(use "bit log [component_id]" to list all available versions)';
-    const outdatedComps = outdatedComponents.map((component) => {
-      const latest =
-        component.latestVersion && component.latestVersion !== component.headVersion
-          ? ` latest: ${component.latestVersion}`
-          : '';
-      return `    > ${chalk.cyan(component.id.toStringWithoutVersion())} current: ${component.id.version} head: ${
-        component.headVersion
-      }${latest}`;
-    });
-    const outdatedStr = formatCategory(outdatedTitle, outdatedDesc, outdatedComps);
-
-    const pendingMergeTitle = 'pending merge';
-    const pendingMergeDesc = `(use "bit reset" to discard local tags/snaps, and bit checkout head to re-merge with the remote.
-alternatively, to keep local tags/snaps history, use "bit merge [component-id]")`;
-    const pendingMergeComps = mergePendingComponents.map((component) => {
-      return `    > ${chalk.cyan(component.id.toString())} local and remote have diverged and have ${
-        component.divergeData.snapsOnSourceOnly.length
-      } (source) and ${component.divergeData.snapsOnTargetOnly.length} (target) uncommon snaps respectively`;
-    });
-
-    const pendingMergeStr = formatCategory(pendingMergeTitle, pendingMergeDesc, pendingMergeComps);
-
-    const compDuringMergeTitle = 'components in merge state';
-    const compDuringMergeDesc = `(use "bit snap/tag [--unmerged]" to complete the merge process.
-to cancel the merge operation, use either "bit lane merge-abort" (for prior "bit lane merge" command)
-or use "bit merge [component-id] --abort" (for prior "bit merge" command)`;
-    const compDuringMergeComps = componentsDuringMergeState.map((c) => format(c));
-
-    const compDuringMergeStr = formatCategory(compDuringMergeTitle, compDuringMergeDesc, compDuringMergeComps);
-
-    const newComponentDescription = '\n(use "bit snap/tag" to lock a version with all your changes)\n';
-    const newComponentsTitle = newComponents.length
-      ? chalk.underline.white('new components') + newComponentDescription
-      : '';
-
-    const newComponentsOutput = [newComponentsTitle, ...(nonMissing || []), ...(missing || [])].join('\n');
-
-    const modifiedDesc = '(use "bit diff" to compare changes)';
-    const modifiedComponentOutput = formatCategory(
-      'modified components',
-      modifiedDesc,
-      modifiedComponents.map((c) => format(c))
-    );
-
-    const autoTagPendingTitle = 'components pending auto-tag (when their modified dependencies are tagged)';
-    const autoTagPendingOutput = formatCategory(
-      autoTagPendingTitle,
-      '',
-      autoTagPendingComponents.map((c) => format(c))
-    );
-
-    const compWithIssuesDesc = '(fix the issues according to the suggested solution)';
-    const compWithIssuesOutput = formatCategory(
-      'components with issues',
-      compWithIssuesDesc,
-      componentsWithIssues.map((c) => format(c.id, true)).sort()
-    );
-
-    const invalidDesc = 'these components failed to load';
-    const invalidComps = invalidComponents.map((c) => format(c.id, false, getInvalidComponentLabel(c.error))).sort();
-    const invalidComponentOutput = formatCategory(statusInvalidComponentsMsg, invalidDesc, invalidComps);
-
-    const locallySoftRemovedDesc =
-      '(tag/snap and export the components to update the deletion to the remote. to undo deletion, run "bit recover")';
-    const locallySoftRemovedOutput = formatCategory(
-      'soft-removed components locally',
-      locallySoftRemovedDesc,
-      locallySoftRemoved.map((c) => format(c)).sort()
-    );
-
-    const remotelySoftRemovedDesc =
-      '(use "bit remove" to remove them from the workspace. use "bit recover" to undo the soft-remove)';
-    const remotelySoftRemovedOutput = formatCategory(
-      'components deleted on the remote',
-      remotelySoftRemovedDesc,
-      remotelySoftRemoved.map((c) => format(c)).sort()
-    );
-
-    const stagedDesc = '(use "bit export" to push these component versions to the remote scope)';
-    const stagedComps = stagedComponents.map((c) => format(c.id, false, undefined, c.versions));
-    const stagedComponentsOutput = formatCategory('staged components', stagedDesc, stagedComps);
-
-    const snappedDesc = '(use "bit tag" or "bit tag --snapped" to lock a semver version)';
-    const snappedComponentsOutput = formatCategory(
-      'snapped components (tag pending)',
-      snappedDesc,
-      snappedComponents.map((c) => format(c))
-    );
-
-    const unavailableOnMainDesc = '(use "bit checkout head" to make them available)';
-    const unavailableOnMainOutput = formatCategory(
-      'components unavailable on main',
-      unavailableOnMainDesc,
-      unavailableOnMain.map((c) => format(c))
-    );
-
-    const getUpdateFromMsg = (divergeData: SnapsDistance, from = 'main'): string => {
-      if (divergeData.err) return divergeData.err.message;
-      let msg = `${from} is ahead by ${divergeData.snapsOnTargetOnly.length || 0} snaps`;
-      if (divergeData.snapsOnSourceOnly && verbose) {
-        msg += ` (diverged since ${divergeData.commonSnapBeforeDiverge?.toShortString()})`;
-      }
-      return msg;
-    };
-
-    const updatesFromMainDesc = '(use "bit lane merge main" to merge the changes)';
-    const pendingUpdatesFromMainIds = pendingUpdatesFromMain.map((c) =>
-      format(c.id, false, getUpdateFromMsg(c.divergeData))
-    );
-    const updatesFromMainOutput = formatCategory(
-      'pending updates from main',
-      updatesFromMainDesc,
-      pendingUpdatesFromMainIds
-    );
-
-    let updatesFromForkedOutput = '';
-    if (forkedLaneId) {
-      const updatesFromForkedDesc = `(use "bit lane merge ${forkedLaneId.toString()}" to merge the changes
-use "bit fetch ${forkedLaneId.toString()} --lanes" to update ${forkedLaneId.name} locally)`;
-      const pendingUpdatesFromForkedIds = updatesFromForked.map((c) =>
-        format(c.id, false, getUpdateFromMsg(c.divergeData, forkedLaneId.name))
-      );
-      updatesFromForkedOutput = formatCategory(
-        `updates from ${forkedLaneId.name}`,
-        updatesFromForkedDesc,
-        pendingUpdatesFromForkedIds
-      );
-    }
-
-    const getLaneStr = () => {
-      if (currentLaneId.isDefault()) return '';
-      const prefix = `\n\ncurrent lane ${chalk.bold(currentLaneId.toString())}`;
-      if (lanes) return prefix;
-      return `${prefix}\nconsider adding "--lanes" flag to see updates from main/forked`;
-    };
-
-    const getWorkspaceIssuesOutput = () => {
-      if (!workspaceIssues.length) return '';
-      const title = chalk.underline.white('workspace issues');
-      const issues = workspaceIssues.join('\n');
-      return `\n\n${title}\n${issues}`;
-    };
-
-    const troubleshootingStr = showTroubleshootingLink ? `\n${TROUBLESHOOTING_MESSAGE}` : '';
-
-    const statusMsg =
-      importPendingWarning +
-      compact([
-        outdatedStr,
-        pendingMergeStr,
-        updatesFromMainOutput,
-        updatesFromForkedOutput,
-        compDuringMergeStr,
-        newComponentsOutput,
-        modifiedComponentOutput,
-        snappedComponentsOutput,
-        stagedComponentsOutput,
-        unavailableOnMainOutput,
-        autoTagPendingOutput,
-        compWithIssuesOutput,
-        invalidComponentOutput,
-        locallySoftRemovedOutput,
-        remotelySoftRemovedOutput,
-      ]).join(chalk.underline('\n                         \n') + chalk.white('\n')) +
-      troubleshootingStr;
-
-    const results = (statusMsg || chalk.yellow(statusWorkspaceIsCleanMsg)) + getWorkspaceIssuesOutput() + getLaneStr();
-
-    const exitCode = componentsWithIssues.length && strict ? 1 : 0;
-
-    return {
-      data: results,
-      code: exitCode,
-    };
-  }
-}
-
-export function formatIssues(issues: IssuesList) {
-  return `       ${issues?.outputForCLI()}\n`;
-}

package/status.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const StatusAspect = Aspect.create({
-  id: 'teambit.component/status',
-});

package/status.main.runtime.ts

@@ -1,260 +0,0 @@
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import pMapSeries from 'p-map-series';
-import { LaneId } from '@teambit/lane-id';
-import { IssuesClasses, IssuesList } from '@teambit/component-issues';
-import WorkspaceAspect, { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
-import LanesAspect, { LanesMain } from '@teambit/lanes';
-import { ComponentID } from '@teambit/component-id';
-import { Component, InvalidComponent } from '@teambit/component';
-import { Analytics } from '@teambit/legacy/dist/analytics/analytics';
-import loader from '@teambit/legacy/dist/cli/loader';
-import { BEFORE_STATUS } from '@teambit/legacy/dist/cli/loader/loader-messages';
-import { RemoveAspect, RemoveMain } from '@teambit/remove';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import ComponentsPendingImport from '@teambit/legacy/dist/consumer/component-ops/exceptions/components-pending-import';
-import ComponentsList from '@teambit/legacy/dist/consumer/component/components-list';
-import { ModelComponent } from '@teambit/legacy/dist/scope/models';
-import { InsightsAspect, InsightsMain } from '@teambit/insights';
-import { SnapsDistance } from '@teambit/legacy/dist/scope/component-ops/snaps-distance';
-import IssuesAspect, { IssuesMain } from '@teambit/issues';
-import { StatusCmd } from './status-cmd';
-import { StatusAspect } from './status.aspect';
-import { MiniStatusCmd, MiniStatusOpts } from './mini-status-cmd';
-
-type DivergeDataPerId = { id: ComponentID; divergeData: SnapsDistance };
-
-export type StatusResult = {
-  newComponents: ComponentID[];
-  modifiedComponents: ComponentID[];
-  stagedComponents: { id: ComponentID; versions: string[] }[];
-  componentsWithIssues: { id: ComponentID; issues: IssuesList }[];
-  importPendingComponents: ComponentID[];
-  autoTagPendingComponents: ComponentID[];
-  invalidComponents: { id: ComponentID; error: Error }[];
-  locallySoftRemoved: ComponentID[];
-  remotelySoftRemoved: ComponentID[];
-  outdatedComponents: { id: ComponentID; headVersion: string; latestVersion?: string }[];
-  mergePendingComponents: DivergeDataPerId[];
-  componentsDuringMergeState: ComponentID[];
-  softTaggedComponents: ComponentID[];
-  snappedComponents: ComponentID[];
-  pendingUpdatesFromMain: DivergeDataPerId[];
-  updatesFromForked: DivergeDataPerId[];
-  unavailableOnMain: ComponentID[];
-  currentLaneId: LaneId;
-  forkedLaneId?: LaneId;
-  workspaceIssues: string[];
-};
-
-export type MiniStatusResults = {
-  modified: ComponentID[];
-  newComps: ComponentID[];
-  compWithIssues?: Component[];
-};
-
-export class StatusMain {
-  constructor(
-    private workspace: Workspace,
-    private issues: IssuesMain,
-    private insights: InsightsMain,
-    private remove: RemoveMain,
-    private lanes: LanesMain
-  ) {}
-
-  async status({
-    lanes,
-    ignoreCircularDependencies,
-  }: {
-    lanes?: boolean;
-    ignoreCircularDependencies?: boolean;
-  }): Promise<StatusResult> {
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    loader.start(BEFORE_STATUS);
-    const loadOpts = {
-      loadDocs: false,
-      loadCompositions: false,
-    };
-    const { components: allComps, invalidComponents: allInvalidComponents } = await this.workspace.listWithInvalid(
-      loadOpts
-    );
-    const consumer = this.workspace.consumer;
-    const laneObj = await consumer.getCurrentLaneObject();
-    const componentsList = new ComponentsList(consumer);
-    const newComponents: ConsumerComponent[] = (await componentsList.listNewComponents(
-      true,
-      loadOpts
-    )) as ConsumerComponent[];
-    const modifiedComponents = (await componentsList.listModifiedComponents(true, loadOpts)) as ConsumerComponent[];
-    const stagedComponents: ModelComponent[] = await componentsList.listExportPendingComponents(laneObj);
-    await this.addRemovedStagedIfNeeded(stagedComponents);
-    const stagedComponentsWithVersions = await pMapSeries(stagedComponents, async (stagedComp) => {
-      const versions = await stagedComp.getLocalTagsOrHashes(consumer.scope.objects);
-      return {
-        id: stagedComp.toComponentId(),
-        versions,
-      };
-    });
-
-    const unavailableOnMain = await this.workspace.getUnavailableOnMainComponents();
-    const autoTagPendingComponents = await componentsList.listAutoTagPendingComponents();
-    const autoTagPendingComponentsIds = autoTagPendingComponents.map((component) => component.id);
-    const locallySoftRemoved = await componentsList.listLocallySoftRemoved();
-    const remotelySoftRemoved = await componentsList.listRemotelySoftRemoved();
-    const importPendingComponents = allInvalidComponents
-      .filter((c) => c.err instanceof ComponentsPendingImport)
-      .map((i) => i.id);
-    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-    const invalidComponents = allInvalidComponents.filter((c) => !(c.error instanceof ComponentsPendingImport));
-    const divergeInvalid = await this.divergeDataErrorsToInvalidComp(allComps);
-    invalidComponents.push(...divergeInvalid);
-    const outdatedComponents = await componentsList.listOutdatedComponents();
-    const idsDuringMergeState = componentsList.listDuringMergeStateComponents();
-    const mergePendingComponents = await componentsList.listMergePendingComponents();
-    if (allComps.length) {
-      const issuesFromFlag = ignoreCircularDependencies ? [IssuesClasses.CircularDependencies.name] : [];
-      const issuesToIgnore = [...this.issues.getIssuesToIgnoreGlobally(), ...issuesFromFlag];
-      await this.issues.triggerAddComponentIssues(allComps, issuesToIgnore);
-      this.issues.removeIgnoredIssuesFromComponents(allComps);
-    }
-    const componentsWithIssues = allComps.filter((component) => !component.state.issues.isEmpty());
-    const softTaggedComponents = this.workspace.filter.bySoftTagged();
-    const snappedComponents = await this.workspace.filter.bySnappedOnMain();
-    const pendingUpdatesFromMain = lanes ? await componentsList.listUpdatesFromMainPending() : [];
-    const updatesFromForked = lanes ? await this.lanes.listUpdatesFromForked(componentsList) : [];
-    const currentLaneId = consumer.getCurrentLaneId();
-    const currentLane = await consumer.getCurrentLaneObject();
-    const forkedLaneId = currentLane?.forkedFrom;
-    const workspaceIssues = this.workspace.getWorkspaceIssues();
-    Analytics.setExtraData('new_components', newComponents.length);
-    Analytics.setExtraData('staged_components', stagedComponents.length);
-    Analytics.setExtraData('num_components_with_missing_dependencies', componentsWithIssues.length);
-    Analytics.setExtraData('autoTagPendingComponents', autoTagPendingComponents.length);
-    Analytics.setExtraData('deleted', invalidComponents.length);
-
-    const convertBitIdToComponentIdsAndSort = async (ids: ComponentID[]) =>
-      ComponentID.sortIds(await this.workspace.resolveMultipleComponentIds(ids));
-
-    const convertObjToComponentIdsAndSort = async <T>(
-      objectsWithId: Array<T & { id: ComponentID }>
-    ): Promise<Array<T & { id: ComponentID }>> => {
-      const results = await Promise.all(
-        objectsWithId.map(async (obj) => {
-          return {
-            ...obj,
-            id: await this.workspace.resolveComponentId(obj.id),
-          };
-        })
-      );
-      return results.sort((a, b) => a.id.toString().localeCompare(b.id.toString()));
-    };
-
-    const sortObjectsWithId = <T>(objectsWithId: Array<T & { id: ComponentID }>): Array<T & { id: ComponentID }> => {
-      return objectsWithId.sort((a, b) => a.id.toString().localeCompare(b.id.toString()));
-    };
-
-    await consumer.onDestroy('status');
-    return {
-      newComponents: await convertBitIdToComponentIdsAndSort(newComponents.map((c) => c.id)),
-      modifiedComponents: await convertBitIdToComponentIdsAndSort(modifiedComponents.map((c) => c.id)),
-      stagedComponents: await convertObjToComponentIdsAndSort(stagedComponentsWithVersions),
-      componentsWithIssues: sortObjectsWithId(componentsWithIssues.map((c) => ({ id: c.id, issues: c.state.issues }))),
-      importPendingComponents, // no need to sort, we use only its length
-      autoTagPendingComponents: await convertBitIdToComponentIdsAndSort(autoTagPendingComponentsIds),
-      invalidComponents: sortObjectsWithId(invalidComponents.map((c) => ({ id: c.id, error: c.err }))),
-      locallySoftRemoved: await convertBitIdToComponentIdsAndSort(locallySoftRemoved),
-      remotelySoftRemoved: await convertBitIdToComponentIdsAndSort(remotelySoftRemoved.map((c) => c.id)),
-      outdatedComponents: await convertObjToComponentIdsAndSort(
-        outdatedComponents.map((c) => ({
-          id: c.id,
-          headVersion: c.headVersion,
-          latestVersion: c.latestVersion,
-        }))
-      ),
-      mergePendingComponents: await convertObjToComponentIdsAndSort(
-        mergePendingComponents.map((c) => ({ id: c.id, divergeData: c.diverge }))
-      ),
-      componentsDuringMergeState: await convertBitIdToComponentIdsAndSort(idsDuringMergeState),
-      softTaggedComponents: ComponentID.sortIds(softTaggedComponents),
-      snappedComponents: await convertBitIdToComponentIdsAndSort(snappedComponents),
-      pendingUpdatesFromMain: await convertObjToComponentIdsAndSort(pendingUpdatesFromMain),
-      updatesFromForked: await convertObjToComponentIdsAndSort(updatesFromForked),
-      unavailableOnMain,
-      currentLaneId,
-      forkedLaneId,
-      workspaceIssues: workspaceIssues.map((err) => err.message),
-    };
-  }
-
-  async statusMini(componentPattern?: string, opts: MiniStatusOpts = {}): Promise<MiniStatusResults> {
-    const ids = componentPattern ? await this.workspace.idsByPattern(componentPattern) : await this.workspace.listIds();
-    const compFiles = await pMapSeries(ids, (id) => this.workspace.getFilesModification(id));
-    const modified: ComponentID[] = [];
-    const newComps: ComponentID[] = [];
-    compFiles.forEach((comp) => {
-      if (!comp.id.hasVersion()) newComps.push(comp.id);
-      if (comp.isModified()) modified.push(comp.id);
-    });
-    const loadOpts = {
-      loadDocs: false,
-      loadCompositions: false,
-    };
-    const comps = opts.showIssues ? await this.workspace.getMany(ids, loadOpts) : [];
-    if (opts.showIssues) {
-      const issuesFromFlag = opts.ignoreCircularDependencies ? [IssuesClasses.CircularDependencies.name] : [];
-      const issuesToIgnore = [...this.issues.getIssuesToIgnoreGlobally(), ...issuesFromFlag];
-      await this.issues.triggerAddComponentIssues(comps, issuesToIgnore);
-      this.issues.removeIgnoredIssuesFromComponents(comps);
-    }
-    const compWithIssues = comps.filter((c) => !c.state.issues.isEmpty());
-
-    return { modified, newComps, compWithIssues };
-  }
-
-  private async addRemovedStagedIfNeeded(stagedComponents: ModelComponent[]) {
-    const removedStagedIds = await this.remove.getRemovedStaged();
-    if (!removedStagedIds.length) return;
-    const removedStagedBitIds = removedStagedIds.map((id) => id);
-    const nonExistsInStaged = removedStagedBitIds.filter(
-      (id) => !stagedComponents.find((c) => c.toComponentId().isEqualWithoutVersion(id))
-    );
-    if (!nonExistsInStaged.length) return;
-    const modelComps = await Promise.all(
-      nonExistsInStaged.map((id) => this.workspace.scope.legacyScope.getModelComponent(id))
-    );
-    stagedComponents.push(...modelComps);
-  }
-
-  private async divergeDataErrorsToInvalidComp(components: Component[]): Promise<InvalidComponent[]> {
-    const invalidComponents: InvalidComponent[] = [];
-    await Promise.all(
-      components.map(async (component) => {
-        const comp = component.state._consumer as ConsumerComponent;
-        if (!comp.modelComponent) return;
-        await comp.modelComponent.setDivergeData(this.workspace.scope.legacyScope.objects, false);
-        const divergeData = comp.modelComponent.getDivergeData();
-        if (divergeData.err) {
-          invalidComponents.push({ id: component.id, err: divergeData.err });
-        }
-      })
-    );
-    return invalidComponents;
-  }
-
-  static slots = [];
-  static dependencies = [CLIAspect, WorkspaceAspect, InsightsAspect, IssuesAspect, RemoveAspect, LanesAspect];
-  static runtime = MainRuntime;
-  static async provider([cli, workspace, insights, issues, remove, lanes]: [
-    CLIMain,
-    Workspace,
-    InsightsMain,
-    IssuesMain,
-    RemoveMain,
-    LanesMain
-  ]) {
-    const statusMain = new StatusMain(workspace, issues, insights, remove, lanes);
-    cli.register(new StatusCmd(statusMain), new MiniStatusCmd(statusMain));
-    return statusMain;
-  }
-}
-
-StatusAspect.addRuntime(StatusMain);