@teambit/workspace 1.0.108 → 1.0.110

package/capsule.cmd.ts

@@ -1,217 +0,0 @@
-// eslint-disable-next-line max-classes-per-file
-import { Command, CommandOptions } from '@teambit/cli';
-import { CapsuleList, IsolateComponentsOptions, IsolatorMain } from '@teambit/isolator';
-import type { ScopeMain } from '@teambit/scope';
-import chalk from 'chalk';
-
-import { Workspace } from '.';
-
-type CreateOpts = {
-  baseDir?: string;
-  rootBaseDir?: string;
-  alwaysNew?: boolean;
-  seedersOnly?: boolean;
-  useHash?: boolean;
-  id: string;
-  installPackages?: boolean;
-};
-
-export class CapsuleCreateCmd implements Command {
-  name = 'create [component-id...]';
-  description = `create capsules for components`;
-  helpUrl = 'reference/build-pipeline/capsule';
-  group = 'capsules';
-  alias = '';
-  options = [
-    [
-      'b',
-      'base-dir <name>',
-      'set base dir of all capsules (hashed to create the base dir inside the root dir - host path by default)',
-    ],
-    ['r', 'root-base-dir <name>', 'set root base dir of all capsules (absolute path to use as root dir)'],
-    ['a', 'always-new', 'create new environment for capsule'],
-    ['s', 'seeders-only', 'create capsules for the seeders only (not for the entire graph)'],
-    ['i', 'id <name>', 'reuse capsule of certain name'],
-    ['', 'use-hash', 'whether to use hash function (of base dir) as capsules root dir name'],
-    ['j', 'json', 'json format'],
-    ['d', 'install-packages', 'install packages by the package-manager'],
-    ['p', 'package-manager <name>', 'npm, yarn or pnpm, default to npm'],
-  ] as CommandOptions;
-
-  constructor(private workspace: Workspace | undefined, private scope: ScopeMain, private isolator: IsolatorMain) {}
-
-  async create(
-    [componentIds = []]: [string[]],
-    { baseDir, rootBaseDir, alwaysNew = false, id, installPackages = false, seedersOnly = false, useHash }: CreateOpts
-  ): Promise<CapsuleList> {
-    // @todo: why it is not an array?
-    if (componentIds && !Array.isArray(componentIds)) componentIds = [componentIds];
-    let finalUseHash = useHash;
-    if (useHash === undefined) {
-      if (baseDir) {
-        finalUseHash = false;
-      } else {
-        finalUseHash = this.workspace
-          ? this.workspace?.shouldUseHashForCapsules()
-          : this.scope.shouldUseHashForCapsules();
-      }
-    }
-
-    const baseInstallOptions = { installPackages };
-    const additionalInstallOptions = this.workspace
-      ? {}
-      : {
-          copyPeerToRuntimeOnRoot: true,
-          useNesting: true,
-          copyPeerToRuntimeOnComponents: true,
-          installPeersFromEnvs: true,
-        };
-    const installOptions = { ...baseInstallOptions, ...additionalInstallOptions };
-
-    const capsuleOptions: IsolateComponentsOptions = {
-      baseDir,
-      rootBaseDir,
-      installOptions,
-      alwaysNew,
-      seedersOnly,
-      includeFromNestedHosts: true,
-      name: id,
-      useHash: finalUseHash,
-    };
-    const host = this.workspace || this.scope;
-    const ids = await host.resolveMultipleComponentIds(componentIds);
-    const network = await this.isolator.isolateComponents(ids, capsuleOptions);
-    const capsules = network.graphCapsules;
-    return capsules;
-  }
-
-  async report([componentIds]: [string[]], opts: CreateOpts) {
-    // @ts-ignore
-    const capsules = await this.create(componentIds, opts);
-    const capsuleOutput = capsules
-      .map((capsule) => `${chalk.bold(capsule.component.id.toString())} - ${capsule.path}`)
-      .join('\n');
-    const title = `${capsules.length} capsule(s) were created successfully`;
-    return `${chalk.green(title)}\n${capsuleOutput}`;
-  }
-
-  async json([componentIds]: [string[]], opts: CreateOpts) {
-    // @ts-ignore
-    const capsules = await this.create(componentIds, opts);
-    return capsules.map((c) => ({
-      id: c.component.id.toString(),
-      path: c.path,
-    }));
-  }
-}
-
-export class CapsuleListCmd implements Command {
-  name = 'list';
-  description = `list the capsules generated for this workspace`;
-  group = 'capsules';
-  alias = '';
-  options = [['j', 'json', 'json format']] as CommandOptions;
-
-  constructor(private isolator: IsolatorMain, private workspace: Workspace | undefined, private scope: ScopeMain) {}
-
-  async report() {
-    const { workspaceCapsulesRootDir, scopeAspectsCapsulesRootDir } = this.getCapsulesRootDirs();
-    const listWs = workspaceCapsulesRootDir ? await this.isolator.list(workspaceCapsulesRootDir) : undefined;
-    const listScope = await this.isolator.list(scopeAspectsCapsulesRootDir);
-
-    const hostPath = this.workspace ? this.workspace.path : this.scope.path;
-    const numOfWsCapsules = listWs ? listWs.capsules.length : listScope.capsules.length;
-    const hostType = this.workspace ? 'workspace' : 'scope';
-
-    const title = chalk.green(
-      `found ${chalk.cyan(numOfWsCapsules.toString())} capsule(s) for ${hostType}:  ${chalk.cyan(hostPath)}`
-    );
-    const wsLine = listWs
-      ? chalk.green(`workspace capsules root-dir:       ${chalk.cyan(workspaceCapsulesRootDir)}`)
-      : undefined;
-    const scopeLine = chalk.green(`scope's aspects capsules root-dir: ${chalk.cyan(scopeAspectsCapsulesRootDir)}`);
-    const suggestLine = chalk.green(`use --json to get the list of all capsules`);
-    const lines = [title, wsLine, scopeLine, suggestLine].filter((x) => x).join('\n');
-
-    // TODO: improve output
-    return lines;
-  }
-
-  async json() {
-    const rootDirs = this.getCapsulesRootDirs();
-    const listWs = rootDirs.workspaceCapsulesRootDir
-      ? await this.isolator.list(rootDirs.workspaceCapsulesRootDir)
-      : undefined;
-    const listScope = await this.isolator.list(rootDirs.scopeAspectsCapsulesRootDir);
-    const capsules = listWs ? listWs.capsules : [];
-    const scopeCapsules = listScope ? listScope.capsules : [];
-    return { ...rootDirs, capsules, scopeCapsules };
-  }
-
-  private getCapsulesRootDirs() {
-    return getCapsulesRootDirs(this.isolator, this.scope, this.workspace);
-  }
-}
-
-export class CapsuleDeleteCmd implements Command {
-  name = 'delete';
-  description = `delete capsules`;
-  extendedDescription = `with no args, only workspace's capsules are deleted`;
-  group = 'capsules';
-  alias = '';
-  options = [
-    ['', 'scope-aspects', 'delete scope-aspects capsules'],
-    ['a', 'all', 'delete all capsules for all workspaces and scopes'],
-  ] as CommandOptions;
-
-  constructor(private isolator: IsolatorMain, private scope: ScopeMain, private workspace?: Workspace) {}
-
-  async report(args: [], { all, scopeAspects }: { all: boolean; scopeAspects: boolean }) {
-    const capsuleBaseDirToDelete = (): string | undefined => {
-      if (all) return undefined;
-      if (scopeAspects) {
-        const { scopeAspectsCapsulesRootDir } = getCapsulesRootDirs(this.isolator, this.scope, this.workspace);
-        return scopeAspectsCapsulesRootDir;
-      }
-      return undefined;
-    };
-    const capsuleBaseDir = capsuleBaseDirToDelete();
-    const deletedDir = await this.isolator.deleteCapsules(capsuleBaseDir);
-    return chalk.green(`the following capsules dir has been deleted ${chalk.bold(deletedDir)}`);
-  }
-}
-
-export class CapsuleCmd implements Command {
-  name = 'capsule';
-  description = 'manage capsules';
-  extendedDescription = `a capsule is a directory containing the component code, isolated from the workspace.
-normally, capsules are created during the build process, the component files are copied and the packages are installed
-via the configured package-manager. the purpose is to compile/test them in isolation to make sure they will work for
-other users after publishing/exporting them.`;
-  alias = '';
-  group = 'capsules';
-  commands: Command[] = [];
-  options = [['j', 'json', 'json format']] as CommandOptions;
-
-  constructor(private isolator: IsolatorMain, private workspace: Workspace | undefined, private scope: ScopeMain) {}
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async report(args: [string]) {
-    return new CapsuleListCmd(this.isolator, this.workspace, this.scope).report();
-  }
-}
-
-function getCapsulesRootDirs(isolator, scope, workspace) {
-  const workspaceCapsulesRootDir = workspace
-    ? isolator.getCapsulesRootDir({
-        baseDir: workspace.getCapsulePath(),
-        useHash: workspace.shouldUseHashForCapsules(),
-      })
-    : undefined;
-  const scopeAspectsCapsulesRootDir = isolator.getCapsulesRootDir({
-    baseDir: scope.getAspectCapsulePath(),
-    useHash: scope.shouldUseHashForCapsules(),
-  });
-
-  return { workspaceCapsulesRootDir, scopeAspectsCapsulesRootDir };
-}

