@teambit/workspace 0.0.555 → 0.0.556

package/watch/watcher.ts

@@ -1,289 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

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

package/workspace-component/workspace-component-loader.ts

@@ -1,276 +0,0 @@
-import { Component, ComponentFS, ComponentID, Config, InvalidComponent, State, TagMap } from '@teambit/component';
-import { BitId } from '@teambit/legacy-bit-id';
-import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
-import mapSeries from 'p-map-series';
-import { compact } from 'lodash';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import { MissingBitMapComponent } from '@teambit/legacy/dist/consumer/bit-map/exceptions';
-import { getLatestVersionNumber } from '@teambit/legacy/dist/utils';
-import { IssuesClasses } from '@teambit/component-issues';
-import { ComponentNotFound } from '@teambit/legacy/dist/scope/exceptions';
-import { DependencyResolverAspect, DependencyResolverMain } from '@teambit/dependency-resolver';
-import { Logger } from '@teambit/logger';
-import { EnvsAspect, EnvsMain } from '@teambit/envs';
-import { ExtensionDataEntry } from '@teambit/legacy/dist/consumer/config';
-import { getMaxSizeForComponents, InMemoryCache } from '@teambit/legacy/dist/cache/in-memory-cache';
-import { createInMemoryCache } from '@teambit/legacy/dist/cache/cache-factory';
-import ComponentNotFoundInPath from '@teambit/legacy/dist/consumer/component/exceptions/component-not-found-in-path';
-import { Workspace } from '../workspace';
-import { WorkspaceComponent } from './workspace-component';
-
-export class WorkspaceComponentLoader {
-  private componentsCache: InMemoryCache<Component>; // cache loaded components
-  private componentsCacheForCapsule: InMemoryCache<Component>; // cache loaded components for capsule, must not use the cache for the workspace
-  constructor(
-    private workspace: Workspace,
-    private logger: Logger,
-    private dependencyResolver: DependencyResolverMain,
-    private envs: EnvsMain
-  ) {
-    this.componentsCache = createInMemoryCache({ maxSize: getMaxSizeForComponents() });
-    this.componentsCacheForCapsule = createInMemoryCache({ maxSize: getMaxSizeForComponents() });
-  }
-
-  async getMany(ids: Array<ComponentID>, forCapsule = false): Promise<Component[]> {
-    const idsWithoutEmpty = compact(ids);
-    const errors: { id: ComponentID; err: Error }[] = [];
-    const longProcessLogger = this.logger.createLongProcessLogger('loading components', ids.length);
-    const componentsP = mapSeries(idsWithoutEmpty, async (id: ComponentID) => {
-      longProcessLogger.logProgress(id.toString());
-      return this.get(id, forCapsule).catch((err) => {
-        if (this.isComponentNotExistsError(err)) {
-          errors.push({
-            id,
-            err,
-          });
-          return undefined;
-        }
-        throw err;
-      });
-    });
-    const components = await componentsP;
-    errors.forEach((err) => {
-      if (!this.workspace.consumer.isLegacy) {
-        this.logger.console(`failed loading component ${err.id.toString()}, see full error in debug.log file`);
-      }
-      this.logger.warn(`failed loading component ${err.id.toString()}`, err.err);
-    });
-    // remove errored components
-    const filteredComponents: Component[] = compact(components);
-    longProcessLogger.end();
-    return filteredComponents;
-  }
-
-  async getInvalid(ids: Array<ComponentID>): Promise<InvalidComponent[]> {
-    const idsWithoutEmpty = compact(ids);
-    const errors: InvalidComponent[] = [];
-    const longProcessLogger = this.logger.createLongProcessLogger('loading components', ids.length);
-    await mapSeries(idsWithoutEmpty, async (id: ComponentID) => {
-      longProcessLogger.logProgress(id.toString());
-      try {
-        await this.workspace.consumer.loadComponent(id._legacy);
-      } catch (err: any) {
-        if (ConsumerComponent.isComponentInvalidByErrorType(err)) {
-          errors.push({
-            id,
-            err,
-          });
-          return;
-        }
-        throw err;
-      }
-    });
-    return errors;
-  }
-
-  async get(
-    componentId: ComponentID,
-    forCapsule = false,
-    legacyComponent?: ConsumerComponent,
-    useCache = true,
-    storeInCache = true
-  ): Promise<Component> {
-    const bitIdWithVersion: BitId = getLatestVersionNumber(
-      this.workspace.consumer.bitmapIdsFromCurrentLane,
-      componentId._legacy
-    );
-    const id = bitIdWithVersion.version ? componentId.changeVersion(bitIdWithVersion.version) : componentId;
-    const fromCache = this.getFromCache(id, forCapsule);
-    if (fromCache && useCache) {
-      return fromCache;
-    }
-    const consumerComponent = legacyComponent || (await this.getConsumerComponent(id, forCapsule));
-    // in case of out-of-sync, the id may changed during the load process
-    const updatedId = consumerComponent ? ComponentID.fromLegacy(consumerComponent.id, id.scope) : id;
-    const component = await this.loadOne(updatedId, consumerComponent);
-    if (storeInCache) {
-      this.addMultipleEnvsIssueIfNeeded(component); // it's in storeInCache block, otherwise, it wasn't fully loaded
-      this.saveInCache(component, forCapsule);
-    }
-    return component;
-  }
-
-  private addMultipleEnvsIssueIfNeeded(component: Component) {
-    const envs = this.envs.getAllEnvsConfiguredOnComponent(component);
-    if (envs.length < 2) {
-      return;
-    }
-    component.state.issues.getOrCreate(IssuesClasses.MultipleEnvs).data = envs.map((e) => e.id);
-  }
-
-  clearCache() {
-    this.componentsCache.deleteAll();
-    this.componentsCacheForCapsule.deleteAll();
-  }
-  clearComponentCache(id: ComponentID) {
-    const idStr = id.toString();
-    this.componentsCache.delete(idStr);
-    this.componentsCacheForCapsule.delete(idStr);
-  }
-
-  private async loadOne(id: ComponentID, consumerComponent?: ConsumerComponent) {
-    const componentFromScope = await this.workspace.scope.get(id);
-    if (!consumerComponent) {
-      if (!componentFromScope) throw new MissingBitMapComponent(id.toString());
-      return componentFromScope;
-    }
-
-    let extensionDataList = await this.workspace.componentExtensions(id, componentFromScope);
-    const extensionsFromConsumerComponent = consumerComponent.extensions || new ExtensionDataList();
-    // Merge extensions added by the legacy code in memory (for example data of dependency resolver)
-    extensionDataList = ExtensionDataList.mergeConfigs([
-      extensionsFromConsumerComponent,
-      extensionDataList,
-    ]).filterRemovedExtensions();
-
-    // temporarily mutate consumer component extensions until we remove all direct access from legacy to extensions data
-    // TODO: remove this once we remove all direct access from legacy code to extensions data
-    consumerComponent.extensions = extensionDataList;
-
-    const state = new State(
-      new Config(consumerComponent.mainFile, extensionDataList),
-      await this.workspace.createAspectList(extensionDataList),
-      ComponentFS.fromVinyls(consumerComponent.files),
-      consumerComponent.dependencies,
-      consumerComponent
-    );
-    if (componentFromScope) {
-      // Removed by @gilad. do not mutate the component from the scope
-      // componentFromScope.state = state;
-      // const workspaceComponent = WorkspaceComponent.fromComponent(componentFromScope, this.workspace);
-      const workspaceComponent = new WorkspaceComponent(
-        componentFromScope.id,
-        componentFromScope.head,
-        state,
-        componentFromScope.tags,
-        this.workspace
-      );
-      return this.executeLoadSlot(workspaceComponent);
-    }
-    return this.executeLoadSlot(this.newComponentFromState(id, state));
-  }
-
-  private saveInCache(component: Component, forCapsule: boolean): void {
-    if (forCapsule) {
-      this.componentsCacheForCapsule.set(component.id.toString(), component);
-    } else {
-      this.componentsCache.set(component.id.toString(), component);
-    }
-  }
-
-  /**
-   * make sure that not only the id-str match, but also the legacy-id.
-   * this is needed because the ComponentID.toString() is the same whether or not the legacy-id has
-   * scope-name, as it includes the defaultScope if the scope is empty.
-   * as a result, when out-of-sync is happening and the id is changed to include scope-name in the
-   * legacy-id, the component is the cache has the old id.
-   */
-  private getFromCache(id: ComponentID, forCapsule: boolean): Component | undefined {
-    const fromCache = forCapsule
-      ? this.componentsCacheForCapsule.get(id.toString())
-      : this.componentsCache.get(id.toString());
-    if (fromCache && fromCache.id._legacy.isEqual(id._legacy)) {
-      return fromCache;
-    }
-    return undefined;
-  }
-
-  private async getConsumerComponent(id: ComponentID, forCapsule = false): Promise<ConsumerComponent | undefined> {
-    try {
-      return forCapsule
-        ? // eslint-disable-next-line @typescript-eslint/return-await
-          await this.workspace.consumer.loadComponentForCapsule(id._legacy)
-        : // eslint-disable-next-line @typescript-eslint/return-await
-          await this.workspace.consumer.loadComponent(id._legacy);
-    } catch (err: any) {
-      // don't return undefined for any error. otherwise, if the component is invalid (e.g. main
-      // file is missing) it returns the model component later unexpectedly, or if it's new, it
-      // shows MissingBitMapComponent error incorrectly.
-      if (this.isComponentNotExistsError(err)) {
-        this.logger.debug(
-          `failed loading component "${id.toString()}" from the workspace due to "${err.name}" error\n${err.message}`
-        );
-        return undefined;
-      }
-      throw err;
-    }
-  }
-
-  private isComponentNotExistsError(err: Error): boolean {
-    return (
-      err instanceof ComponentNotFound ||
-      err instanceof MissingBitMapComponent ||
-      err instanceof ComponentNotFoundInPath
-    );
-  }
-
-  private async executeLoadSlot(component: Component) {
-    const entries = this.workspace.onComponentLoadSlot.toArray();
-    const promises = entries.map(async ([extension, onLoad]) => {
-      const data = await onLoad(component);
-      return this.upsertExtensionData(component, extension, data);
-    });
-
-    // Special load events which runs from the workspace but should run from the correct aspect
-    // TODO: remove this once those extensions dependent on workspace
-    const envsData = await this.workspace.getEnvSystemDescriptor(component);
-
-    // Move to deps resolver main runtime once we switch ws<> deps resolver direction
-    const policy = await this.dependencyResolver.mergeVariantPolicies(component.config.extensions);
-    const dependencies = await this.dependencyResolver.extractDepsFromLegacy(component, policy);
-
-    const depResolverData = {
-      dependencies,
-      policy: policy.serialize(),
-    };
-
-    promises.push(this.upsertExtensionData(component, EnvsAspect.id, envsData));
-    promises.push(this.upsertExtensionData(component, DependencyResolverAspect.id, depResolverData));
-
-    await Promise.all(promises);
-
-    // Update the aspect list to have changes happened during the on load slot (new data added above)
-    const updatedAspectList = await this.workspace.createAspectList(component.state.config.extensions);
-    component.state.aspects = updatedAspectList;
-    return component;
-  }
-
-  private newComponentFromState(id: ComponentID, state: State): Component {
-    return new WorkspaceComponent(id, null, state, new TagMap(), this.workspace);
-  }
-
-  private async upsertExtensionData(component: Component, extension: string, data: any) {
-    const existingExtension = component.state.config.extensions.findExtension(extension);
-    if (existingExtension) {
-      // Only merge top level of extension data
-      Object.assign(existingExtension.data, data);
-      return;
-    }
-    component.state.config.extensions.push(await this.getDataEntry(extension, data));
-  }
-
-  private async getDataEntry(extension: string, data: { [key: string]: any }): Promise<ExtensionDataEntry> {
-    // TODO: @gilad we need to refactor the extension data entry api.
-    return new ExtensionDataEntry(undefined, undefined, extension, undefined, data);
-  }
-}

