@teambit/workspace 1.0.227 → 1.0.229

package/dist/pattern.cmd.d.ts

@@ -0,0 +1,19 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { Workspace } from './workspace';
+export declare class PatternCommand implements Command {
+    private workspace;
+    name: string;
+    alias: string;
+    description: string;
+    extendedDescription: string;
+    examples: {
+        cmd: string;
+        description: string;
+    }[];
+    group: string;
+    private: boolean;
+    options: CommandOptions;
+    constructor(workspace: Workspace);
+    report([pattern]: [string]): Promise<string>;
+    json([pattern]: [string]): Promise<import("@teambit/component-id").ComponentID[]>;
+}

package/dist/{preview-1712719054377.js → preview-1712822929999.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@1.0.227/dist/workspace.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@1.0.227/dist/workspace.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@1.0.229/dist/workspace.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@1.0.229/dist/workspace.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/scope-subcommands/scope-set.cmd.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@teambit/cli';
+import { Workspace } from '../workspace';
+export declare class ScopeSetCmd implements Command {
+    private workspace;
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    options: never[];
+    group: string;
+    extendedDescription: string;
+    constructor(workspace: Workspace);
+    report([scopeName, pattern]: [string, string]): Promise<string>;
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+interface VendorConfig {
+    directory: string;
+}
+export interface WorkspaceExtConfig {
+    /**
+     * name of the workspace.
+     */
+    name: string;
+    /**
+     * path to icon.
+     */
+    icon: string;
+    /**
+     * set the default scope when there is no matching for the component in the components array.
+     */
+    defaultScope: string;
+    /**
+     * set the default directory when there is no matching for the component in the components array.
+     */
+    defaultDirectory: string;
+    /**
+     * set the default structure of components in your project
+     */
+    vendor: VendorConfig;
+    /**
+     * All component extensions applied by default on all components in the workspace (except vendor components)
+     */
+    extensions: {
+        [extensionsId: string]: string;
+    };
+    /**
+     * If set to
+     * `true`, it allows the workspace to resolve scope's aspects from node modules
+     * installed in the workspace's `node_modules` directory. If not set or set to `false`, aspects will only be resolved
+     * from the scope aspects capsule.
+     */
+    resolveAspectsFromNodeModules?: boolean;
+    /**
+     * If set to `true`, it allows the workspace to resolve envs from node modules
+     * installed in the workspace's `node_modules` directory.
+     * the envs will be resolved from the node_modules of the env's root (workspace/node_modules/.bit_roots/{envId})
+     * and if not found (usually when the env was hoisted to the root node_modules) then from the node_modules of the
+     * workspace.
+     * If not set or set to `false`, envs will only be resolved from the scope envs capsule.
+     */
+    resolveEnvsFromRoots?: boolean;
+    /**
+     * If set to `true`, bit will try to load aspects dependencies automatically.
+     * even if the aspects dependencies are not configured in the workspace.jsonc root config.
+     * for example having the aspect
+     * main aspect
+     * export class MainAspectMain {
+     *  ...
+     *   static dependencies = [MyDepAspect];
+     * }
+     * and the in the workspace.jsonc file:
+     * {
+     *  ...
+     *   main-aspect: {}
+     * }
+     * when set to true, bit will try to load MyDepAspect automatically.
+     */
+    autoLoadAspectsDeps?: boolean;
+}
+export {};

package/dist/ui/index.d.ts

@@ -0,0 +1 @@
+export { Workspace } from './workspace';

package/dist/ui/workspace/default-component.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultComponent: {
+    id: string;
+    server: {
+        url: string;
+        env: string;
+    };
+};

package/dist/ui/workspace/index.d.ts

@@ -0,0 +1 @@
+export * from './workspace';

package/dist/ui/workspace/use-workspace.d.ts

@@ -0,0 +1,32 @@
+import { ComponentModel } from '@teambit/component';
+import { ComponentID } from '@teambit/component-id';
+import { Workspace } from './workspace-model';
+type UseWorkspaceOptions = {
+    onComponentAdded?: (component: ComponentModel[]) => void;
+    onComponentUpdated?: (component: ComponentModel[]) => void;
+    onComponentRemoved?: (compId: ComponentID[]) => void;
+};
+export declare function useWorkspace(options?: UseWorkspaceOptions): {
+    client: import("@apollo/client").ApolloClient<any>;
+    observable: import("@apollo/client").ObservableQuery<any, import("@apollo/client").OperationVariables>;
+    previousData?: any;
+    error?: import("@apollo/client").ApolloError | undefined;
+    loading: boolean;
+    networkStatus: import("@apollo/client").NetworkStatus;
+    called: boolean;
+    startPolling: (pollInterval: number) => void;
+    stopPolling: () => void;
+    updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("@apollo/client").OperationVariables>(mapFn: (previousQueryResult: any, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, any>, "variables">) => any) => void;
+    refetch: (variables?: Partial<import("@apollo/client").OperationVariables> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("@apollo/client").OperationVariables, any>> | undefined, newNetworkStatus?: import("@apollo/client").NetworkStatus | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    variables: import("@apollo/client").OperationVariables | undefined;
+    fetchMore: <TFetchData = any, TFetchVars extends import("@apollo/client").OperationVariables = import("@apollo/client").OperationVariables>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
+        updateQuery?: ((previousQueryResult: any, options: {
+            fetchMoreResult: TFetchData;
+            variables: TFetchVars;
+        }) => any) | undefined;
+    }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
+    workspace: Workspace | undefined;
+    subscribeToMore: <TSubscriptionData = any, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("@apollo/client").OperationVariables>(options: import("@apollo/client").SubscribeToMoreOptions<any, TSubscriptionVariables, TSubscriptionData>) => () => void;
+};
+export {};

package/dist/ui/workspace/workspace-context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { Workspace as WorkspaceModel } from './workspace-model';
+export declare const WorkspaceContext: React.Context<WorkspaceModel>;

package/dist/ui/workspace/workspace-model.d.ts

@@ -0,0 +1,68 @@
+import { ComponentID, ComponentModel, ComponentModelProps } from '@teambit/component';
+import { ComponentDescriptor } from '@teambit/component-descriptor';
+import { DeprecationInfo } from '@teambit/deprecation';
+import { Descriptor } from '@teambit/envs';
+import { ComponentStatus } from '../../workspace-component/component-status';
+export type WorkspaceModelComponent = {
+    id: ComponentID;
+    status: ComponentStatus;
+    deprecation: DeprecationInfo;
+    env: Descriptor;
+};
+export type WorkspaceProps = {
+    name: string;
+    path: string;
+    components: (ComponentModelProps & {
+        aspects: Record<string, any>;
+    })[];
+    icon: string;
+};
+export declare class Workspace {
+    /**
+     * name of the workspace.
+     */
+    readonly name: string;
+    /**
+     * absolute path of the workspace.
+     */
+    readonly path: string;
+    /**
+     * icon of the workspace.
+     */
+    readonly icon: string;
+    /**
+     * components container in the workspace.
+     */
+    readonly components: ComponentModel[];
+    /**
+     * components contained in the workspace.
+     */
+    readonly componentDescriptors: ComponentDescriptor[];
+    constructor(
+    /**
+     * name of the workspace.
+     */
+    name: string, 
+    /**
+     * absolute path of the workspace.
+     */
+    path: string, 
+    /**
+     * icon of the workspace.
+     */
+    icon: string, 
+    /**
+     * components container in the workspace.
+     */
+    components: ComponentModel[], 
+    /**
+     * components contained in the workspace.
+     */
+    componentDescriptors: ComponentDescriptor[]);
+    /**
+     * return a component from the workspace.
+     */
+    getComponent(id: ComponentID): ComponentModel | undefined;
+    static from({ name, path, components, icon }: WorkspaceProps): Workspace;
+    static empty(): Workspace;
+}

package/dist/ui/workspace/workspace-overview/index.d.ts

@@ -0,0 +1 @@
+export { WorkspaceOverview } from './workspace-overview';

package/dist/ui/workspace/workspace-overview/link-plugin.d.ts

@@ -0,0 +1,3 @@
+export declare class LinkPlugin {
+    link(id: any): string;
+}

package/dist/ui/workspace/workspace-overview/workspace-overview.d.ts

@@ -0,0 +1,6 @@
+import { ComponentModel } from '@teambit/component';
+import type { ComponentCardPluginType, PluginProps } from '@teambit/explorer.ui.component-card';
+export declare function WorkspaceOverview(): import("react/jsx-runtime").JSX.Element;
+export declare function useCardPlugins({ compModelsById, }: {
+    compModelsById: Map<string, ComponentModel>;
+}): ComponentCardPluginType<PluginProps>[];

package/dist/ui/workspace/workspace-provider.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { Workspace } from './workspace-model';
+export type WorkspaceProviderProps = {
+    /**
+     * workspace model.
+     */
+    workspace: Workspace;
+    /**
+     * react children.
+     */
+    children: ReactNode;
+};
+/**
+ * context provider of the workspace
+ */
+export declare function WorkspaceProvider({ workspace, children }: WorkspaceProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/workspace/workspace.d.ts

@@ -0,0 +1,14 @@
+import 'reset-css';
+import type { RouteSlot } from '@teambit/ui-foundation.ui.react-router.slot-router';
+import { WorkspaceUI } from '../../workspace.ui.runtime';
+export type WorkspaceProps = {
+    routeSlot: RouteSlot;
+    menuSlot: RouteSlot;
+    sidebar: JSX.Element;
+    workspaceUI: WorkspaceUI;
+    onSidebarTogglerChange: (callback: () => void) => void;
+};
+/**
+ * main workspace component.
+ */
+export declare function Workspace({ routeSlot, menuSlot, sidebar, workspaceUI, onSidebarTogglerChange }: WorkspaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/use.cmd.d.ts

@@ -0,0 +1,19 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { Workspace } from './workspace';
+export declare class UseCmd implements Command {
+    private workspace;
+    name: string;
+    group: string;
+    description: string;
+    helpUrl: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    alias: string;
+    options: CommandOptions;
+    loader: boolean;
+    remoteOp: boolean;
+    constructor(workspace: Workspace);
+    report([id]: [string]): Promise<any>;
+}

package/dist/workspace-aspects-loader.d.ts

@@ -0,0 +1,121 @@
+import { GlobalConfigMain } from '@teambit/global-config';
+import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
+import { Harmony } from '@teambit/harmony';
+import { AspectDefinition, AspectLoaderMain } from '@teambit/aspect-loader';
+import { ComponentID } from '@teambit/component-id';
+import { LoadAspectsOptions, ResolveAspectsOptions } from '@teambit/component';
+import { ScopeMain } from '@teambit/scope';
+import { Logger } from '@teambit/logger';
+import { EnvsMain } from '@teambit/envs';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import type { Workspace } from './workspace';
+import { OnAspectsResolveSlot, OnRootAspectAddedSlot } from './workspace.main.runtime';
+export type GetConfiguredUserAspectsPackagesOptions = {
+    externalsOnly?: boolean;
+};
+export type WorkspaceLoadAspectsOptions = LoadAspectsOptions & {
+    useScopeAspectsCapsule?: boolean;
+    runSubscribers?: boolean;
+    skipDeps?: boolean;
+    resolveEnvsFromRoots?: boolean;
+};
+export type AspectPackage = {
+    packageName: string;
+    version: string;
+};
+export declare class WorkspaceAspectsLoader {
+    private workspace;
+    private scope;
+    private aspectLoader;
+    private envs;
+    private dependencyResolver;
+    private logger;
+    private globalConfig;
+    private harmony;
+    private onAspectsResolveSlot;
+    private onRootAspectAddedSlot;
+    private resolveAspectsFromNodeModules;
+    private resolveEnvsFromRoots;
+    private consumer;
+    private resolvedInstalledAspects;
+    constructor(workspace: Workspace, scope: ScopeMain, aspectLoader: AspectLoaderMain, envs: EnvsMain, dependencyResolver: DependencyResolverMain, logger: Logger, globalConfig: GlobalConfigMain, harmony: Harmony, onAspectsResolveSlot: OnAspectsResolveSlot, onRootAspectAddedSlot: OnRootAspectAddedSlot, resolveAspectsFromNodeModules?: boolean, resolveEnvsFromRoots?: boolean);
+    /**
+     * load aspects from the workspace and if not exists in the workspace, load from the node_modules.
+     * keep in mind that the graph may have circles.
+     */
+    loadAspects(ids?: string[], throwOnError?: boolean, neededFor?: string, opts?: WorkspaceLoadAspectsOptions): Promise<string[]>;
+    private loadFromScopeAspectsCapsule;
+    throwWsJsoncAspectNotFoundError(err: any): void;
+    private loadAspectDefsByOrder;
+    resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
+    shouldUseHashForCapsules(): boolean;
+    getCapsulePath(): string;
+    private logFoundWorkspaceVsScope;
+    use(aspectIdStr: string): Promise<string>;
+    getConfiguredUserAspectsPackages(options?: GetConfiguredUserAspectsPackagesOptions): Promise<AspectPackage[]>;
+    private aspectDefsToRequireableComponents;
+    private linkIfMissingWorkspaceAspects;
+    /**
+     * This will return a resolver that knows to resolve aspects which are part of the workspace.
+     * means aspects exist in the bitmap file
+     * @param stringIds
+     * @param runtimeName
+     * @returns
+     */
+    private getWorkspaceAspectResolver;
+    private runOnAspectsResolveFunctions;
+    private getOnAspectsResolveFunctions;
+    private runOnRootAspectAddedFunctions;
+    private getOnRootAspectAddedFunctions;
+    /**
+     * This will return a resolver that knows to resolve aspects which are not part of the workspace.
+     * means aspects that does not exist in the bitmap file
+     * instead it will resolve them from the node_modules recursively
+     * @param graph
+     * @param rootIds
+     * @param runtimeName
+     * @returns
+     */
+    private getInstalledAspectResolver;
+    private resolveInstalledAspectRecursively;
+    /**
+     * Create a graph of aspects without the core aspects.
+     * @param components
+     * @param isAspect
+     * @returns
+     */
+    private getAspectsGraphWithoutCore;
+    /**
+     * Load all unloaded extensions from an extension list
+     * this will resolve the extensions from the scope aspects capsules if they are not in the ws
+     * Only use it for component extensions
+     * for workspace/scope root aspect use the load aspects directly
+     *
+     * The reason we are loading component extensions with "scope aspects capsules" is because for component extensions
+     * we might have the same extension in multiple versions
+     * (for example I might have 2 components using different versions of the same env)
+     * in such case, I can't install both version into the root of the node_modules so I need to place it somewhere else (capsules)
+     * @param extensions list of extensions with config to load
+     */
+    loadComponentsExtensions(extensions: ExtensionDataList, originatedFrom?: ComponentID, opts?: WorkspaceLoadAspectsOptions): Promise<void>;
+    private isAspect;
+    /**
+     * same as `this.importAndGetMany()` with a specific error handling of ComponentNotFound
+     */
+    private importAndGetAspects;
+    /**
+     * split the provided components into 2 groups, one which are workspace components and the other which are not.
+     * @param components
+     * @returns
+     */
+    private groupComponentsByWorkspaceExistence;
+    private groupComponentsByLoadFromRootComps;
+    private shouldLoadFromRootComps;
+    /**
+     * split the provided components into 2 groups, one which are workspace components and the other which are not.
+     * @param components
+     * @returns
+     */
+    private groupAspectDefsByWorkspaceExistence;
+    private groupIdsByWorkspaceExistence;
+}

package/dist/workspace-component/comp-files.d.ts

@@ -0,0 +1,22 @@
+import { ComponentID } from '@teambit/component-id';
+import { SourceFile } from '@teambit/legacy/dist/consumer/component/sources';
+import { SourceFileModel } from '@teambit/legacy/dist/scope/models/version';
+import { Repository } from '@teambit/legacy/dist/scope/objects';
+type FILE_STATUS = 'new' | 'modified' | 'deleted' | 'unchanged';
+type PathLinux = string;
+export type FilesStatus = {
+    [pathRelativeToCompDir: PathLinux]: FILE_STATUS;
+};
+export declare class CompFiles {
+    readonly id: ComponentID;
+    private repository;
+    private currentFiles;
+    readonly compDir: PathLinux;
+    private modelFiles;
+    constructor(id: ComponentID, repository: Repository, currentFiles: SourceFile[], compDir: PathLinux, modelFiles?: SourceFileModel[]);
+    isModified(): boolean;
+    getCurrentFiles(): SourceFile[];
+    getHeadFiles(): Promise<SourceFile[]>;
+    getFilesStatus(): FilesStatus;
+}
+export {};

package/dist/workspace-component/component-status-loader.d.ts

@@ -0,0 +1,38 @@
+import { ComponentID } from '@teambit/component-id';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { Workspace } from '..';
+export type ComponentStatusLegacy = {
+    modified: boolean;
+    newlyCreated: boolean;
+    deleted: boolean;
+    staged: boolean;
+    notExist: boolean;
+    missingFromScope: boolean;
+};
+export type ComponentStatusResult = {
+    id: ComponentID;
+    status: ComponentStatusLegacy;
+};
+export declare class ComponentStatusLoader {
+    private workspace;
+    private _componentsStatusCache;
+    constructor(workspace: Workspace);
+    get consumer(): Consumer;
+    getManyComponentsStatuses(ids: ComponentID[]): Promise<ComponentStatusResult[]>;
+    /**
+     * Get a component status by ID. Return a ComponentStatus object.
+     * Keep in mind that a result can be a partial object of ComponentStatus, e.g. { notExist: true }.
+     * Each one of the ComponentStatus properties can be undefined, true or false.
+     * As a result, in order to check whether a component is not modified use (status.modified === false).
+     * Don't use (!status.modified) because a component may not exist and the status.modified will be undefined.
+     *
+     * The status may have 'true' for several properties. For example, a component can be staged and modified at the
+     * same time.
+     *
+     * The result is cached per ID and can be called several times with no penalties.
+     */
+    getComponentStatusById(id: ComponentID): Promise<ComponentStatusLegacy>;
+    private getStatus;
+    clearOneComponentCache(id: ComponentID): void;
+    clearCache(): void;
+}

package/dist/workspace-component/component-status.d.ts

@@ -0,0 +1,75 @@
+import { ComponentStatusLegacy } from './component-status-loader';
+export type ModifyInfo = {
+    hasModifiedFiles: boolean;
+    hasModifiedDependencies: boolean;
+};
+export declare class ComponentStatus {
+    /**
+     * 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;
+    /**
+     * @deprecated this was relevant for legacy only. can be deleted if it's not used elsewhere
+     * the component is not authored and not imported.
+     */
+    readonly nested?: boolean | undefined;
+    constructor(
+    /**
+     * is the component modified.
+     */
+    modifyInfo: ModifyInfo, 
+    /**
+     * is the new component new.
+     */
+    isNew: boolean, 
+    /**
+     * is the component deleted from the workspace.
+     */
+    isDeleted: boolean, 
+    /**
+     * is the component staged.
+     */
+    isStaged: boolean, 
+    /**
+     * does the component exists in the workspace.
+     */
+    isInWorkspace: boolean, 
+    /**
+     * does the component exists in the scope.
+     */
+    isInScope: boolean, 
+    /**
+     * does the component is outdated (pending for update).
+     */
+    isOutdated: boolean, 
+    /**
+     * @deprecated this was relevant for legacy only. can be deleted if it's not used elsewhere
+     * the component is not authored and not imported.
+     */
+    nested?: boolean | undefined);
+    static fromLegacy(status: ComponentStatusLegacy, hasModifiedDependencies: boolean, isOutdated: boolean): ComponentStatus;
+}

package/dist/workspace-component/index.d.ts

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

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

@@ -0,0 +1,100 @@
+import { Component, InvalidComponent } from '@teambit/component';
+import { ComponentID } from '@teambit/component-id';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Logger } from '@teambit/logger';
+import { EnvsMain } from '@teambit/envs';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { ComponentLoadOptions as LegacyComponentLoadOptions } from '@teambit/legacy/dist/consumer/component/component-loader';
+import { Workspace } from '../workspace';
+type GetManyRes = {
+    components: Component[];
+    invalidComponents: InvalidComponent[];
+};
+export type ComponentLoadOptions = LegacyComponentLoadOptions & {
+    loadExtensions?: boolean;
+    executeLoadSlot?: boolean;
+    idsToNotLoadAsAspects?: string[];
+    loadSeedersAsAspects?: boolean;
+    resolveExtensionsVersions?: boolean;
+};
+type ComponentGetOneOptions = {
+    resolveIdVersion?: boolean;
+};
+export type LoadCompAsAspectsOptions = {
+    /**
+     * In case the component we are loading is app, whether to load it as app (in a scope aspects capsule)
+     */
+    loadApps?: boolean;
+    /**
+     * In case the component we are loading is env, whether to load it as env (in a scope aspects capsule)
+     */
+    loadEnvs?: boolean;
+    /**
+     * In case the component we are loading is a regular aspect, whether to load it as aspect (in a scope aspects capsule)
+     */
+    loadAspects?: boolean;
+    idsToNotLoadAsAspects?: string[];
+    /**
+     * Are this core aspects
+     */
+    core?: boolean;
+    /**
+     * Are this aspects seeders of the load many operation
+     */
+    seeders?: boolean;
+};
+export declare class WorkspaceComponentLoader {
+    private workspace;
+    private logger;
+    private dependencyResolver;
+    private envs;
+    private aspectLoader;
+    private componentsCache;
+    /**
+     * Cache components that loaded from scope (especially for get many for perf improvements)
+     */
+    private scopeComponentsCache;
+    /**
+     * Cache extension list for components. used by get many for perf improvements.
+     * And to make sure we load extensions first.
+     */
+    private componentsExtensionsCache;
+    private componentLoadedSelfAsAspects;
+    constructor(workspace: Workspace, logger: Logger, dependencyResolver: DependencyResolverMain, envs: EnvsMain, aspectLoader: AspectLoaderMain);
+    getMany(ids: Array<ComponentID>, loadOpts?: ComponentLoadOptions, throwOnFailure?: boolean): Promise<GetManyRes>;
+    private getAndLoadSlotOrdered;
+    private buildLoadGroups;
+    private regroupExtIdsFromTheList;
+    private getAndLoadSlot;
+    loadCompsAsAspects(components: Component[], opts?: LoadCompAsAspectsOptions): Promise<void>;
+    private populateScopeAndExtensionsCache;
+    private warnAboutMisconfiguredEnvs;
+    private groupAndUpdateIds;
+    private isInWsIncludeDeleted;
+    private getComponentsWithoutLoadExtensions;
+    getInvalid(ids: Array<ComponentID>): Promise<InvalidComponent[]>;
+    get(componentId: ComponentID, legacyComponent?: ConsumerComponent, useCache?: boolean, storeInCache?: boolean, loadOpts?: ComponentLoadOptions, getOpts?: ComponentGetOneOptions): Promise<Component>;
+    getIfExist(componentId: ComponentID): Promise<Component | undefined>;
+    private resolveVersion;
+    private addMultipleEnvsIssueIfNeeded;
+    clearCache(): void;
+    clearComponentCache(id: ComponentID): void;
+    private loadOne;
+    private saveInCache;
+    /**
+     * 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;
+    private getConsumerComponent;
+    private isComponentNotExistsError;
+    private executeLoadSlot;
+    private newComponentFromState;
+    private upsertExtensionData;
+    private getDataEntry;
+}
+export {};