@teambit/envs 0.0.0-3e44e878fae3f5f31fce2dc240a57a798e67137e

package/dist/services/index.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AsyncServiceHandlerFactory", {
+  enumerable: true,
+  get: function () {
+    return _serviceHandler().AsyncServiceHandlerFactory;
+  }
+});
+Object.defineProperty(exports, "ConcreteService", {
+  enumerable: true,
+  get: function () {
+    return _concreteService().ConcreteService;
+  }
+});
+Object.defineProperty(exports, "EnvService", {
+  enumerable: true,
+  get: function () {
+    return _service().Service;
+  }
+});
+Object.defineProperty(exports, "ServiceExecutionResult", {
+  enumerable: true,
+  get: function () {
+    return _service().ServiceExecutionResult;
+  }
+});
+Object.defineProperty(exports, "ServiceHandler", {
+  enumerable: true,
+  get: function () {
+    return _serviceHandler().ServiceHandler;
+  }
+});
+Object.defineProperty(exports, "ServiceHandlerContext", {
+  enumerable: true,
+  get: function () {
+    return _serviceHandlerContext().ServiceHandlerContext;
+  }
+});
+Object.defineProperty(exports, "ServiceHandlerFactory", {
+  enumerable: true,
+  get: function () {
+    return _serviceHandler().ServiceHandlerFactory;
+  }
+});
+Object.defineProperty(exports, "ServiceTransformationMap", {
+  enumerable: true,
+  get: function () {
+    return _service().TransformationMap;
+  }
+});
+Object.defineProperty(exports, "reduceServiceHandlersFactories", {
+  enumerable: true,
+  get: function () {
+    return _serviceHandler().reduceServiceHandlersFactories;
+  }
+});
+function _service() {
+  const data = require("./service");
+  _service = function () {
+    return data;
+  };
+  return data;
+}
+function _concreteService() {
+  const data = require("./concrete-service");
+  _concreteService = function () {
+    return data;
+  };
+  return data;
+}
+function _serviceHandler() {
+  const data = require("./service-handler");
+  _serviceHandler = function () {
+    return data;
+  };
+  return data;
+}
+function _serviceHandlerContext() {
+  const data = require("./service-handler-context");
+  _serviceHandlerContext = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/services/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_service","data","require","_concreteService","_serviceHandler","_serviceHandlerContext"],"sources":["index.ts"],"sourcesContent":["export {\n  Service as EnvService,\n  ServiceExecutionResult,\n  TransformationMap as ServiceTransformationMap,\n} from './service';\nexport { ConcreteService } from './concrete-service';\nexport {\n  ServiceHandler,\n  ServiceHandlerFactory,\n  AsyncServiceHandlerFactory,\n  reduceServiceHandlersFactories,\n} from './service-handler';\nexport { ServiceHandlerContext } from './service-handler-context';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA,SAAAE,iBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,gBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,gBAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,eAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAMA,SAAAI,uBAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,sBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/services/service-handler-context.d.ts

@@ -0,0 +1,30 @@
+import { ComponentID } from '@teambit/component';
+import { Harmony } from '@teambit/harmony';
+import { Logger, LoggerMain } from '@teambit/logger';
+import { WorkerMain } from '@teambit/worker';
+export declare class ServiceHandlerContext {
+    /**
+     * id of the environment defined in the context.
+     */
+    readonly envId: ComponentID;
+    readonly loggerMain: LoggerMain;
+    readonly workerMain: WorkerMain;
+    readonly harmony: Harmony;
+    constructor(
+    /**
+     * id of the environment defined in the context.
+     */
+    envId: ComponentID, loggerMain: LoggerMain, workerMain: WorkerMain, harmony: Harmony);
+    /**
+     * return a logger instance for the env.
+     */
+    createLogger(name?: string): Logger;
+    /**
+     * get an instance of an aspect. make sure it is loaded prior to requesting it.
+     */
+    getAspect<T>(aspectId: string): T;
+    /**
+     * create worker for the env context.
+     */
+    createWorker<T>(name: string, path: string): import("@teambit/worker").HarmonyWorker<T>;
+}

package/dist/services/service-handler-context.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServiceHandlerContext = void 0;
+class ServiceHandlerContext {
+  constructor(
+  /**
+   * id of the environment defined in the context.
+   */
+  envId, loggerMain, workerMain, harmony) {
+    this.envId = envId;
+    this.loggerMain = loggerMain;
+    this.workerMain = workerMain;
+    this.harmony = harmony;
+  }
+
+  /**
+   * return a logger instance for the env.
+   */
+  createLogger(name) {
+    const loggerName = name ? `${this.envId.toString()}::${name}` : this.envId.toString();
+    return this.loggerMain.createLogger(loggerName);
+  }
+
+  /**
+   * get an instance of an aspect. make sure it is loaded prior to requesting it.
+   */
+  getAspect(aspectId) {
+    return this.harmony.get(aspectId);
+  }
+
+  /**
+   * create worker for the env context.
+   */
+  createWorker(name, path) {
+    const worker = this.workerMain.declareWorker(name, path);
+    return worker;
+  }
+}
+exports.ServiceHandlerContext = ServiceHandlerContext;
+
+//# sourceMappingURL=service-handler-context.js.map

package/dist/services/service-handler-context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ServiceHandlerContext","constructor","envId","loggerMain","workerMain","harmony","createLogger","name","loggerName","toString","getAspect","aspectId","get","createWorker","path","worker","declareWorker","exports"],"sources":["service-handler-context.ts"],"sourcesContent":["import { ComponentID } from '@teambit/component';\nimport { Harmony } from '@teambit/harmony';\nimport { Logger, LoggerMain } from '@teambit/logger';\nimport { WorkerMain } from '@teambit/worker';\n\nexport class ServiceHandlerContext {\n  constructor(\n    /**\n     * id of the environment defined in the context.\n     */\n    readonly envId: ComponentID,\n    readonly loggerMain: LoggerMain,\n    readonly workerMain: WorkerMain,\n    readonly harmony: Harmony\n  ) {}\n\n  /**\n   * return a logger instance for the env.\n   */\n  createLogger(name?: string): Logger {\n    const loggerName = name ? `${this.envId.toString()}::${name}` : this.envId.toString();\n\n    return this.loggerMain.createLogger(loggerName);\n  }\n\n  /**\n   * get an instance of an aspect. make sure it is loaded prior to requesting it.\n   */\n  getAspect<T>(aspectId: string) {\n    return this.harmony.get<T>(aspectId);\n  }\n\n  /**\n   * create worker for the env context.\n   */\n  createWorker<T>(name: string, path: string) {\n    const worker = this.workerMain.declareWorker<T>(name, path);\n    return worker;\n  }\n}\n"],"mappings":";;;;;;AAKO,MAAMA,qBAAqB,CAAC;EACjCC,WAAWA;EACT;AACJ;AACA;EACaC,KAAkB,EAClBC,UAAsB,EACtBC,UAAsB,EACtBC,OAAgB,EACzB;IAAA,KAJSH,KAAkB,GAAlBA,KAAkB;IAAA,KAClBC,UAAsB,GAAtBA,UAAsB;IAAA,KACtBC,UAAsB,GAAtBA,UAAsB;IAAA,KACtBC,OAAgB,GAAhBA,OAAgB;EACxB;;EAEH;AACF;AACA;EACEC,YAAYA,CAACC,IAAa,EAAU;IAClC,MAAMC,UAAU,GAAGD,IAAI,GAAG,GAAG,IAAI,CAACL,KAAK,CAACO,QAAQ,CAAC,CAAC,KAAKF,IAAI,EAAE,GAAG,IAAI,CAACL,KAAK,CAACO,QAAQ,CAAC,CAAC;IAErF,OAAO,IAAI,CAACN,UAAU,CAACG,YAAY,CAACE,UAAU,CAAC;EACjD;;EAEA;AACF;AACA;EACEE,SAASA,CAAIC,QAAgB,EAAE;IAC7B,OAAO,IAAI,CAACN,OAAO,CAACO,GAAG,CAAID,QAAQ,CAAC;EACtC;;EAEA;AACF;AACA;EACEE,YAAYA,CAAIN,IAAY,EAAEO,IAAY,EAAE;IAC1C,MAAMC,MAAM,GAAG,IAAI,CAACX,UAAU,CAACY,aAAa,CAAIT,IAAI,EAAEO,IAAI,CAAC;IAC3D,OAAOC,MAAM;EACf;AACF;AAACE,OAAA,CAAAjB,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/services/service-handler.d.ts

@@ -0,0 +1,18 @@
+import { ServiceHandlerContext } from './service-handler-context';
+/**
+ * definition of the service handler.
+ */
+export type ServiceHandlerFactory<T> = (context: ServiceHandlerContext) => ServiceHandler & T;
+export type AsyncServiceHandlerFactory<T> = (context: ServiceHandlerContext) => Promise<ServiceHandler & T>;
+export interface ServiceHandler {
+    /**
+     * name of the service. e.g. 'typescript-compiler'
+     */
+    name?: string;
+    /**
+     * version of the service. optional.
+     */
+    version?: () => string;
+}
+export type ReduceFactoryCallback<T> = (acc: T, value: T) => ServiceHandler & T;
+export declare function reduceServiceHandlersFactories<T>(factories: ServiceHandlerFactory<T>[], callback: ReduceFactoryCallback<T>): ServiceHandlerFactory<T>;

package/dist/services/service-handler.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reduceServiceHandlersFactories = reduceServiceHandlersFactories;
+/**
+ * definition of the service handler.
+ */
+
+function reduceServiceHandlersFactories(factories, callback) {
+  if (!factories.length) throw new Error('no factories were provided');
+  const result = context => {
+    // @ts-ignore
+    const initialVal = factories.shift()(context);
+    const reduced = factories.reduce((acc, currFactory) => {
+      const curr = currFactory(context);
+      return callback(acc, curr);
+    }, initialVal);
+    return reduced;
+  };
+  return result;
+}
+
+//# sourceMappingURL=service-handler.js.map

package/dist/services/service-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["reduceServiceHandlersFactories","factories","callback","length","Error","result","context","initialVal","shift","reduced","reduce","acc","currFactory","curr"],"sources":["service-handler.ts"],"sourcesContent":["import { ServiceHandlerContext } from './service-handler-context';\n\n/**\n * definition of the service handler.\n */\nexport type ServiceHandlerFactory<T> = (context: ServiceHandlerContext) => ServiceHandler & T;\nexport type AsyncServiceHandlerFactory<T> = (context: ServiceHandlerContext) => Promise<ServiceHandler & T>;\n\nexport interface ServiceHandler {\n  /**\n   * name of the service. e.g. 'typescript-compiler'\n   */\n  name?: string;\n  /**\n   * version of the service. optional.\n   */\n  version?: () => string;\n\n  /**\n   * config of the service. e.g. tsconfig.json\n   */\n  // config?: string;\n}\n\nexport type ReduceFactoryCallback<T> = (acc: T, value: T) => ServiceHandler & T;\nexport function reduceServiceHandlersFactories<T>(\n  factories: ServiceHandlerFactory<T>[],\n  callback: ReduceFactoryCallback<T>\n): ServiceHandlerFactory<T> {\n  if (!factories.length) throw new Error('no factories were provided');\n  const result: ServiceHandlerFactory<T> = (context: ServiceHandlerContext) => {\n    // @ts-ignore\n    const initialVal = factories.shift()(context);\n    const reduced: ServiceHandler & T = factories.reduce((acc, currFactory) => {\n      const curr = currFactory(context);\n      return callback(acc, curr);\n    }, initialVal);\n    return reduced;\n  };\n  return result;\n}\n"],"mappings":";;;;;;AAEA;AACA;AACA;;AAqBO,SAASA,8BAA8BA,CAC5CC,SAAqC,EACrCC,QAAkC,EACR;EAC1B,IAAI,CAACD,SAAS,CAACE,MAAM,EAAE,MAAM,IAAIC,KAAK,CAAC,4BAA4B,CAAC;EACpE,MAAMC,MAAgC,GAAIC,OAA8B,IAAK;IAC3E;IACA,MAAMC,UAAU,GAAGN,SAAS,CAACO,KAAK,CAAC,CAAC,CAACF,OAAO,CAAC;IAC7C,MAAMG,OAA2B,GAAGR,SAAS,CAACS,MAAM,CAAC,CAACC,GAAG,EAAEC,WAAW,KAAK;MACzE,MAAMC,IAAI,GAAGD,WAAW,CAACN,OAAO,CAAC;MACjC,OAAOJ,QAAQ,CAACS,GAAG,EAAEE,IAAI,CAAC;IAC5B,CAAC,EAAEN,UAAU,CAAC;IACd,OAAOE,OAAO;EAChB,CAAC;EACD,OAAOJ,MAAM;AACf","ignoreList":[]}