package/workspace-component/workspace-component.ts

@@ -1,51 +0,0 @@
-import { Component, ComponentID, Snap, State, TagMap } from '@teambit/component';
-import { IssuesList } from '@teambit/component-issues';
-import { Workspace } from '../workspace';
-import { ComponentStatus } from './component-status';
-
-// TODO: refactor this to a composition rather than to use inheritance
-export class WorkspaceComponent extends Component {
-  constructor(
-    /**
-     * component ID represented by the `ComponentId` type.
-     */
-    readonly id: ComponentID,
-
-    /**
-     * head version of the component. can be `null` for new components.
-     */
-    readonly head: Snap | null = null,
-
-    /**
-     * state of the component.
-     */
-    workspaceState: State,
-
-    /**
-     * tags of the component.
-     */
-    readonly tags: TagMap = new TagMap(),
-
-    /**
-     * workspace extension.
-     */
-    readonly workspace: Workspace
-  ) {
-    super(id, head, workspaceState, tags, workspace);
-  }
-
-  async getStatus(): Promise<ComponentStatus> {
-    return this.workspace.getComponentStatus(this);
-  }
-
-  /**
-   * get all issues reported on the component.
-   */
-  getIssues(): IssuesList | null {
-    return this.workspace.getComponentIssues(this);
-  }
-
-  static fromComponent(component: Component, workspace: Workspace) {
-    return new WorkspaceComponent(component.id, component.head, component.state, component.tags, workspace);
-  }
-}