@teambit/harmony 0.0.0-19ea14143ef7d5f4e4daa6e8ac8a8c97c9d683d5

package/harmony.spec.old.ts

@@ -0,0 +1,177 @@
+import { Harmony } from './harmony';
+// import { BitExt } from '../../bit/dist/extensions/bit';
+// import { BaseCompiler } from './fixtures/base-compiler';
+// import { TypeScript } from './fixtures/typescript/typescript';
+// import { Babel } from './fixtures/babel/babel.extension';
+// import { Slot, SlotRegistry } from './slots';
+// import { start } from 'repl';
+// import { ExtensionManifest } from './extension';
+import { ReactAspect } from './fixtures/aspects/react/react.aspect';
+import { ReactCLI } from './fixtures/aspects/react/react.cli';
+import { ReactUI } from './fixtures/aspects/react/react.ui';
+
+describe('Harmony', () => {
+  describe('run()', () => {
+  //   it('should return a string', async () => {
+  //     const manifest = {
+  //       name: 'HelloWorld',
+  //       provider: async () => 'hello world'
+  //     };
+  //     await harmony.run(manifest);
+  //     expect(harmony.get('HelloWorld')).eql('hello world');
+  //   });
+
+  //   it('should load an array of different extensions', async () => {
+  //     await harmony.run([BaseCompiler, TypeScript]);
+  //     const compiler = harmony.get<BaseCompiler>('BaseCompiler')
+  //     const typescript = harmony.get<TypeScript>('typescript')      
+
+  //     expect(typescript.compile()).to.eq('hello world');
+  //     expect(compiler.compile()).to.eq('hello world');
+  //   });
+
+  //   it('should load extensions with slots', async () => {
+  //     class Env {
+  //       build () {
+  //         return 'react built';
+  //       }
+  //     }
+
+  //     it('extension instance should include an ID', async () => {
+  //       const React = { 
+  //         name: '@teambit/react', 
+  //         dependencies: [],
+  //         provide: async () => {} 
+  //       };      
+  
+  //       await harmony.run([React]);
+  //       const react = harmony.get<any>(React.name);  
+  //       expect(react.id).to.eq(React.name);
+  //     });
+
+  //     const Envs: ExtensionManifest = { 
+  //       name: '@teambit/envs', 
+  //       slots: [Slot.withType<Env>()],
+  //       provider: async ([], config: {env: string}, [envSlot]: [SlotRegistry<Env>]) => {
+  //         return {
+  //           register: (env: Env) => {
+  //             envSlot.register(env);
+  //           },
+
+  //           start() {
+  //             const instance = envSlot.get(config.env);
+  //             if (!instance) throw new Error('could not find envs');
+  //             return instance.build();
+  //           }
+  //         };
+  //       }
+  //     };
+
+  //     const React = { 
+  //       name: '@teambit/react', 
+  //       dependencies: [Envs],
+  //       provide: async ([envs]: [{ register: (env: Env) => void }], config: {}) => {
+  //         envs.register(new Env());
+  //       } 
+  //     };      
+
+  //     const harmony = Harmony.load([Envs, React], {
+  //       '@teambit/envs': {
+  //         env: '@teambit/react'
+  //       }
+  //     });
+
+  //     await harmony.run([Envs, React]);
+
+  //     const envs = harmony.get<any>(Envs.name);
+  //     expect(envs.start()).to.eq('react built');
+  //   });
+
+  //   it('should load extensions with config', async () => {
+  //     const e1 = { 
+  //       name: '@teambit/typescript', 
+
+  //       provider: async ([], config: { declarations: boolean }) => {
+  //         return {
+  //           get: () => {
+  //             return config.declarations || false
+  //           }
+  //         };
+  //       }
+  //     };
+
+  //     const e2 = { name: '@teambit/react', defaultConfig: {ts: false}, provide: async ([], config: any) => {
+  //        return {
+  //          config: config.ts
+  //        };
+  //       } 
+  //     };
+
+  //     const harmony = Harmony.load([e1], {
+  //       '@teambit/typescript': {
+  //         declarations: true
+  //       },
+  //     });
+  //     await harmony.run([e1]);
+
+  //     const ts = harmony.get<{get: () => {}}>('@teambit/typescript');
+  //     expect(ts.get()).to.eq(true);
+
+  //     harmony.config.set('@teambit/react', {ts: true});
+  //     await harmony.set([e2]);
+  //     const react = harmony.get<{[key: string]: object}>('@teambit/react');
+  //     expect(react.config).to.eq(true);
+  //   });
+  
+  //   it('should invoke a class extension method', async () => {
+  //     await harmony.run(BaseCompiler);
+  //     const compiler = harmony.get<BaseCompiler>('BaseCompiler')
+  //     expect(compiler.compile()).to.eq('hello world');
+  //   });
+
+  //   it('should invoke a class extension with configured dependencies', async () => {
+  //     await harmony.run(TypeScript);
+  //     const typescript = harmony.get<TypeScript>('typescript')      
+  //     expect(typescript.compile()).to.eq('hello world');
+  //   });
+
+  //   it('should use prefer id over name', async () => {
+  //     const dependency = {
+  //       name: 'dependencyName',
+  //       id: 'dependencyId',
+  //       provider: async () => 'hello world'
+  //     };
+  //     const dependent = {
+  //       name: 'dependentName',
+  //       id: 'dependentId',
+  //       dependencies: [dependency],
+  //       provider: async () => 'hello world'
+  //     };
+  //     await harmony.run(dependent);
+  //     const ids = harmony.extensionsIds;  
+  //     expect(ids).to.contain('dependencyId');
+  //     expect(ids).to.contain('dependentId');
+  //   });
+
+  //   it('should execute bit core extension graph', async () => {
+  //     // const bit = await Harmony.run(BitExt);
+  //   });
+
+  //   it('should register during run', async () => {
+  //     const compiler = await harmony.run(Babel);
+  //   });
+
+    // it('should execute an aspect in the cli runtime', async() => {
+    //   const harmony = await Harmony.load([ReactAspect], 'cli', {});
+    //   await harmony.run();
+    //   const react = harmony.get<ReactCLI>('@teambit/react');
+    // })
+
+    // it('should execute an aspect in the ui runtime', async() => {
+    //   const harmony = await Harmony.load([ReactAspect], 'ui', {});
+    //   await harmony.run();
+    //   const react = harmony.get<ReactUI>('@teambit/react');
+    //   expect(react.render()).toBeTruthy;
+    // })
+  });
+});

