react-obsidian 0.0.13 → 0.0.17

package/example/babel.config.js

@@ -2,7 +2,7 @@ module.exports = {
   presets: ['module:metro-react-native-babel-preset'],
   plugins: [
     ['@babel/plugin-proposal-decorators', {legacy: true}],
-    ['@babel/plugin-proposal-class-properties', {legacy: true}],
-    [`${__dirname}/../dist/transformers/babel-plugin-obsidian-provide`],
+    ['@babel/plugin-proposal-class-properties', {loose: true}],
+    [`${__dirname}/../dist/transformers/babel-plugin-obsidian`],
   ],
 };

package/example/ios/example.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

package/jest.config.js

@@ -7,6 +7,10 @@ const config = {
     'transformers',
     'test',
   ],
+  setupFilesAfterEnv: [
+    './jest.setup-after-env.js'
+  ],
+  testEnvironment: 'jsdom'
 };
 
 module.exports = config;

package/jest.setup-after-env.js

@@ -0,0 +1 @@
+require('setimmediate');

package/jest.setup.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "react-obsidian",
-  "version": "0.0.13",
+  "version": "0.0.17",
   "description": "Dependency injection framework for React and React Native applications",
+  "scripts": {
+    "prepack": "npm run lint && tsc --project tsconfig.prod.json",
+    "lint": "npx eslint src transformers test --ignore-pattern '*.d.ts' --ext .ts,.tsx,.js",
+    "pretest": "tsc",
+    "test": "npx jest"
+  },
   "main": "src/index.ts",
   "directories": {
     "test": "test"
@@ -11,17 +17,18 @@
     "reflect-metadata": "~0.1.13"
   },
   "peerDependencies": {
-    "react": "*"
+    "react": "*",
+    "lodash": "*"
   },
   "devDependencies": {
     "@babel/core": "7.16.x",
-    "@babel/generator": "7.16.x",
-    "@babel/plugin-proposal-class-properties": "7.16.x",
     "@babel/plugin-proposal-decorators": "7.16.x",
     "@babel/preset-env": "7.16.x",
+    "babel-plugin-parameter-decorator": "1.x.x",
     "@babel/preset-react": "7.16.x",
     "@babel/preset-typescript": "7.16.x",
     "@babel/types": "7.16.x",
+    "@babel/traverse": "7.16.x",
     "@johanblumenberg/ts-mockito": "1.x.x",
     "@testing-library/react": "^12.1.2",
     "@testing-library/react-hooks": "^7.0.2",
@@ -40,17 +47,12 @@
     "eslint-plugin-jsx-a11y": "^6.4.1",
     "eslint-plugin-react": "^7.26.1",
     "eslint-plugin-react-hooks": "^4.2.0",
-    "jest": "26.x.x",
+    "jest": "27.x.x",
     "lodash": "^4.17.21",
     "react": "17.0.2",
     "react-dom": "17.0.2",
-    "typescript": "^4.4.4"
-  },
-  "scripts": {
-    "prepack": "npm run lint && tsc --project tsconfig.prod.json",
-    "lint": "npx eslint src transformers test --ignore-pattern '*.d.ts' --ext .ts,.tsx,.js",
-    "pretest": "tsc",
-    "test": "npx jest"
+    "typescript": "^4.5.4",
+    "setimmediate": "^1.0.5"
   },
   "repository": {
     "type": "git",

package/src/Obsidian.ts

@@ -2,6 +2,7 @@ import graphRegistry from './graph/registry/GraphRegistry';
 import { ObjectGraph } from './graph/ObjectGraph';
 import { Constructable, GraphInternals, ServiceLocator } from './types';
 import { GraphMiddleware } from './graph/registry/GraphMiddleware';
+import lazyInjector from './injectors/class/LazyInjector';
 
 export default class Obsidian {
   obtain<T extends ObjectGraph<P>, P = any>(
@@ -11,6 +12,10 @@ export default class Obsidian {
     return graphRegistry.resolve(Graph, props) as unknown as ServiceLocator<T>;
   }
 
+  inject<T extends object>(target: T) {
+    return lazyInjector.inject(target);
+  }
+
   addGraphMiddleware(middleware: GraphMiddleware) {
     graphRegistry.addGraphMiddleware(middleware);
   }

package/src/decorators/Singleton.ts

@@ -1,4 +1,4 @@
-import { Constructable } from 'src';
+import { Constructable } from '../types';
 import { ObjectGraph } from '../graph/ObjectGraph';
 
 export function Singleton() {

package/src/decorators/inject/Inject.ts

@@ -0,0 +1,17 @@
+import { isNumber } from 'lodash';
+import InjectionMetadata from '../../injectors/class/InjectionMetadata';
+
+export function Inject(name?: string) {
+  return (
+    target: Object | any,
+    _propertyKey?: string,
+    indexOrPropertyDescriptor?: number | PropertyDescriptor,
+  ) => {
+    const metadata = new InjectionMetadata();
+    if (isNumber(indexOrPropertyDescriptor)) {
+      metadata.saveConstructorParamMetadata(target, name!, indexOrPropertyDescriptor);
+    } else {
+      metadata.savePropertyMetadata(target.constructor, name!);
+    }
+  };
+}

package/src/decorators/inject/Injectable.ts

@@ -0,0 +1,8 @@
+import { Constructable } from '../../types';
+import { Graph } from '../../graph/Graph';
+import graphRegistry from '../../graph/registry/GraphRegistry';
+import ClassInjector from '../../injectors/class/ClassInjector';
+
+export function Injectable(Graph: Constructable<Graph>): any {
+  return new ClassInjector(graphRegistry).inject(Graph);
+}

package/src/decorators/inject/LazyInject.ts

@@ -0,0 +1,8 @@
+import InjectionMetadata from '../../injectors/class/InjectionMetadata';
+
+export function LazyInject(name?: string): any {
+  return (target: object) => {
+    const metadata = new InjectionMetadata();
+    metadata.saveLazyPropertyMetadata(target.constructor, name!);
+  };
+}

package/src/graph/ObjectGraph.ts

@@ -3,6 +3,7 @@ import Memoize from '../decorators/Memoize';
 import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
+import { Constructable } from '../types';
 
 export abstract class ObjectGraph<T = unknown> implements Graph {
   private propertyRetriever = new PropertyRetriever(this);
@@ -20,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

@@ -6,6 +6,7 @@ import GraphMiddlewareChain from './GraphMiddlewareChain';
 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 readonly graphMiddlewares = new GraphMiddlewareChain();
 
@@ -19,6 +20,10 @@ export class GraphRegistry {
     return Array.from(subgraphs).map((G) => this.resolve(G));
   }
 
+  getGraphInstance(name: string): Graph {
+    return this.nameToInstance.get(name)!;
+  }
+
   resolve<T extends Graph>(Graph: Constructable<T>, props?: any): T {
     if (this.isSingleton(Graph) && this.has(Graph)) {
       return this.getFirst(Graph);
@@ -41,6 +46,7 @@ export class GraphRegistry {
     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 {
@@ -51,6 +57,7 @@ export class GraphRegistry {
     const Graph = this.instanceToConstructor.get(graph)!;
     this.instanceToConstructor.delete(graph);
     this.constructorToInstance.get(Graph)!.delete(graph);
+    this.nameToInstance.delete(graph.name);
   }
 
   addGraphMiddleware(middleware: Middleware<Graph>) {
@@ -60,6 +67,12 @@ export class GraphRegistry {
   clearGraphMiddlewares() {
     this.graphMiddlewares.clear();
   }
+
+  reset() {
+    this.instanceToConstructor.clear();
+    this.constructorToInstance.clear();
+    this.nameToInstance.clear();
+  }
 }
 
 export default new GraphRegistry();

package/src/index.ts

@@ -12,8 +12,9 @@ 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();
@@ -29,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/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/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"}