package/constants.ts

@@ -1 +0,0 @@
-export const EXT_NAME = 'teambit.workspace/workspace';

package/eject-conf.cmd.ts

@@ -1,57 +0,0 @@
-import path from 'path';
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { PATTERN_HELP } from '@teambit/legacy/dist/constants';
-
-import { EjectConfOptions, EjectConfResult, Workspace } from './workspace';
-
-type EjectConfArgs = [string];
-// From the cli we might get those as string in case we run it like --propagate true (return string) as opposed to only --propagate
-type EjectConfOptionsCLI = {
-  propagate: string | boolean | undefined;
-  override: string | boolean | undefined;
-};
-
-export default class EjectConfCmd implements Command {
-  name = 'eject-conf <pattern>';
-  description = 'eject components configuration (create a `component.json` file)';
-  extendedDescription = `note this can be reversed at any time by snapping/tagging changes and deleting the component.json file \n${PATTERN_HELP(
-    'eject-conf'
-  )}`;
-  alias = '';
-  group = 'development';
-  options = [
-    [
-      'p',
-      'propagate',
-      'mark propagate true in the config file, so that component.json configs will be merge with workspace configs',
-    ],
-    ['o', 'override', 'override file if exist'],
-  ] as CommandOptions;
-
-  constructor(private workspace: Workspace) {}
-
-  async report(args: EjectConfArgs, options: EjectConfOptionsCLI): Promise<string> {
-    const ejectResult = await this.json(args, options);
-    const paths = ejectResult
-      .map((result) => result.configPath)
-      .map((p) => path.relative(this.workspace.path, p))
-      .join('\n');
-    return chalk.green(`successfully ejected config to the following path(s)
-${chalk.bold(paths)}`);
-  }
-
-  async json([pattern]: EjectConfArgs, options: EjectConfOptionsCLI): Promise<EjectConfResult[]> {
-    const ejectOptions = options;
-    if (ejectOptions.propagate === 'true') {
-      ejectOptions.propagate = true;
-    }
-    if (ejectOptions.override === 'true') {
-      ejectOptions.override = true;
-    }
-
-    const componentIds = await this.workspace.idsByPattern(pattern);
-    const results = await this.workspace.ejectMultipleConfigs(componentIds, ejectOptions as EjectConfOptions);
-    return results;
-  }
-}

