react-obsidian 0.0.10 → 0.0.14

package/dist/transformers/{babel-plugin-obsidian-provide → babel-plugin-obsidian}/index.js

@@ -12,14 +12,40 @@ var internalVisitor = {
     ClassMethod: {
         enter: function (_a) {
             var node = _a.node;
-            var decorator = (0, helpers_1.getProviderDecorator)(node.decorators);
+            var decorator = (0, helpers_1.getDecoratorByName)(node.decorators, 'Provides');
             if ((0, helpers_1.getDecoratorName)(decorator) === 'Provides') {
                 convertProviderParamsToDestructuringAssignment(node);
                 saveUnmangledMethodNameInProviderArguments(node, decorator);
             }
         },
     },
+    Identifier: {
+        enter: function (_a) {
+            var node = _a.node;
+            var decorator = (0, helpers_1.getDecoratorByName)(node.decorators, 'Inject');
+            if ((0, helpers_1.getDecoratorName)(decorator) === 'Inject') {
+                saveUnmangledParamName(node, decorator);
+            }
+        },
+    },
+    TSParameterProperty: {
+        enter: function (_a) {
+            var node = _a.node;
+            var decorator = (0, helpers_1.getDecoratorByName)(node.decorators, 'Inject');
+            if ((0, helpers_1.getDecoratorName)(decorator) === 'Inject') {
+                saveUnmangledParamName(node, decorator);
+            }
+        },
+    },
 };