package/dist/services/service.d.ts

@@ -0,0 +1,66 @@
+import { Component } from '@teambit/component';
+import { Env } from '../env-interface';
+import { Environment } from '../environment';
+import { ServiceHandler } from './service-handler';
+import { ServiceHandlerContext } from './service-handler-context';
+export type EnvContext = {
+    components: Component[];
+};
+export interface ServiceExecutionResult {
+    errors?: Error[];
+}
+export type ServiceTransformHandlerFactory<T> = (handlerContext?: any) => (ServiceHandler & T) | Promise<ServiceHandler & T>;
+/**
+ * definition of the service handler type
+ * This used to define new types of handlers like
+ * Compiler, Tester, Preview, etc.
+ */
+export type TransformationMap = {
+    /**
+     * The name of the function that will be called on the service run/run once later.
+     * This func will be exist on the final env object
+     */
+    [funcName: string]: ServiceTransformHandlerFactory<any>;
+};
+/**
+ * services allows to reuse and standardize services for development environments.
+ * examples for services can be: `linting`, `compilation`, `build`, and others which offer
+ * standard services to environments such as `react`, `angular` and `vue` and different compositions of each for
+ * more concrete needs.
+ *
+ * `TData` - type of data returned by the service handler.
+ * `TOpts` is the type of options passed to the environment through execution.
+ * `TExecResponse` is the execution result of the service.
+ */
+export interface Service<TExecResponse extends ServiceExecutionResult, TData = {}, TOpts = {}> {
+    /**
+     * name of the service. (e.g. `compile`, `test`, etc.)
+     */
+    name?: string;
+    /**
+     * description of the env.
+     */
+    description?: string;
+    /**
+     * create a string to describe to service in the env cli.
+     */
+    render?(env: Environment, context: EnvContext[]): string | Promise<string>;
+    /**
+     * get service data from an environment.
+     */
+    getDescriptor?(environment: Environment, context?: EnvContext[]): TData | undefined | Promise<TData | undefined>;
+    /**
+     * executes a service on a subset of components.
+     */
+    run?(context: EnvContext, options?: TOpts): Promise<TExecResponse>;
+    /**
+     * run the service only once.
+     */
+    runOnce?(context: EnvContext[], options?: TOpts): Promise<any>;
+    /**
+     * Return a map of functions that will be called on the service run/run once later.
+     * @param env the original env plugin object
+     * @param context ServiceHandlerContext(EnvContext)
+     */
+    transform?(env: Env, context: ServiceHandlerContext): TransformationMap | undefined;
+}

