@teambit/remove 1.0.107 → 1.0.108

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/remove",
-  "version": "1.0.107",
+  "version": "1.0.108",
   "homepage": "https://bit.cloud/teambit/component/remove",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.component",
     "name": "remove",
-    "version": "1.0.107"
+    "version": "1.0.108"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -16,33 +16,27 @@
     "p-map-series": "2.1.0",
     "ramda": "0.27.1",
     "lodash": "4.17.21",
-    "core-js": "^3.0.0",
-    "@babel/runtime": "7.20.0",
     "@teambit/bit-error": "0.0.404",
     "@teambit/component-id": "1.2.0",
     "@teambit/harmony": "0.4.6",
-    "@teambit/cli": "0.0.839",
-    "@teambit/workspace": "1.0.107",
-    "@teambit/component": "1.0.107",
-    "@teambit/component-issues": "0.0.137",
-    "@teambit/dependency-resolver": "1.0.107",
-    "@teambit/importer": "1.0.107",
-    "@teambit/issues": "1.0.107",
-    "@teambit/logger": "0.0.932"
+    "@teambit/cli": "0.0.840",
+    "@teambit/workspace": "1.0.108",
+    "@teambit/component": "1.0.108",
+    "@teambit/component-issues": "0.0.138",
+    "@teambit/dependency-resolver": "1.0.108",
+    "@teambit/importer": "1.0.108",
+    "@teambit/issues": "1.0.108",
+    "@teambit/logger": "0.0.933"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
-    "@types/node": "12.20.4",
-    "@types/react": "^17.0.8",
-    "@types/react-dom": "^17.0.5",
-    "@types/jest": "^26.0.0",
-    "@types/testing-library__jest-dom": "5.9.5"
+    "@types/jest": "^29.2.2",
+    "@types/testing-library__jest-dom": "^5.9.5",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.13"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.624",
-    "react": "^16.8.0 || ^17.0.0",
-    "react-dom": "^16.8.0 || ^17.0.0"
+    "@teambit/legacy": "1.0.624"
   },
   "license": "Apache-2.0",
   "optionalDependencies": {},
@@ -56,7 +50,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=12.22.0"
+    "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
@@ -65,12 +59,9 @@
   "keywords": [
     "bit",
     "bit-aspect",
+    "bit-core-aspect",
     "components",
     "collaboration",
-    "web",
-    "react",
-    "react-components",
-    "angular",
-    "angular-components"
+    "web"
   ]
 }

package/recover-cmd.ts

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import { BitError } from '@teambit/bit-error';
+import { Command, CommandOptions } from '@teambit/cli';
+import { RemoveMain } from './remove.main.runtime';
+
+export type RecoverOptions = {
+  skipDependencyInstallation?: boolean;
+  skipWriteConfigFiles?: boolean;
+};
+
+export class RecoverCmd implements Command {
+  name = 'recover <component-name>';
+  description = 'EXPERIMENTAL. recover component(s) soft-deleted from the workspace, or a remote scope';
+  group = 'collaborate';
+  options = [
+    ['x', 'skip-dependency-installation', 'do not install packages in case of importing components'],
+    ['', 'skip-write-config-files', 'do not write config files (such as eslint, tsconfig, prettier, etc...)'],
+  ] as CommandOptions;
+  loader = true;
+  migration = true;
+
+  constructor(private remove: RemoveMain) {}
+
+  async report([componentName]: [string], options: RecoverOptions) {
+    const hasRecovered = await this.remove.recover(componentName, options);
+    if (!hasRecovered) {
+      throw new BitError(`component ${componentName} was not soft-deleted, nothing to recover`);
+    }
+    return chalk.green(`successfully recovered ${componentName}`);
+  }
+}