package/filter.ts

@@ -1,139 +0,0 @@
-import { ComponentID, ComponentIdList } from '@teambit/component-id';
-import pMapSeries from 'p-map-series';
-import { ModelComponent } from '@teambit/legacy/dist/scope/models';
-import { compact } from 'lodash';
-import { Workspace } from './workspace';
-
-export const statesFilter = [
-  'new',
-  'modified',
-  'deprecated',
-  'deleted',
-  'snappedOnMain',
-  'softTagged',
-  'codeModified',
-] as const;
-export type StatesFilter = typeof statesFilter[number];
-
-export class Filter {
-  constructor(private workspace: Workspace) {}
-
-  async by(criteria: StatesFilter | string, ids: ComponentID[]): Promise<ComponentID[]> {
-    return criteria.includes(':') ? this.byMultiParamState(criteria, ids) : this.byState(criteria as StatesFilter, ids);
-  }
-
-  async byState(state: StatesFilter, ids: ComponentID[]): Promise<ComponentID[]> {
-    const statePerMethod = {
-      new: this.byNew,
-      modified: this.byModified,
-      deprecated: this.byDeprecated,
-      deleted: this.byDeleted,
-      snappedOnMain: this.bySnappedOnMain,
-      softTagged: this.bySoftTagged,
-      codeModified: this.byCodeModified,
-    };
-    if (!statePerMethod[state]) {
-      throw new Error(`state ${state} is not recognized, possible values: ${statesFilter.join(', ')}`);
-    }
-    return statePerMethod[state].bind(this)(ids);
-  }
-
-  async byMultiParamState(state: string, ids: ComponentID[]): Promise<ComponentID[]> {
-    const stateSplit = state.split(':');
-    if (stateSplit.length < 2) {
-      throw new Error(`byMultiParamState expect the state to have at least one param after the colon, got ${state}`);
-    }
-    const [stateName, ...stateParams] = stateSplit;
-    if (stateName === 'env') {
-      return this.byEnv(stateParams[0], ids);
-    }
-    throw new Error(`byMultiParamState expect the state to be one of the following: ['env'], got ${stateName}`);
-  }
-
-  async byEnv(env: string, withinIds?: ComponentID[]): Promise<ComponentID[]> {
-    const ids = withinIds || (await this.workspace.listIds());
-    const comps = await this.workspace.getMany(ids);
-    const compsUsingEnv = comps.filter((c) => {
-      const envId = this.workspace.envs.getEnvId(c);
-      const envIdWithoutVer = ComponentID.getStringWithoutVersion(envId);
-      return envIdWithoutVer === env;
-    });
-    return compsUsingEnv.map((c) => c.id);
-  }
-
-  async byModified(withinIds?: ComponentID[]): Promise<ComponentID[]> {
-    const ids = withinIds || (await this.workspace.listIds());
-    const comps = await this.workspace.getMany(ids);
-    const modifiedIds = await Promise.all(comps.map(async (comp) => ((await comp.isModified()) ? comp.id : undefined)));
-    return compact(modifiedIds);
-  }
-
-  async byCodeModified(withinIds?: ComponentID[]): Promise<ComponentID[]> {
-    const ids = withinIds || (await this.workspace.listIds());
-    const compFiles = await pMapSeries(ids, (id) => this.workspace.getFilesModification(id));
-    const modifiedIds = compFiles.filter((c) => c.isModified()).map((c) => c.id);
-    return compact(modifiedIds);
-  }
-
-  async byNew(withinIds?: ComponentID[]): Promise<ComponentID[]> {
-    const ids = withinIds || (await this.workspace.listIds());
-    return ids.filter((id) => !id.hasVersion());
-  }
-
-  async byDeprecated(withinIds?: ComponentID[]) {
-    const ids = withinIds || (await this.workspace.listIds());
-    const comps = await this.workspace.getMany(ids);
-    const results = await Promise.all(
-      comps.map(async (c) => {
-        const modelComponent = await this.workspace.consumer.scope.getModelComponentIfExist(c.id);
-        const deprecated = await modelComponent?.isDeprecated(this.workspace.consumer.scope.objects);
-        return deprecated ? c.id : null;
-      })
-    );
-    return compact(results);
-  }
-
-  async byDeleted(withinIds?: ComponentID[]) {
-    const ids = withinIds || (await this.workspace.listIds());
-    const comps = await this.workspace.getMany(ids);
-    const deletedIds = comps.filter((c) => c.isDeleted()).map((c) => c.id);
-    return compact(deletedIds);
-  }
-
-  byDuringMergeState(): ComponentIdList {
-    const unmergedComponents = this.workspace.scope.legacyScope.objects.unmergedComponents.getComponents();
-    return ComponentIdList.fromArray(unmergedComponents.map((u) => ComponentID.fromObject(u.id)));
-  }
-
-  /**
-   * list components that their head is a snap, not a tag.
-   * this is relevant only when the lane is the default (main), otherwise, the head is always a snap.
-   * components that are during-merge are filtered out, we don't want them during tag and don't want
-   * to show them in the "snapped" section in bit-status.
-   */
-  async bySnappedOnMain(withinIds?: ComponentID[]) {
-    if (!this.workspace.isOnMain()) {
-      return [];
-    }
-    const ids = withinIds || (await this.workspace.listIds());
-    const compIds = ComponentIdList.fromArray(ids);
-    const componentsFromModel = await this.getModelComps(ids);
-    const compsDuringMerge = this.byDuringMergeState();
-    const comps = componentsFromModel
-      .filter((c) => compIds.hasWithoutVersion(c.toComponentId()))
-      .filter((c) => !compsDuringMerge.hasWithoutVersion(c.toComponentId()))
-      .filter((c) => c.isHeadSnap());
-    return comps.map((c) => c.toComponentIdWithHead());
-  }
-
-  bySoftTagged(withinIds?: ComponentID[]): ComponentID[] {
-    const withCompIds = ComponentIdList.fromArray(withinIds || []);
-    const all = this.workspace.consumer.bitMap.components.filter((c) => c.nextVersion).map((c) => c.id);
-    return withinIds ? all.filter((id) => withCompIds.hasWithoutVersion(id)) : all;
-  }
-
-  private async getModelComps(ids: ComponentID[]): Promise<ModelComponent[]> {
-    const comps = await Promise.all(ids.map((id) => this.workspace.scope.getBitObjectModelComponent(id, false)));
-    return compact(comps);
-  }
-}

