@teambit/harmony 0.0.0-19ea14143ef7d5f4e4daa6e8ac8a8c97c9d683d5

package/dist/fixtures/typescript/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../fixtures/typescript/index.ts"],"names":[],"mappings":""}

package/dist/fixtures/typescript/typescript.d.ts

@@ -0,0 +1,7 @@
+import { BaseCompiler } from '../base-compiler';
+export declare class TypeScript {
+    private compiler;
+    constructor(compiler: string);
+    compile(): string;
+    static provider([baseCompiler]: [BaseCompiler]): Promise<TypeScript>;
+}

package/dist/fixtures/typescript/typescript.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScript = void 0;
+// @Extension({
+//   name: 'typescript',
+//   dependencies: [BaseCompiler]
+// })
+class TypeScript {
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    compile() {
+        return this.compiler;
+    }
+    static provider(_a) {
+        return __awaiter(this, arguments, void 0, function* ([baseCompiler]) {
+            return new TypeScript(baseCompiler.compile());
+        });
+    }
+}
+exports.TypeScript = TypeScript;
+//# sourceMappingURL=typescript.js.map

package/dist/fixtures/typescript/typescript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../../fixtures/typescript/typescript.ts"],"names":[],"mappings":";;;;;;;;;;;;AAGA,eAAe;AACf,wBAAwB;AACxB,iCAAiC;AACjC,KAAK;AACL,MAAa,UAAU;IACrB,YACU,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;IACvB,CAAC;IAEJ,OAAO;QACL,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,MAAM,CAAO,QAAQ;6DAAC,CAAC,YAAY,CAAiB;YAClD,OAAO,IAAI,UAAU,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;QAChD,CAAC;KAAA;CACF;AAZD,gCAYC"}

package/dist/harmony-config/config-reader.d.ts

@@ -0,0 +1 @@
+export declare function readConfigFile(path: string, mustExist?: boolean): Record<string, any>;

package/dist/harmony-config/config-reader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfigFile = readConfigFile;
+const comment_json_1 = require("comment-json");
+const fs_1 = require("fs");
+const read_config_error_1 = require("./exceptions/read-config-error");
+function readConfigFile(path, mustExist = true) {
+    if (!mustExist && !(0, fs_1.existsSync)(path)) {
+        return {};
+    }
+    try {
+        const parsed = (0, comment_json_1.parse)((0, fs_1.readFileSync)(path, 'utf8'));
+        const json = parsed && typeof parsed === 'object' ? parsed : {};
+        delete json['$schema'];
+        return json;
+    }
+    catch (err) {
+        throw new read_config_error_1.ReadConfigError(path, err instanceof Error ? err : new Error(String(err)));
+    }
+}
+//# sourceMappingURL=config-reader.js.map

package/dist/harmony-config/config-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-reader.js","sourceRoot":"","sources":["../../harmony-config/config-reader.ts"],"names":[],"mappings":";;AAIA,wCAaC;AAjBD,+CAAqC;AACrC,2BAA8C;AAC9C,sEAAiE;AAEjE,SAAgB,cAAc,CAAC,IAAY,EAAE,SAAS,GAAG,IAAI;IAC3D,IAAI,CAAC,SAAS,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC,EAAE,CAAC;QACpC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAA,oBAAK,EAAC,IAAA,iBAAY,EAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;QACjD,MAAM,IAAI,GAAwB,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAE,MAA8B,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9G,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,mCAAe,CAAC,IAAI,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACvF,CAAC;AACH,CAAC"}

package/dist/harmony-config/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { ReadConfigError } from './read-config-error';

package/dist/harmony-config/exceptions/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadConfigError = void 0;
+var read_config_error_1 = require("./read-config-error");
+Object.defineProperty(exports, "ReadConfigError", { enumerable: true, get: function () { return read_config_error_1.ReadConfigError; } });
+//# sourceMappingURL=index.js.map

package/dist/harmony-config/exceptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../harmony-config/exceptions/index.ts"],"names":[],"mappings":";;;AAAA,yDAAsD;AAA7C,oHAAA,eAAe,OAAA"}

package/dist/harmony-config/exceptions/read-config-error.d.ts

@@ -0,0 +1,5 @@
+export declare class ReadConfigError extends Error {
+    private err;
+    constructor(path: string, err: Error);
+    get stack(): string;
+}

package/dist/harmony-config/exceptions/read-config-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadConfigError = void 0;
+class ReadConfigError extends Error {
+    constructor(path, err) {
+        super(`failed to read config from path: ${path}`);
+        this.err = err;
+    }
+    get stack() {
+        return this.err.stack;
+    }
+}
+exports.ReadConfigError = ReadConfigError;
+//# sourceMappingURL=read-config-error.js.map