package/harmony.ts

@@ -0,0 +1,148 @@
+import 'reflect-metadata';
+import ExtensionGraph, { DependencyGraphOptions } from './extension-graph/extension-graph';
+import { ExtensionLoadError } from './exceptions';
+import { Extension, ExtensionManifest } from './extension';
+import { asyncForEach } from './utils';
+import { Config } from './config';
+import { Aspect } from './aspect';
+import { Runtimes } from './runtimes/runtimes';
+import { RuntimeDefinition } from './runtimes/runtime-definition';
+import { RuntimeNotDefined } from './runtimes/exceptions';
+
+export type GlobalConfig = {
+  [key: string]: object
+};
+
+export type RequireFn = (aspect: Extension, runtime: RuntimeDefinition) => Promise<void>;
+
+export class Harmony {
+  constructor(
+    /**
+     * extension graph
+     */
+    readonly graph: ExtensionGraph,
+
+    /**
+     * harmony top level config
+     */
+    readonly config: Config,
+
+    readonly runtimes: Runtimes,
+
+    readonly activeRuntime: string,
+
+    private depOptions: DependencyGraphOptions
+  ) {}
+
+  public current: string|null = null;
+
+  private runtime: RuntimeDefinition | undefined;
+
+  /**
+   * 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.
+   */
+  async load(extensions: ExtensionManifest[]) {
+    return this.set(extensions);
+  }
+
+  /**
+   * set extensions during Harmony runtime.
+   * hack!
+   */
+  async set(extensions: ExtensionManifest[]) {
+    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
+    await this.graph.enrichRuntime(this.runtime, this.runtimes, () => {});
+    // @ts-ignore
+    const subgraphs = this.graph.successorsSubgraph(extensionsToLoad);
+    if (subgraphs) {
+      const executionOrder = subgraphs.toposort(true);
+      await asyncForEach(executionOrder, async (ext: Extension) => {
+        if (!this.runtime) throw new RuntimeNotDefined(this.activeRuntime);
+        await this.runOne(ext, this.runtime);
+      });
+    }
+  }
+
+  private async runOne(extension: Extension, runtime: RuntimeDefinition) {
+    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 ExtensionLoadError(extension, err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+
+  getDependencies(aspect: Extension) {
+    if (!this.runtime) throw new RuntimeNotDefined(this.activeRuntime);
+    return this.graph.getRuntimeDependencies(aspect, this.runtime, this.depOptions);
+  }
+
+  initExtension(id: string) {
+    this.current = id;
+  }
+
+  endExtension() {
+    this.current = null;
+  }
+
+  /**
+   * get an extension from harmony.
+   */
+  get<T>(id: string): T {
+    const extension = this.graph.get(id);
+    if (!extension || !extension.instance) throw new Error(`failed loading extension ${id}`);
+    return extension.instance;
+  }
+
+  resolveRuntime(name: string): RuntimeDefinition {
+    return this.runtimes.get(name);
+  }
+
+  async run(requireFn?: RequireFn) {
+    const runtime = this.resolveRuntime(this.activeRuntime);
+    this.runtime = runtime;
+    const defaultRequireFn: RequireFn = async (aspect: Extension, runtime: RuntimeDefinition) => {
+      const runtimeFile = runtime.getRuntimeFile(aspect.files);
+      if (!runtimeFile) return;
+      // runtime.require(runtimeFile);
+    };
+    // requireFn ? await requireFn(aspect, runtime) : defaultRequireFn(this.graph);
+    await this.graph.enrichRuntime(runtime, this.runtimes, requireFn || defaultRequireFn, this.depOptions);
+    
+    const executionOrder = this.graph.byExecutionOrder();
+    await asyncForEach(executionOrder, async (ext: Extension) => {
+      await this.runOne(ext, runtime);
+    });
+  }
+  
+  static async load(aspects: Aspect[], runtime: string, globalConfig: GlobalConfig, options: DependencyGraphOptions = {}) {
+    const aspectGraph = ExtensionGraph.from(aspects as any, options);
+    const runtimes = await Runtimes.load(aspectGraph);
+    return new Harmony(aspectGraph, Config.from(globalConfig), runtimes, runtime, options);
+  }
+}

package/index.ts

@@ -0,0 +1,13 @@
+export { ExtensionDecorator, Extension, register, HookRegistry, hook, provider, createHook } from './extension';
+export { Harmony, GlobalConfig } from './harmony';
+export { Slot, SlotRegistry } from './slots';
+export { ProviderFn } from './types';
+export { ExtensionManifest } from './extension/extension-manifest';
+export { HarmonyError } from './exceptions/harmony-error';
+export { Aspect } from './aspect';
+export { RuntimeDefinition, RuntimeManifest } from './runtimes';
+export { default as AspectGraph } from './extension-graph/extension-graph';
+// `Config` / `ConfigOptions` are not re-exported from the root because they
+// pull in node-only modules and would break browser bundles. They are exposed
+// via the subpath `@teambit/harmony/harmony-config` with a `node` exports
+// condition — see this component's `packageJson.exports` in component.json.

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@teambit/harmony",
+  "version": "0.0.0-19ea14143ef7d5f4e4daa6e8ac8a8c97c9d683d5",
+  "homepage": "https://bit.cloud/teambit/harmony/harmony",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.harmony",
+    "name": "harmony",
+    "version": "19ea14143ef7d5f4e4daa6e8ac8a8c97c9d683d5"
+  },
+  "dependencies": {
+    "reflect-metadata": "0.1.14",
+    "comment-json": "4.2.5",
+    "user-home": "3.0.0",
+    "cleargraph": "5.8.0"
+  },
+  "devDependencies": {
+    "@types/comment-json": "^2.4.5",
+    "@types/jest": "26.0.20",
+    "@types/node": "22.10.5"
+  },
+  "peerDependencies": {},
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "private": false,
+  "engines": {
+    "node": ">=12.22.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/harmony"
+  },
+  "description": "abstract extension system",
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "components",
+    "collaboration",
+    "harmony",
+    "aspects",
+    "extensions"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "node": {
+        "require": "./dist/index.js",
+        "import": "./dist/esm.mjs"
+      },
+      "default": "./dist/index.js"
+    },
+    "./harmony-config": {
+      "node": {
+        "types": "./dist/harmony-config/index.d.ts",
+        "default": "./dist/harmony-config/index.js"
+      }
+    },
+    "./harmony-config/config-reader": {
+      "node": {
+        "types": "./dist/harmony-config/config-reader.d.ts",
+        "default": "./dist/harmony-config/config-reader.js"
+      }
+    },
+    "./dist/harmony-config": "./dist/harmony-config/index.js",
+    "./dist/harmony-config/config-reader": "./dist/harmony-config/config-reader.js"
+  }
+}