package/remove-cmd.ts

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import yesno from 'yesno';
+import { Command, CommandOptions } from '@teambit/cli';
+import { Workspace } from '@teambit/workspace';
+import { BitError } from '@teambit/bit-error';
+import { COMPONENT_PATTERN_HELP } from '@teambit/legacy/dist/constants';
+import { RemovedLocalObjects } from './removed-local-objects';
+import { RemoveMain } from './remove.main.runtime';
+import { removeTemplate } from './remove-template';
+
+export class RemoveCmd implements Command {
+  name = 'remove <component-pattern>';
+  description = 'remove component(s) from the local workspace';
+  extendedDescription = `to mark components as deleted on the remote scope, use "bit delete".`;
+  arguments = [
+    {
+      name: 'component-pattern',
+      description: COMPONENT_PATTERN_HELP,
+    },
+  ];
+  group = 'collaborate';
+  helpUrl = 'reference/components/removing-components';
+  skipWorkspace = true;
+  alias = 'rm';
+  options = [
+    ['t', 'track', 'keep tracking component in .bitmap (default = false), helps transform a tagged-component to new'],
+    ['', 'keep-files', 'keep component files (just untrack the component)'],
+    [
+      'f',
+      'force',
+      'removes the component from the scope, even if used as a dependency. WARNING: you will need to fix the components that depend on this component',
+    ],
+    ['s', 'silent', 'skip confirmation'],
+  ] as CommandOptions;
+  loader = true;
+  migration = true;
+  remoteOp = true;
+
+  constructor(private remove: RemoveMain, private workspace?: Workspace) {}
+
+  async report(
+    [componentsPattern]: [string],
+    {
+      force = false,
+      track = false,
+      silent = false,
+      keepFiles = false,
+    }: {
+      force?: boolean;
+      track?: boolean;
+      silent?: boolean;
+      keepFiles?: boolean;
+    }
+  ) {
+    if (!silent) {
+      await this.removePrompt(!keepFiles);
+    }
+    const {
+      localResult,
+    }: {
+      localResult: RemovedLocalObjects;
+    } = await this.remove.remove({ componentsPattern, force, track, deleteFiles: !keepFiles });
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    const localMessage = removeTemplate(localResult, false);
+    // if (localMessage !== '')
+    //   localMessage +=
+    //     '. Note: these components were not deleted from the remote - if you want to delete components run "bit delete"\n';
+    return localMessage;
+  }
+
+  private async removePrompt(deleteFiles?: boolean) {
+    this.remove.logger.clearStatusLine();
+    const filesDeletionStr = deleteFiles
+      ? ' and the files will be deleted from the filesystem (can be avoided by entering --keep-files)'
+      : '';
+    const ok = await yesno({
+      question: `this command will remove the component/s only from your local workspace. if your intent is to delete the component/s also from the remote scope, refer to "bit delete".
+the component(s) will be untracked${filesDeletionStr}.
+${chalk.bold('Would you like to proceed? [yes(y)/no(n)]')}`,
+    });
+    if (!ok) {
+      throw new BitError('the operation has been canceled');
+    }
+  }
+}

package/remove-components.ts