package/index.ts

@@ -1,22 +0,0 @@
-import { WorkspaceAspect } from './workspace.aspect';
-// eslint-disable-next-line import/prefer-default-export
-export type { default as Workspace, ExtensionsOrigin } from './workspace';
-// TODO: change to module path once track the utils folder
-export type { ResolvedComponent } from '@teambit/harmony.modules.resolved-component';
-export type { AlreadyExistsError as ComponentConfigFileAlreadyExistsError } from './component-config-file';
-export type { WorkspaceMain } from './workspace.main.runtime';
-export * from './events';
-export type { WorkspaceUI } from './workspace.ui.runtime';
-export type { SerializableResults, OnComponentLoad, OnComponentEventResult } from './on-component-events';
-export { ComponentStatus } from './workspace-component';
-export type { WorkspaceModelComponent } from './ui/workspace/workspace-model';
-export { Workspace as WorkspaceModel } from './ui/workspace/workspace-model';
-export { WorkspaceContext } from './ui/workspace/workspace-context';
-export { OutsideWorkspaceError } from './exceptions/outside-workspace';
-export type { WorkspaceComponent } from './workspace-component';
-export type { ComponentConfigFile } from './component-config-file';
-export type { CompFiles, FilesStatus } from './workspace-component/comp-files';
-export type { MergeOptions as BitmapMergeOptions } from './bit-map';
-export type { WorkspaceExtConfig } from './types';
-export { WorkspaceAspect };
-export default WorkspaceAspect;

