@teambit/component 0.0.553 → 0.0.557

package/dist/aspect-list.d.ts

@@ -1,14 +1,32 @@
 import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
 import { ComponentID } from '@teambit/component-id';
 import { AspectEntry, SerializableMap } from './aspect-entry';
+/**
+ * list of aspects, each may have data and artifacts saved per component.
+ */
 export declare class AspectList {
     readonly entries: AspectEntry[];
     constructor(entries: AspectEntry[]);
     addEntry(aspectId: ComponentID, data?: SerializableMap): AspectEntry;
+    /**
+     * get all ids as strings from the aspect list.
+     */
     get ids(): string[];
+    /**
+     * get an aspect from the list using a serialized ID.
+     */
     get(id: string): AspectEntry | undefined;
+    /**
+     * find aspect by component ID.
+     */
     find(id: ComponentID, ignoreVersion?: boolean): AspectEntry | undefined;
+    /**
+     * transform an aspect list into a new one.
+     */
     map(predicate: (entry: AspectEntry) => AspectEntry): AspectList;
+    /**
+     * transform an aspect list into a new one.
+     */
     pmap(predicate: (entry: AspectEntry) => Promise<AspectEntry>): Promise<AspectList>;
     toConfigObject(): {};
     serialize(): {

package/dist/component-factory.d.ts

@@ -8,28 +8,77 @@ import { Component, InvalidComponent } from './component';
 import { State } from './state';
 import { Snap } from './snap';
 export interface ComponentFactory {
+    /**
+     * name of the component host.
+     */
     name: string;
+    /**
+     * path to the component host.
+     */
     path: string;
     isLegacy: boolean;
+    /**
+     * resolve a `string` component ID to an instance of a ComponentID.
+     */
     resolveComponentId(id: string | ComponentID | BitId): Promise<ComponentID>;
+    /**
+     * resolve multiple `string` component ID to an instance of a ComponentID.
+     */
     resolveMultipleComponentIds(ids: (string | ComponentID | BitId)[]): Promise<ComponentID[]>;
+    /**
+     * returns a component by ID.
+     */
     get(id: ComponentID | string, withState?: boolean, consumerComponent?: ConsumerComponent): Promise<Component | undefined>;
+    /**
+     * returns many components by ids.
+     */
     getMany(ids: ComponentID[]): Promise<Component[]>;
+    /**
+     * returns many components by their legacy representation.
+     */
     getManyByLegacy(components: ConsumerComponent[]): Promise<Component[]>;
+    /**
+     * get a component from a remote without importing it
+     */
     getRemoteComponent?: (id: ComponentID) => Promise<Component>;
     getLegacyGraph(ids?: ComponentID[]): Promise<LegacyGraph>;
     getLogs(id: ComponentID): Promise<ComponentLog[]>;
+    /**
+     * returns a specific state of a component by hash or semver.
+     */
     getState(id: ComponentID, snapId: string): Promise<State>;
+    /**
+     * returns a specific snap of a component by hash.
+     */
     getSnap(id: ComponentID, snapId: string): Promise<Snap>;
+    /**
+     * load extension.
+     */
     loadAspects: (ids: string[], throwOnError: boolean) => Promise<void>;
+    /**
+     * Resolve dirs for aspects
+     */
     resolveAspects: (runtimeName?: string, componentIds?: ComponentID[]) => Promise<AspectDefinition[]>;
+    /**
+     * list all components in the host.
+     */
     list(filter?: {
         offset: number;
         limit: number;
     }): Promise<Component[]>;
+    /**
+     * list invalid components, such as components with missing files on the fs.
+     */
     listInvalid(): Promise<InvalidComponent[]>;
     listIds(): Promise<ComponentID[]>;
     hasId(componentId: ComponentID): Promise<boolean>;
+    /**
+     * Check if the host has the id, if no, search for the id in inner host (for example, workspace will search in the scope)
+     * @param componentId
+     */
     hasIdNested(componentId: ComponentID, includeCache?: boolean): Promise<boolean>;
+    /**
+     * determine whether host should be the prior one in case multiple hosts persist.
+     */
     priority?: boolean;
 }

package/dist/component-fs.d.ts

@@ -1,10 +1,29 @@
 import { MemoryFS } from '@teambit/any-fs';
 import type { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+/**
+ * The virtual component filesystem
+ */
 export default class ComponentFS extends MemoryFS {
+    /**
+     * array of all fs files.
+     */
     readonly files: AbstractVinyl[];
-    constructor(files: AbstractVinyl[]);
+    constructor(
+    /**
+     * array of all fs files.
+     */
+    files: AbstractVinyl[]);
+    /**
+     * hash to represent all contents within this filesystem volume.
+     */
     get hash(): string;
+    /**
+     * filter all component files by regex.
+     */
     byRegex(extension: RegExp): AbstractVinyl[];
+    /**
+     * filter all files using an array of glob patterns.
+     */
     byGlob(patterns: string[]): AbstractVinyl[];
     toObject(): void;
     toJSON(): void;

package/dist/component-map/component-map.d.ts

@@ -1,17 +1,49 @@
 import { ComponentID } from '@teambit/component-id';
 import { Component } from '../component';
+/**
+ * allows to index components -> values.
+ */
 export declare class ComponentMap<T> {
     readonly hashMap: Map<string, [Component, T]>;
     constructor(hashMap: Map<string, [Component, T]>);
+    /**
+     * @deprecated please use `get` instead
+     */
     byComponent(component: Component): [Component, T] | undefined;
     get components(): Component[];
+    /**
+     * get a value for a component.
+     */
     get(component: Component): [Component, T] | undefined;
+    /**
+     * get a value by the component-id
+     */
     getValueByComponentId(componentId: ComponentID): T | null;
+    /**
+     * returns an array.
+     */
     toArray(): [Component, T][];
+    /**
+     * map entries and return a new component map.
+     */
     map<NewType>(predicate: (value: T, component: Component) => NewType): ComponentMap<NewType>;
+    /**
+     * flatten values of all components into a single array.
+     */
     flattenValue(): T[];
+    /**
+     * filter all components with empty values and return a new map.
+     */
     filter(predicate: (value: T) => boolean): ComponentMap<T>;
+    /**
+     * get all component ids.
+     */
     keys(): IterableIterator<string>;
     static create<U>(rawMap: [Component, U][]): ComponentMap<U>;
+    /**
+     * create a component map from components and a value predicate.
+     * @param components components to zip into the map.
+     * @param predicate predicate for returning desired value.
+     */
     static as<U>(components: Component[], predicate: (component: Component) => U): ComponentMap<U>;
 }

package/dist/component-meta.d.ts

@@ -1,7 +1,17 @@
 import { ComponentID } from '@teambit/component-id';
 export declare class ComponentMeta {
+    /**
+     * id the component.
+     */
     readonly id: ComponentID;
-    constructor(id: ComponentID);
+    constructor(
+    /**
+     * id the component.
+     */
+    id: ComponentID);
+    /**
+     * display name of the component.
+     */
     get displayName(): string;
     toObject(): {
         id: import("@teambit/component-id").ComponentIdObj;

package/dist/component.d.ts

@@ -17,32 +17,127 @@ export declare type InvalidComponent = {
     id: ComponentID;
     err: Error;
 };
+/**
+ * in-memory representation of a component.
+ */
 export declare class Component {
+    /**
+     * 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;
+    /**
+     * state of the component.
+     */
     private _state;
+    /**
+     * tags of the component.
+     */
     readonly tags: TagMap;
+    /**
+     * the component factory
+     */
     private factory;
-    constructor(id: ComponentID, head: Snap | null, _state: State, tags: TagMap, factory: ComponentFactory);
+    constructor(
+    /**
+     * component ID represented by the `ComponentId` type.
+     */
+    id: ComponentID, 
+    /**
+     * head version of the component. can be `null` for new components.
+     */
+    head: Snap | null, 
+    /**
+     * state of the component.
+     */
+    _state: State, 
+    /**
+     * tags of the component.
+     */
+    tags: TagMap, 
+    /**
+     * the component factory
+     */
+    factory: ComponentFactory);
     get state(): State;
     set state(state: State);
+    /**
+     * component configuration which is later generated to a component `package.json` and `bit.json`.
+     */
     get config(): ComponentConfig;
+    /**
+     * in-memory representation of the component current filesystem.
+     */
     get filesystem(): ComponentFS;
+    /**
+     * build status of the component
+     */
     get buildStatus(): BuildStatus;
     get headTag(): Tag | undefined;
     get latest(): string | undefined;
     stringify(): string;
+    /**
+     * record component changes in the `Scope`.
+     */
+    /**
+     * display name of the component.
+     */
     get displayName(): string;
+    /**
+     * tag a component `Snap` with a semantic version. we follow SemVer specs as defined [here](https://semver.org/)).
+     */
     tag(version: SemVer): void;
+    /**
+     * determines whether this component is modified in the workspace.
+     */
     isModified(): Promise<boolean>;
+    /**
+     * is component isOutdated
+     */
     isOutdated(): boolean;
+    /**
+     * determines whether this component is new.
+     */
     isNew(): Promise<boolean>;
     loadState(snapId: string): Promise<State>;
     loadSnap(snapId?: string): Promise<Snap>;
+    /**
+     * Get iterable which iterate over snap parents lazily
+     * @param snapId
+     * @param options
+     */
     snapsIterable(snapId?: string, options?: SnapsIterableOpts): AsyncIterable<Snap>;
+    /**
+     * traverse recursively from the provided snap (or head) upwards until it finds a tag
+     * @param snapToStartFrom
+     */
     getClosestTag(snapToStartFrom?: string): Promise<Tag | undefined>;
+    /**
+     * checkout the component to a different version in its working tree.
+     */
     checkout(version: SemVer): void;
+    /**
+     * examine difference between two components.
+     */
+    /**
+     * merge two different components
+     */
+    /**
+     * write a component to a given file system.
+     * @param path root path to write the component
+     * @param fs instance of any fs to use.
+     */
     write(path: string, fs?: AnyFS): void;
+    /**
+     *
+     * Check if 2 components are equal
+     * @param {Component} component
+     * @returns {boolean}
+     * @memberof Component
+     */
     equals(component: Component): boolean;
 }
 export {};

package/dist/component.main.runtime.d.ts

@@ -12,20 +12,49 @@ import { ShowFragment } from './show';
 export declare type ComponentHostSlot = SlotRegistry<ComponentFactory>;
 export declare type ShowFragmentSlot = SlotRegistry<ShowFragment[]>;
 export declare class ComponentMain {
+    /**
+     * slot for component hosts to register.
+     */
     private hostSlot;
+    /**
+     * Express Extension
+     */
     private express;
     private showFragmentSlot;
-    constructor(hostSlot: ComponentHostSlot, express: ExpressMain, showFragmentSlot: ShowFragmentSlot);
+    constructor(
+    /**
+     * slot for component hosts to register.
+     */
+    hostSlot: ComponentHostSlot, 
+    /**
+     * Express Extension
+     */
+    express: ExpressMain, showFragmentSlot: ShowFragmentSlot);
+    /**
+     * register a new component host.
+     */
     registerHost(host: ComponentFactory): this;
     createAspectList(legacyExtensionDataList: ExtensionDataList, scope?: string): AspectList;
     createAspectListFromEntries(entries: AspectEntry[]): AspectList;
     registerRoute(routes: Route[]): this;
+    /**
+     * set the prior host.
+     */
     setHostPriority(id: string): this;
+    /**
+     * get component host by extension ID.
+     */
     getHost(id?: string): ComponentFactory;
     getRoute(id: ComponentID, routeName: string): string;
+    /**
+     * get the prior host.
+     */
     private getPriorHost;
     getShowFragments(): ShowFragment[];
     isHost(name: string): boolean;
+    /**
+     * register a show fragment to display further information in the `bit show` command.
+     */
     registerShowFragments(showFragments: ShowFragment[]): this;
     private _priorHost;
     static slots: (((registerFn: () => string) => SlotRegistry<Route[]>) | ((registerFn: () => string) => SlotRegistry<ComponentFactory>) | ((registerFn: () => string) => SlotRegistry<ShowFragment[]>))[];

package/dist/component.ui.runtime.d.ts

@@ -16,17 +16,37 @@ export declare type ComponentMeta = {
 };
 export declare const componentIdUrlRegex = "[\\w\\/-]*[\\w-]";
 export declare class ComponentUI {
+    /**
+     * Pubsub aspects
+     */
     private pubsub;
     private routeSlot;
     private navSlot;
+    /**
+     * slot for registering a new widget to the menu.
+     */
     private widgetSlot;
     private menuItemSlot;
     private pageItemSlot;
     private commandBarUI;
     readonly routePath: string;
-    constructor(pubsub: PubsubUI, routeSlot: RouteSlot, navSlot: OrderedNavigationSlot, widgetSlot: OrderedNavigationSlot, menuItemSlot: MenuItemSlot, pageItemSlot: ComponentPageSlot, commandBarUI: CommandBarUI);
+    constructor(
+    /**
+     * Pubsub aspects
+     */
+    pubsub: PubsubUI, routeSlot: RouteSlot, navSlot: OrderedNavigationSlot, 
+    /**
+     * slot for registering a new widget to the menu.
+     */
+    widgetSlot: OrderedNavigationSlot, menuItemSlot: MenuItemSlot, pageItemSlot: ComponentPageSlot, commandBarUI: CommandBarUI);
+    /**
+     * the current visible component
+     */
     private activeComponent?;
     private copyNpmId;
+    /**
+     * key bindings used by component aspect
+     */
     private keyBindings;
     private menuItems;
     registerPubSub(): void;

package/dist/config.d.ts

@@ -10,10 +10,27 @@ declare type LegacyConfigProps = {
     extensions?: ExtensionDataList;
     overrides?: ComponentOverridesData;
 };
+/**
+ * in-memory representation of the component configuration.
+ */
 export default class Config {
+    /**
+     * version main file
+     */
     readonly main: PathLinux;
+    /**
+     * configured extensions
+     */
     readonly extensions: ExtensionDataList;
     readonly legacyProperties?: LegacyConfigProps | undefined;
-    constructor(main: PathLinux, extensions: ExtensionDataList, legacyProperties?: LegacyConfigProps | undefined);
+    constructor(
+    /**
+     * version main file
+     */
+    main: PathLinux, 
+    /**
+     * configured extensions
+     */
+    extensions: ExtensionDataList, legacyProperties?: LegacyConfigProps | undefined);
 }
 export {};

package/dist/dependencies/dependencies.d.ts

@@ -10,6 +10,12 @@ export declare class PackageDependency extends Dependency {
 export declare class ComponentDependency extends Dependency {
 }
 export declare class DependencyList extends Array<Dependency> {
+    /**
+     * Get only package dependencies
+     *
+     * @readonly
+     * @memberof DependencyList
+     */
     get packages(): PackageDependency[];
     get components(): ComponentDependency[];
     static fromArray(dependencies: Dependency[]): DependencyList;
@@ -20,6 +26,18 @@ export declare class Dependencies {
     peer: DependencyList;
     constructor(runtime: DependencyList, dev: DependencyList, peer: DependencyList);
     private getByEnvironment;
+    /**
+     * Get dependencies needed for development environnement such as runtime, dev and peer
+     *
+     * @returns {DependencyList}
+     * @memberof Dependencies
+     */
     computeDev(): DependencyList;
+    /**
+     * Get dependencies needed for runtime environnement such as runtime and peer
+     *
+     * @returns {DependencyList}
+     * @memberof Dependencies
+     */
     computeRuntime(): DependencyList;
 }

package/dist/exceptions/host-not-found.d.ts

@@ -1,5 +1,12 @@
 export declare class HostNotFound extends Error {
+    /**
+     * name of the host.
+     */
     private hostName;
-    constructor(hostName: string);
+    constructor(
+    /**
+     * name of the host.
+     */
+    hostName: string);
     toString(): string;
 }

package/dist/hash.d.ts

@@ -1 +1,4 @@
+/**
+ * type for representing content-addressable filesystem hashes.
+ */
 export declare type Hash = string;

package/dist/show/show-fragment.d.ts

@@ -1,14 +1,37 @@
 import { Component } from '../component';
 export interface ShowFragment {
+    /**
+     * render a row into the `show` CLI.
+     */
     renderRow(component: Component): Promise<ShowRow>;
+    /**
+     * return a json output.
+     */
     json?(component: Component): Promise<JSONRow>;
+    /**
+     * weight is used to determine the position of the fragment
+     * within the `show` table.
+     */
     weight?: number;
 }
 export interface JSONRow {
+    /**
+     * name of the field.
+     */
     title: string;
+    /**
+     * json content.
+     * TODO: change this from any to a more structured type (e.g. Serializable).
+     */
     json: any;
 }
 export interface ShowRow {
+    /**
+     * title of the fragment
+     */
     title: string;
+    /**
+     * content to render within the fragment.
+     */
     content: string;
 }

package/dist/snap/author.d.ts

@@ -1,5 +1,17 @@
+/**
+ * author type.
+ */
 export declare type Author = {
+    /**
+     * author full name (for example: "Ran Mizrahi")
+     */
     displayName: string;
+    /**
+     * author username (for example: "ranm8")
+     */
     name?: string;
+    /**
+     * author email in a proper format (e.g. "ran@bit.dev")
+     */
     email: string;
 };

package/dist/snap/snap.d.ts

@@ -6,13 +6,51 @@ export declare type SnapProps = {
     author: Author;
     message: string;
 };
+/**
+ * `Snap` represents a sealed state of the component in the working tree.
+ */
 export declare class Snap {
+    /**
+     * hash of the snap.
+     */
     readonly hash: string;
+    /**
+     * date time of the snap.
+     */
     readonly timestamp: Date;
+    /**
+     * parent snap
+     */
     readonly parents: string[];
+    /**
+     * author of the component `Snap`.
+     */
     readonly author: Author;
+    /**
+     * message added by the `Snap` author.
+     */
     readonly message: string;
-    constructor(hash: string, timestamp: Date, parents: string[], author: Author, message: string);
+    constructor(
+    /**
+     * hash of the snap.
+     */
+    hash: string, 
+    /**
+     * date time of the snap.
+     */
+    timestamp: Date, 
+    /**
+     * parent snap
+     */
+    parents: string[], 
+    /**
+     * author of the component `Snap`.
+     */
+    author: Author, 
+    /**
+     * message added by the `Snap` author.
+     */
+    message: string);
     static fromObject(snapObject: SnapProps): Snap;
     toObject(): SnapProps;
 }

package/dist/state.d.ts

@@ -3,14 +3,57 @@ import ComponentFS from './component-fs';
 import Config from './config';
 import { AspectList } from './aspect-list';
 export declare class State {
+    /**
+     * component configuration which is later generated to a component `package.json` and `bit.json`.
+     * @deprecated please use `aspects` instead.
+     */
     readonly config: Config;
+    /**
+     * list of aspects configured on the component.
+     */
     private _aspects;
+    /**
+     * in-memory representation of the component current filesystem.
+     */
     readonly filesystem: ComponentFS;
+    /**
+     * dependency graph of the component current. ideally package dependencies would be also placed here.
+     */
     readonly dependencies: any;
+    /**
+     * instance of legacy consumer component.
+     */
     readonly _consumer: any;
-    constructor(config: Config, _aspects: AspectList, filesystem: ComponentFS, dependencies: any, _consumer: any);
+    constructor(
+    /**
+     * component configuration which is later generated to a component `package.json` and `bit.json`.
+     * @deprecated please use `aspects` instead.
+     */
+    config: Config, 
+    /**
+     * list of aspects configured on the component.
+     */
+    _aspects: AspectList, 
+    /**
+     * in-memory representation of the component current filesystem.
+     */
+    filesystem: ComponentFS, 
+    /**
+     * dependency graph of the component current. ideally package dependencies would be also placed here.
+     */
+    dependencies: any, 
+    /**
+     * instance of legacy consumer component.
+     */
+    _consumer: any);
+    /**
+     * calculate the hash of this state
+     */
     get hash(): string;
     get issues(): IssuesList;
+    /**
+     * is modified
+     */
     get isModified(): boolean;
     get aspects(): AspectList;
     set aspects(aspects: AspectList);