package/dist/services/service.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=service.js.map

package/dist/services/service.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["service.ts"],"sourcesContent":["import { Component } from '@teambit/component';\nimport { Env } from '../env-interface';\nimport { Environment } from '../environment';\nimport { ServiceHandler } from './service-handler';\nimport { ServiceHandlerContext } from './service-handler-context';\n\nexport type EnvContext = {\n  components: Component[];\n};\n\nexport interface ServiceExecutionResult {\n  errors?: Error[];\n}\n\nexport type ServiceTransformHandlerFactory<T> = (\n  handlerContext?: any\n) => (ServiceHandler & T) | Promise<ServiceHandler & T>;\n\n/**\n * definition of the service handler type\n * This used to define new types of handlers like\n * Compiler, Tester, Preview, etc.\n */\nexport type TransformationMap = {\n  /**\n   * The name of the function that will be called on the service run/run once later.\n   * This func will be exist on the final env object\n   */\n  [funcName: string]: ServiceTransformHandlerFactory<any>;\n};\n\n/**\n * services allows to reuse and standardize services for development environments.\n * examples for services can be: `linting`, `compilation`, `build`, and others which offer\n * standard services to environments such as `react`, `angular` and `vue` and different compositions of each for\n * more concrete needs.\n *\n * `TData` - type of data returned by the service handler.\n * `TOpts` is the type of options passed to the environment through execution.\n * `TExecResponse` is the execution result of the service.\n */\nexport interface Service<TExecResponse extends ServiceExecutionResult, TData = {}, TOpts = {}> {\n  /**\n   * name of the service. (e.g. `compile`, `test`, etc.)\n   */\n  name?: string;\n\n  /**\n   * description of the env.\n   */\n  description?: string;\n\n  /**\n   * create a string to describe to service in the env cli.\n   */\n  render?(env: Environment, context: EnvContext[]): string | Promise<string>;\n\n  /**\n   * get service data from an environment.\n   */\n  getDescriptor?(environment: Environment, context?: EnvContext[]): TData | undefined | Promise<TData | undefined>;\n\n  /**\n   * executes a service on a subset of components.\n   */\n  run?(context: EnvContext, options?: TOpts): Promise<TExecResponse>;\n\n  /**\n   * run the service only once.\n   */\n  runOnce?(context: EnvContext[], options?: TOpts): Promise<any>;\n\n  /**\n   * Return a map of functions that will be called on the service run/run once later.\n   * @param env the original env plugin object\n   * @param context ServiceHandlerContext(EnvContext)\n   */\n  transform?(env: Env, context: ServiceHandlerContext): TransformationMap | undefined;\n}\n"],"mappings":"","ignoreList":[]}

