@teambit/workspace 0.0.553 → 0.0.557

package/dist/workspace.d.ts

@@ -3,7 +3,7 @@ import { IssuesList } from '@teambit/component-issues';
 import type { AspectLoaderMain, AspectDefinition } from '@teambit/aspect-loader';
 import { ComponentMain, Component, ComponentFactory, ComponentID, ComponentMap, AspectList, AspectData, InvalidComponent } from '@teambit/component';
 import { ComponentScopeDirMap } from '@teambit/config';
-import { DependencyLifecycleType, DependencyResolverMain, LinkingOptions, LinkResults } from '@teambit/dependency-resolver';
+import { WorkspaceDependencyLifecycleType, DependencyResolverMain, LinkingOptions, LinkResults } from '@teambit/dependency-resolver';
 import { EnvsMain } from '@teambit/envs';
 import { GraphqlMain } from '@teambit/graphql';
 import { Harmony } from '@teambit/harmony';
@@ -45,7 +45,7 @@ export interface EjectConfOptions {
 }
 export declare type WorkspaceInstallOptions = {
     variants?: string;
-    lifecycleType?: DependencyLifecycleType;
+    lifecycleType?: WorkspaceDependencyLifecycleType;
     dedupe: boolean;
     import: boolean;
     copyPeerToRuntimeOnRoot?: boolean;
@@ -64,11 +64,26 @@ export declare type TrackResult = {
     files: string[];
     warnings: Warnings;
 };
+/**
+ * API of the Bit Workspace
+ */
 export declare class Workspace implements ComponentFactory {
+    /**
+     * private pubsub.
+     */
     private pubsub;
     private config;
+    /**
+     * private access to the legacy consumer instance.
+     */
     consumer: Consumer;
+    /**
+     * access to the workspace `Scope` instance
+     */
     readonly scope: ScopeMain;
+    /**
+     * access to the `ComponentProvider` instance
+     */
     private componentAspect;
     private isolator;
     private dependencyResolver;
@@ -76,10 +91,22 @@ export declare class Workspace implements ComponentFactory {
     private aspectLoader;
     private logger;
     private componentList;
+    /**
+     * private reference to the instance of Harmony.
+     */
     private harmony;
+    /**
+     * on component load slot.
+     */
     onComponentLoadSlot: OnComponentLoadSlot;
+    /**
+     * on component change slot.
+     */
     private onComponentChangeSlot;
     private envs;
+    /**
+     * on component add slot.
+     */
     private onComponentAddSlot;
     private onComponentRemoveSlot;
     private onPreWatchSlot;
@@ -88,10 +115,49 @@ export declare class Workspace implements ComponentFactory {
     owner?: string;
     componentsScopeDirsMap: ComponentScopeDirMap;
     componentLoader: WorkspaceComponentLoader;
-    constructor(pubsub: PubsubMain, config: WorkspaceExtConfig, consumer: Consumer, scope: ScopeMain, componentAspect: ComponentMain, isolator: IsolatorMain, dependencyResolver: DependencyResolverMain, variants: VariantsMain, aspectLoader: AspectLoaderMain, logger: Logger, componentList: ComponentsList, harmony: Harmony, onComponentLoadSlot: OnComponentLoadSlot, onComponentChangeSlot: OnComponentChangeSlot, envs: EnvsMain, onComponentAddSlot: OnComponentAddSlot, onComponentRemoveSlot: OnComponentRemoveSlot, onPreWatchSlot: OnPreWatchSlot, graphql: GraphqlMain);
+    constructor(
+    /**
+     * private pubsub.
+     */
+    pubsub: PubsubMain, config: WorkspaceExtConfig, 
+    /**
+     * private access to the legacy consumer instance.
+     */
+    consumer: Consumer, 
+    /**
+     * access to the workspace `Scope` instance
+     */
+    scope: ScopeMain, 
+    /**
+     * access to the `ComponentProvider` instance
+     */
+    componentAspect: ComponentMain, isolator: IsolatorMain, dependencyResolver: DependencyResolverMain, variants: VariantsMain, aspectLoader: AspectLoaderMain, logger: Logger, componentList: ComponentsList, 
+    /**
+     * private reference to the instance of Harmony.
+     */
+    harmony: Harmony, 
+    /**
+     * on component load slot.
+     */
+    onComponentLoadSlot: OnComponentLoadSlot, 
+    /**
+     * on component change slot.
+     */
+    onComponentChangeSlot: OnComponentChangeSlot, envs: EnvsMain, 
+    /**
+     * on component add slot.
+     */
+    onComponentAddSlot: OnComponentAddSlot, onComponentRemoveSlot: OnComponentRemoveSlot, onPreWatchSlot: OnPreWatchSlot, graphql: GraphqlMain);
     private validateConfig;
+    /**
+     * watcher api.
+     */
     readonly watcher: Watcher;
+    /**
+     * root path of the Workspace.
+     */
     get path(): string;
+    /** get the `node_modules` folder of this workspace */
     private get modulesPath();
     get isLegacy(): boolean;
     onComponentLoad(loadFn: OnComponentLoad): this;
@@ -99,29 +165,78 @@ export declare class Workspace implements ComponentFactory {
     registerOnComponentAdd(onComponentAddFunc: OnComponentAdd): this;
     registerOnComponentRemove(onComponentRemoveFunc: OnComponentRemove): this;
     registerOnPreWatch(onPreWatchFunc: OnPreWatch): this;
+    /**
+     * name of the workspace as configured in either `workspace.json`.
+     * defaults to workspace root directory name.
+     */
     get name(): string;
     get icon(): string;
     hasModifiedDependencies(component: Component): Promise<boolean>;
+    /**
+     * get Component issues
+     */
     getComponentIssues(component: Component): IssuesList | null;
+    /**
+     * provides status of all components in the workspace.
+     */
     getComponentStatus(component: Component): Promise<ComponentStatus>;
+    /**
+     * list all workspace components.
+     */
     list(filter?: {
         offset: number;
         limit: number;
     }): Promise<Component[]>;
+    /**
+     * list all invalid components.
+     * (see the invalid criteria in ConsumerComponent.isComponentInvalidByErrorType())
+     */
     listInvalid(): Promise<InvalidComponent[]>;
+    /**
+     * get ids of all workspace components.
+     */
     listIds(): Promise<ComponentID[]>;
+    /**
+     * Check if a specific id exist in the workspace
+     * @param componentId
+     */
     hasId(componentId: ComponentID): Promise<boolean>;
+    /**
+     * whether or not a workspace has a component with the given name
+     */
     hasName(name: string): Promise<boolean>;
+    /**
+     * Check if a specific id exist in the workspace or in the scope
+     * @param componentId
+     */
     hasIdNested(componentId: ComponentID, includeCache?: boolean): Promise<boolean>;
+    /**
+     * list all modified components in the workspace.
+     */
     modified(): Promise<Component[]>;
+    /**
+     * list all new components in the workspace.
+     */
     newComponents(): Promise<Component[]>;
+    /**
+     * get all workspace component-ids, include vendor components.
+     * (exclude nested dependencies in case dependencies are saved as components and not packages)
+     */
     getAllComponentIds(): Promise<ComponentID[]>;
     getNewAndModifiedIds(): Promise<ComponentID[]>;
     getLogs(id: ComponentID): Promise<ComponentLog[]>;
     getLegacyGraph(ids?: ComponentID[]): Promise<LegacyGraph>;
     loadCapsules(bitIds: string[]): Promise<import("@teambit/isolator").Capsule[]>;
+    /**
+     * fully load components, including dependency resolution and prepare them for runtime.
+     * @todo: remove the string option, use only BitId
+     */
     load(ids: Array<BitId | string>): Promise<ResolvedComponent[]>;
     createAspectList(extensionDataList: ExtensionDataList): Promise<AspectList>;
+    /**
+     * get a component from workspace
+     * @param id component ID
+     */
     get(componentId: ComponentID, forCapsule?: boolean, legacyComponent?: ConsumerComponent, useCache?: boolean, storeInCache?: boolean): Promise<Component>;
     getEnvSystemDescriptor(component: Component): Promise<AspectData>;
     clearCache(): void;
@@ -132,21 +247,62 @@ export declare class Workspace implements ComponentFactory {
     getState(id: ComponentID, hash: string): Promise<import("@teambit/component").State>;
     getSnap(id: ComponentID, hash: string): Promise<import("@teambit/component").Snap>;
     getCurrentLaneId(): LocalLaneId;
+    /**
+     * if checked out to a lane, return the remote lane id (name+scope). otherwise, return null.
+     */
     getCurrentRemoteLaneId(): RemoteLaneId | null;
     getDefaultExtensions(): ExtensionDataList;
     ejectConfig(id: ComponentID, options: EjectConfOptions): Promise<EjectConfResult>;
     private resolveScopeAspectListIds;
+    /**
+     * load components into the workspace through a variants pattern.
+     * @param pattern variants.
+     * @param scope scope name.
+     */
     byPattern(pattern: string, scope?: string): Promise<Component[]>;
     getMany(ids: Array<ComponentID>, forCapsule?: boolean): Promise<Component[]>;
     getManyByLegacy(components: ConsumerComponent[]): Promise<Component[]>;
+    /**
+     * This will make sure to fetch the objects prior to load them
+     * do not use it if you are not sure you need it.
+     * It will influence the performance
+     * currently it used only for get many of aspects
+     * @param ids
+     * @param forCapsule
+     */
     importAndGetMany(ids: Array<ComponentID>, forCapsule?: boolean): Promise<Component[]>;
+    /**
+     * @deprecated use this.track() instead
+     * track a new component. (practically, add it to .bitmap).
+     *
+     * @param componentPaths component paths relative to the workspace dir
+     * @param id if not set, will be concluded from the filenames
+     * @param main if not set, will try to guess according to some strategies and throws if failed
+     * @param override whether add details to an existing component or re-define it
+     */
     add(componentPaths: PathOsBasedRelative[], id?: string, main?: string, override?: boolean): Promise<AddActionResults>;
+    /**
+     * add a new component to the .bitmap file.
+     * this method only adds the records in memory but doesn't persist to the filesystem.
+     * to write the .bitmap file once completed, run "await this.writeBitMap();"
+     */
     track(trackData: TrackData): Promise<TrackResult>;
     write(rootPath: string, component: Component): Promise<void>;
     writeBitMap(): Promise<void>;
+    /**
+     * Get the component root dir in the file system (relative to workspace or full)
+     * @param componentId
+     * @param relative return the path relative to the workspace or full path
+     */
     componentDir(componentId: ComponentID, bitMapOptions?: GetBitMapComponentOptions, options?: {
         relative: boolean;
     }): PathOsBased;
+    /**
+     * component's files in the workspace are symlinked to the node_modules, and a package.json file is generated on that
+     * package directory to simulate a valid node package.
+     * @returns the package directory inside the node_module.
+     * by default the absolute path, unless `options.relative` was set
+     */
     componentPackageDir(component: Component, options?: {
         relative: boolean;
     }): string;
@@ -156,34 +312,111 @@ export declare class Workspace implements ComponentFactory {
     componentDefaultScopeFromComponentDirAndName(relativeComponentDir: PathOsBasedRelative, name: string): Promise<string | undefined>;
     get defaultScope(): string;
     private componentDefaultScopeFromComponentDirAndNameWithoutConfigFile;
+    /**
+     * Calculate the component config based on:
+     * the component.json file in the component folder
+     * matching pattern in the variants config
+     * defaults extensions from workspace config
+     *
+     * @param {ComponentID} componentId
+     * @param {Component} [componentFromScope]
+     * @returns {Promise<ExtensionDataList>}
+     * @memberof Workspace
+     */
     componentExtensions(componentId: ComponentID, componentFromScope?: Component): Promise<ExtensionDataList>;
     triggerOnPreWatch(componentIds: ComponentID[], watchOpts: WatchOptions): Promise<void>;
+    /**
+     * This will mutate the entries with extensionId prop to have resolved legacy id
+     * This should be worked on the extension data list not the new aspect list
+     * @param extensionList
+     */
     private resolveExtensionListIds;
     private isVendorComponentByComponentDir;
+    /**
+     * return the component config from its folder (component.json)
+     * @param componentId
+     */
     private componentConfigFile;
     private componentConfigFileFromComponentDirAndName;
     getAspectsGraphWithoutCore(components: Component[], isAspect?: ShouldIgnoreFunc): Promise<LegacyGraph>;
+    /**
+     * load aspects from the workspace and if not exists in the workspace, load from the scope.
+     * keep in mind that the graph may have circles.
+     */
     loadAspects(ids?: string[], throwOnError?: boolean): Promise<void>;
+    /**
+     * Note - this gets called from Harmony only.
+     * returns one graph that includes all dependencies types. each edge has a label of the dependency
+     * type. the nodes content is the Component object.
+     */
     buildOneGraphForComponents(ids: BitId[], ignoreIds?: BitIds, shouldIgnoreFunc?: ShouldIgnoreFunc): Promise<LegacyGraph>;
     resolveAspects(runtimeName?: string, componentIds?: ComponentID[]): Promise<AspectDefinition[]>;
     private groupIdsByWorkspaceAndScope;
     private groupComponentsByWorkspaceAndScope;
+    /**
+     * Load all unloaded extensions from a list
+     * @param extensions list of extensions with config to load
+     */
     loadExtensions(extensions: ExtensionDataList, throwOnError?: boolean): Promise<void>;
+    /**
+     * Provides a cache folder, unique per key.
+     * Return value may be undefined, if workspace folder is unconventional (bare-scope, no node_modules, etc)
+     */
     getTempDir(id: string): string;
     requireComponents(components: Component[]): Promise<RequireableComponent[]>;
     private getComponentsDirectory;
+    /**
+     * Install dependencies for all components in the workspace
+     *
+     * @returns
+     * @memberof Workspace
+     */
     install(packages?: string[], options?: WorkspaceInstallOptions): Promise<ComponentMap<string>>;
     link(options?: WorkspaceLinkOptions): Promise<LinkResults>;
+    /**
+     * Generate a filter to pass to the installer
+     * This will filter deps which are come from remotes which defined in scope.json
+     * those components comes from local remotes, usually doesn't have a package in a registry
+     * so no reason to try to install them (it will fail)
+     */
     private generateFilterFnForDepsFromLocalRemote;
+    /**
+     * same as `this.importAndGetMany()` with a specific error handling of ComponentNotFound
+     */
     private importAndGetAspects;
     private importObjects;
+    /**
+     * this should be rarely in-use.
+     * it's currently used by watch extension as a quick workaround to load .bitmap and the components
+     */
     _reloadConsumer(): Promise<void>;
     getComponentPackagePath(component: ConsumerComponent | Component): string;
     get defaultDirectory(): string;
     get legacyDefaultDirectory(): string;
+    /**
+     * Transform the id to ComponentId and get the exact id as appear in bitmap
+     *
+     * @param {(string | ComponentID | BitId)} id
+     * @returns {Promise<ComponentID>}
+     * @memberof Workspace
+     */
     resolveComponentId(id: string | ComponentID | BitId): Promise<ComponentID>;
     resolveMultipleComponentIds(ids: Array<string | ComponentID | BitId>): Promise<ComponentID[]>;
+    /**
+     * This will mutate the original extensions list and resolve it's ids
+     *
+     * @param {ExtensionDataList} extensions
+     * @returns {Promise<void[]>}
+     * @memberof Workspace
+     */
     resolveExtensionsList(extensions: ExtensionDataList): Promise<void[]>;
+    /**
+     * This will mutate the original extensions list and make sure all extensions has the ids with the scope / default scope
+     *
+     * @param {ExtensionDataList} extensions
+     * @returns {Promise<void[]>}
+     * @memberof Workspace
+     */
     addDefaultScopeToExtensionsList(extensions: ExtensionDataList): Promise<void[]>;
 }
 export default Workspace;

package/dist/workspace.js

@@ -35,6 +35,16 @@ function _chalk() {
   return data;
 }
 
+function _memoizee() {
+  const data = _interopRequireDefault(require("memoizee"));
+
+  _memoizee = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _pMapSeries() {
   const data = _interopRequireDefault(require("p-map-series"));
 
@@ -459,7 +469,14 @@ class Workspace {
     // TODO: refactor - prefer to avoid code inside the constructor.
     this.owner = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.defaultOwner;
     this.componentLoader = new (_workspaceComponentLoader().WorkspaceComponentLoader)(this, logger, dependencyResolver, envs);
-    this.validateConfig();
+    this.validateConfig(); // memoize this method to improve performance.
+
+    this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile = (0, _memoizee().default)(this.componentDefaultScopeFromComponentDirAndNameWithoutConfigFile.bind(this), {
+      primitive: true,
+      promise: true,
+      maxAge: 60 * 1000 // 1 min
+
+    });
   }
 
   validateConfig() {
@@ -1618,6 +1635,8 @@ class Workspace {
   async generateFilterFnForDepsFromLocalRemote() {
     // TODO: once scope create a new API for this, replace it with the new one
     const remotes = await this.scope._legacyRemotes();
+    const reg = await this.dependencyResolver.getRegistries();
+    const packageScopes = Object.keys(reg.scopes);
     return dependencyList => {
       const filtered = dependencyList.filter(dep => {
         if (!(dep instanceof _dependencyResolver().ComponentDependency)) {
@@ -1628,6 +1647,10 @@ class Workspace {
           return true;
         }
 
+        if (packageScopes.some(scope => dep.packageName.startsWith(`@${scope}/`))) {
+          return true;
+        }
+
         return false;
       });
       return filtered;
@@ -1807,10 +1830,19 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       }
     }
 
-    const relativeComponentDir = this.componentDirFromLegacyId(legacyId, undefined, {
-      relative: true
-    });
-    const defaultScope = await this.componentDefaultScopeFromComponentDirAndName(relativeComponentDir, legacyId.toStringWithoutScopeAndVersion());
+    const getDefaultScope = async bitId => {
+      if (bitId.scope) {
+        return bitId.scope;
+      }
+
+      const relativeComponentDir = this.componentDirFromLegacyId(bitId, undefined, {
+        relative: true
+      });
+      const defaultScope = await this.componentDefaultScopeFromComponentDirAndName(relativeComponentDir, bitId.toStringWithoutScopeAndVersion());
+      return defaultScope;
+    };
+
+    const defaultScope = await getDefaultScope(legacyId);
     return _component().ComponentID.fromLegacy(legacyId, defaultScope);
   }