package/readme.md

@@ -0,0 +1,80 @@
+# Harmony
+Harmony is the engine that drives Bit extensibility and composability.
+It's an abstract extension system indended to make any software extendable and composable.
+
+Harmony takes a "micro-kernel" approach and implements the near-minimum amount of software required to build any JavaScript system from independent components through composition.
+
+## Installation
+```bash
+$ bit install @teambit/harmony
+```
+
+## Quick start
+```ts
+import { Harmony, Extension } from 'harmony';
+
+@Extensioin
+class Person {
+  sayHello(name = 'world') {
+    return `hello ${name}!`;
+  }
+}
+
+const person = Harmony.load(Person); 
+helloWorld.sayHello(); // returns 'hello world!'
+```
+
+## Component composition
+
+### DI
+```ts
+class Dude {
+  constructor(
+    private person: Person
+  ) {}
+
+  sayHello() {
+    return this.person.sayHello('dude');
+  }
+};
+
+Harmony.load([Dude]).sayHello(); // echos 'hello dude!'
+```
+
+### Hooks
+```ts
+@Extension()
+class CLI {
+  // @hook('command') commands = Hook.create<Command>();
+  static command() {
+    return Hook.create<Command>();
+  }
+
+  run() {
+    const allCommands = this.commands.list(); // outputs all hook subscribers
+  }
+} 
+
+@Extension()
+class Compiler {
+  
+  @command()
+  main() {
+    return {
+      synopsis: 'compile <path>',
+      render: () => <Box></Box>
+    };
+  }
+}
+```
+
+## Extension configuration
+
+## Extension metadata
+
+## API reference
+
+## License
+Apache License, Version 2.0
+
+Made with ❤ to open software by Team Bit.

