@teambit/workspace 0.0.566 → 0.0.570

package/ui/workspace-components-drawer/workspace-components.drawer.tsx

@@ -0,0 +1,49 @@
+import type { DrawerType } from '@teambit/ui-foundation.ui.tree.drawer';
+import { FullLoader } from '@teambit/ui-foundation.ui.full-loader';
+import {
+  ComponentTree,
+  PayloadType,
+  ComponentView,
+  ScopeTreeNode,
+  NamespaceTreeNode,
+  ScopePayload,
+} from '@teambit/ui-foundation.ui.side-bar';
+
+import type { TreeNodeProps } from '@teambit/base-ui.graph.tree.recursive-tree';
+
+import React, { useCallback, useContext } from 'react';
+import classNames from 'classnames';
+import { ComponentTreeSlot } from '@teambit/component-tree';
+import { mutedItalic } from '@teambit/design.ui.styles.muted-italic';
+import { ellipsis } from '@teambit/design.ui.styles.ellipsis';
+import { WorkspaceContext } from '../workspace/workspace-context';
+import styles from './workspace-components-drawer.module.scss';
+
+export class WorkspaceComponentsDrawer implements DrawerType {
+  constructor(private treeNodeSlot: ComponentTreeSlot) {}
+
+  name = 'COMPONENTS';
+
+  render = () => {
+    const workspace = useContext(WorkspaceContext);
+    const { treeNodeSlot } = this;
+
+    const TreeNodeRenderer = useCallback(
+      function TreeNode(props: TreeNodeProps<PayloadType>) {
+        const children = props.node.children;
+
+        if (!children) return <ComponentView {...props} treeNodeSlot={treeNodeSlot} />;
+
+        if (props.node.payload instanceof ScopePayload) return <ScopeTreeNode {...props} />;
+
+        return <NamespaceTreeNode {...props} />;
+      },
+      [treeNodeSlot]
+    );
+
+    if (!workspace) return <FullLoader />;
+    if (workspace.components.length === 0)
+      return <span className={classNames(mutedItalic, ellipsis, styles.emptyWorkspace)}>Workspace is empty</span>;
+    return <ComponentTree components={workspace.components} TreeNode={TreeNodeRenderer} />;
+  };
+}

package/update.cmd.tsx

@@ -0,0 +1,30 @@
+import { Command, CommandOptions } from '@teambit/cli';
+
+import { Workspace } from './workspace';
+
+type UpdateCmdOptions = {
+  yes?: boolean;
+};
+
+export default class UpdateCmd implements Command {
+  name = 'update';
+  description = 'update dependencies';
+  alias = 'up';
+  group = 'development';
+  shortDescription = '';
+  options = [['y', 'yes', 'automatically update all outdated packages']] as CommandOptions;
+
+  constructor(
+    /**
+     * workspace extension.
+     */
+    private workspace: Workspace
+  ) {}
+
+  async report(args: [string[]], options: UpdateCmdOptions) {
+    await this.workspace.updateDependencies({
+      all: options.yes === true,
+    });
+    return '';
+  }
+}

package/watch/check-types.ts

@@ -0,0 +1,5 @@
+export enum CheckTypes {
+  None, // keep this. it equals zero. this way we can do "if checkTypes() ... "
+  EntireProject,
+  ChangedFile,
+}