+function saveUnmangledParamName(node, decorator) {
+    if (injectIsNotNamed(decorator)) {
+        (0, helpers_1.passParamNameAsInjectArgument)(node, decorator);
+    }
+}
+function injectIsNotNamed(decorator) {
+    return (0, helpers_1.getDecoratorArgument)(decorator) === undefined;
+}
 function convertProviderParamsToDestructuringAssignment(node) {
     if (node.params.length === 0)
         return;

package/dist/transformers/babel-plugin-obsidian/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../transformers/babel-plugin-obsidian/index.ts"],"names":[],"mappings":";;AASA,qCAQmB;AAEnB,IAAM,4BAA4B,GAAc;IAC9C,OAAO,EAAE;QACP,OAAO,EAAP,UAAQ,IAAuB;YAC7B,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QACjC,CAAC;KACF;CACF,CAAC;AAEF,IAAM,eAAe,GAAG;IACtB,WAAW,EAAE;QACX,KAAK,EAAL,UAAM,EAA+B;gBAA7B,IAAI,UAAA;YACV,IAAM,SAAS,GAAG,IAAA,4BAAkB,EAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YAClE,IAAI,IAAA,0BAAgB,EAAC,SAAS,CAAC,KAAK,UAAU,EAAE;gBAC9C,8CAA8C,CAAC,IAAI,CAAC,CAAC;gBACrD,0CAA0C,CAAC,IAAI,EAAE,SAAU,CAAC,CAAC;aAC9D;QACH,CAAC;KACF;IACD,UAAU,EAAE;QACV,KAAK,EAAL,UAAM,EAA8B;gBAA5B,IAAI,UAAA;YACV,IAAM,SAAS,GAAG,IAAA,4BAAkB,EAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YAChE,IAAI,IAAA,0BAAgB,EAAC,SAAS,CAAC,KAAK,QAAQ,EAAE;gBAC5C,sBAAsB,CAAC,IAAI,EAAE,SAAU,CAAC,CAAC;aAC1C;QACH,CAAC;KACF;IACD,mBAAmB,EAAE;QACnB,KAAK,EAAL,UAAM,EAAuC;gBAArC,IAAI,UAAA;YACV,IAAM,SAAS,GAAG,IAAA,4BAAkB,EAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YAChE,IAAI,IAAA,0BAAgB,EAAC,SAAS,CAAC,KAAK,QAAQ,EAAE;gBAC5C,sBAAsB,CAAC,IAAI,EAAE,SAAU,CAAC,CAAC;aAC1C;QACH,CAAC;KACF;CACF,CAAC;AAEF,SAAS,sBAAsB,CAAC,IAAsC,EAAE,SAAoB;IAC1F,IAAI,gBAAgB,CAAC,SAAS,CAAC,EAAE;QAC/B,IAAA,uCAA6B,EAAC,IAAI,EAAE,SAAS,CAAC,CAAC;KAChD;AACH,CAAC;AAED,SAAS,gBAAgB,CAAC,SAAoB;IAC5C,OAAO,IAAA,8BAAoB,EAAC,SAAS,CAAC,KAAK,SAAS,CAAC;AACvD,CAAC;AAED,SAAS,8CAA8C,CAAC,IAAiB;IACvE,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACrC,IAAM,kBAAkB,GAAG,IAAA,yCAA+B,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,0CAA0C,CAAC,IAAiB,EAAE,SAAoB;IACzF,IAAI,IAAA,4BAAkB,EAAC,SAAS,CAAC,EAAE;QACjC,IAAA,oCAA0B,EAAC,IAAI,EAAE,SAAS,CAAC,CAAC;KAC7C;AACH,CAAC;AAED,SAAwB,MAAM;IAC5B,OAAO,4BAA4B,CAAC;AACtC,CAAC;AAFD,yBAEC"}

package/example/babel.config.js

@@ -3,6 +3,6 @@ module.exports = {
   plugins: [
     ['@babel/plugin-proposal-decorators', {legacy: true}],
     ['@babel/plugin-proposal-class-properties', {legacy: true}],
-    [`${__dirname}/../dist/transformers/babel-plugin-obsidian-provide`],
+    [`${__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,6 +1,6 @@
 {
   "name": "react-obsidian",
-  "version": "0.0.10",
+  "version": "0.0.14",
   "description": "Dependency injection framework for React and React Native applications",
   "main": "src/index.ts",
   "directories": {
@@ -19,6 +19,7 @@
     "@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",
@@ -40,11 +41,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"
+    "typescript": "^4.5.4",
+    "setimmediate": "^1.0.5"
   },
   "scripts": {
     "prepack": "npm run lint && tsc --project tsconfig.prod.json",

package/src/GraphProperties.ts

@@ -8,4 +8,8 @@ export default class GraphProperties {
   getMangledProperty(unmangledProperty: string): string | undefined {
     return this.unmangledToMangledPropKeys.get(unmangledProperty);
   }
+
+  getMangledProperties(): string[] {
+    return Array.from(this.unmangledToMangledPropKeys.values());
+  }
 }

package/src/ProvidedPropertiesStore.ts

@@ -14,6 +14,10 @@ class ProvidedPropertiesStore {
     this.providedPropertiesForGraph.set(graph.name, graphProperties);
   }
 
+  getMangledProperties(graph: Graph): string[] {
+    return this.providedPropertiesForGraph.get(graph.name)?.getMangledProperties() ?? [];
+  }
+
   clear(graph: Graph) {
     this.providedPropertiesForGraph.delete(graph.name);
   }

package/src/decorators/Graph.ts

@@ -1,20 +1,17 @@
-import { Constructable, Scope } from '../types';
+import { Constructable } from '../types';
 import 'reflect-metadata';
 import graphRegistry from '../graph/registry/GraphRegistry';
 import { ObjectGraph } from '../graph/ObjectGraph';
 
 interface GraphParams {
-  scope: Scope | undefined;
   subgraphs: Constructable<ObjectGraph>[];
 }
 
 export function Graph({
-  scope,
   subgraphs = [],
 }: Partial<GraphParams> = {}) {
   return <T extends ObjectGraph>(constructor: Constructable<T>) => {
-    Reflect.defineMetadata('scope', scope, constructor);
-    graphRegistry.register(constructor, scope, subgraphs);
+    graphRegistry.register(constructor, subgraphs);
     return constructor;
   };
 }

package/src/decorators/Singleton.ts

@@ -0,0 +1,14 @@
+import { Constructable } from '../types';
+import { ObjectGraph } from '../graph/ObjectGraph';
+
+export function Singleton() {
+  return function singleton(
+    constructorOrGraph: Constructable<ObjectGraph> | ObjectGraph,
+    _property?: string,
+    descriptor?: PropertyDescriptor,
+  ): any {
+    const target = descriptor || constructorOrGraph;
+    Reflect.defineMetadata('isSingleton', true, target);
+    return target;
+  };
+}

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 (name && isNumber(indexOrPropertyDescriptor)) {
+      metadata.saveConstructorParamMetadata(target, name!, indexOrPropertyDescriptor);
+    } else {
+      metadata.savePropertyMetadata(target.constructor, propertyKey!);
+    }
+  };
+}

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/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,10 @@
 import { uniqueId } from 'lodash';
 import Memoize from '../decorators/Memoize';
-import { Scope } from '../types';
-import { autobind } from './autobind';
+import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
 
 export abstract class ObjectGraph<T = unknown> implements Graph {
-  // TODO? rename scope to singleInstance
-  public scope!: Scope;
   private propertyRetriever = new PropertyRetriever(this);
 
   @Memoize()
@@ -16,7 +13,7 @@ export abstract class ObjectGraph<T = unknown> implements Graph {
   }
 
   constructor(protected _props?: T) {
-    autobind(this);
+    bindProviders(this);
   }
 
   retrieve<Dependency>(property: string, receiver?: unknown): Dependency | undefined {

package/src/graph/ProviderBinder.ts

@@ -0,0 +1,12 @@
+/* eslint-disable no-param-reassign */
+import providedPropertiesStore from '../ProvidedPropertiesStore';
+import { Graph } from './Graph';
+
+export function bindProviders(graph: Graph & Record<string, any>) {
+  providedPropertiesStore.getMangledProperties(graph)
+    .forEach((method) => {
+      if (graph[method] !== undefined) {
+        graph[method] = graph[method].bind(graph);
+      }
+    });
+}

package/src/graph/registry/GraphRegistry.ts

@@ -1,37 +1,18 @@
-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 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();
@@ -39,23 +20,37 @@ class GraphRegistry {
   }
 
   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;
-
-      // this.set(Graph, new Graph(props));
+    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);
+  }
+
+  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);
   }
 
   addGraphMiddleware(middleware: Middleware<Graph>) {

package/src/index.ts

@@ -8,11 +8,12 @@ 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 { GraphMiddleware } from './graph/registry/GraphMiddleware';
 export { GraphResolveChain as ResolveChain } from './graph/registry/GraphResolveChain';
 export const Obsidian = new _Obsidian();

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';
+
+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);
+
+        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,32 @@
+import { ConstructorArgs } from './ConstructorArgs';
+
+export default class InjectionMetadata {
+  private readonly injectionMetadataKey = 'injectionMetadata';
+  private readonly injectedConstructorArgsKey = 'injectedConstructorArgsKey';
+
+  getConstructorArgsToInject(target: any): ConstructorArgs {
+    return Reflect.getMetadata(this.injectedConstructorArgsKey, target) ?? new ConstructorArgs();
+  }
+
+  getPropertiesToInject(target: any): Set<string> {
+    return Reflect.getMetadata(this.injectionMetadataKey, target) ?? new Set();
+  }
+
+  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) {
+    Reflect.defineMetadata(
+      this.injectionMetadataKey,
+      this.getPropertiesToInject(target).add(property),
+      target,
+    );
+  }
+}

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,4 +1,4 @@
-import { GraphResolveChain } from 'src/graph/registry/GraphResolveChain';
+import { GraphResolveChain } from '../src/graph/registry/GraphResolveChain';
 import {
   ObjectGraph,
   Constructable,

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

@@ -7,9 +7,12 @@ import {
   Identifier,
   ObjectExpression,
   ObjectPattern,
+  TSParameterProperty,
 } from '@babel/types';
 import { get } from 'lodash';
 
+const never = '';
+
 export function providerIsNotNamed(decorator: Decorator): boolean {
   const argument = getDecoratorArgument(decorator);
   if (t.isObjectExpression(argument)) {
@@ -44,8 +47,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 +63,21 @@ 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: Identifier | TSParameterProperty, decorator: Decorator) {
+  if (t.isCallExpression(decorator.expression)) {
+    decorator.expression.arguments = [
+      t.stringLiteral(getIdentifierOrParamName(node)),
+    ];
+  }
+}
+
+function getIdentifierOrParamName(node: Identifier | TSParameterProperty): string {
+  if (t.isTSParameterProperty(node)) {
+    if (t.isIdentifier(node.parameter)) {
+      return node.parameter.name;
+    }
+    return never;
+  }
+  return node.name;
+}

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

@@ -1,12 +1,20 @@
 /* eslint-disable no-param-reassign */
-import { ClassMethod, Decorator, Program } from '@babel/types';
+import {
+  ClassMethod,
+  Identifier,
+  Decorator,
+  Program,
+  TSParameterProperty,
+} from '@babel/types';
 import { NodePath, PluginObj } from '@babel/core';
 import {
   addNameToProviderArguments,
   getDecoratorName,
-  getProviderDecorator,
+  getDecoratorByName,
   paramsToDestructuringAssignment,
   providerIsNotNamed,
+  passParamNameAsInjectArgument,
+  getDecoratorArgument,
 } from './helpers';
 
 const providerArgumentsTransformer: PluginObj = {
@@ -20,15 +28,41 @@ const providerArgumentsTransformer: PluginObj = {
 const internalVisitor = {
   ClassMethod: {
     enter({ node }: NodePath<ClassMethod>) {
-      const decorator = getProviderDecorator(node.decorators);
+      const decorator = getDecoratorByName(node.decorators, 'Provides');
       if (getDecoratorName(decorator) === 'Provides') {
         convertProviderParamsToDestructuringAssignment(node);
         saveUnmangledMethodNameInProviderArguments(node, decorator!);
       }
     },
   },
+  Identifier: {
+    enter({ node }: NodePath<Identifier>) {
+      const decorator = getDecoratorByName(node.decorators, 'Inject');
+      if (getDecoratorName(decorator) === 'Inject') {
+        saveUnmangledParamName(node, decorator!);
+      }
+    },
+  },
+  TSParameterProperty: {
+    enter({ node }: NodePath<TSParameterProperty>) {
+      const decorator = getDecoratorByName(node.decorators, 'Inject');
+      if (getDecoratorName(decorator) === 'Inject') {
+        saveUnmangledParamName(node, decorator!);
+      }
+    },
+  },
 };
 
+function saveUnmangledParamName(node: Identifier | TSParameterProperty, decorator: Decorator) {
+  if (injectIsNotNamed(decorator)) {
+    passParamNameAsInjectArgument(node, decorator);
+  }
+}
+
+function injectIsNotNamed(decorator: Decorator): boolean {
+  return getDecoratorArgument(decorator) === undefined;
+}
+
 function convertProviderParamsToDestructuringAssignment(node: ClassMethod) {
   if (node.params.length === 0) return;
   const destructuredParams = paramsToDestructuringAssignment(node.params);

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"}