package/runtimes/exceptions/index.ts

@@ -0,0 +1,2 @@
+export { RuntimeNotDefined } from './runtime-not-defined';
+export { RuntimeModuleError } from './runtime-module-error';

package/runtimes/exceptions/runtime-module-error.ts

@@ -0,0 +1,9 @@
+export class RuntimeModuleError extends Error {
+  constructor(
+    private err: Error
+  ) { super(`failed to load Harmony aspect with error message: ${err.message}`) }
+
+  get stack() {
+    return this.err.stack;
+  }
+}

package/runtimes/exceptions/runtime-not-defined.ts

@@ -0,0 +1,5 @@
+export class RuntimeNotDefined extends Error {
+  constructor(
+    name: string
+  ) { super(`runtime: '${name}' was not defined by any aspect`) }
+}

package/runtimes/index.ts

@@ -0,0 +1,3 @@
+export { RuntimeManifest } from './runtime-manifest';
+export { Runtimes } from './runtimes';
+export { RuntimeDefinition } from './runtime-definition';

package/runtimes/runtime-definition.ts

@@ -0,0 +1,32 @@
+import { RuntimeModuleError } from './exceptions';
+
+export type RuntimeDefProps = {
+  name: string
+};
+
+const DEFAULT_PREDICATE = (filePath: string, name: string) => {
+  return filePath.includes(`.${name}.`);
+}
+
+export class RuntimeDefinition {
+  constructor(
+    readonly name: string,
+    readonly filePredicate: (filePath: string, name: string) => boolean = DEFAULT_PREDICATE
+  ) {}
+
+  getRuntimeFile(paths: string[]): string|undefined {
+    return paths.find(path => this.filePredicate(path, this.name));
+  }
+
+  require(file: string) {
+    // try {
+    //   require(file);
+    // } catch(err) {
+    //   throw new RuntimeModuleError(err);
+    // }
+  }
+
+  static create(def: RuntimeDefProps) {
+    return new RuntimeDefinition(def.name);
+  }
+}