package/watch/output-formatter.ts

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { OnComponentEventResult } from '../on-component-events';
+
+const verboseComponentFilesArrayToString = (componentFiles) => {
+  return componentFiles.reduce((outputString, filePath) => `${outputString} \t - ${filePath}\n`, ``);
+};
+
+const resultsForExtensionArrayToString = (resultsForExtension, verbose) => {
+  return resultsForExtension.reduce(
+    (outputString, resultForExtension) =>
+      `${outputString}${chalk.green('√')}SUCCESS\t${resultForExtension.component}\n
+     ${verbose ? resultForExtension.componentFilesAsString : ''}\n`,
+    ''
+  );
+};
+
+export const formatWatchPathsSortByComponent = (trackDirs) => {
+  return Object.keys(trackDirs).reduce(
+    (outputString, watchPath) =>
+      `${outputString}
+    ${chalk.green('√')} SUCCESS\t${trackDirs[watchPath]}\n
+    \t - ${watchPath}\n\n`,
+    ` ${chalk.underline('STATUS\t\tCOMPONENT ID')}\n`
+  );
+};
+
+/**
+ * todo: this was implemented incorrectly.
+ * the original idea of `SerializableResults` was to have each one of the aspects registered to the slot, the
+ * ability to have their own formatting to their results, and then `toString()` method to print them.
+ * Here, the printing is specifically to the Compiler aspect. It should move to where it belongs.
+ */
+export function formatCompileResults(compileResults: OnComponentEventResult[], verbose: boolean) {
+  if (!compileResults.length || !Array.isArray(compileResults)) return '';
+  return compileResults
+    .filter((compileResult) => compileResult.results?.results && Array.isArray(compileResult.results?.results))
+    .map((compileResult) => ({
+      extensionId: compileResult.extensionId,
+      resultsForExtension: compileResult.results?.results?.map((resultForExtension) => ({
+        component: resultForExtension.component,
+        componentFilesAsString: verboseComponentFilesArrayToString(resultForExtension.buildResults),
+      })),
+    }))
+    .reduce(
+      (outputString, compileResult) =>
+        `${outputString}
+  ${resultsForExtensionArrayToString(compileResult.resultsForExtension, verbose)}`,
+      ` ${chalk.underline('STATUS\tCOMPONENT ID')}`
+    );
+}

package/watch/watch.cmd.tsx

@@ -0,0 +1,142 @@
+import chalk from 'chalk';
+import moment from 'moment';
+import { Command, CommandOptions } from '@teambit/cli';
+import type { Logger } from '@teambit/logger';
+import type { BitBaseEvent, PubsubMain } from '@teambit/pubsub';
+
+// import IDs and events
+import { CompilerAspect, CompilerErrorEvent } from '@teambit/compiler';
+
+import { Watcher, WatchOptions } from './watcher';
+import { formatCompileResults, formatWatchPathsSortByComponent } from './output-formatter';
+import { OnComponentEventResult } from '../on-component-events';
+import { CheckTypes } from './check-types';
+
+export type WatchCmdOpts = {
+  verbose?: boolean;
+  skipPreCompilation?: boolean;
+  checkTypes?: string | boolean;
+};
+
+export class WatchCommand implements Command {
+  msgs = {
+    onAll: (event, path) => this.logger.console(`Event: "${event}". Path: ${path}`),
+    onStart: () => {},
+    onReady: (workspace, watchPathsSortByComponent, verbose) => {
+      clearOutdatedData();
+      if (verbose) {
+        this.logger.console(formatWatchPathsSortByComponent(watchPathsSortByComponent));
+      }
+      this.logger.console(
+        chalk.yellow(
+          `Watching for component changes in workspace ${workspace.config.name} (${moment().format('HH:mm:ss')})...\n`
+        )
+      );
+    },
+    onChange: (filePath: string, buildResults: OnComponentEventResult[], verbose: boolean, duration) => {
+      clearOutdatedData();
+      if (!buildResults.length) {
+        this.logger.console(`The file ${filePath} has been changed, but nothing to compile.\n\n`);
+        return;
+      }
+      this.logger.console(`The file ${filePath} has been changed.\n\n`);
+      this.logger.console(formatCompileResults(buildResults, verbose));
+      this.logger.console(`Finished. (${duration}ms)`);
+      this.logger.console(chalk.yellow(`Watching for component changes (${moment().format('HH:mm:ss')})...`));
+    },
+    onAdd: (filePath: string, buildResults: OnComponentEventResult[], verbose: boolean, duration) => {
+      clearOutdatedData();
+      this.logger.console(`The file ${filePath} has been added.\n\n`);
+      this.logger.console(formatCompileResults(buildResults, verbose));
+      this.logger.console(`Finished. (${duration}ms)`);
+      this.logger.console(chalk.yellow(`Watching for component changes (${moment().format('HH:mm:ss')})...`));
+    },
+    onUnlink: (p) => {
+      this.logger.console(`file ${p} has been removed`);
+    },
+    onError: (err) => {
+      this.logger.console(`Watcher error ${err}`);
+    },
+  };
+
+  name = 'watch';
+  description = 'watch a set of components';
+  alias = '';
+  group = 'development';
+  shortDescription = '';
+  options = [
+    ['v', 'verbose', 'showing npm verbose output for inspection and prints stack trace'],
+    ['', 'skip-pre-compilation', 'skip the compilation step before starting to watch'],
+    [
+      't',
+      'check-types [string]',
+      'EXPERIMENTAL. show errors/warnings for types. options are [file, project] to investigate only changed file or entire project. defaults to project',
+    ],
+  ] as CommandOptions;
+
+  constructor(
+    /**
+     * logger extension.
+     */
+    private pubsub: PubsubMain,
+
+    /**
+     * logger extension.
+     */
+    private logger: Logger,
+
+    /**
+     * watcher extension.
+     */
+    private watcher: Watcher
+  ) {
+    this.registerToEvents();
+  }
+
+  private registerToEvents() {
+    this.pubsub.sub(CompilerAspect.id, this.eventsListener);
+  }
+
+  private eventsListener = (event: BitBaseEvent<any>) => {
+    switch (event.type) {
+      case CompilerErrorEvent.TYPE:
+        this.logger.console(`Watcher error ${event.data.error}, 'error'`);
+        break;
+      default:
+    }
+  };
+
+  async report(cliArgs: [], watchCmdOpts: WatchCmdOpts) {
+    const { verbose, checkTypes } = watchCmdOpts;
+    const getCheckTypesEnum = () => {
+      switch (checkTypes) {
+        case undefined:
+        case false:
+          return CheckTypes.None;
+        case 'project':
+        case true: // project is the default
+          return CheckTypes.EntireProject;
+        case 'file':
+          return CheckTypes.ChangedFile;
+        default:
+          throw new Error(`check-types can be either "file" or "project". got "${checkTypes}"`);
+      }
+    };
+    const watchOpts: WatchOptions = {
+      msgs: this.msgs,
+      verbose,
+      preCompile: !watchCmdOpts.skipPreCompilation,
+      spawnTSServer: Boolean(checkTypes), // if check-types is enabled, it must spawn the tsserver.
+      checkTypes: getCheckTypesEnum(),
+    };
+    await this.watcher.watchAll(watchOpts);
+    return 'watcher terminated';
+  }
+}
+
+/**
+ * with console.clear() all history is deleted from the console. this function preserver the history.
+ */
+function clearOutdatedData() {
+  process.stdout.write('\x1Bc');
+}