package/merge-conflict-file.ts

@@ -1,129 +0,0 @@
-import { MergeConfigFilename } from '@teambit/legacy/dist/constants';
-import path from 'path';
-import fs from 'fs-extra';
-import { MergeConfigConflict } from './exceptions/merge-config-conflict';
-
-const idPrefix = `[*]`;
-const idDivider = '-'.repeat(80);
-type ConflictPerId = { [compIdWithoutVersion: string]: string };
-
-export class MergeConflictFile {
-  conflictPerId: ConflictPerId | undefined;
-  constructor(private workspacePath: string) {}
-
-  addConflict(id: string, conflict: string) {
-    if (!this.conflictPerId) this.conflictPerId = {};
-    this.conflictPerId[id] = conflict;
-  }
-
-  removeConflict(id: string) {
-    delete this.conflictPerId?.[id];
-  }
-
-  async getConflict(id: string): Promise<string | undefined> {
-    await this.loadIfNeeded();
-    if (!this.conflictPerId) throw new Error(`this.conflictPerId must be instantiated after load`);
-    return this.conflictPerId[id];
-  }
-
-  getConflictAssumeIsLoaded(id: string): string | undefined {
-    if (!this.conflictPerId)
-      throw new Error(`MergeConflictFile was not loaded yet, please load it before calling this function`);
-    return this.conflictPerId[id];
-  }
-
-  getConflictParsed(id: string): Record<string, any> | undefined {
-    const configMergeContent = this.getConflictAssumeIsLoaded(id);
-    if (!configMergeContent) return undefined;
-    try {
-      return JSON.parse(configMergeContent);
-    } catch (err: any) {
-      if (this.stringHasConflictMarker(configMergeContent)) {
-        throw new MergeConfigConflict(this.getPath());
-      }
-      throw new Error(`unable to parse the merge-conflict entry for ${id} as the JSON is invalid. err: ${err.message}`);
-    }
-  }
-
-  hasConflict(): boolean {
-    return Boolean(this.conflictPerId && Object.keys(this.conflictPerId).length);
-  }
-
-  getPath() {
-    return path.join(this.workspacePath, MergeConfigFilename);
-  }
-
-  async loadIfNeeded() {
-    if (this.conflictPerId) return; // already loaded
-    const fileContent = await this.getFileContentIfExists();
-    if (!fileContent) {
-      this.conflictPerId = {}; // to indicate that it's loaded
-      return;
-    }
-    const parsedConflict = this.parseConflict(fileContent);
-    this.conflictPerId = parsedConflict;
-  }
-
-  async write() {
-    if (!this.hasConflict()) return;
-    const afterFormat = this.formatConflicts();
-    await fs.writeFile(this.getPath(), afterFormat);
-  }
-
-  async delete() {
-    await fs.remove(this.getPath());
-  }
-
-  private formatConflicts(): string {
-    const conflictPerId = this.conflictPerId;
-    if (!conflictPerId) throw new Error('conflictPerId is not populated');
-    const title = `# Resolve configuration conflicts per component and make sure the Component ID remain in place`;
-    const conflicts = Object.keys(conflictPerId)
-      .map((id) => {
-        const conflict = conflictPerId[id];
-        return `${idDivider}
-${idPrefix} ${id}
-${idDivider}
-${conflict}`;
-      })
-      .join('\n\n');
-    return `${title}\n\n${conflicts}`;
-  }
-
-  private stringHasConflictMarker(str: string): boolean {
-    return str.includes('<<<<<<<') || str.includes('>>>>>>>');
-  }
-
-  private parseConflict(conflict: string): ConflictPerId {
-    // remove irrelevant lines
-    conflict = conflict
-      .split('\n')
-      .filter((line) => line !== idDivider && !line.startsWith('#'))
-      .join('\n');
-    // split by id
-    const conflictPerId: ConflictPerId = {};
-    const split = conflict.split(idPrefix);
-    split.forEach((conflictItem) => {
-      const conflictItemSplit = conflictItem.split('\n');
-      const [rawId, ...conflictStr] = conflictItemSplit;
-      const id = rawId.trim();
-      if (!id) return; // first line has it empty
-      conflictPerId[id] = conflictStr.join('\n');
-    });
-    return conflictPerId;
-  }
-
-  private async getFileContentIfExists(): Promise<string | undefined> {
-    const filePath = this.getPath();
-    let fileContent: string;
-    try {
-      fileContent = await fs.readFile(filePath, 'utf-8');
-    } catch (err: any) {
-      if (err.code === 'ENOENT') {
-        return undefined;
-      }
-      throw err;
-    }
-    return fileContent;
-  }
-}