package/env.composition.tsx

@@ -0,0 +1,7 @@
+import React from 'react';
+
+export const Logo = () => (
+  <div style={{ height: '100%', display: 'flex', justifyContent: 'center' }}>
+    <img style={{ width: 70 }} src="https://static.bit.dev/extensions-icons/env.svg" />
+  </div>
+);

package/envs.docs.mdx

@@ -0,0 +1,8 @@
+---
+description: A composable engine for creating and maintaining development environments.
+labels: ['environments', 'core aspect']
+---
+
+import { Envs } from '@teambit/envs.aspect-docs.envs';
+
+<Envs />

package/esm.mjs

@@ -0,0 +1,13 @@
+// eslint-disable-next-line import/no-unresolved
+import cjsModule from './index.js';
+
+export const EnvsAspect = cjsModule.EnvsAspect;
+export const EnvContext = cjsModule.EnvContext;
+export const DEFAULT_ENV = cjsModule.DEFAULT_ENV;
+export const ExecutionContext = cjsModule.ExecutionContext;
+export const reduceServiceHandlersFactories = cjsModule.reduceServiceHandlersFactories;
+export const EnvRuntime = cjsModule.EnvRuntime;
+export const EnvsExecutionResult = cjsModule.EnvsExecutionResult;
+export const EnvDefinition = cjsModule.EnvDefinition;
+
+export default cjsModule;

