react-obsidian 0.0.12 → 0.0.16

package/src/decorators/provides/MemoizeDescriptor.ts

@@ -2,12 +2,11 @@
 export function memoizeDescriptor(propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor {
   const originalValue = descriptor.value;
   descriptor.value = function value(...args: any[]) {
+    const memoizationTarget = Reflect.getMetadata('isSingleton', descriptor) ? descriptor : this;
     const key = `memoized${propertyKey}`;
-    if (Reflect.hasMetadata(key, this)) {
-      return Reflect.getMetadata(key, this);
-    }
+    if (Reflect.hasMetadata(key, memoizationTarget)) return Reflect.getMetadata(key, memoizationTarget);
     const result = originalValue.apply(this, args);
-    Reflect.defineMetadata(key, result, this);
+    Reflect.defineMetadata(key, result, memoizationTarget);
     return result;
   };
   return descriptor;

package/src/decorators/provides/Provides.ts

@@ -1,10 +1,8 @@
-import { Scope } from '../../types';
 import { Graph } from '../../graph/Graph';
 import providedPropertiesStore from '../../ProvidedPropertiesStore';
 import { memoizeDescriptor } from './MemoizeDescriptor';
 
 interface ProvidesParams {
-  scope?: Scope;
   name: string;
 }
 

package/src/graph/ObjectGraph.ts

@@ -1,13 +1,11 @@
 import { uniqueId } from 'lodash';
 import Memoize from '../decorators/Memoize';
-import { Scope } from '../types';
 import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
+import { Constructable } from '../types';
 
 export abstract class ObjectGraph<T = unknown> implements Graph {
-  // TODO? rename scope to singleInstance
-  public scope!: Scope;
   private propertyRetriever = new PropertyRetriever(this);
 
   @Memoize()
@@ -23,3 +21,9 @@ export abstract class ObjectGraph<T = unknown> implements Graph {
     return this.propertyRetriever.retrieve(property, receiver) as Dependency | undefined;
   }
 }
+
+Reflect.set(ObjectGraph, 'typeDiscriminator', 'ObjectGraph');
+
+export function isGraph(object: Constructable<ObjectGraph> | any): object is Constructable<ObjectGraph> {
+  return Reflect.get(object, 'typeDiscriminator') === 'ObjectGraph';
+}

package/src/graph/ProviderBinder.ts

@@ -4,9 +4,8 @@ import { Graph } from './Graph';
 
 export function bindProviders(graph: Graph & Record<string, any>) {
   providedPropertiesStore.getMangledProperties(graph)
+    .filter((method) => graph[method])
     .forEach((method) => {
-      if (graph[method] !== undefined) {
-        graph[method] = graph[method].bind(graph);
-      }
+      graph[method] = graph[method].bind(graph);
     });
 }

package/src/graph/registry/GraphRegistry.ts

@@ -1,61 +1,63 @@
-import { Constructable, Scope } from '../../types';
+import { Constructable } from '../../types';
 import { Graph } from '../Graph';
 import { Middleware } from './Middleware';
 import GraphMiddlewareChain from './GraphMiddlewareChain';
 
-class GraphRegistry {
-  private readonly scopedGraphs: Record<Scope, Constructable<Graph>> = {};
-  private readonly constructorToInstance = new Map<Constructable<Graph>, Graph>();
+export class GraphRegistry {
+  private readonly constructorToInstance = new Map<Constructable<Graph>, Set<Graph>>();
   private readonly instanceToConstructor = new Map<Graph, Constructable<Graph>>();
+  private readonly nameToInstance = new Map<string, Graph>();
   private readonly graphToSubgraphs = new Map<Constructable<Graph>, Set<Constructable<Graph>>>();
-  private graphMiddlewares = new GraphMiddlewareChain();
+  private readonly graphMiddlewares = new GraphMiddlewareChain();
 
-  register(
-    constructor: Constructable<Graph>,
-    scope: Scope | undefined = undefined,
-    subgraphs: Constructable<Graph>[] = [],
-  ) {
-    if (scope) this.scopedGraphs[scope] = constructor;
+  register(constructor: Constructable<Graph>, subgraphs: Constructable<Graph>[] = []) {
     this.graphToSubgraphs.set(constructor, new Set(subgraphs));
   }
 
-  has(Graph: Constructable<Graph>) {
-    return this.constructorToInstance.has(Graph);
-  }
-
-  get<T extends Graph>(Graph: Constructable<T>): T {
-    return this.constructorToInstance.get(Graph)! as unknown as T;
-  }
-
-  set(Graph: Constructable<Graph>, graph: Graph) {
-    this.constructorToInstance.set(Graph, graph);
-    this.instanceToConstructor.set(graph, Graph);
-  }
-
   getSubgraphs(graph: Graph): Graph[] {
     const Graph = this.instanceToConstructor.get(graph)!;
     const subgraphs = this.graphToSubgraphs.get(Graph) ?? new Set();
     return Array.from(subgraphs).map((G) => this.resolve(G));
   }
 
-  resolve<T extends Graph>(Graph: Constructable<T>, props?: any): T {
-    if (this.has(Graph)) {
-      return this.get(Graph);
-      // const graph: T = this.get(Graph);
-      // const scope = Reflect.getMetadata('scope', Graph);
-      // if (scope) return graph;
+  getGraphInstance(name: string): Graph {
+    return this.nameToInstance.get(name)!;
+  }
 
-      // this.set(Graph, new Graph(props));
+  resolve<T extends Graph>(Graph: Constructable<T>, props?: any): T {
+    if (this.isSingleton(Graph) && this.has(Graph)) {
+      return this.getFirst(Graph);
     }
     const graph = this.graphMiddlewares.resolve(Graph, props);
     this.set(Graph, graph);
     return graph as T;
   }
 
+  private has(Graph: Constructable<Graph>) {
+    return this.constructorToInstance.has(Graph);
+  }
+
+  private getFirst<T extends Graph>(Graph: Constructable<T>): T {
+    return this.constructorToInstance.get(Graph)!.values().next().value;
+  }
+
+  private set(Graph: Constructable<Graph>, graph: Graph) {
+    const graphs = this.constructorToInstance.get(Graph) ?? new Set();
+    graphs.add(graph);
+    this.constructorToInstance.set(Graph, graphs);
+    this.instanceToConstructor.set(graph, Graph);
+    this.nameToInstance.set(graph.name, graph);
+  }
+
+  private isSingleton(Graph: Constructable<Graph>): boolean {
+    return Reflect.getMetadata('isSingleton', Graph) ?? false;
+  }
+
   clear(graph: Graph) {
     const Graph = this.instanceToConstructor.get(graph)!;
     this.instanceToConstructor.delete(graph);
-    this.constructorToInstance.delete(Graph);
+    this.constructorToInstance.get(Graph)!.delete(graph);
+    this.nameToInstance.delete(graph.name);
   }
 
   addGraphMiddleware(middleware: Middleware<Graph>) {
@@ -65,6 +67,12 @@ class GraphRegistry {
   clearGraphMiddlewares() {
     this.graphMiddlewares.clear();
   }
+
+  reset() {
+    this.instanceToConstructor.clear();
+    this.constructorToInstance.clear();
+    this.nameToInstance.clear();
+  }
 }
 
 export default new GraphRegistry();

package/src/index.ts

@@ -8,11 +8,13 @@ import { Constructable } from './types';
 export * from './types';
 
 export { Graph } from './decorators/Graph';
+export { Singleton } from './decorators/Singleton';
 export { ObjectGraph } from './graph/ObjectGraph';
 export { Graph as IGraph } from './graph/Graph';
 export { Provides } from './decorators/provides/Provides';
-export { Injectable } from './decorators/injectClass';
-export { Inject } from './decorators/injectClass';
+export { Injectable } from './decorators/inject/Injectable';
+export { Inject } from './decorators/inject/Inject';
+export { LazyInject } from './decorators/inject/LazyInject';
 export { GraphMiddleware } from './graph/registry/GraphMiddleware';
 export { GraphResolveChain as ResolveChain } from './graph/registry/GraphResolveChain';
 export const Obsidian = new _Obsidian();
@@ -28,3 +30,5 @@ export const injectHook = <Args, Result> (
   hook: (args: Args) => Result,
   Graph: Constructable<_ObjectGraph>,
 ) => hookInjector.inject(hook, Graph);
+
+export { testKit } from '../testkit';

package/src/injectors/class/ClassInjector.ts

@@ -0,0 +1,49 @@
+import { Constructable } from '../../types';
+import { GraphRegistry } from '../../graph/registry/GraphRegistry';
+import { Graph } from '../../graph/Graph';
+import InjectionMetadata from './InjectionMetadata';
+import { GRAPH_INSTANCE_NAME_KEY } from './LazyInjector';
+
+export default class ClassInjector {
+  constructor(
+    private graphRegistry: GraphRegistry,
+    private injectionMetadata: InjectionMetadata = new InjectionMetadata(),
+  ) {}
+
+  inject(Graph: Constructable<Graph>) {
+    return (Target: Constructable<any>) => {
+      return new Proxy(Target, this.createProxyHandler(Graph, this.graphRegistry, this.injectionMetadata));
+    };
+  }
+
+  private createProxyHandler(
+    Graph: Constructable<Graph>,
+    graphRegistry: GraphRegistry,
+    injectionMetadata: InjectionMetadata,
+  ): ProxyHandler<any> {
+    return new class Handler implements ProxyHandler<any> {
+      construct(target: any, args: any[], newTarget: Function): any {
+        const graph = graphRegistry.resolve(Graph);
+        Reflect.defineMetadata(GRAPH_INSTANCE_NAME_KEY, graph.name, target);
+        const argsToInject = this.injectConstructorArgs(args, graph, target);
+        const createdObject = Reflect.construct(target, argsToInject, newTarget);
+        this.injectProperties(target, createdObject, graph);
+        return createdObject;
+      }
+
+      private injectConstructorArgs(args: any[], graph: Graph, target: any): any[] {
+        const argsToInject = injectionMetadata.getConstructorArgsToInject(target);
+        if (!argsToInject.hasArgs()) return args;
+        return [...args, ...new Array(Math.abs(args.length - argsToInject.size()))].map((value, idx): any => {
+          return value ?? graph.retrieve(argsToInject.getProperty(idx));
+        });
+      }
+
+      private injectProperties(target: any, createdObject: any, graph: Graph) {
+        injectionMetadata.getPropertiesToInject(target).forEach((key) => {
+          Reflect.set(createdObject, key, graph.retrieve(key));
+        });
+      }
+    }();
+  }
+}

package/src/injectors/class/ConstructorArgs.ts

@@ -0,0 +1,20 @@
+export class ConstructorArgs {
+  private readonly args = new Array<[string, number]>();
+
+  hasArgs(): boolean {
+    return this.args.length > 0;
+  }
+
+  size(): number {
+    return this.args.length;
+  }
+
+  add(paramName: string, index: number) {
+    this.args.push([paramName, index]);
+  }
+
+  getProperty(index: number): any {
+    if (this.args.length <= index) throw new Error('IOOB while trying to get constructor args to inject');
+    return this.args[index][0];
+  }
+}

package/src/injectors/class/InjectionMetadata.ts

@@ -0,0 +1,57 @@
+import { ConstructorArgs } from './ConstructorArgs';
+
+export default class InjectionMetadata {
+  private readonly injectionMetadataKey = 'injectionMetadata';
+  private readonly injectedConstructorArgsKey = 'injectedConstructorArgsKey';
+  private readonly lazyInjectionMetadataKey = 'lazyInjectionMetadataKey';
+
+  getConstructorArgsToInject(target: any): ConstructorArgs {
+    return Reflect.getMetadata(this.injectedConstructorArgsKey, target) ?? new ConstructorArgs();
+  }
+
+  getPropertiesToInject(target: any): Set<string> {
+    return this.getProperties(this.injectionMetadataKey, target);
+  }
+
+  getLazyPropertiesToInject(target: any): Set<string> {
+    return this.getProperties(this.lazyInjectionMetadataKey, target);
+  }
+
+  saveConstructorParamMetadata(target: any, paramName: string, index: number) {
+    const argsToInject = this.getConstructorArgsToInject(target);
+    argsToInject.add(paramName, index);
+    Reflect.defineMetadata(
+      this.injectedConstructorArgsKey,
+      argsToInject,
+      target,
+    );
+  }
+
+  savePropertyMetadata(target: any, property: string) {
+    this.saveProperties(
+      this.injectionMetadataKey,
+      this.getPropertiesToInject(target).add(property),
+      target,
+    );
+  }
+
+  saveLazyPropertyMetadata(target: any, property: string) {
+    this.saveProperties(
+      this.lazyInjectionMetadataKey,
+      this.getLazyPropertiesToInject(target).add(property),
+      target,
+    );
+  }
+
+  private saveProperties(key: string, properties: Set<string>, target: any) {
+    Reflect.defineMetadata(
+      key,
+      properties,
+      target,
+    );
+  }
+
+  private getProperties(key: string, target: any): Set<string> {
+    return Reflect.getMetadata(key, target) ?? new Set();
+  }
+}

package/src/injectors/class/LazyInjector.ts

@@ -0,0 +1,22 @@
+import graphRegistry from '../../graph/registry/GraphRegistry';
+import InjectionMetadata from './InjectionMetadata';
+
+export const GRAPH_INSTANCE_NAME_KEY = 'GRAPH_INSTANCE_NAME';
+
+class LazyInjector<T extends object> {
+  inject(target: T): T {
+    const injectionMetadata = new InjectionMetadata();
+    const graph = this.getGraphInstance(target);
+    injectionMetadata.getLazyPropertiesToInject(target.constructor).forEach((key) => {
+      Reflect.set(target, key, graph.retrieve(key));
+    });
+    return target;
+  }
+
+  private getGraphInstance(target: T) {
+    const graphInstanceName = Reflect.getMetadata(GRAPH_INSTANCE_NAME_KEY, target.constructor);
+    return graphRegistry.getGraphInstance(graphInstanceName);
+  }
+}
+
+export default new LazyInjector();

package/src/injectors/components/ComponentInjector.tsx

@@ -1,6 +1,5 @@
 import React, { useState } from 'react';
 import hoistNonReactStatics from 'hoist-non-react-statics';
-import 'reflect-metadata';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import PropsInjector from './PropsInjector';
 import useGraph from './useGraph';

package/src/types/index.ts

@@ -2,8 +2,6 @@ export type Constructable<T> = {
   new(...args: any): T;
 };
 
-export type Scope = string | number | symbol;
-
 export type Constructor = { new(...args: any[]): any };
 
 export type ServiceLocator<Clazz> = {

package/testkit/index.ts

@@ -1,28 +1,27 @@
-import { GraphResolveChain } from 'src/graph/registry/GraphResolveChain';
-import {
-  ObjectGraph,
-  Constructable,
-  GraphMiddleware,
-  Obsidian,
-} from '../src';
+import { GraphResolveChain } from '../src/graph/registry/GraphResolveChain';
+import { isGraph, ObjectGraph } from '../src/graph/ObjectGraph';
+import { GraphMiddleware } from '../src/graph/registry/GraphMiddleware';
+import { Constructable } from '../src/types';
+import graphRegistry from '../src/graph/registry/GraphRegistry';
 
 beforeEach(() => {
-  Obsidian.clearGraphMiddlewares();
+  graphRegistry.clearGraphMiddlewares();
+  graphRegistry.reset();
 });
 
-class Index {
-  mockGraphs(graphNameToGraph: Record<string, Constructable<ObjectGraph>>) {
+class TestKit {
+  public mockGraphs(graphNameToGraph: Record<string, Constructable<ObjectGraph> | ((props: any) => ObjectGraph)>) {
     const graphMiddleware = new class extends GraphMiddleware {
       resolve<Props>(resolveChain: GraphResolveChain, Graph: Constructable<ObjectGraph>, props?: Props) {
         if (graphNameToGraph[Graph.name]) {
-          const TheGraph = graphNameToGraph[Graph.name];
-          return new TheGraph(props);
+          const GraphOrGenerator = graphNameToGraph[Graph.name];
+          return isGraph(GraphOrGenerator) ? new GraphOrGenerator(props) : GraphOrGenerator(props);
         }
         return resolveChain.proceed(Graph, props);
       }
     }();
-    Obsidian.addGraphMiddleware(graphMiddleware);
+    graphRegistry.addGraphMiddleware(graphMiddleware);
   }
 }
 
-export default new Index();
+export const testKit = new TestKit();

package/transformers/{babel-plugin-obsidian-provide → babel-plugin-obsidian}/helpers/index.ts

@@ -3,13 +3,19 @@ import { types as t } from '@babel/core';
 import {
   CallExpression,
   ClassMethod,
+  ClassProperty,
   Decorator,
   Identifier,
   ObjectExpression,
   ObjectPattern,
+  TSParameterProperty,
 } from '@babel/types';
 import { get } from 'lodash';
 
+const never = '';
+
+export type AcceptedNodeType = Identifier | TSParameterProperty | ClassProperty;
+
 export function providerIsNotNamed(decorator: Decorator): boolean {
   const argument = getDecoratorArgument(decorator);
   if (t.isObjectExpression(argument)) {
@@ -44,8 +50,11 @@ export function getMethodName(node: ClassMethod): string {
   throw new Error(`Tried to get class name but encountered unexpected key of type: ${node.key.type}`);
 }
 
-export function getProviderDecorator(decorators: Array<Decorator> | undefined | null): Decorator | undefined {
-  return decorators?.find((decorator) => get(decorator, 'expression.callee.name') === 'Provides');
+export function getDecoratorByName(
+  decorators: Array<Decorator> | undefined | null,
+  decoratorName: string,
+): Decorator | undefined {
+  return decorators?.find((decorator) => get(decorator, 'expression.callee.name') === decoratorName);
 }
 
 export function getDecoratorName(decorator?: Decorator): string | undefined {
@@ -57,3 +66,30 @@ export function paramsToDestructuringAssignment(params: (Identifier | any)[]): O
     .filter((p) => t.isIdentifier(p))
     .map((p) => t.objectProperty(t.identifier(p.name), t.identifier(p.name))));
 }
+
+export function passParamNameAsInjectArgument(
+  node: AcceptedNodeType,
+  decorator: Decorator,
+) {
+  if (t.isCallExpression(decorator.expression)) {
+    decorator.expression.arguments = [
+      t.stringLiteral(getNodeName(node)),
+    ];
+  }
+}
+
+function getNodeName(node: AcceptedNodeType): string {
+  if (t.isTSParameterProperty(node)) {
+    if (t.isIdentifier(node.parameter)) {
+      return node.parameter.name;
+    }
+    return never;
+  }
+  if (t.isClassProperty(node)) {
+    if (t.isIdentifier(node.key)) {
+      return node.key.name;
+    }
+    return never;
+  }
+  return node.name;
+}

package/transformers/babel-plugin-obsidian/index.ts

@@ -0,0 +1,46 @@
+/* eslint-disable no-param-reassign */
+import {
+  ClassMethod,
+  ClassProperty,
+  Identifier,
+  Program,
+  TSParameterProperty,
+} from '@babel/types';
+import { NodePath, PluginObj } from '@babel/core';
+import unmagler from './unmagler';
+
+const providerArgumentsTransformer: PluginObj = {
+  visitor: {
+    Program(path: NodePath<Program>) {
+      path.traverse(internalVisitor);
+    },
+  },
+};
+
+const internalVisitor = {
+  ClassMethod: {
+    enter({ node }: NodePath<ClassMethod>) {
+      unmagler.saveClassMethod('Provides', node);
+    },
+  },
+  ClassProperty: {
+    enter({ node }: NodePath<ClassProperty>) {
+      unmagler.saveClassProperty('Inject', node);
+      unmagler.saveClassProperty('LazyInject', node);
+    },
+  },
+  Identifier: {
+    enter({ node }: NodePath<Identifier>) {
+      unmagler.saveIdentifier('Inject', node);
+    },
+  },
+  TSParameterProperty: {
+    enter({ node }: NodePath<TSParameterProperty>) {
+      unmagler.saveTSParameterProperty('Inject', node);
+    },
+  },
+};
+
+export default function plugin() {
+  return providerArgumentsTransformer;
+}

package/transformers/babel-plugin-obsidian/unmagler/index.ts

@@ -0,0 +1,9 @@
+import saveMethod from './method';
+import saveProperty from './property';
+
+export default {
+  saveClassMethod: saveMethod,
+  saveClassProperty: saveProperty,
+  saveIdentifier: saveProperty,
+  saveTSParameterProperty: saveProperty,
+};

package/transformers/babel-plugin-obsidian/unmagler/method.ts

@@ -0,0 +1,31 @@
+import { ClassMethod, Decorator } from '@babel/types';
+import {
+  addNameToProviderArguments,
+  getDecoratorName,
+  getDecoratorByName,
+  paramsToDestructuringAssignment,
+  providerIsNotNamed,
+} from '../helpers';
+
+function saveMethod(name: string, node: ClassMethod) {
+  const decorator = getDecoratorByName(node.decorators, name);
+  if (getDecoratorName(decorator) === name) {
+    convertProviderParamsToDestructuringAssignment(node);
+    saveUnmangledMethodNameInProviderArguments(node, decorator!);
+  }
+}
+
+function convertProviderParamsToDestructuringAssignment(node: ClassMethod) {
+  if (node.params.length === 0) { return; }
+  const destructuredParams = paramsToDestructuringAssignment(node.params);
+  // eslint-disable-next-line no-param-reassign
+  node.params.length = 0;
+  node.params.push(destructuredParams);
+}
+
+function saveUnmangledMethodNameInProviderArguments(node: ClassMethod, decorator: Decorator) {
+  if (providerIsNotNamed(decorator)) {
+    addNameToProviderArguments(node, decorator);
+  }
+}
+export default saveMethod;

package/transformers/babel-plugin-obsidian/unmagler/property.ts

@@ -0,0 +1,21 @@
+import { Decorator } from '@babel/types';
+import {
+  getDecoratorName,
+  getDecoratorByName,
+  passParamNameAsInjectArgument,
+  getDecoratorArgument,
+  AcceptedNodeType,
+} from '../helpers';
+
+function savePropertyName(name: string, node: AcceptedNodeType) {
+  const decorator = getDecoratorByName(node.decorators, name);
+  if (getDecoratorName(decorator) === name && injectIsNotNamed(decorator!)) {
+    passParamNameAsInjectArgument(node, decorator!);
+  }
+}
+
+function injectIsNotNamed(decorator: Decorator): boolean {
+  return getDecoratorArgument(decorator) === undefined;
+}
+
+export default savePropertyName;

package/dist/src/ScopedValuesRegistry.d.ts

@@ -1,11 +0,0 @@
-import { Scope } from './types';
-declare class ScopedValuesRegistry {
-    private readonly values;
-    has(scope: Scope, property: string): boolean;
-    get(scope: Scope, property: string): any;
-    set(scope: Scope, property: string, value: any): void;
-    clear(scope: Scope, property: string): void;
-}
-declare const _default: ScopedValuesRegistry;
-export default _default;
-//# sourceMappingURL=ScopedValuesRegistry.d.ts.map

package/dist/src/ScopedValuesRegistry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScopedValuesRegistry.d.ts","sourceRoot":"","sources":["../../src/ScopedValuesRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,cAAM,oBAAoB;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IAEtD,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI5C,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,GAAG;IAOxC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAI9C,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM;CAGrC;;AAED,wBAA0C"}

package/dist/src/ScopedValuesRegistry.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var ScopedValuesRegistry = /** @class */ (function () {
-    function ScopedValuesRegistry() {
-        this.values = new Map();
-    }
-    ScopedValuesRegistry.prototype.has = function (scope, property) {
-        return this.values.has(scope.toString() + property);
-    };
-    ScopedValuesRegistry.prototype.get = function (scope, property) {
-        if (this.values.has(scope.toString() + property)) {
-            return this.values.get(scope.toString() + property);
-        }
-        throw new Error("Property ".concat(property, " does not exist"));
-    };
-    ScopedValuesRegistry.prototype.set = function (scope, property, value) {
-        this.values.set(scope.toString() + property, value);
-    };
-    ScopedValuesRegistry.prototype.clear = function (scope, property) {
-        this.values.delete(scope.toString() + property);
-    };
-    return ScopedValuesRegistry;
-}());
-exports.default = new ScopedValuesRegistry();
-//# sourceMappingURL=ScopedValuesRegistry.js.map

package/dist/src/ScopedValuesRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ScopedValuesRegistry.js","sourceRoot":"","sources":["../../src/ScopedValuesRegistry.ts"],"names":[],"mappings":";;AAEA;IAAA;QACmB,WAAM,GAAqB,IAAI,GAAG,EAAE,CAAC;IAoBxD,CAAC;IAlBC,kCAAG,GAAH,UAAI,KAAY,EAAE,QAAgB;QAChC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED,kCAAG,GAAH,UAAI,KAAY,EAAE,QAAgB;QAChC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,EAAE;YAChD,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,CAAC;SACrD;QACD,MAAM,IAAI,KAAK,CAAC,mBAAY,QAAQ,oBAAiB,CAAC,CAAC;IACzD,CAAC;IAED,kCAAG,GAAH,UAAI,KAAY,EAAE,QAAgB,EAAE,KAAU;QAC5C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,QAAQ,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IAED,oCAAK,GAAL,UAAM,KAAY,EAAE,QAAgB;QAClC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,CAAC;IAClD,CAAC;IACH,2BAAC;AAAD,CAAC,AArBD,IAqBC;AAED,kBAAe,IAAI,oBAAoB,EAAE,CAAC"}

package/dist/src/decorators/injectClass.d.ts

@@ -1,7 +0,0 @@
-import { Constructable } from '../types';
-import { ObjectGraph } from '../graph/ObjectGraph';
-export declare function Injectable<T extends {
-    new (...args: any[]): any;
-}>(Graph: Constructable<ObjectGraph>): any;
-export declare function Inject(target: Object, propertyKey: string): void;
-//# sourceMappingURL=injectClass.d.ts.map

package/dist/src/decorators/injectClass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectClass.d.ts","sourceRoot":"","sources":["../../../src/decorators/injectClass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,UAAU,CAAC,CAAC,SAAS;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,EAAE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,GAAG,CAgBzG;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAGzD"}