react-obsidian 3.0.0-alpha.3 → 3.0.0-alpha.7

package/src/decorators/inject/Inject.ts

@@ -1,10 +1,7 @@
 import InjectionMetadata from '../../injectors/class/InjectionMetadata';
 
 export function inject<This, Return>(name?: string) {
-  return (
-    _target: undefined,
-    context: ClassFieldDecoratorContext<This, Return>,
-  ) => {
+  return (_target: undefined, context: ClassFieldDecoratorContext<This, Return>) => {
     context.addInitializer(function (this: This) {
       const metadata = new InjectionMetadata();
       metadata.savePropertyMetadata((this as object).constructor, name!);

package/src/decorators/inject/Injectable.ts

@@ -3,6 +3,6 @@ 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);
+export function injectable(keyOrGraph: string | Constructable<Graph>): any {
+  return new ClassInjector(graphRegistry).inject(keyOrGraph);
 }

package/src/graph/ObjectGraph.ts

@@ -1,17 +1,21 @@
 import { uniqueId } from '../utils/uniqueId';
-import memoize from '../decorators/Memoize';
 import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
 import { Constructable } from '../types';
 import { CircularDependenciesDetector } from './CircularDependenciesDetector';
+import { defineMetadata, getMetadata, hasMetadata } from '../utils/reflect';
 
 export abstract class ObjectGraph<T = unknown> implements Graph {
   private propertyRetriever = new PropertyRetriever(this);
 
-  @memoize
   get name(): string {
-    return uniqueId(this.constructor.name);
+    if (hasMetadata(this.constructor, 'memoizedName')) {
+      return getMetadata(this.constructor, 'memoizedName');
+    }
+    const name = uniqueId(this.constructor.name);
+    defineMetadata(this.constructor, 'memoizedName', name);
+    return name;
   }
 
   constructor(protected _props?: T) {

package/src/graph/ServiceLocatorFactory.ts

@@ -3,8 +3,8 @@ import { Constructable, ServiceLocator as ServiceLocatorType } from '../types';
 import graphRegistry from './registry/GraphRegistry';
 
 export default class ServiceLocatorFactory {
-  static fromGraph<T extends ObjectGraph<P>, P = any>(Graph: Constructable<T>, props?: P) {
-    const resolved = graphRegistry.resolve(Graph, 'serviceLocator', props);
+  static fromGraph<T extends ObjectGraph<P>, P = any>(keyOrGraph: string | Constructable<T>, props?: P) {
+    const resolved = graphRegistry.resolve(keyOrGraph, 'serviceLocator', props);
     const wrapped = new Proxy(resolved, {
       get(_target: any, property: string, receiver: any) {
         return () => resolved.retrieve(property, receiver);

package/src/graph/registry/GraphRegistry.ts

@@ -4,6 +4,9 @@ import { Middleware } from './Middleware';
 import GraphMiddlewareChain from './GraphMiddlewareChain';
 import { ObtainLifecycleBoundGraphException } from './ObtainLifecycleBoundGraphException';
 import { getMetadata } from '../../utils/reflect';
+import { getGlobal } from '../../utils/getGlobal';
+import { isString } from '../../utils/isString';
+import referenceCounter from '../../ReferenceCounter';
 
 export class GraphRegistry {
   private readonly constructorToInstance = new Map<Constructable<Graph>, Set<Graph>>();
@@ -13,16 +16,30 @@ export class GraphRegistry {
   private readonly nameToInstance = new Map<string, Graph>();
   private readonly graphToSubgraphs = new Map<Constructable<Graph>, Set<Constructable<Graph>>>();
   private readonly graphMiddlewares = new GraphMiddlewareChain();
+  private readonly keyToGenerator = new Map<string, () => Constructable<Graph>>();
+  private readonly keyToGraph = new Map<string, Constructable<Graph>>();
+  private readonly onClearListeners = new Map<Graph, Set<() => void>>();
 
   register(constructor: Constructable<Graph>, subgraphs: Constructable<Graph>[] = []) {
     this.graphToSubgraphs.set(constructor, new Set(subgraphs));
   }
 
-  ensureRegistered(graph: Graph) {
+  registerGraphGenerator(key: string, generator: () => Constructable<Graph>) {
+    if (this.keyToGenerator.has(key)) throw new Error(`Attempted to register a graph generator for key "${key}" that is already registered.`);
+    this.keyToGenerator.set(key, generator);
+  }
+
+  ensureRegistered(keyOrGraph: string | Graph) {
+    if (isString(keyOrGraph)) return;
+    const graph = keyOrGraph;
     if (this.instanceToConstructor.get(graph)) return;
     this.set(graph.constructor as any, graph);
   }
 
+  public isInstantiated(G: Constructable<Graph>): boolean {
+    return (this.constructorToInstance.get(G)?.size ?? 0) > 0;
+  }
+
   getSubgraphs(graph: Graph): Graph[] {
     const Graph = this.instanceToConstructor.get(graph)!;
     const subgraphs = this.graphToSubgraphs.get(Graph) ?? new Set();
@@ -34,24 +51,85 @@ export class GraphRegistry {
   }
 
   resolve<T extends Graph>(
-    Graph: Constructable<T>,
+    keyOrGraph: string | Constructable<T>,
     source: 'lifecycleOwner' | 'classInjection' | 'serviceLocator' = 'lifecycleOwner',
     props: any = undefined,
     injectionToken?: string,
   ): T {
+    const Graph = isString(keyOrGraph) ?
+      this.getGraphConstructorByKey<T>(keyOrGraph) :
+      keyOrGraph;
     if ((this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph, injectionToken)) {
-      return this.isComponentScopedLifecycleBound(Graph)
-        ? this.getByInjectionToken(Graph, injectionToken)
-        : this.getFirst(Graph);
+      return this.isComponentScopedLifecycleBound(Graph) ?
+        this.getByInjectionToken(Graph, injectionToken) :
+        this.getFirst(Graph);
     }
     if (this.isBoundToReactLifecycle(Graph) && source !== 'lifecycleOwner') {
       throw new ObtainLifecycleBoundGraphException(Graph);
     }
     const graph = this.graphMiddlewares.resolve(Graph, props);
     this.set(Graph, graph, injectionToken);
+    this.instantiateCustomScopedSubgraphs(graph, props);
     return graph as T;
   }
 
+  private instantiateCustomScopedSubgraphs(graph: Graph, props: any) {
+    this.assertInstantiatingCustomScopedSubgraphFromSameScope(graph);
+    if (!this.isCustomScopedLifecycleBound(this.instanceToConstructor.get(graph)!)) return;
+    const customScope = getMetadata(this.instanceToConstructor.get(graph)!, 'lifecycleScope');
+    const subgraphs = this.getSubgraphsConstructors(graph);
+    const sameScopeSubgraphs = subgraphs.filter(
+      subgraph => getMetadata(subgraph, 'lifecycleScope') === customScope,
+    );
+    const instantiatedSubgraphs = sameScopeSubgraphs.map(
+      (subgraph) => {
+        return this.resolve(subgraph, 'lifecycleOwner', props);
+      },
+    );
+    instantiatedSubgraphs.forEach(subgraph => referenceCounter.retain(subgraph));
+    this.registerOnClearListener(graph, () => {
+      instantiatedSubgraphs.forEach(subgraph => referenceCounter.release(subgraph, () => this.clear(subgraph)));
+    });
+  }
+
+  private assertInstantiatingCustomScopedSubgraphFromSameScope(graph: Graph) {
+    const graphScope = getMetadata(this.instanceToConstructor.get(graph)!, 'lifecycleScope');
+    const subgraphs = this.getSubgraphsConstructors(graph);
+    subgraphs.forEach((subgraph) => {
+      const subgraphScope = getMetadata(subgraph, 'lifecycleScope');
+      if (
+        !this.isInstantiated(subgraph)
+        && this.isCustomScopedLifecycleBound(subgraph)
+        && graphScope !== subgraphScope
+      ) {
+        throw new Error(`Cannot instantiate the scoped graph '${subgraph.name}' as a subgraph of '${graph.constructor.name}' because the scopes do not match. ${graphScope} !== ${subgraphScope}`);
+      }
+    });
+  }
+
+  private getSubgraphsConstructors(graph: Graph | Constructable<Graph>): Constructable<Graph>[] {
+    const Graph = typeof graph === 'function' ? graph : this.instanceToConstructor.get(graph)!;
+    const directSubgraphs = Array.from(this.graphToSubgraphs.get(Graph) ?? new Set<Constructable<Graph>>());
+    if (directSubgraphs.length === 0) return [];
+    return [
+      ...directSubgraphs,
+      ...new Set(
+        directSubgraphs
+          .map(subgraph => this.getSubgraphsConstructors(subgraph))
+          .flat(),
+      ),
+    ];
+  }
+
+  private getGraphConstructorByKey<T extends Graph>(key: string): Constructable<T> {
+    if (this.keyToGraph.has(key)) return this.keyToGraph.get(key) as Constructable<T>;
+    const generator = this.keyToGenerator.get(key);
+    if (!generator) throw new Error(`Attempted to resolve a graph by key "${key}" that is not registered. Did you forget to call Obsidian.registerGraph?`);
+    const constructor = generator();
+    this.keyToGraph.set(key, constructor);
+    return constructor as Constructable<T>;
+  }
+
   private has(Graph: Constructable<Graph>, injectionToken?: string): boolean {
     const instances = this.constructorToInstance.get(Graph);
     if (!instances) return false;
@@ -101,6 +179,11 @@ export class GraphRegistry {
     return getMetadata(Graph, 'lifecycleScope') === 'component';
   }
 
+  private isCustomScopedLifecycleBound(Graph: Constructable<Graph>): boolean {
+    const scope = getMetadata(Graph, 'lifecycleScope');
+    return typeof scope === 'string' && scope !== 'component' && scope !== 'feature';
+  }
+
   clearGraphAfterItWasMockedInTests(graphName: string) {
     const graphNames = this.nameToInstance.keys();
     for (const name of graphNames) {
@@ -118,6 +201,7 @@ export class GraphRegistry {
           this.injectionTokenToInstance.delete(token);
           this.instanceToInjectionToken.delete(graph);
         }
+        this.invokeOnClearListeners(graph);
       }
     }
   }
@@ -133,6 +217,32 @@ export class GraphRegistry {
       this.injectionTokenToInstance.delete(token);
       this.instanceToInjectionToken.delete(graph);
     }
+
+    this.clearGraphsRegisteredByKey(Graph);
+    this.invokeOnClearListeners(graph);
+  }
+
+  private registerOnClearListener(graph: Graph, callback: () => void) {
+    const listeners = this.onClearListeners.get(graph) ?? new Set();
+    listeners.add(callback);
+    this.onClearListeners.set(graph, listeners);
+  }
+
+  private invokeOnClearListeners(graph: Graph) {
+    const listeners = this.onClearListeners.get(graph);
+    if (!listeners) return;
+    listeners.forEach(listener => listener());
+    this.onClearListeners.delete(graph);
+  }
+
+  private clearGraphsRegisteredByKey(Graph: Constructable<Graph>) {
+    [...this.keyToGraph.keys()]
+      .map(key => [key, this.keyToGraph.get(key)!] as [string, Constructable<Graph>])
+      .filter(([_, $Graph]) => $Graph === Graph)
+      .forEach(([key, _]) => {
+        this.keyToGraph.delete(key);
+        this.keyToGenerator.delete(key);
+      });
   }
 
   addGraphMiddleware(middleware: Middleware<Graph>) {
@@ -149,10 +259,11 @@ export class GraphRegistry {
     this.nameToInstance.clear();
     this.injectionTokenToInstance.clear();
     this.instanceToInjectionToken.clear();
+    this.keyToGenerator.clear();
+    this.keyToGraph.clear();
   }
 }
 
-// @ts-expect-error - workaround an issue in jest tests where the registry was created multiple times
-global.graphRegistry = global.graphRegistry || new GraphRegistry();
-// @ts-expect-error - see above
-export default global.graphRegistry as GraphRegistry;
+const globalObject = getGlobal();
+globalObject.graphRegistry = globalObject.graphRegistry || new GraphRegistry();
+export default globalObject.graphRegistry as GraphRegistry;

package/src/injectors/class/ClassInjector.ts

@@ -12,14 +12,14 @@ export default class ClassInjector {
     private injectionMetadata: InjectionMetadata = new InjectionMetadata(),
   ) {}
 
-  inject(Graph: Constructable<Graph>) {
+  inject(keyOrGraph: string | Constructable<Graph>) {
     return (Target: Constructable<any>) => {
-      return new Proxy(Target, this.createProxyHandler(Graph, this.graphRegistry, this.injectionMetadata));
+      return new Proxy(Target, this.createProxyHandler(keyOrGraph, this.graphRegistry, this.injectionMetadata));
     };
   }
 
   private createProxyHandler(
-    Graph: Constructable<Graph>,
+    keyOrGraph: string | Constructable<Graph>,
     graphRegistry: GraphRegistry,
     injectionMetadata: InjectionMetadata,
   ): ProxyHandler<any> {
@@ -27,14 +27,14 @@ export default class ClassInjector {
       construct(target: any, args: any[], newTarget: Function): any {
         const isReactClassComponent = target.prototype?.isReactComponent;
         const source = isReactClassComponent ? 'lifecycleOwner' : 'classInjection';
-        const graph = graphRegistry.resolve(Graph, source, args.length > 0 ? args[0] : undefined);
+        const graph = graphRegistry.resolve(keyOrGraph, source, args.length > 0 ? args[0] : undefined);
         if (isReactClassComponent) {
           referenceCounter.retain(graph);
         }
         defineMetadata(target, GRAPH_INSTANCE_NAME_KEY, graph.name);
-        const argsToInject = this.injectConstructorArgs(args, graph, target);
+
         graph.onBind(target);
-        const createdObject = Reflect.construct(target, argsToInject, newTarget);
+        const createdObject = Reflect.construct(target, args, newTarget);
         this.injectProperties(target, createdObject, graph);
         const originalComponentWillUnmount: () => void | undefined = createdObject.componentWillUnmount;
         createdObject.componentWillUnmount = () => {
@@ -44,14 +44,6 @@ export default class ClassInjector {
         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/LateInjector.ts

@@ -1,3 +1,4 @@
+import { isString } from 'lodash';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import graphRegistry from '../../graph/registry/GraphRegistry';
 import { getMetadata } from '../../utils/reflect';
@@ -6,16 +7,22 @@ import InjectionMetadata from './InjectionMetadata';
 export const GRAPH_INSTANCE_NAME_KEY = 'GRAPH_INSTANCE_NAME';
 
 class LateInjector<T extends object> {
-  inject(target: T, sourceGraph?: ObjectGraph): T {
-    if (sourceGraph) graphRegistry.ensureRegistered(sourceGraph);
+  inject(target: T, keyOrGraph?: string | ObjectGraph): T {
+    if (keyOrGraph) graphRegistry.ensureRegistered(keyOrGraph);
     const injectionMetadata = new InjectionMetadata();
-    const graph = sourceGraph ?? this.getGraphInstance(target);
+    const graph = this.getGraph(target, keyOrGraph);
     injectionMetadata.getLatePropertiesToInject(target.constructor).forEach((key) => {
       Reflect.set(target, key, graph.retrieve(key));
     });
     return target;
   }
 
+  private getGraph(target: T, keyOrGraph?: string | ObjectGraph) {
+    if (keyOrGraph instanceof ObjectGraph) return keyOrGraph;
+    if (isString(keyOrGraph)) return graphRegistry.resolve(keyOrGraph, 'classInjection');
+    return this.getGraphInstance(target);
+  }
+
   private getGraphInstance(target: T) {
     const graphInstanceName = getMetadata(target.constructor, GRAPH_INSTANCE_NAME_KEY);
     return graphRegistry.getGraphInstance(graphInstanceName);

package/src/injectors/components/ComponentInjector.tsx

@@ -11,24 +11,24 @@ import { useInjectionToken } from './useInjectionToken';
 export default class ComponentInjector {
   inject<P>(
     Target: React.FunctionComponent<P>,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): React.FunctionComponent<Partial<P>> {
-    const Wrapped = this.wrapComponent(Target, Graph);
+    const Wrapped = this.wrapComponent(Target, keyOrGraph);
     hoistNonReactStatics(Wrapped, Target);
     return Wrapped;
   }
 
   private wrapComponent<P>(
     InjectionCandidate: React.FunctionComponent<P>,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): React.FunctionComponent<Partial<P>> {
     const isMemoized = isMemoizedComponent(InjectionCandidate);
     const Target = isMemoized ? InjectionCandidate.type : InjectionCandidate;
     const compare = isMemoized ? InjectionCandidate.compare : undefined;
 
     return genericMemo((passedProps: P) => {
-      const injectionToken = useInjectionToken(Graph);
-      const graph = useGraph<P>(Graph, Target, passedProps, injectionToken);
+      const injectionToken = useInjectionToken(keyOrGraph);
+      const graph = useGraph<P>(keyOrGraph, Target, passedProps, injectionToken);
       const proxiedProps = new PropsInjector(graph).inject(passedProps);
 
       return (

package/src/injectors/components/InjectComponent.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
+import { isString } from '../../utils/isString';
 import ComponentInjector from './ComponentInjector';
 
 interface Discriminator {
@@ -14,18 +15,18 @@ export const injectComponent = <OwnProps = Discriminator, InjectedProps = Discri
   (OwnProps extends infer P ? OwnProps extends Discriminator ? P : OwnProps : never) &
   (InjectedProps extends Discriminator ? any : InjectedProps)
   >,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ) => {
-  assertGraph(Graph, Target);
+  assertGraph(keyOrGraph, Target);
 
-  return componentInjector.inject(Target, Graph) as React.FunctionComponent<
+  return componentInjector.inject(Target, keyOrGraph) as React.FunctionComponent<
     InjectedProps extends Discriminator ?
       OwnProps extends Discriminator ? Partial<OwnProps> : OwnProps :
       OwnProps extends InjectedProps ? Partial<OwnProps> : OwnProps & Partial<InjectedProps>
   >;
 };
-function assertGraph(Graph: Constructable<ObjectGraph<unknown>>, Target: any) {
-  if (!Graph) {
+function assertGraph(keyOrGraph: string | Constructable<ObjectGraph>, Target: any) {
+  if (!isString(keyOrGraph) && !keyOrGraph) {
     throw new Error(
       `injectComponent was called with an undefined Graph.`
       + `This is probably not an issue with Obsidian.`

package/src/injectors/components/useGraph.ts

@@ -5,13 +5,13 @@ import graphRegistry from '../../graph/registry/GraphRegistry';
 import referenceCounter from '../../ReferenceCounter';
 
 export default <P>(
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
   target: any,
   props?: Partial<P>,
   injectionToken?: string,
 ) => {
   const [graph] = useState(() => {
-    const resolvedGraph = graphRegistry.resolve(Graph, 'lifecycleOwner', props, injectionToken);
+    const resolvedGraph = graphRegistry.resolve(keyOrGraph, 'lifecycleOwner', props, injectionToken);
     resolvedGraph.onBind(target);
     return resolvedGraph;
   });

package/src/injectors/components/useInjectionToken.ts

@@ -2,9 +2,12 @@ import { useContext, useState } from 'react';
 import { GraphContext } from './graphContext';
 import type { Constructable, ObjectGraph } from '../..';
 import { uniqueId } from '../../utils/uniqueId';
+import { isString } from '../../utils/isString';
 
-export const useInjectionToken = (Graph: Constructable<ObjectGraph>) => {
+export const useInjectionToken = (keyOrGraph: string | Constructable<ObjectGraph>) => {
   const ctx = useContext(GraphContext);
-  const [injectionToken] = useState(() => ctx?.injectionToken ?? uniqueId(Graph.name));
+  const [injectionToken] = useState(() => {
+    return ctx?.injectionToken ?? uniqueId(isString(keyOrGraph) ? keyOrGraph : keyOrGraph.name);
+  });
   return injectionToken;
 };

package/src/injectors/hooks/HookInjector.ts

@@ -6,10 +6,10 @@ import { Constructable } from '../../types';
 export default class HookInjector {
   inject<Args, Result>(
     hook: (args: Args) => Result,
-    Graph: Constructable<ObjectGraph>,
+    keyOrGraph: string | Constructable<ObjectGraph>,
   ): (args?: Partial<Args>) => Result {
     return (args?: Partial<Args>): Result => {
-      const graph = useGraph(Graph, hook, args);
+      const graph = useGraph(keyOrGraph, hook, args);
       return hook(new Proxy(args ?? {}, new Injector(graph)));
     };
   }

package/src/injectors/hooks/InjectHook.ts

@@ -11,14 +11,14 @@ const hookInjector = new HookInjector();
 
 export function injectHookWithArguments<Injected, Own, Result = {}>(
   hook: (args: Injected & Own) => Result,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ): (props: Own & Partial<Injected>) => Result {
-  return hookInjector.inject(hook, Graph) as (props: Own & Partial<Injected>) => Result;
+  return hookInjector.inject(hook, keyOrGraph) as (props: Own & Partial<Injected>) => Result;
 }
 
 export function injectHook<Injected, Result = {}>(
   hook: (args: Injected) => Result,
-  Graph: Constructable<ObjectGraph>,
+  keyOrGraph: string | Constructable<ObjectGraph>,
 ): (props?: Partial<Injected>) => Result {
-  return hookInjector.inject(hook, Graph);
+  return hookInjector.inject(hook, keyOrGraph);
 }

package/src/utils/getGlobal.ts

@@ -0,0 +1,3 @@
+export function getGlobal(): any {
+  return typeof window !== 'undefined' ? window : global;
+}

package/src/utils/isString.ts

@@ -0,0 +1,3 @@
+export function isString(value: any): value is string {
+  return typeof value === 'string';
+}

package/src/utils/reflect.ts

@@ -1,4 +1,12 @@
-const metadataStore = new WeakMap();
+import { getGlobal } from './getGlobal';
+
+function getStore(): WeakMap<any, any> {
+  const global = getGlobal();
+  global.__metadataStore = global.__metadataStore || new WeakMap();
+  return global.__metadataStore;
+}
+
+const metadataStore = getStore();
 
 export function defineMetadata(target: any, key: string, value: any) {
   let metadata = metadataStore.get(target);
@@ -15,3 +23,8 @@ export function getMetadata(target: any, key: string) {
   const metadata = metadataStore.get(target);
   return metadata ? metadata[key] : undefined;
 }
+
+export function hasMetadata(target: any, key: string) {
+  const metadata = metadataStore.get(target);
+  return metadata ? metadata[key] !== undefined : false;
+}

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

@@ -9,6 +9,7 @@ import {
   ObjectPattern,
   TSParameterProperty,
   Node,
+  type StringLiteral,
 } from '@babel/types';
 
 const never = '';
@@ -16,7 +17,7 @@ const never = '';
 export type AcceptedNodeType = Identifier | TSParameterProperty | ClassProperty;
 
 export function providerIsNotNamed(decorator: Decorator): boolean {
-  const argument = getDecoratorArgument(decorator);
+  const argument = getDecoratorObjectArgument(decorator);
   if (t.isObjectExpression(argument)) {
     return argument.properties.find((p) => {
       if (t.isObjectProperty(p)) {
@@ -29,7 +30,7 @@ export function providerIsNotNamed(decorator: Decorator): boolean {
 }
 
 export function addNameToProviderArguments(node: ClassMethod, decorator: Decorator) {
-  const argument = getDecoratorArgument(decorator) ?? t.objectExpression([]);
+  const argument = getDecoratorObjectArgument(decorator) ?? t.objectExpression([]);
   argument.properties.push(t.objectProperty(
     t.identifier('name'),
     t.stringLiteral(getMethodName(node)),
@@ -37,13 +38,20 @@ export function addNameToProviderArguments(node: ClassMethod, decorator: Decorat
   (decorator.expression as CallExpression).arguments = [argument];
 }
 
-export function getDecoratorArgument(decorator: Decorator): ObjectExpression | undefined {
+export function getDecoratorObjectArgument(decorator: Decorator): ObjectExpression | undefined {
   if (t.isCallExpression(decorator.expression)) {
     return decorator.expression.arguments.find(a => t.isObjectExpression(a)) as ObjectExpression;
   }
   return undefined;
 }
 
+export function getDecoratorStringArgument(decorator: Decorator): StringLiteral | undefined {
+  if (t.isCallExpression(decorator.expression)) {
+    return decorator.expression.arguments.find(a => t.isStringLiteral(a)) as StringLiteral;
+  }
+  return undefined;
+}
+
 export function getMethodName(node: ClassMethod): string {
   if (t.isIdentifier(node.key)) return node.key.name;
   throw new Error(`Tried to get class name but encountered unexpected key of type: ${node.key.type}`);

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

@@ -20,22 +20,27 @@ const internalVisitor = {
   ClassMethod: {
     enter({ node }: NodePath<ClassMethod>) {
       unmagler.saveClassMethod('provides', node);
+      unmagler.saveClassMethod('Provides', node);
     },
   },
   ClassProperty: {
     enter({ node }: NodePath<ClassProperty>) {
       unmagler.saveClassProperty('inject', node);
       unmagler.saveClassProperty('lateInject', node);
+      unmagler.saveClassProperty('Inject', node);
+      unmagler.saveClassProperty('LateInject', node);
     },
   },
   Identifier: {
     enter({ node }: NodePath<Identifier>) {
       unmagler.saveIdentifier('inject', node);
+      unmagler.saveIdentifier('Inject', node);
     },
   },
   TSParameterProperty: {
     enter({ node }: NodePath<TSParameterProperty>) {
       unmagler.saveTSParameterProperty('inject', node);
+      unmagler.saveTSParameterProperty('Inject', node);
     },
   },
 };

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

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

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

@@ -1,2 +0,0 @@
-export default function memoize<This, Return>(target: (this: This) => Return, context: ClassGetterDecoratorContext): (this: This) => Return;
-//# sourceMappingURL=Memoize.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Memoize.d.ts","sourceRoot":"","sources":["../../../src/decorators/Memoize.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,IAAI,EAAE,MAAM,EAC1C,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,EAC9B,OAAO,EAAE,2BAA2B,UAEZ,IAAI,KAAG,MAAM,CAMtC"}

package/dist/src/decorators/Memoize.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = memoize;
-function memoize(target, context) {
-    function memoizer() {
-        const value = target.call(this);
-        Object.defineProperty(this, context.name, { value, enumerable: true });
-        return value;
-    }
-    return memoizer;
-}
-//# sourceMappingURL=Memoize.js.map

package/dist/src/decorators/Memoize.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Memoize.js","sourceRoot":"","sources":["../../../src/decorators/Memoize.ts"],"names":[],"mappings":";;AAAA,0BAUC;AAVD,SAAwB,OAAO,CAC7B,MAA8B,EAC9B,OAAoC;IAEpC,SAAS,QAAQ;QACf,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QACvE,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/src/decorators/Memoize.ts

@@ -1,11 +0,0 @@
-export default function memoize<This, Return>(
-  target: (this: This) => Return,
-  context: ClassGetterDecoratorContext,
-) {
-  function memoizer(this: This): Return {
-    const value = target.call(this);
-    Object.defineProperty(this, context.name, { value, enumerable: true });
-    return value;
-  }
-  return memoizer;
-}