package/dist/harmony-config/exceptions/read-config-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-config-error.js","sourceRoot":"","sources":["../../../harmony-config/exceptions/read-config-error.ts"],"names":[],"mappings":";;;AAAA,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,IAAY,EAAU,GAAU;QAC1C,KAAK,CAAC,oCAAoC,IAAI,EAAE,CAAC,CAAC;QADlB,QAAG,GAAH,GAAG,CAAO;IAE5C,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;IACxB,CAAC;CACF;AARD,0CAQC"}

package/dist/harmony-config/harmony-config.d.ts

@@ -0,0 +1,17 @@
+export type ConfigOptions = {
+    cwd?: string;
+    global?: GlobalConfigOpts;
+    shouldThrow?: boolean;
+};
+export type GlobalConfigOpts = {
+    dir?: string;
+    name: string;
+};
+export declare class HarmonyConfig {
+    private raw;
+    constructor(raw: Record<string, any>);
+    toObject(): Record<string, any>;
+    toString(): string;
+    static load(fileName: string, opts?: ConfigOptions): HarmonyConfig;
+    static loadGlobal(globalOpts: GlobalConfigOpts, config?: any): HarmonyConfig;
+}

package/dist/harmony-config/harmony-config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyConfig = void 0;
+const comment_json_1 = require("comment-json");
+const path_1 = require("path");
+const config_reader_1 = require("./config-reader");
+const userHome = require('user-home');
+const defaultConfig = {
+    cwd: process.cwd(),
+    shouldThrow: true,
+};
+class HarmonyConfig {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    toObject() {
+        return this.raw;
+    }
+    toString() {
+        return (0, comment_json_1.stringify)(this.raw);
+    }
+    static load(fileName, opts) {
+        const mergedOpts = Object.assign(defaultConfig, opts);
+        const config = (0, config_reader_1.readConfigFile)((0, path_1.join)(mergedOpts.cwd, fileName), mergedOpts.shouldThrow);
+        if (mergedOpts.global) {
+            return HarmonyConfig.loadGlobal(mergedOpts.global, config);
+        }
+        return new HarmonyConfig(config);
+    }
+    static loadGlobal(globalOpts, config = {}) {
+        const globalConfig = (0, config_reader_1.readConfigFile)((0, path_1.join)(globalOpts.dir || userHome, globalOpts.name), false);
+        return new HarmonyConfig((0, comment_json_1.assign)(config, globalConfig));
+    }
+}
+exports.HarmonyConfig = HarmonyConfig;
+//# sourceMappingURL=harmony-config.js.map

package/dist/harmony-config/harmony-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harmony-config.js","sourceRoot":"","sources":["../../harmony-config/harmony-config.ts"],"names":[],"mappings":";;;AAAA,+CAAiD;AACjD,+BAA4B;AAC5B,mDAAiD;AAEjD,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;AAatC,MAAM,aAAa,GAAG;IACpB,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;IAClB,WAAW,EAAE,IAAI;CAClB,CAAC;AAEF,MAAa,aAAa;IACxB,YAAoB,GAAwB;QAAxB,QAAG,GAAH,GAAG,CAAqB;IAAG,CAAC;IAEhD,QAAQ;QACN,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,QAAQ;QACN,OAAO,IAAA,wBAAS,EAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,QAAgB,EAAE,IAAoB;QAChD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,IAAA,8BAAc,EAAC,IAAA,WAAI,EAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;QAEtF,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YACtB,OAAO,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,UAA4B,EAAE,SAAc,EAAE;QAC9D,MAAM,YAAY,GAAG,IAAA,8BAAc,EAAC,IAAA,WAAI,EAAC,UAAU,CAAC,GAAG,IAAI,QAAQ,EAAE,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;QAC9F,OAAO,IAAI,aAAa,CAAC,IAAA,qBAAM,EAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IACzD,CAAC;CACF;AA1BD,sCA0BC"}

package/dist/harmony-config/index.d.ts

@@ -0,0 +1 @@
+export { HarmonyConfig as Config, ConfigOptions } from './harmony-config';