package/exceptions/env-not-configured-for-component.ts

@@ -0,0 +1,10 @@
+import { BitError } from '@teambit/bit-error';
+
+export class EnvNotConfiguredForComponent extends BitError {
+  constructor(id: string, componentId?: string) {
+    const suffix = componentId ? ` for the component ${componentId}` : '';
+    super(`environment with ID: "${id}" is not configured as extension${suffix}.
+you probably need to set this environment to your component(s). for example, "bit env set <component-pattern> ${id}"
+`);
+  }
+}

package/exceptions/env-not-found-in-runtime.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export class EnvNotFoundInRuntime extends BitError {
+  constructor(private id: string) {
+    super(`environment with ID: ${id} was not found configured to any of your components`);
+  }
+}

package/exceptions/env-not-found.ts

@@ -0,0 +1,15 @@
+import { BitError } from '@teambit/bit-error';
+
+export class EnvNotFound extends BitError {
+  constructor(
+    private id: string,
+    private componentId?: string
+  ) {
+    super(getMessage(id, componentId));
+  }
+}
+
+function getMessage(id: string, componentId?: string): string {
+  const compIdDetails = componentId ? `configured on component ${componentId}` : '';
+  return `environment with ID: ${id} ${compIdDetails} was not found`;
+}

package/exceptions/index.ts