package/runtimes/runtime-manifest.ts

@@ -0,0 +1,12 @@
+import { RuntimeDefinition } from './runtime-definition';
+import { ProviderFn } from '../types';
+import { Aspect } from '../aspect';
+import { SlotProvider } from '../slots';
+
+export interface RuntimeManifest {
+  runtime: RuntimeDefinition|string
+  provider: ProviderFn,
+  dependencies?: Aspect[],
+  slots?: SlotProvider<unknown>[],
+  defaultConfig?: {[key: string]: any},
+}

package/runtimes/runtimes.ts

@@ -0,0 +1,34 @@
+import { RuntimeDefinition } from './runtime-definition';
+import DependencyGraph from '../extension-graph/extension-graph';
+import { RuntimeNotDefined } from './exceptions';
+
+export class Runtimes {
+  constructor(
+    readonly runtimeDefinition: {[key: string]: RuntimeDefinition}
+  ) {}  
+
+  add(runtime: RuntimeDefinition) {
+    this.runtimeDefinition[runtime.name] = runtime;
+    return this;
+  }
+
+  get(name: string): RuntimeDefinition {
+    const runtime = this.runtimeDefinition[name];
+    if (!runtime) throw new RuntimeNotDefined(name);
+    return this.runtimeDefinition[name];
+  }
+
+  dispose() {
+
+  }
+
+  static async load(graph: DependencyGraph) {
+    const runtimes: { [key: string]: RuntimeDefinition } = {};
+    graph.extensions.forEach(manifest => {
+      if (!manifest.declareRuntime) return;
+      runtimes[manifest.declareRuntime.name] = manifest.declareRuntime;
+    });
+
+    return new Runtimes(runtimes);
+  }
+}

package/slots/index.ts

@@ -0,0 +1,2 @@
+export { Slot, SlotProvider } from './slot';
+export { SlotRegistry } from './registry';

package/slots/registry.ts

@@ -0,0 +1,36 @@
+
+export class SlotRegistry<T> {
+  constructor(
+    private registerFn: () => string,
+    readonly map = new Map<string, T>()
+  ) {}
+
+  /**
+   * get a slot value by extension id.
+   */
+  get(id: string): T|undefined {
+    return this.map.get(id);
+  }
+
+  /**
+   * return an array of all slots.
+   */
+  toArray() {
+    return Array.from(this.map.entries());
+  }
+
+  /**
+   * get all registered values.
+   */
+  values() {
+    return Array.from(this.map.values());
+  }
+
+  /**
+   * register a new entry to the slot registry
+   */
+  register(value: T) {
+    const id = this.registerFn();
+    this.map.set(id, value);
+  }
+}

package/slots/slot.ts

@@ -0,0 +1,11 @@
+import { SlotRegistry } from './registry';
+
+export class Slot {
+  static withType<T>() {
+    return (registerFn: () => string) => {
+      return new SlotRegistry<T>(registerFn);
+    }
+  }
+}
+
+export type SlotProvider<T> = (registerFn: () => string) => SlotRegistry<T>;

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  const src: string;
+  export default src;
+}
+
+// @TODO Gilad
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}