@teambit/envs 0.0.0-3e44e878fae3f5f31fce2dc240a57a798e67137e

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

@@ -0,0 +1,366 @@
+import { Dependency as LegacyDependency } from '@teambit/legacy.consumer-component';
+import { SourceFile } from '@teambit/component.sources';
+import { CLIMain } from '@teambit/cli';
+import { Component, ComponentMain } from '@teambit/component';
+import type { EnvPolicyConfigObject } from '@teambit/dependency-resolver';
+import { GraphqlMain } from '@teambit/graphql';
+import { IssuesMain } from '@teambit/issues';
+import type { EnvJsoncPatterns } from '@teambit/dev-files';
+import { Harmony, SlotRegistry } from '@teambit/harmony';
+import { Logger, LoggerMain } from '@teambit/logger';
+import { ExtensionDataList, ExtensionDataEntry } from '@teambit/legacy.extension-data';
+import { WorkerMain } from '@teambit/worker';
+import { ComponentID } from '@teambit/component-id';
+import { EnvService } from './services';
+import { Environment } from './environment';
+import { Runtime } from './runtime';
+import { EnvDefinition } from './env-definition';
+import { EnvServiceList } from './env-service-list';
+import { EnvPlugin } from './env.plugin';
+import { EnvJsoncDetector } from './env-jsonc.detector';
+export type EnvJsonc = {
+    extends?: string;
+    policy?: EnvPolicyConfigObject;
+    patterns?: EnvJsoncPatterns;
+};
+/**
+ * The resolved env jsonc is the env jsonc after it was resolved from all the parent envs
+ */
+export type ResolvedEnvJsonc = Omit<EnvJsonc, 'extends'>;
+export type EnvJsoncMergeCustomizer = (parentObj: EnvJsonc, childObj: EnvJsonc) => Partial<EnvJsonc>;
+export type EnvJsoncResolver = (parentId: string, envExtendsDeps?: LegacyDependency[]) => Promise<ResolvedEnvJsonc>;
+export type EnvsRegistry = SlotRegistry<Environment>;
+export type EnvJsoncMergeCustomizerRegistry = SlotRegistry<EnvJsoncMergeCustomizer>;
+export type EnvJsoncResolverRegistry = SlotRegistry<EnvJsoncResolver>;
+export type EnvsConfig = {
+    env: string;
+    options: EnvOptions;
+};
+type GetCalcEnvOptions = {
+    skipWarnings?: boolean;
+};
+export type EnvOptions = {};
+export type EnvTransformer = (env: Environment) => Environment;
+export type ServicesRegistry = SlotRegistry<Array<EnvService<any>>>;
+export type RegularCompDescriptor = {
+    id: string;
+    icon?: string;
+    type?: string;
+    name?: string;
+    description?: string;
+};
+export type EnvCompDescriptorProps = RegularCompDescriptor & {
+    resolvedEnvJsonc?: ResolvedEnvJsonc;
+    services?: {
+        env: {
+            id: string;
+            icon: string;
+            name?: string;
+            description?: string;
+        };
+        services: Array<{
+            id: string;
+            name?: string;
+            description?: string;
+            data: any;
+        }>;
+    };
+};
+export type EnvCompDescriptor = EnvCompDescriptorProps & {
+    self?: EnvCompDescriptorProps;
+};
+export type Descriptor = RegularCompDescriptor | EnvCompDescriptor;
+export declare const DEFAULT_ENV = "teambit.harmony/node";
+export declare class EnvsMain {
+    /**
+     * environments extension configuration.
+     */
+    readonly config: EnvsConfig;
+    /**
+     * harmony context.
+     */
+    private harmony;
+    /**
+     * slot for allowing extensions to register new environment.
+     */
+    private envSlot;
+    private logger;
+    private servicesRegistry;
+    private componentMain;
+    private loggerMain;
+    private workerMain;
+    private envJsoncMergeCustomizerSlot;
+    private envJsoncResolverSlot;
+    /**
+     * Envs that are failed to load
+     */
+    private failedToLoadEnvs;
+    /**
+     * Extensions that are failed to load
+     * We use this as sometime when we couldn't load an extension we don't know if it's an env or not
+     * We should ideally take it from the aspect loader aspect, but right now the aspect loader is using envs
+     */
+    private failedToLoadExt;
+    /**
+     * Ids of envs (not neccesrraly loaded successfully)
+     */
+    envIds: Set<string>;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    private alreadyShownWarning;
+    private coreAspectIds;
+    /**
+     * icon of the extension.
+     */
+    icon(): string;
+    constructor(
+    /**
+     * environments extension configuration.
+     */
+    config: EnvsConfig, 
+    /**
+     * harmony context.
+     */
+    harmony: Harmony, 
+    /**
+     * slot for allowing extensions to register new environment.
+     */
+    envSlot: EnvsRegistry, logger: Logger, servicesRegistry: ServicesRegistry, componentMain: ComponentMain, loggerMain: LoggerMain, workerMain: WorkerMain, envJsoncMergeCustomizerSlot: EnvJsoncMergeCustomizerRegistry, envJsoncResolverSlot: EnvJsoncResolverRegistry);
+    /**
+     * creates a new runtime environments for a set of components.
+     */
+    createEnvironment(components: Component[]): Promise<Runtime>;
+    setCoreAspectIds(ids: string[]): void;
+    isCoreAspect(id: string): boolean;
+    /**
+     *
+     * @param id
+     */
+    /**
+     * This function adds an extension ID to a set of failed to load extensions.
+     * This mostly used by the aspect loader to add such issues
+     * Then it is used to hide different errors that are caused by the same issue.
+     * @param {string} id - string - represents the unique identifier of an extension that failed to load.
+     */
+    addFailedToLoadEnvs(id: string): void;
+    addFailedToLoadExt(id: string): void;
+    resetFailedToLoadEnvs(): void;
+    getFailedToLoadEnvs(): string[];
+    /**
+     * get the configured default env.
+     */
+    getDefaultEnv(): EnvDefinition;
+    getCoreEnvsIds(): string[];
+    /**
+     * compose a new environment from a list of environment transformers.
+     */
+    compose(targetEnv: Environment, envTransformers: EnvTransformer[]): Environment;
+    /**
+     * create an env transformer which overrides specific env properties.
+     */
+    override(propsToOverride: Environment): EnvTransformer;
+    /**
+     * compose two environments into one.
+     */
+    merge<T extends Environment, S extends Environment>(targetEnv: Environment, sourceEnv: Environment): T & S;
+    /**
+     * This function checks if an environment manifest file exists in a given component or set of legacy files.
+     * @param {Component} [envComponent] - A component object that represents an environment. It contains information about
+     * the files and directories that make up the environment.
+     * @param {SourceFile[]} [legacyFiles] - An optional array of SourceFile objects representing the files in the legacy
+     * file system. If this parameter is not provided, the function will attempt to retrieve the files from the envComponent
+     * parameter.
+     * @returns a boolean value indicating whether an `env.jsonc` or `env.json` file exists in the `files` array of either
+     * the `envComponent` object or the `legacyFiles` array. If neither `envComponent` nor `legacyFiles` are provided, the
+     * function returns `undefined`.
+     */
+    hasEnvManifest(envComponent?: Component, legacyFiles?: SourceFile[]): boolean | undefined;
+    getEnvManifest(envComponent: Component): ResolvedEnvJsonc | undefined;
+    getOrCalculateEnvManifest(component: Component, legacyFiles?: SourceFile[], envExtendsDeps?: LegacyDependency[]): Promise<ResolvedEnvJsonc | undefined>;
+    calculateEnvManifest(envComponent?: Component, legacyFiles?: SourceFile[], envExtendsDeps?: LegacyDependency[]): Promise<EnvJsonc | undefined>;
+    recursivelyMergeWithParentManifest(object: EnvJsonc, envExtendsDeps?: LegacyDependency[]): Promise<EnvJsonc>;
+    mergeEnvManifests(parent: EnvJsonc, child: EnvJsonc): EnvJsonc;
+    hasEnvManifestById(envId: string, requesting: string): Promise<boolean | undefined>;
+    getEnvData(component: Component): Descriptor;
+    /**
+     * Return the id of the env as configured in the envs data (without version by default)
+     * The reason it's not contain version by default is that we want to take the version from the aspect defined on the component itself
+     * As this version is stay up to date during tagging the env along with the component
+     * @param component
+     * @param ignoreVersion
+     */
+    private getEnvIdFromEnvsData;
+    /**
+     * get the env id of the given component.
+     */
+    getEnvId(component: Component): string;
+    isUsingCoreEnv(component: Component): boolean;
+    isCoreEnv(envId: string): boolean;
+    /**
+     * get the env of the given component.
+     * In case you are asking for the env during on load you should use calculateEnv instead
+     */
+    getEnv(component: Component): EnvDefinition;
+    /**
+     * get the env component of the given component.
+     */
+    getEnvComponent(component: Component): Promise<Component>;
+    /**
+     * get the env component by the env id.
+     */
+    getEnvComponentByEnvId(envId: string, requesting?: string): Promise<Component>;
+    /**
+     * get the env of the given component.
+     * This will try to use the regular getEnv but fallback to the calculate env (in case you are using it during on load)
+     * This is safe to be used on onLoad as well
+     */
+    getOrCalculateEnv(component: Component): EnvDefinition;
+    getOrCalculateEnvId(component: Component): Promise<ComponentID>;
+    /**
+     * get an environment Descriptor.
+     */
+    getDescriptor(component: Component): Descriptor | undefined;
+    calcDescriptor(component: Component, opts?: GetCalcEnvOptions): Promise<Descriptor | undefined>;
+    /**
+     * Get env descriptor from the env itself if the component is an env
+     * This will be empty for regular component, and will only contain data for env themself
+     */
+    private getEnvSelfDescriptor;
+    /**
+     * Get env descriptor from the env that a given component is using
+     */
+    private getComponentEnvDescriptor;
+    private getEnvDescriptorFromEnvDef;
+    resolveEnv(component: Component, id: string): ComponentID | undefined;
+    /**
+     * This used to calculate the actual env during the component load.
+     * Do not use it to get the env (use getEnv instead)
+     * This should be used only during on load
+     */
+    calculateEnvId(component: Component): Promise<ComponentID>;
+    /**
+     * This used to calculate the actual env during the component load.
+     * Do not use it to get the env (use getEnv instead)
+     * This should be used only during on load
+     */
+    calculateEnv(component: Component, opts?: GetCalcEnvOptions): EnvDefinition;
+    /**
+     * an env can be configured on a component in two ways:
+     * 1) explicitly inside "teambit.envs/envs". `{ "teambit.envs/envs": { "env": "my-env" } }`
+     * 2) the env aspect is set on the variant as any other aspect, e.g. `{ "my-env": {} }`
+     *
+     * this method returns #1 if exists, otherwise, #2.
+     */
+    getAllEnvsConfiguredOnComponent(component: Component): EnvDefinition[];
+    /**
+     * whether a component has an env configured (either by variant or .bitmap).
+     */
+    hasEnvConfigured(component: Component): boolean;
+    getAllRegisteredEnvsIds(): string[];
+    getAllRegisteredEnvs(): Environment[];
+    getAllRegisteredEnvJsoncCustomizers(): EnvJsoncMergeCustomizer[];
+    getAllRegisteredEnvJsoncResolvers(): EnvJsoncResolver[];
+    getEnvPlugin(): EnvPlugin;
+    /**
+     * an env can be configured on a component in two ways:
+     * 1) explicitly inside "teambit.envs/envs". `{ "teambit.envs/envs": { "env": "my-env" } }`
+     * 2) the env aspect is set on the variant as any other aspect, e.g. `{ "my-env": {} }`
+     *
+     * this method returns only #1
+     */
+    getEnvFromEnvsConfig(component: Component): EnvDefinition | undefined;
+    /**
+     * an env can be configured on a component in two ways:
+     * 1) explicitly inside "teambit.envs/envs". `{ "teambit.envs/envs": { "env": "my-env" } }`
+     * 2) the env aspect is set on the variant as any other aspect, e.g. `{ "my-env": {} }`
+     *
+     * this method returns only #2
+     */
+    getEnvsNotFromEnvsConfig(component: Component): EnvDefinition[];
+    getEnvIdFromEnvsLegacyExtensions(extensions: ExtensionDataList): string | undefined;
+    /**
+     * @deprecated DO NOT USE THIS METHOD ANYMORE!!! (PLEASE USE .calculateEnvId() instead!)
+     */
+    calculateEnvIdFromExtensions(extensions: ExtensionDataList): Promise<string>;
+    validateEnvId(ext: ExtensionDataEntry): {
+        errorMsg: string;
+        minBitVersion: string;
+    } | undefined;
+    /**
+     * @deprecated DO NOT USE THIS METHOD ANYMORE!!! (PLEASE USE .calculateEnv() instead!)
+     */
+    calculateEnvFromExtensions(extensions: ExtensionDataList): Promise<EnvDefinition>;
+    /**
+     * This function finds the first environment ID from a list of IDs by checking if it is register as env (to the slot).
+     * or contains env.jsonc file
+     * @param {string[]} ids - `ids` is an array of string values representing environment IDs. The function `findFirstEnv`
+     * takes this array as input and returns a Promise that resolves to a string value representing the first environment ID
+     * that matches certain conditions.
+     * @returns The `findFirstEnv` function returns a Promise that resolves to a string or undefined. The string represents
+     * the ID of the first environment that matches the conditions specified in the function, or undefined if no environment
+     * is found.
+     */
+    private findFirstEnv;
+    private getEnvDefinitionByLegacyExtension;
+    getEnvIdFromEnvsConfig(component: Component): string | undefined;
+    getEnvDefinition(id: ComponentID): EnvDefinition | undefined;
+    getEnvDefinitionById(id: ComponentID): EnvDefinition | undefined;
+    getEnvDefinitionByStringId(envId: string): EnvDefinition | undefined;
+    getEnvFromComponent(envComponent: Component): EnvDefinition | undefined;
+    /**
+     * Return the env definition of teambit.envs/env
+     */
+    getEnvsEnvDefinition(): EnvDefinition;
+    private printWarningIfFirstTime;
+    /**
+     * determines whether an env is registered.
+     */
+    isEnvRegistered(id: string): boolean;
+    isUsingAspectEnv(component: Component): boolean;
+    isUsingEnvEnv(component: Component): boolean;
+    /**
+     * Check if the given component is an env component.
+     * @param component
+     * @returns
+     */
+    isEnv(component: Component): boolean;
+    /**
+     * register a new environment service.
+     */
+    registerService(...envServices: EnvService<any>[]): this;
+    /**
+     * get list of services enabled on an env.
+     */
+    getServices(env: EnvDefinition): EnvServiceList;
+    implements(env: EnvDefinition, service: EnvService<any>): boolean;
+    /**
+     * register an environment.
+     */
+    registerEnv(env: Environment): void;
+    /**
+     * register an env.jsonc merge customizer.
+     */
+    registerEnvJsoncMergeCustomizer(customizer: EnvJsoncMergeCustomizer): void;
+    registerEnvJsoncResolver(resolver: EnvJsoncResolver): void;
+    getEnvJsoncDetector(): EnvJsoncDetector;
+    addNonLoadedEnvAsComponentIssues(components: Component[]): Promise<void>;
+    private createRuntime;
+    private aggregateByDefs;
+    private getEnvAspectDef;
+    private throwForDuplicateComponents;
+    static slots: (((registerFn: () => string) => SlotRegistry<Environment>) | ((registerFn: () => string) => SlotRegistry<EnvService<any, {}, {}>>) | ((registerFn: () => string) => SlotRegistry<EnvJsoncMergeCustomizerRegistry>) | ((registerFn: () => string) => SlotRegistry<EnvJsoncResolverRegistry>))[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static provider([graphql, loggerAspect, component, cli, worker, issues]: [
+        GraphqlMain,
+        LoggerMain,
+        ComponentMain,
+        CLIMain,
+        WorkerMain,
+        IssuesMain
+    ], config: EnvsConfig, [envSlot, servicesRegistry, envJsoncMergeCustomizerSlot, envJsoncResolverSlot]: [
+        EnvsRegistry,
+        ServicesRegistry,
+        EnvJsoncMergeCustomizerRegistry,
+        EnvJsoncResolverRegistry
+    ], context: Harmony): Promise<EnvsMain>;
+}
+export {};