@@ -0,0 +1,3 @@
+export { EnvNotFoundInRuntime } from './env-not-found-in-runtime';
+export { EnvNotFound } from './env-not-found';
+export { EnvNotConfiguredForComponent } from './env-not-configured-for-component';

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@teambit/envs",
+  "version": "0.0.0-3e44e878fae3f5f31fce2dc240a57a798e67137e",
+  "homepage": "https://bit.cloud/teambit/envs/envs",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.envs",
+    "name": "envs",
+    "version": "3e44e878fae3f5f31fce2dc240a57a798e67137e"
+  },
+  "dependencies": {
+    "comment-json": "4.2.5",
+    "chalk": "4.1.2",
+    "lodash": "4.17.21",
+    "graphql-tag": "2.12.1",
+    "p-locate": "5.0.0",
+    "p-map-series": "2.1.0",
+    "@teambit/harmony": "0.4.7",
+    "@teambit/bit-error": "0.0.404",
+    "@teambit/component-id": "1.2.4",
+    "@teambit/dependency-resolver": "0.0.0-19d0b976dbeddcecb365fb558ea83042f04ab2d1",
+    "@teambit/component": "0.0.0-c8ba8f4e3b6fdc2e774efe3c2d40eac295ccd914",
+    "@teambit/aspect-loader": "0.0.0-7ea1cbdf0e9bd47c4a1d51479ce10c975b28c953",
+    "@teambit/cli": "0.0.0-d52a20dfe7f90d6d807ddba2a1deef609d335076",
+    "@teambit/logger": "0.0.0-5dec32734b29aa18fab6933c221ed88ec6cad975",
+    "@teambit/worker": "0.0.0-ebf2fb59e3f5526c8e7a5e2edfd029c06179697c",
+    "@teambit/builder": "0.0.0-6bd1048b37afde835ce234c006226828c5e6a66c",
+    "@teambit/bundler": "0.0.0-0cf352ce9e86ee13b74f6603d8b93ca26f9e8d89",
+    "@teambit/compiler": "0.0.0-eda8f485d7d4c0c7f81596735f67c3e664b12be0",
+    "@teambit/formatter": "0.0.0-1a616cfd1feccfbdc35ef05b801437b4f4f995c0",
+    "@teambit/isolator": "0.0.0-32ffef9b6a8b78db2d8f8af969486ee8b04571db",
+    "@teambit/linter": "0.0.0-0d0aaa7ddeaa4d78dd244bae82eb612826f0aad9",
+    "@teambit/pkg": "0.0.0-8fc29d531e629f35c2e58a1143664a2d6a77ac8f",
+    "@teambit/preview": "0.0.0-95dacf87f5f920d5ba9e07d049e5db1bde70090f",
+    "@teambit/schema": "0.0.0-a0ccff8e3e73763262206b81e90f34b832b4fa6f",
+    "@teambit/tester": "0.0.0-9c53069e69970106400a9343fad851e13f3937d2",
+    "@teambit/typescript": "0.0.0-db4aec20dc9806fe40f565da134118923c576706",
+    "@teambit/webpack": "0.0.0-24b7f745a9a18c534db1d211592707afeb57f067",
+    "@teambit/graphql": "0.0.0-fd3e774bac57829b5798d5c35433faed38d0292d",
+    "@teambit/component-issues": "0.0.159",
+    "@teambit/component.sources": "0.0.0-0a7957d9dce8437df5c368f4c1278bf3f2b1f560",
+    "@teambit/dev-files": "0.0.0-a8cf4609d2167ba8d86fa8d612d1752bedbc23cd",
+    "@teambit/issues": "0.0.0-47aa9235bd6b99f4b9bc0458e0deed4fce546d52",
+    "@teambit/legacy.consumer-component": "0.0.0-dba92da5457a298373d07f2bb6057c0d91e1f494",
+    "@teambit/legacy.extension-data": "0.0.0-6c006730fa831ef48f3a6ef6765e95d8a1209999",
+    "@teambit/toolbox.array.duplications-finder": "0.0.3",
+    "@teambit/cli-table": "0.0.50"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.14.165",
+    "@types/mocha": "9.1.0",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.69",
+    "@teambit/envs.aspect-docs.envs": "0.0.173"
+  },
+  "peerDependencies": {
+    "react": "^17.0.0 || ^18.0.0",
+    "@types/react": "^17.0.73"
+  },
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "exports": {
+    ".": {
+      "node": {
+        "require": "./dist/index.js",
+        "import": "./dist/esm.mjs"
+      },
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./artifacts/*": "./artifacts/*",
+    "./*": "./*.ts"
+  },
+  "private": false,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "bit-core-aspect",
+    "components",
+    "collaboration",
+    "web"
+  ]
+}

package/runtime/env-runtime.ts

@@ -0,0 +1,31 @@
+import { AspectDefinition } from '@teambit/aspect-loader';
+import { Component } from '@teambit/component';
+
+import { Environment } from '../environment';
+
+/**
+ * env runtime is an instance which represent the given env in a
+ */
+export class EnvRuntime {
+  constructor(
+    /**
+     * ID of the wrapping extension.
+     */
+    readonly id: string,
+
+    /**
+     * environment
+     */
+    readonly env: Environment,
+
+    /**
+     * components to be loaded in the environment
+     */
+    readonly components: Component[],
+
+    /**
+     * Aspect definition of the env.
+     */
+    readonly envAspectDefinition: AspectDefinition
+  ) {}
+}

package/runtime/envs-execution-result.ts

@@ -0,0 +1,46 @@
+import { flatten } from 'lodash';
+
+import { ServiceExecutionResult } from '../services';
+import { EnvResult } from './runtime';
+
+export class EnvsExecutionResult<T extends ServiceExecutionResult> {
+  constructor(readonly results: EnvResult<T>[]) {}
+
+  hasErrors() {
+    return Boolean(this.errors.length);
+  }
+
+  /**
+   * execution errors.
+   */
+  get errors(): Error[] {
+    return flatten(this.results.map((envResult) => this.getErrorsOfEnv(envResult)));
+  }
+
+  getErrorsOfEnv(envResult: EnvResult<T>): Error[] {
+    const execError = envResult.error;
+    const errors = envResult.data ? envResult.data.errors || [] : [];
+    if (execError) errors.push(execError);
+    return errors;
+  }
+
+  /**
+   * if only one error is found, throw it. otherwise, summarize the errors per env and throw the
+   * output
+   */
+  throwErrorsIfExist() {
+    if (!this.errors || !this.errors.length) return;
+    if (this.errors.length === 1 && this.errors[0] instanceof Error) throw this.errors[0];
+    const errorsPerEnvs = this.results.map((envResult) => this.getEnvErrorsAsString(envResult));
+    const errorOutput = errorsPerEnvs.join('\n\n');
+    throw new Error(errorOutput);
+  }
+
+  getEnvErrorsAsString(envResult: EnvResult<T>): string {
+    const errors = this.getErrorsOfEnv(envResult);
+    if (!errors.length) return '';
+    const title = `found ${errors.length} error(s) for ${envResult.env.id}`;
+    const errorsStr = errors.map((error) => `${error.message}\n${error.stack}`).join('\n');
+    return `${title}\n${errorsStr}`;
+  }
+}

package/runtime/index.ts

@@ -0,0 +1,2 @@
+export { Runtime } from './runtime';
+export { EnvRuntime } from './env-runtime';

package/runtime/runtime.ts

@@ -0,0 +1,100 @@
+import { Logger } from '@teambit/logger';
+import { ComponentID } from '@teambit/component';
+import mapSeries from 'p-map-series';
+import { EnvNotFoundInRuntime } from '../exceptions';
+import { ExecutionContext } from '../context';
+import { EnvService, ServiceExecutionResult } from '../services';
+import { EnvRuntime } from './env-runtime';
+import { EnvsExecutionResult } from './envs-execution-result';
+
+export interface EnvResult<T extends ServiceExecutionResult> {
+  env: EnvRuntime;
+  data?: T;
+  error?: Error;
+}
+
+export class Runtime {
+  constructor(
+    /**
+     * runtime instances of the environments.
+     */
+    readonly runtimeEnvs: EnvRuntime[],
+
+    private logger: Logger
+  ) {}
+
+  /**
+   * execute a service on a specific env.
+   */
+  runEnv<T extends ServiceExecutionResult>(
+    envRuntimeId: string,
+    service: EnvService<T>,
+    options?: { [key: string]: any }
+  ): Promise<EnvsExecutionResult<T>> {
+    const envRuntime = this.runtimeEnvs.find((runtime) => {
+      const id = ComponentID.fromString(runtime.id);
+      const withoutVersion = id.toStringWithoutVersion();
+      return withoutVersion === envRuntimeId;
+    });
+    if (!envRuntime) throw new EnvNotFoundInRuntime(envRuntimeId);
+    return this.run(service, options, [envRuntime]);
+  }
+
+  /**
+   * execute a service once for all environments.
+   */
+  async runOnce<T extends ServiceExecutionResult>(
+    service: EnvService<T>,
+    options?: { [key: string]: any }
+  ): Promise<any> {
+    if (!service.runOnce) throw new Error('a service must implement `runOnce()` in order to be executed');
+    const envsExecutionContext = this.getEnvExecutionContext();
+    const serviceResult = await service.runOnce(envsExecutionContext, options);
+    return serviceResult;
+  }
+
+  getEnvExecutionContext(): ExecutionContext[] {
+    const envsExecutionContext = this.runtimeEnvs.map((env) => new ExecutionContext(this, env));
+    return envsExecutionContext;
+  }
+
+  /**
+   * execute a service on each one of the environments.
+   */
+  async run<T extends ServiceExecutionResult>(
+    /**
+     * environment service to execute.
+     */
+    service: EnvService<T>,
+
+    /**
+     * options to proxy to the service upon execution.
+     */
+    options?: { [key: string]: any },
+    runtimes?: EnvRuntime[]
+  ): Promise<EnvsExecutionResult<T>> {
+    if (!service.run) throw new Error('a service must implement `run()` in order to be executed');
+    const errors: Error[] = [];
+    const contexts: EnvResult<T>[] = await mapSeries(runtimes || this.runtimeEnvs, async (env) => {
+      try {
+        // @ts-ignore
+        const serviceResult = await service.run(new ExecutionContext(this, env), options);
+
+        return {
+          env,
+          data: serviceResult,
+        };
+      } catch (err: any) {
+        this.logger.error(err.message, err);
+        this.logger.consoleFailure(`service "${service.name}" of env "${env.id}" has failed. error: ${err.message}`);
+        errors.push(err);
+        return {
+          env,
+          error: err,
+        };
+      }
+    });
+
+    return new EnvsExecutionResult(contexts);
+  }
+}

package/services/concrete-service.ts

@@ -0,0 +1,8 @@
+/**
+ * please do not use this.
+ * @deprecated
+ */
+export interface ConcreteService {
+  getPackageJsonProps?: () => Record<string, any>;
+  dependencies?: () => any;
+}