@teambit/envs 0.0.0-3e44e878fae3f5f31fce2dc240a57a798e67137e

package/dist/environments.main.runtime.js

@@ -0,0 +1,1160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EnvsMain = exports.DEFAULT_ENV = void 0;
+function _pLocate() {
+  const data = _interopRequireDefault(require("p-locate"));
+  _pLocate = function () {
+    return data;
+  };
+  return data;
+}
+function _commentJson() {
+  const data = require("comment-json");
+  _commentJson = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _graphql() {
+  const data = require("@teambit/graphql");
+  _graphql = function () {
+    return data;
+  };
+  return data;
+}
+function _issues() {
+  const data = require("@teambit/issues");
+  _issues = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _componentIssues() {
+  const data = require("@teambit/component-issues");
+  _componentIssues = function () {
+    return data;
+  };
+  return data;
+}
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxArray() {
+  const data = require("@teambit/toolbox.array.duplications-finder");
+  _toolboxArray = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _worker() {
+  const data = require("@teambit/worker");
+  _worker = function () {
+    return data;
+  };
+  return data;
+}
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _environments() {
+  const data = require("./environments.aspect");
+  _environments = function () {
+    return data;
+  };
+  return data;
+}
+function _environments2() {
+  const data = require("./environments.graphql");
+  _environments2 = function () {
+    return data;
+  };
+  return data;
+}
+function _runtime() {
+  const data = require("./runtime");
+  _runtime = function () {
+    return data;
+  };
+  return data;
+}
+function _envDefinition() {
+  const data = require("./env-definition");
+  _envDefinition = function () {
+    return data;
+  };
+  return data;
+}
+function _envServiceList() {
+  const data = require("./env-service-list");
+  _envServiceList = function () {
+    return data;
+  };
+  return data;
+}
+function _envs() {
+  const data = require("./envs.cmd");
+  _envs = function () {
+    return data;
+  };
+  return data;
+}
+function _env() {
+  const data = require("./env.fragment");
+  _env = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("./exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _env2() {
+  const data = require("./env.plugin");
+  _env2 = function () {
+    return data;
+  };
+  return data;
+}
+function _envJsonc() {
+  const data = require("./env-jsonc.detector");
+  _envJsonc = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * The resolved env jsonc is the env jsonc after it was resolved from all the parent envs
+ */
+
+const DEFAULT_ENV = exports.DEFAULT_ENV = 'teambit.harmony/node';
+class EnvsMain {
+  /**
+   * icon of the extension.
+   */
+  icon() {
+    return `<svg width="50" height="50" xmlns="http://www.w3.org/2000/svg">
+      <circle cx="25" cy="25" r="20"/>
+    </svg>`;
+  }
+  constructor(
+  /**
+   * environments extension configuration.
+   */
+  config,
+  /**
+   * harmony context.
+   */
+  harmony,
+  /**
+   * slot for allowing extensions to register new environment.
+   */
+  envSlot, logger, servicesRegistry, componentMain, loggerMain, workerMain, envJsoncMergeCustomizerSlot, envJsoncResolverSlot) {
+    this.config = config;
+    this.harmony = harmony;
+    this.envSlot = envSlot;
+    this.logger = logger;
+    this.servicesRegistry = servicesRegistry;
+    this.componentMain = componentMain;
+    this.loggerMain = loggerMain;
+    this.workerMain = workerMain;
+    this.envJsoncMergeCustomizerSlot = envJsoncMergeCustomizerSlot;
+    this.envJsoncResolverSlot = envJsoncResolverSlot;
+    /**
+     * Envs that are failed to load
+     */
+    _defineProperty(this, "failedToLoadEnvs", new Set());
+    /**
+     * 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
+     */
+    _defineProperty(this, "failedToLoadExt", new Set());
+    /**
+     * Ids of envs (not neccesrraly loaded successfully)
+     */
+    _defineProperty(this, "envIds", new Set());
+    _defineProperty(this, "alreadyShownWarning", {});
+    _defineProperty(this, "coreAspectIds", []);
+  }
+
+  /**
+   * creates a new runtime environments for a set of components.
+   */
+  async createEnvironment(components) {
+    return this.createRuntime(components);
+  }
+  setCoreAspectIds(ids) {
+    this.coreAspectIds = ids;
+  }
+  isCoreAspect(id) {
+    return this.coreAspectIds.includes(id);
+  }
+
+  /**
+   *
+   * @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) {
+    this.failedToLoadEnvs.add(id);
+    this.envIds.add(id);
+  }
+  addFailedToLoadExt(id) {
+    this.failedToLoadExt.add(id);
+    if (this.envIds.has(id)) {
+      this.addFailedToLoadEnvs(id);
+    }
+  }
+  resetFailedToLoadEnvs() {
+    this.failedToLoadEnvs.clear();
+    this.failedToLoadExt.clear();
+  }
+  getFailedToLoadEnvs() {
+    const failedToLoadEnvs = Array.from(this.failedToLoadEnvs);
+    // Add all extensions which are also envs
+    for (const extId of this.failedToLoadExt) {
+      if (this.envIds.has(extId)) {
+        failedToLoadEnvs.push(extId);
+      }
+    }
+    return (0, _lodash().uniq)(failedToLoadEnvs);
+  }
+
+  /**
+   * get the configured default env.
+   */
+  getDefaultEnv() {
+    const defaultEnv = this.envSlot.get(DEFAULT_ENV);
+    if (!defaultEnv) throw new Error('default env must be set.');
+    return new (_envDefinition().EnvDefinition)(DEFAULT_ENV, defaultEnv);
+  }
+  getCoreEnvsIds() {
+    return ['teambit.harmony/aspect', 'teambit.react/react', 'teambit.harmony/node', 'teambit.react/react-native', 'teambit.html/html', 'teambit.mdx/mdx', 'teambit.envs/env', 'teambit.mdx/readme', 'teambit.harmony/bit-custom-aspect'];
+  }
+
+  /**
+   * compose a new environment from a list of environment transformers.
+   */
+  compose(targetEnv, envTransformers) {
+    const a = envTransformers.reduce((acc, transformer) => {
+      acc = transformer(acc);
+      return acc;
+    }, targetEnv);
+    return a;
+  }
+
+  /**
+   * create an env transformer which overrides specific env properties.
+   */
+  override(propsToOverride) {
+    return env => {
+      return this.merge(propsToOverride, env);
+    };
+  }
+
+  /**
+   * compose two environments into one.
+   */
+  merge(targetEnv, sourceEnv) {
+    const allNames = new Set();
+    const keys = ['icon', 'name', 'description'];
+    for (let o = sourceEnv; o !== Object.prototype; o = Object.getPrototypeOf(o)) {
+      for (const name of Object.getOwnPropertyNames(o)) {
+        allNames.add(name);
+      }
+    }
+    allNames.forEach(key => {
+      const fn = sourceEnv[key];
+      if (targetEnv[key]) return;
+      if (keys.includes(key)) targetEnv[key] = fn;
+      if (!fn || !fn.bind) {
+        return;
+      }
+      targetEnv[key] = fn.bind(sourceEnv);
+    });
+    return targetEnv;
+  }
+
+  /**
+   * 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, legacyFiles) {
+    if (!envComponent && !legacyFiles) return undefined;
+    // @ts-ignore
+    const files = legacyFiles || envComponent.filesystem.files;
+    const envJson = files.find(file => {
+      return file.relative === 'env.jsonc' || file.relative === 'env.json';
+    });
+    if (!envJson) return false;
+    return true;
+  }
+  getEnvManifest(envComponent) {
+    const data = this.getEnvData(envComponent);
+    if (!data) return undefined;
+    return data.resolvedEnvJsonc;
+  }
+  async getOrCalculateEnvManifest(component, legacyFiles, envExtendsDeps) {
+    try {
+      return this.getEnvManifest(component) || (await this.calculateEnvManifest(component, legacyFiles, envExtendsDeps));
+    } catch {
+      return this.calculateEnvManifest(component);
+    }
+  }
+  async calculateEnvManifest(envComponent, legacyFiles, envExtendsDeps) {
+    // TODO: maybe throw an error here?
+    if (!envComponent && !legacyFiles) return undefined;
+    // @ts-ignore
+    const files = legacyFiles || envComponent.filesystem.files;
+    const envJson = files.find(file => {
+      return file.relative === 'env.jsonc' || file.relative === 'env.json';
+    });
+    if (!envJson) return undefined;
+    const object = (0, _commentJson().parse)(envJson.contents.toString('utf8'), undefined, true);
+    if (!object.extends) return object;
+    const resolvedObject = await this.recursivelyMergeWithParentManifest(object, envExtendsDeps);
+    return resolvedObject;
+  }
+  async recursivelyMergeWithParentManifest(object, envExtendsDeps) {
+    if (!object.extends) return object;
+    const parentEnvId = object.extends;
+    const resolver = this.getAllRegisteredEnvJsoncResolvers()[0];
+    const parentObject = await resolver(parentEnvId, envExtendsDeps);
+    const mergedObject = this.mergeEnvManifests(parentObject, object);
+    if (mergedObject.extends) {
+      return this.recursivelyMergeWithParentManifest(mergedObject);
+    }
+    return mergedObject;
+  }
+  mergeEnvManifests(parent, child) {
+    let merged = {};
+    const mergeCustomizer = this.getAllRegisteredEnvJsoncCustomizers();
+    for (const customizer of mergeCustomizer) {
+      const oneMerged = customizer(parent, child);
+      merged = _objectSpread(_objectSpread({}, merged), oneMerged);
+    }
+    // This is important to make sure we won't keep the extends from the child
+    delete child.extends;
+    // Take extends specifically from the parent so we can propagate it to the next parent
+    if (parent.extends) {
+      merged.extends = parent.extends;
+    }
+    return merged;
+  }
+  async hasEnvManifestById(envId, requesting) {
+    const component = await this.getEnvComponentByEnvId(envId, requesting);
+    return this.hasEnvManifest(component);
+  }
+  getEnvData(component) {
+    let envsData = component.state.aspects.get(_environments().EnvsAspect.id);
+    if (!envsData) {
+      // TODO: remove this once we re-export old components used to store the data here
+      envsData = component.state.aspects.get('teambit.workspace/workspace');
+    }
+    if (!envsData) throw new Error(`env was not configured on component ${component.id.toString()}`);
+    return envsData.data;
+  }
+
+  /**
+   * 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
+   */
+  getEnvIdFromEnvsData(component, ignoreVersion = true) {
+    const envsData = this.getEnvData(component);
+    if (!envsData) return undefined;
+    const rawEnvId = envsData.id;
+    if (!rawEnvId) return undefined;
+    if (!ignoreVersion) return rawEnvId;
+    const envIdWithoutVersion = _componentId().ComponentID.fromString(rawEnvId).toStringWithoutVersion();
+    return envIdWithoutVersion;
+  }
+
+  /**
+   * get the env id of the given component.
+   */
+  getEnvId(component) {
+    const envIdFromEnvData = this.getEnvIdFromEnvsData(component);
+    if (!envIdFromEnvData) {
+      // This should never happen
+      throw new Error(`no env found for ${component.id.toString()}`);
+    }
+    const withVersion = this.resolveEnv(component, envIdFromEnvData);
+    const withVersionMatch = this.envSlot.toArray().find(([envId]) => {
+      return withVersion?.toString() === envId;
+    });
+    const withVersionMatchId = withVersionMatch?.[0];
+    if (withVersionMatchId) return withVersionMatchId;
+
+    // Handle core envs
+    const exactMatch = this.envSlot.toArray().find(([envId]) => {
+      return envIdFromEnvData === envId;
+    });
+    const exactMatchId = exactMatch?.[0];
+    if (exactMatchId) return exactMatchId;
+    if (!withVersion) throw new (_exceptions().EnvNotConfiguredForComponent)(envIdFromEnvData, component.id.toString());
+    return withVersion.toString();
+  }
+  isUsingCoreEnv(component) {
+    const envId = this.getEnvId(component);
+    return this.isCoreEnv(envId);
+  }
+  isCoreEnv(envId) {
+    return this.getCoreEnvsIds().includes(envId);
+  }
+
+  /**
+   * 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) {
+    const id = this.getEnvId(component);
+    const envDef = this.getEnvDefinitionByStringId(id);
+    if (envDef) {
+      return envDef;
+    }
+    // Do not allow a non existing env
+    throw new (_exceptions().EnvNotFound)(id, component.id.toString());
+  }
+
+  /**
+   * get the env component of the given component.
+   */
+  async getEnvComponent(component) {
+    const envId = this.getEnvId(component);
+    return this.getEnvComponentByEnvId(envId, component.id.toString());
+  }
+
+  /**
+   * get the env component by the env id.
+   */
+  async getEnvComponentByEnvId(envId, requesting) {
+    const host = this.componentMain.getHost();
+    const newId = await host.resolveComponentId(envId);
+    const envComponent = await host.get(newId);
+    if (!envComponent) {
+      throw new (_bitError().BitError)(`can't load env. env id is ${envId} used by component ${requesting || 'unknown'}`);
+    }
+    return envComponent;
+  }
+
+  /**
+   * 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) {
+    try {
+      return this.getEnv(component);
+    } catch {
+      return this.calculateEnv(component);
+    }
+  }
+  getOrCalculateEnvId(component) {
+    try {
+      const idStr = this.getEnvId(component);
+      return Promise.resolve(_componentId().ComponentID.fromString(idStr));
+    } catch {
+      return this.calculateEnvId(component);
+    }
+  }
+
+  /**
+   * get an environment Descriptor.
+   */
+  getDescriptor(component) {
+    const envsData = this.getEnvData(component);
+    envsData.id = this.resolveEnv(component, envsData.id)?.toString() || envsData.id;
+    return envsData;
+  }
+  async calcDescriptor(component, opts = {}) {
+    const componentDescriptor = await this.getComponentEnvDescriptor(component, opts);
+    if (!componentDescriptor) return undefined;
+    const envComponentSelfDescriptor = await this.getEnvSelfDescriptor(component);
+    // const resolvedEnvJsonc = await this.calculateEnvManifest(component);
+    const result = componentDescriptor;
+    if (envComponentSelfDescriptor) {
+      // @ts-ignore
+      result.self = envComponentSelfDescriptor;
+    }
+    // if (resolvedEnvJsonc) {
+    //   // @ts-ignore
+    //   result.resolvedEnvJsonc = resolvedEnvJsonc;
+    // }
+    return result;
+  }
+
+  /**
+   * 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
+   */
+  async getEnvSelfDescriptor(envComponent) {
+    // !important calculate only on the env itself.
+    if (!this.isEnvRegistered(envComponent.id.toString())) {
+      return undefined;
+    }
+    const envDef = this.getEnvFromComponent(envComponent);
+    if (!envDef) return undefined;
+    const rawServices = this.getServices(envDef);
+    const services = rawServices.toObject();
+    // const selfDescriptor = (await this.getEnvDescriptorFromEnvDef(envDef)) || {};
+    const selfDescriptor = await this.getEnvDescriptorFromEnvDef(envDef);
+    if (!selfDescriptor) return undefined;
+    return _objectSpread(_objectSpread({}, selfDescriptor), {}, {
+      services
+    });
+  }
+
+  /**
+   * Get env descriptor from the env that a given component is using
+   */
+  async getComponentEnvDescriptor(component, opts = {}) {
+    const envDef = this.calculateEnv(component, opts);
+    return this.getEnvDescriptorFromEnvDef(envDef);
+  }
+  async getEnvDescriptorFromEnvDef(envDef) {
+    if (!envDef.env.__getDescriptor || typeof envDef.env.__getDescriptor !== 'function') {
+      return undefined;
+    }
+    const systemDescriptor = await envDef.env.__getDescriptor();
+    return {
+      type: systemDescriptor.type,
+      // Make sure to store the env id in the data without the version
+      // The version should always come from the aspect id configured on the component
+      id: envDef.id.split('@')[0],
+      name: envDef.name,
+      icon: envDef.env.icon,
+      description: envDef.description
+    };
+  }
+  resolveEnv(component, id) {
+    const matchedEntry = component.state.aspects.entries.find(aspectEntry => {
+      return id === aspectEntry.id.toString() || id === aspectEntry.id.toString({
+        ignoreVersion: true
+      });
+    });
+    return matchedEntry?.id;
+  }
+
+  /**
+   * 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
+   */
+  async calculateEnvId(component) {
+    // Search first for env configured via envs aspect itself
+    const envIdFromEnvsConfig = this.getEnvIdFromEnvsConfig(component);
+    // if (!envIdFromEnvsConfig) return this.getDefaultEnv();
+    const envIdFromEnvsConfigWithoutVersion = envIdFromEnvsConfig ? _componentId().ComponentID.fromString(envIdFromEnvsConfig).toStringWithoutVersion() : undefined;
+    if (envIdFromEnvsConfig && this.isCoreEnv(envIdFromEnvsConfig)) {
+      return _componentId().ComponentID.fromString(envIdFromEnvsConfig);
+    }
+
+    // in some cases we have the id configured in the teambit.envs/envs but without the version
+    // in such cases we won't find it in the slot
+    // we search in the component aspect list a matching aspect which is match the id from the teambit.envs/envs
+    if (envIdFromEnvsConfigWithoutVersion) {
+      const matchedEntry = component.state.aspects.entries.find(aspectEntry => {
+        return envIdFromEnvsConfigWithoutVersion === aspectEntry.id.toString() || envIdFromEnvsConfigWithoutVersion === aspectEntry.id.toString({
+          ignoreVersion: true
+        });
+      });
+      if (matchedEntry?.id) return matchedEntry?.id;
+    }
+
+    // in case there is no config in teambit.envs/envs search the aspects for the first env that registered as env
+    let ids = [];
+    component.state.aspects.entries.forEach(aspectEntry => {
+      ids.push(aspectEntry.id.toString());
+      // ids.push(aspectEntry.id.toString({ ignoreVersion: true }));
+    });
+    ids = (0, _lodash().uniq)(ids);
+    const envId = await this.findFirstEnv(ids);
+    const finalId = envId || this.getDefaultEnv().id;
+    return _componentId().ComponentID.fromString(finalId);
+  }
+
+  /**
+   * 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, opts = {}) {
+    // Search first for env configured via envs aspect itself
+    const envIdFromEnvsConfig = this.getEnvIdFromEnvsConfig(component);
+    let envIdFromEnvsConfigWithoutVersion;
+    if (envIdFromEnvsConfig) {
+      envIdFromEnvsConfigWithoutVersion = _componentId().ComponentID.fromString(envIdFromEnvsConfig).toStringWithoutVersion();
+      const envDef = this.getEnvDefinitionByStringId(envIdFromEnvsConfigWithoutVersion);
+      if (envDef) {
+        this.envIds.add(envDef.id);
+        return envDef;
+      }
+    }
+
+    // in some cases we have the id configured in the teambit.envs/envs but without the version
+    // in such cases we won't find it in the slot
+    // we search in the component aspect list a matching aspect which is match the id from the teambit.envs/envs
+    if (envIdFromEnvsConfigWithoutVersion) {
+      const matchedEntry = component.state.aspects.entries.find(aspectEntry => {
+        return envIdFromEnvsConfigWithoutVersion === aspectEntry.id.toString() || envIdFromEnvsConfigWithoutVersion === aspectEntry.id.toString({
+          ignoreVersion: true
+        });
+      });
+      if (matchedEntry) {
+        // during the tag process, the version in the aspect-entry-id is changed and is not the
+        // same as it was when it registered to the slot.
+        const envDef = this.getEnvDefinitionById(matchedEntry.id);
+        if (envDef) {
+          this.envIds.add(envDef.id);
+          return envDef;
+        }
+        if (!opts.skipWarnings) {
+          // Do not allow a non existing env
+          this.printWarningIfFirstTime(matchedEntry.id.toString(), `environment with ID: ${matchedEntry.id.toString()} configured on component ${component.id.toString()} was not loaded (run "bit install")`);
+        }
+      }
+      // Do not allow configure teambit.envs/envs on the component without configure the env aspect itself
+      // const errMsg = new EnvNotConfiguredForComponent(envIdFromEnvsConfig as string, component.id.toString()).message;
+      // this.printWarningIfFirstTime(envIdFromEnvsConfig as string, errMsg);
+    }
+
+    // in case there is no config in teambit.envs/envs search the aspects for the first env that registered as env
+    let envDefFromList;
+    component.state.aspects.entries.find(aspectEntry => {
+      const envDef = this.getEnvDefinitionById(aspectEntry.id);
+      if (envDef) {
+        envDefFromList = envDef;
+      }
+      return !!envDef;
+    });
+    if (envDefFromList) {
+      this.envIds.add(envDefFromList.id);
+      return envDefFromList;
+    }
+    return this.getDefaultEnv();
+  }
+
+  /**
+   * 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) {
+    // if a component has "envs" config, use it and ignore other components that are set up
+    // in this components which happen to be envs.
+    const envDef = this.getEnvFromEnvsConfig(component);
+    if (envDef) {
+      return [envDef];
+    }
+    return this.getEnvsNotFromEnvsConfig(component);
+  }
+
+  /**
+   * whether a component has an env configured (either by variant or .bitmap).
+   */
+  hasEnvConfigured(component) {
+    return Boolean(this.getAllEnvsConfiguredOnComponent(component).length);
+  }
+  getAllRegisteredEnvsIds() {
+    return this.envSlot.toArray().map(envData => envData[0]);
+  }
+  getAllRegisteredEnvs() {
+    return this.envSlot.toArray().map(envData => envData[1]);
+  }
+  getAllRegisteredEnvJsoncCustomizers() {
+    return this.envJsoncMergeCustomizerSlot.toArray().map(customizerEntry => customizerEntry[1]);
+  }
+  getAllRegisteredEnvJsoncResolvers() {
+    return this.envJsoncResolverSlot.toArray().map(resolver => resolver[1]);
+  }
+  getEnvPlugin() {
+    return new (_env2().EnvPlugin)(this.envSlot, this.servicesRegistry, this.loggerMain, this.workerMain, this.harmony);
+  }
+
+  /**
+   * 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) {
+    const envIdFromEnvsConfig = this.getEnvIdFromEnvsConfig(component);
+    if (!envIdFromEnvsConfig) {
+      return undefined;
+    }
+    const envIdFromEnvsConfigWithoutVersion = _componentId().ComponentID.fromString(envIdFromEnvsConfig).toStringWithoutVersion();
+    const envDef = this.getEnvDefinitionByStringId(envIdFromEnvsConfigWithoutVersion);
+    return envDef;
+  }
+
+  /**
+   * 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) {
+    return component.state.aspects.entries.reduce((acc, aspectEntry) => {
+      const envDef = this.getEnvDefinitionById(aspectEntry.id);
+      if (envDef) acc.push(envDef);
+      return acc;
+    }, []);
+  }
+  getEnvIdFromEnvsLegacyExtensions(extensions) {
+    const envsAspect = extensions.findCoreExtension(_environments().EnvsAspect.id);
+    const envIdFromEnvsConfig = envsAspect?.data.id;
+    return envIdFromEnvsConfig;
+  }
+
+  /**
+   * @deprecated DO NOT USE THIS METHOD ANYMORE!!! (PLEASE USE .calculateEnvId() instead!)
+   */
+  async calculateEnvIdFromExtensions(extensions) {
+    // Search first for env configured via envs aspect itself
+    const envsAspect = extensions.findCoreExtension(_environments().EnvsAspect.id);
+    const envIdFromEnvsConfig = envsAspect?.config.env;
+    const envIdFromEnvsConfigWithoutVersion = envIdFromEnvsConfig ? _componentId().ComponentID.fromString(envIdFromEnvsConfig).toStringWithoutVersion() : undefined;
+    if (envIdFromEnvsConfig && this.isCoreEnv(envIdFromEnvsConfig)) {
+      return envIdFromEnvsConfig;
+    }
+
+    // in some cases we have the id configured in the teambit.envs/envs but without the version
+    // in such cases we won't find it in the slot
+    // we search in the component aspect list a matching aspect which is match the id from the teambit.envs/envs
+    if (envIdFromEnvsConfigWithoutVersion) {
+      const matchedEntry = extensions.find(extension => {
+        if (extension.extensionId) {
+          return envIdFromEnvsConfigWithoutVersion === extension.extensionId.toString() || envIdFromEnvsConfigWithoutVersion === extension.extensionId.toString({
+            ignoreVersion: true
+          });
+        }
+        return envIdFromEnvsConfigWithoutVersion === extension.stringId;
+      });
+      if (matchedEntry?.id) return matchedEntry?.stringId;
+    }
+
+    // in case there is no config in teambit.envs/envs search the aspects for the first env that registered as env
+    const ids = [];
+    extensions.forEach(extension => {
+      if (extension.extensionId) {
+        ids.push(extension.extensionId.toString());
+      } else {
+        ids.push(extension.stringId);
+      }
+    });
+    const envId = await this.findFirstEnv(ids);
+    const finalId = envId || this.getDefaultEnv().id;
+    return finalId;
+  }
+  validateEnvId(ext) {
+    if (!ext.config?.env || !ext.data?.id || ext.config.env === ext.data.id) return;
+    let errorMsg;
+    if (ext.data.id === DEFAULT_ENV) {
+      errorMsg = `the env id "${ext.data.id}" is set to the default env (${DEFAULT_ENV}) in the aspect data, but it is set to "${ext.config.env}" in the aspect config.
+this may indicate that the env was not loaded properly. try running "bit install" to ensure the env is correctly loaded.
+to explicitly set the default env, use "bit env set" command.`;
+    } else {
+      errorMsg = `env id "${ext.data.id}" is different from the id in the envs aspect config "${ext.config.env}".
+if needed, use "bit env set" command to align the env id`;
+    }
+    return {
+      errorMsg,
+      minBitVersion: '1.9.82'
+    };
+  }
+
+  /**
+   * @deprecated DO NOT USE THIS METHOD ANYMORE!!! (PLEASE USE .calculateEnv() instead!)
+   */
+  async calculateEnvFromExtensions(extensions) {
+    // Search first for env configured via envs aspect itself
+    const envsAspect = extensions.findCoreExtension(_environments().EnvsAspect.id);
+    const envIdFromEnvsConfig = envsAspect?.config.env;
+    let envIdFromEnvsConfigWithoutVersion;
+    if (envIdFromEnvsConfig) {
+      envIdFromEnvsConfigWithoutVersion = _componentId().ComponentID.fromString(envIdFromEnvsConfig).toStringWithoutVersion();
+      const envDef = this.getEnvDefinitionByStringId(envIdFromEnvsConfigWithoutVersion);
+      if (envDef) {
+        this.envIds.add(envDef.id);
+        return envDef;
+      }
+    }
+
+    // in some cases we have the id configured in the teambit.envs/envs but without the version
+    // in such cases we won't find it in the slot
+    // we search in the component aspect list a matching aspect which is match the id from the teambit.envs/envs
+    if (envIdFromEnvsConfigWithoutVersion) {
+      const matchedEntry = extensions.find(extension => {
+        if (extension.extensionId) {
+          return envIdFromEnvsConfigWithoutVersion === extension.extensionId.toString() || envIdFromEnvsConfigWithoutVersion === extension.extensionId.toString({
+            ignoreVersion: true
+          });
+        }
+        return envIdFromEnvsConfigWithoutVersion === extension.stringId;
+      });
+      if (matchedEntry) {
+        // during the tag process, the version in the aspect-entry-id is changed and is not the
+        // same as it was when it registered to the slot.
+        const envDef = this.getEnvDefinitionByLegacyExtension(matchedEntry);
+        if (envDef) {
+          this.envIds.add(envDef.id);
+          return envDef;
+        }
+        // Do not allow a non existing env
+        // this.printWarningIfFirstTime(
+        //   matchedEntry.id.toString(),
+        //   `environment with ID: ${matchedEntry.id.toString()} was not found`
+        // );
+      }
+      // Do not allow configure teambit.envs/envs on the component without configure the env aspect itself
+      // const errMsg = new EnvNotConfiguredForComponent(envIdFromEnvsConfig).message;
+      // this.printWarningIfFirstTime(envIdFromEnvsConfig, errMsg);
+    }
+
+    // in case there is no config in teambit.envs/envs search the aspects for the first env that registered as env
+    const ids = [];
+    extensions.forEach(extension => {
+      if (extension.extensionId) {
+        ids.push(extension.extensionId.toString());
+      } else {
+        ids.push(extension.stringId);
+      }
+    });
+    const envId = await this.findFirstEnv(ids);
+    const envDef = envId ? this.getEnvDefinitionByStringId(envId) : undefined;
+    return envDef || this.getDefaultEnv();
+  }
+
+  /**
+   * 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.
+   */
+  async findFirstEnv(ids) {
+    let isFoundWithoutVersion = false;
+    const envId = await (0, _pLocate().default)(ids, async id => {
+      const idWithoutVersion = id.split('@')[0];
+      if (this.isCoreEnv(idWithoutVersion)) return true;
+      if (this.isCoreAspect(idWithoutVersion)) return false;
+      const envDef = this.getEnvDefinitionByStringId(id);
+      if (envDef) return true;
+      const envDefWithoutVersion = this.getEnvDefinitionByStringId(idWithoutVersion);
+      if (envDefWithoutVersion) {
+        isFoundWithoutVersion = true;
+        return true;
+      }
+      const envComponent = await this.getEnvComponentByEnvId(id);
+      const hasManifest = this.hasEnvManifest(envComponent);
+      if (hasManifest) return true;
+      const isUsingEnvEnv = this.isUsingEnvEnv(envComponent);
+      return !!isUsingEnvEnv;
+    });
+    let finalEnvId;
+    if (envId) {
+      finalEnvId = isFoundWithoutVersion ? envId?.split('@')[0] : envId;
+      this.envIds.add(envId);
+    }
+    return finalEnvId;
+  }
+  getEnvDefinitionByLegacyExtension(extension) {
+    const envDef = extension.extensionId ? this.getEnvDefinitionById(extension.extensionId) : this.getEnvDefinitionByStringId(extension.stringId);
+    return envDef;
+  }
+  getEnvIdFromEnvsConfig(component) {
+    const envsAspect = component.state.aspects.get(_environments().EnvsAspect.id);
+    return envsAspect?.config.env;
+  }
+  getEnvDefinition(id) {
+    const allVersions = this.envSlot.toArray();
+    const all = allVersions.filter(([envId]) => envId.includes(id.toStringWithoutVersion()));
+    const first = (0, _lodash().head)(all);
+    if (!first) return undefined;
+    const [envId, env] = first;
+    return new (_envDefinition().EnvDefinition)(envId, env);
+  }
+  getEnvDefinitionById(id) {
+    const envDef = this.getEnvDefinitionByStringId(id.toString()) || this.getEnvDefinitionByStringId(id.toString({
+      ignoreVersion: true
+    }));
+    return envDef;
+  }
+  getEnvDefinitionByStringId(envId) {
+    const env = this.envSlot.get(envId);
+    if (env) {
+      return new (_envDefinition().EnvDefinition)(envId, env);
+    }
+    return undefined;
+  }
+  getEnvFromComponent(envComponent) {
+    const env = this.getEnvDefinitionById(envComponent.id);
+    return env;
+  }
+
+  /**
+   * Return the env definition of teambit.envs/env
+   */
+  getEnvsEnvDefinition() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.getEnvDefinitionByStringId('teambit.envs/env');
+  }
+  printWarningIfFirstTime(envId, message) {
+    if (!this.alreadyShownWarning[envId] && !this.failedToLoadEnvs.has(envId)) {
+      this.alreadyShownWarning[envId] = true;
+      this.logger.consoleWarning(message);
+      this.addFailedToLoadEnvs(envId);
+    }
+  }
+
+  /**
+   * determines whether an env is registered.
+   */
+  isEnvRegistered(id) {
+    return Boolean(this.envSlot.get(id));
+  }
+  isUsingAspectEnv(component) {
+    const data = this.getEnvData(component);
+    if (!data) return false;
+    return data.type === 'aspect';
+  }
+  isUsingEnvEnv(component) {
+    const data = this.getEnvData(component);
+    if (!data) return false;
+    return data.type === 'env';
+  }
+
+  /**
+   * Check if the given component is an env component.
+   * @param component
+   * @returns
+   */
+  isEnv(component) {
+    return this.isUsingEnvEnv(component) || this.isEnvRegistered(component.id.toString()) || this.isEnvRegistered(component.id.toStringWithoutVersion());
+  }
+
+  /**
+   * register a new environment service.
+   */
+  registerService(...envServices) {
+    this.servicesRegistry.register(envServices);
+    return this;
+  }
+
+  /**
+   * get list of services enabled on an env.
+   */
+  getServices(env) {
+    const allServices = this.servicesRegistry.toArray();
+    const services = [];
+    allServices.forEach(([id, currentServices]) => {
+      currentServices.forEach(service => {
+        try {
+          if (this.implements(env, service)) {
+            services.push([id, service]);
+          }
+        } catch {
+          this.logger.warn(`failed loading service ${id} for env ${env.id}`);
+        }
+      });
+    });
+    return new (_envServiceList().EnvServiceList)(env, services);
+  }
+  implements(env, service) {
+    // TODO: remove this after refactoring everything and remove getDescriptor from being optional.
+    if (!service.getDescriptor) return false;
+    return !!service.getDescriptor(env);
+  }
+
+  /**
+   * register an environment.
+   */
+  registerEnv(env) {
+    return this.envSlot.register(env);
+  }
+
+  /**
+   * register an env.jsonc merge customizer.
+   */
+  registerEnvJsoncMergeCustomizer(customizer) {
+    return this.envJsoncMergeCustomizerSlot.register(customizer);
+  }
+  registerEnvJsoncResolver(resolver) {
+    return this.envJsoncResolverSlot.register(resolver);
+  }
+  getEnvJsoncDetector() {
+    return new (_envJsonc().EnvJsoncDetector)();
+  }
+  async addNonLoadedEnvAsComponentIssues(components) {
+    await (0, _pMapSeries().default)(components, async component => {
+      const envId = await this.calculateEnvId(component);
+      const envIdStr = envId.toString();
+      if (!this.isEnvRegistered(envIdStr)) {
+        this.addFailedToLoadEnvs(envIdStr);
+        // If there is no version and the env is not in the workspace this is not valid
+        // you can't set external env without version
+        if (!envIdStr.includes('@')) {
+          const foundComp = components.find(c => c.id.toStringWithoutVersion() === envIdStr);
+          if (!foundComp) {
+            component.state.issues.getOrCreate(_componentIssues().IssuesClasses.ExternalEnvWithoutVersion).data = {
+              envId: envIdStr,
+              componentId: component.id.toString()
+            };
+          } else {
+            component.state.issues.getOrCreate(_componentIssues().IssuesClasses.NonLoadedEnv).data = envIdStr;
+          }
+        } else {
+          component.state.issues.getOrCreate(_componentIssues().IssuesClasses.NonLoadedEnv).data = envIdStr;
+        }
+      }
+    });
+  }
+
+  // refactor here
+  async createRuntime(components) {
+    return new (_runtime().Runtime)(await this.aggregateByDefs(components), this.logger);
+  }
+
+  // :TODO can be refactored to few utilities who will make repeating this very easy.
+  async aggregateByDefs(components) {
+    this.throwForDuplicateComponents(components);
+    const envsMap = {};
+    components.forEach(component => {
+      const envDef = this.getEnv(component);
+      const envId = envDef.id;
+      const env = envDef.env;
+      // handle config as well when aggregating envs.
+      if (envsMap[envId]) envsMap[envId].components.push(component);else envsMap[envId] = {
+        components: [component],
+        env
+      };
+    });
+    return Promise.all(Object.keys(envsMap).map(async key => {
+      const envAspectDef = await this.getEnvAspectDef(key);
+      return new (_runtime().EnvRuntime)(key, envsMap[key].env, envsMap[key].components, envAspectDef);
+    }));
+  }
+  async getEnvAspectDef(envId) {
+    const host = this.componentMain.getHost();
+    const id = await host.resolveComponentId(envId);
+    // We don't want to filter by runtime here as we want to also get envs that configured as plugins. so they don't
+    // contain the runtime path.
+    const resolvedAspects = await host.resolveAspects(_cli().MainRuntime.name, [id], {
+      requestedOnly: true,
+      filterByRuntime: false,
+      useScopeAspectsCapsule: true
+    });
+    const def = resolvedAspects[0];
+    return def;
+  }
+  throwForDuplicateComponents(components) {
+    const idsStr = components.map(c => c.id.toString());
+    const duplications = (0, _toolboxArray().findDuplications)(idsStr);
+    if (duplications.length) {
+      throw new Error(`found duplicated components: ${duplications.join(', ')}`);
+    }
+  }
+  static async provider([graphql, loggerAspect, component, cli, worker, issues], config, [envSlot, servicesRegistry, envJsoncMergeCustomizerSlot, envJsoncResolverSlot], context) {
+    const logger = loggerAspect.createLogger(_environments().EnvsAspect.id);
+    const envs = new EnvsMain(config, context, envSlot, logger, servicesRegistry, component, loggerAspect, worker, envJsoncMergeCustomizerSlot, envJsoncResolverSlot);
+    component.registerShowFragments([new (_env().EnvFragment)(envs)]);
+    if (issues) issues.registerAddComponentsIssues(envs.addNonLoadedEnvAsComponentIssues.bind(envs));
+    const envsCmd = new (_envs().EnvsCmd)(envs, component);
+    envsCmd.commands = [new (_envs().ListEnvsCmd)(envs, component), new (_envs().GetEnvCmd)(envs, component)];
+    cli.register(envsCmd);
+    graphql.register(() => (0, _environments2().environmentsSchema)(envs));
+    return envs;
+  }
+}
+exports.EnvsMain = EnvsMain;
+_defineProperty(EnvsMain, "runtime", _cli().MainRuntime);
+_defineProperty(EnvsMain, "slots", [_harmony().Slot.withType(), _harmony().Slot.withType(), _harmony().Slot.withType(), _harmony().Slot.withType()]);
+_defineProperty(EnvsMain, "dependencies", [_graphql().GraphqlAspect, _logger().LoggerAspect, _component().ComponentAspect, _cli().CLIAspect, _worker().WorkerAspect, _issues().IssuesAspect]);
+_environments().EnvsAspect.addRuntime(EnvsMain);
+
+//# sourceMappingURL=environments.main.runtime.js.map