package/dist/harmony-config/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+var harmony_config_1 = require("./harmony-config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return harmony_config_1.HarmonyConfig; } });
+//# sourceMappingURL=index.js.map

package/dist/harmony-config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../harmony-config/index.ts"],"names":[],"mappings":";;;AAAA,mDAA0E;AAAjE,wGAAA,aAAa,OAAU"}

package/dist/harmony-config/locator.js

@@ -0,0 +1 @@
+//# sourceMappingURL=locator.js.map

package/dist/harmony-config/locator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locator.js","sourceRoot":"","sources":["../../harmony-config/locator.ts"],"names":[],"mappings":""}

package/dist/harmony.d.ts

@@ -0,0 +1,63 @@
+import 'reflect-metadata';
+import ExtensionGraph, { DependencyGraphOptions } from './extension-graph/extension-graph';
+import { Extension, ExtensionManifest } from './extension';
+import { Config } from './config';
+import { Aspect } from './aspect';
+import { Runtimes } from './runtimes/runtimes';
+import { RuntimeDefinition } from './runtimes/runtime-definition';
+export type GlobalConfig = {
+    [key: string]: object;
+};
+export type RequireFn = (aspect: Extension, runtime: RuntimeDefinition) => Promise<void>;
+export declare class Harmony {
+    /**
+     * extension graph
+     */
+    readonly graph: ExtensionGraph;
+    /**
+     * harmony top level config
+     */
+    readonly config: Config;
+    readonly runtimes: Runtimes;
+    readonly activeRuntime: string;
+    private depOptions;
+    constructor(
+    /**
+     * extension graph
+     */
+    graph: ExtensionGraph, 
+    /**
+     * harmony top level config
+     */
+    config: Config, runtimes: Runtimes, activeRuntime: string, depOptions: DependencyGraphOptions);
+    current: string | null;
+    private runtime;
+    /**
+     * list all registered extensions
+     */
+    get extensions(): Map<string, Extension>;
+    /**
+     * list all registered extensions ids
+     */
+    get extensionsIds(): string[];
+    /**
+     * load an Aspect into the dependency graph.
+     */
+    load(extensions: ExtensionManifest[]): Promise<void>;
+    /**
+     * set extensions during Harmony runtime.
+     * hack!
+     */
+    set(extensions: ExtensionManifest[]): Promise<void>;
+    private runOne;
+    getDependencies(aspect: Extension): Extension[];
+    initExtension(id: string): void;
+    endExtension(): void;
+    /**
+     * get an extension from harmony.
+     */
+    get<T>(id: string): T;
+    resolveRuntime(name: string): RuntimeDefinition;
+    run(requireFn?: RequireFn): Promise<void>;
+    static load(aspects: Aspect[], runtime: string, globalConfig: GlobalConfig, options?: DependencyGraphOptions): Promise<Harmony>;
+}

package/dist/harmony.docs.mdx

@@ -0,0 +1,250 @@
+---
+description: Harmony is an abstract extension system you can use to make any software extendable and composable. It is the engine that drives Bit extensibility and composability.
+labels: ['aspect', 'composition', 'extendability']
+---
+
+## Basic features
+
+Harmony allows you to implement Aspects as the main building blocks that compose your software. Each Aspect has:
+
+* Dependency declaration - Where you declare other Aspects as dependencies.
+* Dependency injection - An Aspect gets providers for all its dependencies.
+* Slots - An easy way for an Aspect to provide API for another aspect to hook into any of its processes.
+* Multiple runtimes - Aspect can annotate in which runtimes it can run (for example providing functionality to run on the server and on the browser).
+
+## Harmony config file
+
+Use a config file to describe your desired composition of Aspects and their configuration. Harmony uses a basic JSON syntax, where each key is an aspect.
+
+```json
+{
+  "teambit.dependencies/dependency-resolver": {}, // load an Aspect without providing configuration
+  "teambit.workspace/workspace": {                // Load an Aspect with configuration
+    "name": "bit",
+    "icon": "https://static.bit.dev/bit-logo.svg",
+}
+```
+
+## Define an aspect
+
+Harmony Aspect is  an object that implements the `ExtensionManifest` interface
+
+```js
+export type ExtensionManifest = {
+  /**
+   * Aspect's name.
+   */
+  name: string;
+
+  /**
+   * Aspect unique ID.
+   */
+  id?: string;
+
+  /**
+   * Array of dependencies.
+   * These other Aspects to be installed and resolved prior to this Aspect activation.
+   */
+  dependencies?: ExtensionManifest[];
+
+  /**
+   * Reference to the Aspect factory function.
+   */
+  provider?: ProviderFn;
+
+  /**
+   * Default Aspect configuration. 
+   */
+  defaultConfig?: object;
+
+  /**
+   * Alias to the provider.
+   */
+  provide?: ProviderFn;
+
+  /**
+   * Array of slots the Aspect exposes.
+   */
+  slots?: SlotProvider<unknown>[],
+
+  /**
+   * Additional keys which might be expected by other Aspects.
+   */
+  [key: string]: any;
+}
+```
+
+## Programmatic API
+
+### Static API
+
+```js
+// Create instance of harmony with the provided aspects, on specific runtime, with provided config
+static async load(aspects: Aspect[], runtime: string, globalConfig: GlobalConfig) {
+```
+
+### Instance API
+
+```js
+// load an Aspect into the dependency graph
+async load(extensions: ExtensionManifest[])
+
+// set extensions during Harmony runtime.
+async set(extensions: ExtensionManifest[])
+
+export type RequireFn = (aspect: Extension, runtime: RuntimeDefinition) => Promise<void>;
+
+// Start harmony. 
+// The require function is a function that get's the aspect and its runtime, and knows to require/load it
+async run(requireFn?: RequireFn) 
+```
+
+## Assumptions
+
+* Harmony does not allow circular dependencies between Aspects.
+
+{/*
+
+-------------------------for reference only - to remove ------------------
+
+## composition model
+Harmony proposes a graph composition model.
+composition model should allow:
+
+- full control over composition including dependency composition.
+- easy overrides mechanism for configs.
+- full encapsulation of an extension. 
+
+bit.config.js
+```js
+import FlowSchemaPlugin from '@bit/plugins.flow-schema';
+
+export default () => {
+  return [ // returns an array of PluginInstance
+    [FlowSchemaPlugin, {
+
+    }],
+    [ReactSchemaPlugin, {
+      eslintrc: './.eslintrc'
+    }]
+  ];
+}
+```
+
+configured extensions in bit.json
+```json
+{
+  "extensions": {
+    "bit.envs/eslint@0.0.4": {
+      "eslintrc": "./.eslintrc"
+    },
+    "bit.envs/babel@0.0.1": {
+      "babelrc": "./.babelrc",
+      "strict": true,
+      "__alias": "compile"
+    },
+    "bit.envs/webpack@0.0.1": {
+      "config": "./webpack.config.js",
+      "mode": "prod",
+      "__alias": "bundle"
+    },
+    "bit.envs/mocha@0.0.1": {
+      "reporter": "json",
+      "mochaOptions": "./mocha.opts",
+      "__alias": "test-mocha"
+    }
+  },
+  "pipes": {
+    "tag": [""]
+  },
+  "dist": {
+    "target": "",
+    "entry": ""
+  }
+}
+```
+
+### Open questions
+- How do I install a Bit extensions? Where the component is configured?
+- Is the extension installed with Bit/NPM?
+- What's the impl. behind `bit use <plugin/extension name>`
+- maybe an composition model can co-exist as json and js? what are the tradeoffs?
+
+## extension registration
+```js
+import { register } from 'harmony';
+import { DocGen } from '@bit/bit.exts.doc-gen';
+
+const extensions = register([DocGen]);
+```
+
+## lifecycle event invocation
+
+```js
+import { invoke } from 'harmony';
+
+invoke('tag', ...data);
+```
+
+## lifecycle event registration
+```js
+import { Lifecycle } from 'harmony';
+
+@Lifecycle(Tag);
+function tag() {
+  
+}
+```
+
+## state / schema management
+```ts
+@Lifecycle(Tag)
+function tag(component: Component) {
+  const docs = component.get('docs'); // returns `Maybe` type?
+  const docs: Docs = docs.get();
+}
+```
+
+## function extension 
+
+```js
+export default function foo() {
+  context.a
+}
+```
+
+## configuration
+an extension can declaratively ask for configuration type. this can be reflected
+- extensions can be configured during instantiation.
+- configuration types can be built from multiple sources
+
+## context
+- standard context can be shared between all extensions in the same instance.
+
+## extension composition
+- hook invocation from an extension
+- extension dependencies? how can an extension declare a dependency as part of its execution? 
+- contextual/namespaced hooks
+- config api
+
+## extension resolution
+```js
+import { resolve } from 'harmony';
+
+const extension = resolve('doc-gen');
+```
+
+## Questions (?)
+- can extensions be added/configured during runtime? DI
+- is there a difference between extension composition to registration?
+- how to make autocomplete work for hooks?
+- how to avoid unintentional hook invocation (decorators?) 
+- how to declare a new hook..
+- schema validator
+- dev experience of an extension.
+- how do manage different runtime environments? should I? Why is that relevant?
+- runtime capsules?
+- how can one extension run from both server and client? how capsule is related?
+- in which process extensions will run from? also, what will happen from the backend?
+- 
+*/}

package/dist/harmony.js

@@ -0,0 +1,151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Harmony = void 0;
+require("reflect-metadata");
+const extension_graph_1 = __importDefault(require("./extension-graph/extension-graph"));
+const exceptions_1 = require("./exceptions");
+const utils_1 = require("./utils");
+const config_1 = require("./config");
+const runtimes_1 = require("./runtimes/runtimes");
+const exceptions_2 = require("./runtimes/exceptions");
+class Harmony {
+    constructor(
+    /**
+     * extension graph
+     */
+    graph, 
+    /**
+     * harmony top level config
+     */
+    config, runtimes, activeRuntime, depOptions) {
+        this.graph = graph;
+        this.config = config;
+        this.runtimes = runtimes;
+        this.activeRuntime = activeRuntime;
+        this.depOptions = depOptions;
+        this.current = null;
+    }
+    /**
+     * list all registered extensions
+     */
+    get extensions() {
+        return this.graph.nodes;
+    }
+    /**
+     * list all registered extensions ids
+     */
+    get extensionsIds() {
+        return [...this.graph.nodes.keys()];
+    }
+    /**
+     * load an Aspect into the dependency graph.
+     */
+    load(extensions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.set(extensions);
+        });
+    }
+    /**
+     * set extensions during Harmony runtime.
+     * hack!
+     */
+    set(extensions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.graph.load(extensions);
+            // Only load new extensions and their dependencies
+            const extensionsToLoad = extensions.map((ext) => {
+                // @ts-ignore
+                return Reflect.getMetadata('harmony:name', ext) || ext.id || ext.name;
+            });
+            // @ts-ignore
+            yield this.graph.enrichRuntime(this.runtime, this.runtimes, () => { });
+            // @ts-ignore
+            const subgraphs = this.graph.successorsSubgraph(extensionsToLoad);
+            if (subgraphs) {
+                const executionOrder = subgraphs.toposort(true);
+                yield (0, utils_1.asyncForEach)(executionOrder, (ext) => __awaiter(this, void 0, void 0, function* () {
+                    if (!this.runtime)
+                        throw new exceptions_2.RuntimeNotDefined(this.activeRuntime);
+                    yield this.runOne(ext, this.runtime);
+                }));
+            }
+        });
+    }
+    runOne(extension, runtime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (extension.loaded)
+                return;
+            // create an index of all vertices in dependency graph
+            const deps = this.graph.getRuntimeDependencies(extension, runtime, this.depOptions);
+            const instances = deps.map(extension => extension.instance);
+            try {
+                return extension.__run(instances, this, runtime);
+            }
+            catch (err) {
+                throw new exceptions_1.ExtensionLoadError(extension, err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    getDependencies(aspect) {
+        if (!this.runtime)
+            throw new exceptions_2.RuntimeNotDefined(this.activeRuntime);
+        return this.graph.getRuntimeDependencies(aspect, this.runtime, this.depOptions);
+    }
+    initExtension(id) {
+        this.current = id;
+    }
+    endExtension() {
+        this.current = null;
+    }
+    /**
+     * get an extension from harmony.
+     */
+    get(id) {
+        const extension = this.graph.get(id);
+        if (!extension || !extension.instance)
+            throw new Error(`failed loading extension ${id}`);
+        return extension.instance;
+    }
+    resolveRuntime(name) {
+        return this.runtimes.get(name);
+    }
+    run(requireFn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runtime = this.resolveRuntime(this.activeRuntime);
+            this.runtime = runtime;
+            const defaultRequireFn = (aspect, runtime) => __awaiter(this, void 0, void 0, function* () {
+                const runtimeFile = runtime.getRuntimeFile(aspect.files);
+                if (!runtimeFile)
+                    return;
+                // runtime.require(runtimeFile);
+            });
+            // requireFn ? await requireFn(aspect, runtime) : defaultRequireFn(this.graph);
+            yield this.graph.enrichRuntime(runtime, this.runtimes, requireFn || defaultRequireFn, this.depOptions);
+            const executionOrder = this.graph.byExecutionOrder();
+            yield (0, utils_1.asyncForEach)(executionOrder, (ext) => __awaiter(this, void 0, void 0, function* () {
+                yield this.runOne(ext, runtime);
+            }));
+        });
+    }
+    static load(aspects_1, runtime_1, globalConfig_1) {
+        return __awaiter(this, arguments, void 0, function* (aspects, runtime, globalConfig, options = {}) {
+            const aspectGraph = extension_graph_1.default.from(aspects, options);
+            const runtimes = yield runtimes_1.Runtimes.load(aspectGraph);
+            return new Harmony(aspectGraph, config_1.Config.from(globalConfig), runtimes, runtime, options);
+        });
+    }
+}
+exports.Harmony = Harmony;
+//# sourceMappingURL=harmony.js.map