package/on-component-events.ts

@@ -1,24 +0,0 @@
-import { Component, ComponentID, AspectData } from '@teambit/component';
-import { ComponentLoadOptions } from '@teambit/legacy/dist/consumer/component/component-loader';
-import type { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
-import { WatchOptions } from '@teambit/watcher';
-
-export type SerializableResults = { results: any; toString: () => string };
-export type OnComponentChange = (
-  component: Component,
-  files: PathOsBasedAbsolute[],
-  removedFiles: PathOsBasedAbsolute[],
-  watchOpts: WatchOptions
-) => Promise<SerializableResults | void>;
-export type OnComponentAdd = (
-  component: Component,
-  files: string[],
-  watchOpts: WatchOptions
-) => Promise<SerializableResults | void>;
-export type OnComponentRemove = (componentId: ComponentID) => Promise<SerializableResults>;
-export type OnComponentEventResult = { extensionId: string; results: SerializableResults };
-
-export type OnComponentLoad = (
-  component: Component,
-  loadOpts?: ComponentLoadOptions
-) => Promise<AspectData | undefined>;

package/pattern.cmd.ts

@@ -1,53 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { Workspace } from './workspace';
-import { statesFilter } from './filter';
-
-export class PatternCommand implements Command {
-  name = 'pattern <pattern>';
-  alias = '';
-  description = 'list the component ids matching the given pattern';
-  extendedDescription = `this command helps validating a pattern before using it in other commands.
-NOTE: always wrap the pattern with quotes to avoid collision with shell commands. depending on your shell, it might be single or double quotes.
-a pattern can be a simple component-id or component-name. e.g. 'ui/button'.
-a pattern can be used with wildcards for multiple component ids, e.g. 'org.scope/utils/**' or '**/utils/**' to capture all org/scopes.
-to enter multiple patterns, separate them by a comma, e.g. 'ui/*, lib/*'
-to exclude, use '!'. e.g. 'ui/**, !ui/button'
-the matching algorithm is from multimatch (@see https://github.com/sindresorhus/multimatch).
-
-to filter by a state or attribute, prefix the pattern with "$". e.g. '$deprecated', '$modified'.
-list of supported states: [${statesFilter.join(', ')}].
-to filter by multi-params state/attribute, separate the params with ":", e.g. '$env:teambit.react/react'.
-list of supported multi-params states: [env].
-to match a state and another criteria, use " AND " keyword. e.g. '$modified AND teambit.workspace/**'. note that the state must be first.
-`;
-  examples = [
-    { cmd: "bit pattern '**'", description: 'matches all components' },
-    {
-      cmd: "bit pattern '*/ui/*'",
-      description:
-        'matches components with any scope-name and the "ui" namespace. e.g. "ui/button" but not "ui/elements/button"',
-    },
-    {
-      cmd: "bit pattern '*/ui/**'",
-      description: 'matches components whose namespace starts with "ui/" e.g. "ui/button", "ui/elements/button"',
-    },
-    { cmd: "bit pattern 'bar, foo'", description: 'matches two components: bar and foo' },
-    { cmd: "bit pattern 'my-scope.org/**'", description: 'matches all components of the scope "my-scope.org"' },
-  ];
-  group = 'development';
-  private = false;
-  options = [['j', 'json', 'return the output as JSON']] as CommandOptions;
-
-  constructor(private workspace: Workspace) {}
-
-  async report([pattern]: [string]) {
-    const ids = await this.json([pattern]);
-    const title = chalk.green(`found ${chalk.bold(ids.length.toString())} components matching the pattern`);
-    return `${title}\n${ids.join('\n')}`;
-  }
-
-  async json([pattern]: [string]) {
-    return this.workspace.idsByPattern(pattern, false);
-  }
-}