package/watch/watcher.ts

@@ -0,0 +1,289 @@
+import { PubsubMain } from '@teambit/pubsub';
+import { dirname, sep } from 'path';
+import { difference } from 'lodash';
+import { ComponentID } from '@teambit/component';
+import { BitId } from '@teambit/legacy-bit-id';
+import loader from '@teambit/legacy/dist/cli/loader';
+import { BIT_MAP, COMPONENT_ORIGINS } from '@teambit/legacy/dist/constants';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import logger from '@teambit/legacy/dist/logger/logger';
+import { pathNormalizeToLinux } from '@teambit/legacy/dist/utils';
+import mapSeries from 'p-map-series';
+import chalk from 'chalk';
+import { ChildProcess } from 'child_process';
+import chokidar, { FSWatcher } from 'chokidar';
+import ComponentMap from '@teambit/legacy/dist/consumer/bit-map/component-map';
+import { PathLinux, PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
+import { CompilationInitiator } from '@teambit/compiler';
+import { WorkspaceAspect } from '../';
+import { OnComponentChangeEvent, OnComponentAddEvent, OnComponentRemovedEvent } from '../events';
+import { Workspace } from '../workspace';
+import { OnComponentEventResult } from '../on-component-events';
+import { CheckTypes } from './check-types';
+
+export type WatcherProcessData = { watchProcess: ChildProcess; compilerId: BitId; componentIds: BitId[] };
+
+export type WatchOptions = {
+  msgs?: any;
+  initiator?: CompilationInitiator;
+  verbose?: boolean; // print watch events to the console. (also ts-server events if spawnTSServer is true)
+  spawnTSServer?: boolean; // needed for check types and extract API/docs.
+  checkTypes?: CheckTypes; // if enabled, the spawnTSServer becomes true.
+  preCompile?: boolean; // whether compile all components before start watching
+};
+
+export class Watcher {
+  private fsWatcher: FSWatcher;
+  constructor(
+    private workspace: Workspace,
+    private pubsub: PubsubMain,
+    private trackDirs: { [dir: PathLinux]: ComponentID } = {},
+    private verbose = false,
+    private multipleWatchers: WatcherProcessData[] = []
+  ) {}
+
+  get consumer(): Consumer {
+    return this.workspace.consumer;
+  }
+
+  async watchAll(opts: WatchOptions) {
+    const { msgs, ...watchOpts } = opts;
+    // TODO: run build in the beginning of process (it's work like this in other envs)
+    const pathsToWatch = await this.getPathsToWatch();
+    const componentIds = Object.values(this.trackDirs);
+    await this.workspace.triggerOnPreWatch(componentIds, watchOpts);
+    await this.createWatcher(pathsToWatch);
+    const watcher = this.fsWatcher;
+    msgs?.onStart(this.workspace);
+
+    return new Promise((resolve, reject) => {
+      // prefix your command with "BIT_LOG=*" to see all watch events
+      if (process.env.BIT_LOG) {
+        if (msgs?.onAll) watcher.on('all', msgs?.onAll);
+      }
+      watcher.on('ready', () => {
+        msgs?.onReady(this.workspace, this.trackDirs, this.verbose);
+      });
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      watcher.on('change', async (filePath) => {
+        const startTime = new Date().getTime();
+        const buildResults = (await this.handleChange(filePath, opts?.initiator)) || [];
+        const duration = new Date().getTime() - startTime;
+        msgs?.onChange(filePath, buildResults, this.verbose, duration);
+      });
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      watcher.on('add', async (filePath) => {
+        const startTime = new Date().getTime();
+        const buildResults = (await this.handleChange(filePath)) || [];
+        const duration = new Date().getTime() - startTime;
+        msgs?.onAdd(filePath, buildResults, this.verbose, duration);
+      });
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      watcher.on('unlink', async (p) => {
+        msgs?.onUnlink(p);
+        await this.handleChange(p);
+      });
+      watcher.on('error', (err) => {
+        msgs?.onError(err);
+        reject(err);
+      });
+    });
+  }
+
+  private async handleChange(filePath: string, initiator?: CompilationInitiator): Promise<OnComponentEventResult[]> {
+    try {
+      if (filePath.endsWith(BIT_MAP)) {
+        const buildResults = await this.handleBitmapChanges();
+        this.completeWatch();
+        return buildResults;
+      }
+      const componentId = await this.getComponentIdAndClearItsCache(filePath);
+      if (!componentId) {
+        logger.debug(`file ${filePath} is not part of any component, ignoring it`);
+        return this.completeWatch();
+      }
+
+      const buildResults = await this.executeWatchOperationsOnComponent(componentId, [filePath], true, initiator);
+      this.completeWatch();
+      return buildResults;
+    } catch (err: any) {
+      const msg = `watcher found an error while handling ${filePath}`;
+      logger.error(msg, err);
+      logger.console(`${msg}, ${err.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * if .bitmap changed, it's possible that a new component has been added. trigger onComponentAdd.
+   */
+  private async handleBitmapChanges(): Promise<OnComponentEventResult[]> {
+    const previewsTrackDirs = { ...this.trackDirs };
+    await this.workspace._reloadConsumer();
+    await this.setTrackDirs();
+    const newDirs: string[] = difference(Object.keys(this.trackDirs), Object.keys(previewsTrackDirs));
+    const removedDirs: string[] = difference(Object.keys(previewsTrackDirs), Object.keys(this.trackDirs));
+    const results: OnComponentEventResult[] = [];
+    if (newDirs.length) {
+      this.fsWatcher.add(newDirs);
+      const addResults = await mapSeries(newDirs, async (dir) =>
+        this.executeWatchOperationsOnComponent(this.trackDirs[dir], [], false)
+      );
+      results.push(...addResults.flat());
+    }
+    if (removedDirs.length) {
+      await this.fsWatcher.unwatch(removedDirs);
+      await mapSeries(removedDirs, (dir) => this.executeWatchOperationsOnRemove(previewsTrackDirs[dir]));
+    }
+    return results;
+  }
+
+  private async executeWatchOperationsOnRemove(componentId: ComponentID) {
+    logger.debug(`running OnComponentRemove hook for ${chalk.bold(componentId.toString())}`);
+    this.pubsub.pub(WorkspaceAspect.id, this.creatOnComponentRemovedEvent(componentId.toString()));
+    await this.workspace.triggerOnComponentRemove(componentId);
+  }
+
+  private async executeWatchOperationsOnComponent(
+    componentId: ComponentID,
+    files: string[],
+    isChange = true,
+    initiator?: CompilationInitiator
+  ): Promise<OnComponentEventResult[]> {
+    if (this.isComponentWatchedExternally(componentId)) {
+      // update capsule, once done, it automatically triggers the external watcher
+      await this.workspace.get(componentId);
+      return [];
+    }
+    const idStr = componentId.toString();
+
+    if (isChange) {
+      logger.debug(`running OnComponentChange hook for ${chalk.bold(idStr)}`);
+      this.pubsub.pub(WorkspaceAspect.id, this.creatOnComponentChangeEvent(idStr, 'OnComponentChange'));
+    } else {
+      logger.debug(`running OnComponentAdd hook for ${chalk.bold(idStr)}`);
+      this.pubsub.pub(WorkspaceAspect.id, this.creatOnComponentAddEvent(idStr, 'OnComponentAdd'));
+    }
+
+    let buildResults: OnComponentEventResult[];
+    try {
+      buildResults = isChange
+        ? await this.workspace.triggerOnComponentChange(componentId, files, initiator)
+        : await this.workspace.triggerOnComponentAdd(componentId);
+    } catch (err: any) {
+      // do not exit the watch process on errors, just print them
+      const msg = `found an issue during onComponentChange or onComponentAdd hooks`;
+      logger.error(msg, err);
+      logger.console(`\n${msg}: ${err.message || err}`);
+      return [];
+    }
+    if (buildResults && buildResults.length) {
+      return buildResults;
+    }
+    logger.console(`${idStr} doesn't have a compiler, nothing to build`);
+    return [];
+  }
+
+  private creatOnComponentRemovedEvent(idStr) {
+    return new OnComponentRemovedEvent(Date.now(), idStr);
+  }
+
+  private creatOnComponentChangeEvent(idStr, hook) {
+    return new OnComponentChangeEvent(Date.now(), idStr, hook);
+  }
+
+  private creatOnComponentAddEvent(idStr, hook) {
+    return new OnComponentAddEvent(Date.now(), idStr, hook);
+  }
+
+  private completeWatch() {
+    loader.stop();
+    return [];
+  }
+
+  private isComponentWatchedExternally(componentId: ComponentID) {
+    const watcherData = this.multipleWatchers.find((m) => m.componentIds.find((id) => id.isEqual(componentId._legacy)));
+    if (watcherData) {
+      logger.debug(`${componentId.toString()} is watched by ${watcherData.compilerId.toString()}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * if a file was added/remove, once the component is loaded, it changes .bitmap, and then the
+   * entire cache is invalidated and the consumer is reloaded.
+   * when a file just changed, no need to reload the consumer, it is enough to just delete the
+   * component from the cache (both, workspace and consumer)
+   */
+  private async getComponentIdAndClearItsCache(filePath: string): Promise<ComponentID | null> {
+    const relativeFile = pathNormalizeToLinux(this.consumer.getPathRelativeToConsumer(filePath));
+    const trackDir = this.findTrackDirByFilePathRecursively(relativeFile);
+    if (!trackDir) {
+      // the file is not part of any component. If it was a new component, or a new file of
+      // existing component, then, handleBitmapChanges() should deal with it.
+      return null;
+    }
+    const componentId = this.trackDirs[trackDir];
+    this.workspace.clearComponentCache(componentId);
+    const component = await this.workspace.get(componentId);
+    const componentMap: ComponentMap = component.state._consumer.componentMap;
+    if (componentMap.getFilesRelativeToConsumer().find((p) => p === relativeFile)) {
+      return componentId;
+    }
+    // the file is inside the component dir but it's ignored. (e.g. it's in IGNORE_LIST)
+    return null;
+  }
+
+  private findTrackDirByFilePathRecursively(filePath: string): string | null {
+    if (this.trackDirs[filePath]) return filePath;
+    const parentDir = dirname(filePath);
+    if (parentDir === filePath) return null;
+    return this.findTrackDirByFilePathRecursively(parentDir);
+  }
+
+  private async createWatcher(pathsToWatch: string[]) {
+    this.fsWatcher = chokidar.watch(pathsToWatch, {
+      ignoreInitial: true,
+      // Using the function way since the regular way not working as expected
+      // It might be solved when upgrading to chokidar > 3.0.0
+      // See:
+      // https://github.com/paulmillr/chokidar/issues/773
+      // https://github.com/paulmillr/chokidar/issues/492
+      // https://github.com/paulmillr/chokidar/issues/724
+      ignored: (path) => {
+        // Ignore package.json temporarily since it cerates endless loop since it's re-written after each build
+        if (path.includes(`${sep}node_modules${sep}`) || path.includes(`${sep}package.json`)) {
+          return true;
+        }
+        return false;
+      },
+      persistent: true,
+      useFsEvents: false,
+    });
+  }
+
+  async setTrackDirs() {
+    this.trackDirs = {};
+    const componentsFromBitMap = this.consumer.bitMap.getAllComponents([
+      COMPONENT_ORIGINS.AUTHORED,
+      COMPONENT_ORIGINS.IMPORTED,
+    ]);
+    await Promise.all(
+      componentsFromBitMap.map(async (componentMap) => {
+        const bitId = componentMap.id;
+        const trackDir = componentMap.getTrackDir();
+        if (!trackDir) throw new Error(`${bitId.toString()} has no rootDir, which is invalid in Harmony`);
+        const componentId = await this.workspace.resolveComponentId(bitId);
+        this.trackDirs[trackDir] = componentId;
+      })
+    );
+  }
+
+  private async getPathsToWatch(): Promise<PathOsBasedAbsolute[]> {
+    await this.setTrackDirs();
+    const paths = [...Object.keys(this.trackDirs), BIT_MAP];
+    const pathsAbsolute = paths.map((dir) => this.consumer.toAbsolutePath(dir));
+    return pathsAbsolute;
+  }
+}

package/workspace-component/component-status.ts

@@ -0,0 +1,67 @@
+import { ComponentStatus as LegacyComponentStatus } from '@teambit/legacy/dist/consumer/component-ops/component-status-loader';
+
+export type ModifyInfo = {
+  hasModifiedFiles: boolean;
+  hasModifiedDependencies: boolean;
+};
+
+export class ComponentStatus {
+  constructor(
+    /**
+     * is the component modified.
+     */
+    readonly modifyInfo: ModifyInfo,
+
+    /**
+     * is the new component new.
+     */
+    readonly isNew: boolean,
+
+    /**
+     * is the component deleted from the workspace.
+     */
+    readonly isDeleted: boolean,
+
+    /**
+     * is the component staged.
+     */
+    readonly isStaged: boolean,
+
+    /**
+     * does the component exists in the workspace.
+     */
+    readonly isInWorkspace: boolean,
+
+    /**
+     * does the component exists in the scope.
+     */
+    readonly isInScope: boolean,
+
+    /**
+     * does the component is outdated (pending for update).
+     */
+    readonly isOutdated: boolean,
+
+    /**
+     *  the component is not authored and not imported.
+     */
+    readonly nested?: boolean
+  ) {}
+
+  static fromLegacy(status: LegacyComponentStatus, hasModifiedDependencies: boolean, isOutdated: boolean) {
+    const modify: ModifyInfo = {
+      hasModifiedFiles: !!status.modified,
+      hasModifiedDependencies,
+    };
+    return new ComponentStatus(
+      modify,
+      !!status.newlyCreated,
+      !!status.deleted,
+      !!status.staged,
+      !status.notExist,
+      !status.missingFromScope,
+      isOutdated,
+      !!status.nested
+    );
+  }
+}

package/workspace-component/index.ts

@@ -0,0 +1,2 @@
+export { WorkspaceComponent } from './workspace-component';
+export { ComponentStatus } from './component-status';