@@ -0,0 +1,171 @@
+import groupArray from 'group-array';
+import partition from 'lodash.partition';
+import R from 'ramda';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { ComponentIdList } from '@teambit/component-id';
+import { CENTRAL_BIT_HUB_NAME, CENTRAL_BIT_HUB_URL, LATEST_BIT_VERSION } from '@teambit/legacy/dist/constants';
+import GeneralError from '@teambit/legacy/dist/error/general-error';
+import enrichContextFromGlobal from '@teambit/legacy/dist/hooks/utils/enrich-context-from-global';
+import logger from '@teambit/legacy/dist/logger/logger';
+import { Http } from '@teambit/legacy/dist/scope/network/http';
+import { Remotes } from '@teambit/legacy/dist/remotes';
+import { getScopeRemotes } from '@teambit/legacy/dist/scope/scope-remotes';
+import deleteComponentsFiles from '@teambit/legacy/dist/consumer/component-ops/delete-component-files';
+import ComponentsList from '@teambit/legacy/dist/consumer/component/components-list';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import RemovedObjects from '@teambit/legacy/dist/scope/removed-components';
+import * as packageJsonUtils from '@teambit/legacy/dist/consumer/component/package-json-utils';
+import pMapSeries from 'p-map-series';
+import { RemovedLocalObjects } from './removed-local-objects';
+
+export type RemoveComponentsResult = { localResult: RemovedLocalObjects; remoteResult: RemovedObjects[] };
+
+/**
+ * Remove components local and remote
+ * splits array of ids into local and remote and removes according to flags
+ * @param {string[]} ids - list of remote component ids to delete
+ * @param {boolean} force - delete component that are used by other components.
+ * @param {boolean} remote - delete component from a remote scope
+ * @param {boolean} track - keep tracking local staged components in bitmap.
+ * @param {boolean} deleteFiles - delete local added files from fs.
+ */
+export async function removeComponents({
+  consumer,
+  ids,
+  force,
+  remote,
+  track,
+  deleteFiles,
+}: {
+  consumer: Consumer | null | undefined; // when remote is false, it's always set
+  ids: ComponentIdList;
+  force: boolean;
+  remote: boolean;
+  track: boolean;
+  deleteFiles: boolean;
+}): Promise<RemoveComponentsResult> {
+  logger.debugAndAddBreadCrumb('removeComponents', `{ids}. force: ${force.toString()}`, { ids: ids.toString() });
+  // added this to remove support for remove only one version from a component
+  const bitIdsLatest = ComponentIdList.fromArray(
+    ids.map((id) => {
+      return id.changeVersion(LATEST_BIT_VERSION);
+    })
+  );
+  const [localIds, remoteIds] = partition(bitIdsLatest, (id) => id.isLocal());
+  if (remote && localIds.length) {
+    throw new GeneralError(
+      `unable to remove the remote components: ${localIds.join(',')} as they don't contain a scope-name`
+    );
+  }
+  const remoteResult = remote && !R.isEmpty(remoteIds) ? await removeRemote(consumer, remoteIds, force) : [];
+  const localResult = !remote
+    ? await removeLocal(consumer as Consumer, bitIdsLatest, force, track, deleteFiles)
+    : new RemovedLocalObjects();
+
+  return { localResult, remoteResult };
+}
+
+/**
+ * Remove remote component from ssh server
+ * this method groups remote components by remote name and deletes remote components together
+ * @param {ComponentIdList} bitIds - list of remote component ids to delete
+ * @param {boolean} force - delete component that are used by other components.
+ */
+async function removeRemote(
+  consumer: Consumer | null | undefined,
+  bitIds: ComponentIdList,
+  force: boolean
+): Promise<RemovedObjects[]> {
+  const groupedBitsByScope = groupArray(bitIds, 'scope');
+  const remotes = consumer ? await getScopeRemotes(consumer.scope) : await Remotes.getGlobalRemotes();
+  const shouldGoToCentralHub = remotes.shouldGoToCentralHub(Object.keys(groupedBitsByScope));
+  if (shouldGoToCentralHub) {
+    const http = await Http.connect(CENTRAL_BIT_HUB_URL, CENTRAL_BIT_HUB_NAME);
+    return http.deleteViaCentralHub(
+      bitIds.map((id) => id.toString()),
+      { force, idsAreLanes: false }
+    );
+  }
+  const context = {};
+  enrichContextFromGlobal(context);
+  const removeP = Object.keys(groupedBitsByScope).map(async (key) => {
+    const resolvedRemote = await remotes.resolve(key, consumer?.scope);
+    const idsStr = groupedBitsByScope[key].map((id) => id.toStringWithoutVersion());
+    return resolvedRemote.deleteMany(idsStr, force, context);
+  });
+
+  return Promise.all(removeP);
+}
+
+/**
+ * removeLocal - remove local (imported, new staged components) from modules and bitmap according to flags
+ * @param {ComponentIdList} bitIds - list of component ids to delete
+ * @param {boolean} force - delete component that are used by other components.
+ * @param {boolean} deleteFiles - delete component that are used by other components.
+ */
+async function removeLocal(
+  consumer: Consumer,
+  bitIds: ComponentIdList,
+  force: boolean,
+  track: boolean,
+  deleteFiles: boolean
+): Promise<RemovedLocalObjects> {
+  // local remove in case user wants to delete tagged components
+  const modifiedComponents = new ComponentIdList();
+  const nonModifiedComponents = new ComponentIdList();
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  if (R.isEmpty(bitIds)) return new RemovedLocalObjects();
+  if (!force) {
+    await pMapSeries(bitIds, async (id) => {
+      try {
+        const componentStatus = await consumer.getComponentStatusById(id);
+        if (componentStatus.modified) modifiedComponents.push(id);
+        else nonModifiedComponents.push(id);
+      } catch (err: any) {
+        // if a component has an error, such as, missing main file, we do want to allow removing that component
+        if (Component.isComponentInvalidByErrorType(err)) {
+          nonModifiedComponents.push(id);
+        } else {
+          throw err;
+        }
+      }
+    });
+  }
+  const idsToRemove = force ? bitIds : nonModifiedComponents;
+  const componentsList = new ComponentsList(consumer);
+  const newComponents = (await componentsList.listNewComponents(false)) as ComponentIdList;
+  const idsToRemoveFromScope = ComponentIdList.fromArray(
+    idsToRemove.filter((id) => !newComponents.hasWithoutVersion(id))
+  );
+  const idsToCleanFromWorkspace = ComponentIdList.fromArray(
+    idsToRemove.filter((id) => newComponents.hasWithoutVersion(id))
+  );
+  const { components: componentsToRemove, invalidComponents } = await consumer.loadComponents(idsToRemove, false);
+  const { removedComponentIds, missingComponents, dependentBits, removedFromLane } = await consumer.scope.removeMany(
+    idsToRemoveFromScope,
+    force,
+    consumer
+  );
+  // otherwise, components should still be in .bitmap file
+  idsToCleanFromWorkspace.push(...removedComponentIds);
+  if (idsToCleanFromWorkspace.length) {
+    if (deleteFiles) await deleteComponentsFiles(consumer, idsToCleanFromWorkspace);
+    if (!track) {
+      const invalidComponentsIds = invalidComponents.map((i) => i.id);
+      const removedComponents = componentsToRemove.filter((c) => idsToCleanFromWorkspace.hasWithoutVersion(c.id));
+      await packageJsonUtils.removeComponentsFromWorkspacesAndDependencies(
+        consumer,
+        removedComponents,
+        invalidComponentsIds
+      );
+      await consumer.cleanFromBitMap(idsToCleanFromWorkspace);
+    }
+  }
+  return new RemovedLocalObjects(
+    ComponentIdList.uniqFromArray([...idsToCleanFromWorkspace, ...removedComponentIds]),
+    missingComponents,
+    modifiedComponents,
+    dependentBits,
+    removedFromLane
+  );
+}

package/remove-template.ts

@@ -0,0 +1,73 @@
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import chalk from 'chalk';
+import R from 'ramda';
+
+export function removeTemplate(
+  { dependentBits, modifiedComponents = [], removedComponentIds, missingComponents, removedFromLane },
+  isRemote
+) {
+  const paintMissingComponents = () => {
+    if (R.isEmpty(missingComponents)) return '';
+    return (
+      chalk.red('missing components:') +
+      chalk(
+        ` ${missingComponents.map((id) => {
+          if (!(id instanceof ComponentID)) id = ComponentID.fromObject(id); // when the id was received from a remote it's not an instance of ComponentID
+          return id.version === 'latest' ? id.toStringWithoutVersion() : id.toString();
+        })}\n`
+      )
+    );
+  };
+  const paintRemoved = () => {
+    if (R.isEmpty(removedComponentIds) && R.isEmpty(removedFromLane)) return '';
+    const compToStr = (comps: ComponentIdList) =>
+      chalk(` ${comps.map((id) => (id.version === 'latest' ? id.toStringWithoutVersion() : id.toString()))}\n`);
+    const getMsg = (isLane = false) => {
+      const removedFrom = isLane ? 'lane' : 'scope';
+      const msg = isRemote
+        ? `successfully removed components from the remote ${removedFrom}:`
+        : `successfully removed components from the local ${removedFrom}:`;
+      return chalk.green(msg);
+    };
+    const newLine = '\n';
+    const compOutput = R.isEmpty(removedComponentIds) ? '' : getMsg(false) + compToStr(removedComponentIds) + newLine;
+    const laneOutput = R.isEmpty(removedFromLane) ? '' : getMsg(true) + compToStr(removedFromLane);
+
+    return `${compOutput}${laneOutput}`;
+  };
+
+  const paintUnRemovedComponents = () => {
+    if (R.isEmpty(dependentBits)) return '';
+    return Object.keys(dependentBits)
+      .map((key) => {
+        const header = chalk.underline.red(
+          `error: unable to delete ${key}, because the following components depend on it:`
+        );
+        const body = dependentBits[key].join('\n');
+        return `${header}\n${body}`;
+      })
+      .join('\n\n');
+  };
+
+  const paintModifiedComponents = () => {
+    if (R.isEmpty(modifiedComponents)) return '';
+    const modifiedStr = modifiedComponents.map((id: ComponentID) =>
+      id.version === 'latest' ? id.toStringWithoutVersion() : id.toString()
+    );
+    return `${
+      chalk.red('error: unable to remove modified components (please use --force to remove modified components)\n') +
+      chalk(`- ${modifiedStr}`)
+    }`;
+  };
+
+  return (
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    paintUnRemovedComponents(dependentBits) +
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    paintRemoved(removedComponentIds) +
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    paintMissingComponents(missingComponents) +
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    paintModifiedComponents(modifiedComponents)
+  );
+}

package/remove.aspect.ts

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

package/remove.fragment.ts

@@ -0,0 +1,26 @@
+import { Component, ShowFragment } from '@teambit/component';
+import { RemoveMain } from './remove.main.runtime';
+
+export class RemoveFragment implements ShowFragment {
+  constructor(private remove: RemoveMain) {}
+
+  title = 'removed';
+
+  async renderRow(component: Component) {
+    const isRemoved = this.remove.isRemoved(component);
+    return {
+      title: this.title,
+      // when it's not removed, set as an empty string so then it won't be shown in bit-show
+      content: isRemoved ? isRemoved.toString() : '',
+    };
+  }
+
+  async json(component: Component) {
+    return {
+      title: this.title,
+      json: this.remove.getRemoveInfo(component),
+    };
+  }
+
+  weight = 3;
+}