react-obsidian 2.11.3 → 2.12.0

package/dist/src/injectors/components/useInjectionToken.js

@@ -4,9 +4,13 @@ exports.useInjectionToken = void 0;
 const react_1 = require("react");
 const graphContext_1 = require("./graphContext");
 const uniqueId_1 = require("../../utils/uniqueId");
-const useInjectionToken = (Graph) => {
+const isString_1 = require("../../utils/isString");
+const useInjectionToken = (keyOrGraph) => {
     const ctx = (0, react_1.useContext)(graphContext_1.GraphContext);
-    const [injectionToken] = (0, react_1.useState)(() => { var _a; return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.injectionToken) !== null && _a !== void 0 ? _a : (0, uniqueId_1.uniqueId)(Graph.name); });
+    const [injectionToken] = (0, react_1.useState)(() => {
+        var _a;
+        return (_a = ctx === null || ctx === void 0 ? void 0 : ctx.injectionToken) !== null && _a !== void 0 ? _a : (0, uniqueId_1.uniqueId)((0, isString_1.isString)(keyOrGraph) ? keyOrGraph : keyOrGraph.name);
+    });
     return injectionToken;
 };
 exports.useInjectionToken = useInjectionToken;

package/dist/src/injectors/components/useInjectionToken.js.map

@@ -1 +1 @@
-{"version":3,"file":"useInjectionToken.js","sourceRoot":"","sources":["../../../../src/injectors/components/useInjectionToken.ts"],"names":[],"mappings":";;;AAAA,iCAA6C;AAC7C,iDAA8C;AAE9C,mDAAgD;AAEzC,MAAM,iBAAiB,GAAG,CAAC,KAAiC,EAAE,EAAE;IACrE,MAAM,GAAG,GAAG,IAAA,kBAAU,EAAC,2BAAY,CAAC,CAAC;IACrC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAA,gBAAQ,EAAC,GAAG,EAAE,WAAC,OAAA,MAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,cAAc,mCAAI,IAAA,mBAAQ,EAAC,KAAK,CAAC,IAAI,CAAC,CAAA,EAAA,CAAC,CAAC;IACrF,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC;AAJW,QAAA,iBAAiB,qBAI5B"}
+{"version":3,"file":"useInjectionToken.js","sourceRoot":"","sources":["../../../../src/injectors/components/useInjectionToken.ts"],"names":[],"mappings":";;;AAAA,iCAA6C;AAC7C,iDAA8C;AAE9C,mDAAgD;AAChD,mDAAgD;AAEzC,MAAM,iBAAiB,GAAG,CAAC,UAA+C,EAAE,EAAE;IACnF,MAAM,GAAG,GAAG,IAAA,kBAAU,EAAC,2BAAY,CAAC,CAAC;IACrC,MAAM,CAAC,cAAc,CAAC,GAAG,IAAA,gBAAQ,EAAC,GAAG,EAAE;;QACrC,OAAO,MAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,cAAc,mCAAI,IAAA,mBAAQ,EAAC,IAAA,mBAAQ,EAAC,UAAU,CAAC,CAAA,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC7F,CAAC,CAAC,CAAC;IACH,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC;AANW,QAAA,iBAAiB,qBAM5B"}

package/dist/src/injectors/hooks/HookInjector.d.ts

@@ -1,6 +1,6 @@
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
 export default class HookInjector {
-    inject<Args, Result>(hook: (args: Args) => Result, Graph: Constructable<ObjectGraph>): (args?: Partial<Args>) => Result;
+    inject<Args, Result>(hook: (args: Args) => Result, keyOrGraph: string | Constructable<ObjectGraph>): (args?: Partial<Args>) => Result;
 }
 //# sourceMappingURL=HookInjector.d.ts.map

package/dist/src/injectors/hooks/HookInjector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HookInjector.d.ts","sourceRoot":"","sources":["../../../../src/injectors/hooks/HookInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,MAAM,CAAC,IAAI,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,EAC5B,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAChC,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM;CAMpC"}
+{"version":3,"file":"HookInjector.d.ts","sourceRoot":"","sources":["../../../../src/injectors/hooks/HookInjector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,MAAM,CAAC,IAAI,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,EAC5B,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,GAC9C,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM;CAMpC"}

package/dist/src/injectors/hooks/HookInjector.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const useGraph_1 = __importDefault(require("../components/useGraph"));
 class HookInjector {
-    inject(hook, Graph) {
+    inject(hook, keyOrGraph) {
         return (args) => {
-            const graph = (0, useGraph_1.default)(Graph, hook, args);
+            const graph = (0, useGraph_1.default)(keyOrGraph, hook, args);
             return hook(new Proxy(args !== null && args !== void 0 ? args : {}, new Injector(graph)));
         };
     }

package/dist/src/injectors/hooks/HookInjector.js.map

@@ -1 +1 @@
-{"version":3,"file":"HookInjector.js","sourceRoot":"","sources":["../../../../src/injectors/hooks/HookInjector.ts"],"names":[],"mappings":";;;;;AAEA,sEAA8C;AAG9C,MAAqB,YAAY;IAC/B,MAAM,CACJ,IAA4B,EAC5B,KAAiC;QAEjC,OAAO,CAAC,IAAoB,EAAU,EAAE;YACtC,MAAM,KAAK,GAAG,IAAA,kBAAQ,EAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAC1C,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,EAAE,EAAE,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC;IACJ,CAAC;CACF;AAVD,+BAUC;AAED,MAAM,QAAQ;IACZ,YAAoB,KAAY;QAAZ,UAAK,GAAL,KAAK,CAAO;IAAG,CAAC;IAEpC,GAAG,CAAC,GAAQ,EAAE,QAAgB,EAAE,QAAa;QAC3C,OAAO,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACnF,CAAC;CACF"}
+{"version":3,"file":"HookInjector.js","sourceRoot":"","sources":["../../../../src/injectors/hooks/HookInjector.ts"],"names":[],"mappings":";;;;;AAEA,sEAA8C;AAG9C,MAAqB,YAAY;IAC/B,MAAM,CACJ,IAA4B,EAC5B,UAA+C;QAE/C,OAAO,CAAC,IAAoB,EAAU,EAAE;YACtC,MAAM,KAAK,GAAG,IAAA,kBAAQ,EAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAC/C,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,EAAE,EAAE,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC;IACJ,CAAC;CACF;AAVD,+BAUC;AAED,MAAM,QAAQ;IACZ,YAAoB,KAAY;QAAZ,UAAK,GAAL,KAAK,CAAO;IAAG,CAAC;IAEpC,GAAG,CAAC,GAAQ,EAAE,QAAgB,EAAE,QAAa;QAC3C,OAAO,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACnF,CAAC;CACF"}

package/dist/src/injectors/hooks/InjectHook.d.ts

@@ -1,5 +1,5 @@
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
-export declare function injectHookWithArguments<Injected, Own, Result = {}>(hook: (args: Injected & Own) => Result, Graph: Constructable<ObjectGraph>): (props: Own & Partial<Injected>) => Result;
-export declare function injectHook<Injected, Result = {}>(hook: (args: Injected) => Result, Graph: Constructable<ObjectGraph>): (props?: Partial<Injected>) => Result;
+export declare function injectHookWithArguments<Injected, Own, Result = {}>(hook: (args: Injected & Own) => Result, keyOrGraph: string | Constructable<ObjectGraph>): (props: Own & Partial<Injected>) => Result;
+export declare function injectHook<Injected, Result = {}>(hook: (args: Injected) => Result, keyOrGraph: string | Constructable<ObjectGraph>): (props?: Partial<Injected>) => Result;
 //# sourceMappingURL=InjectHook.d.ts.map

package/dist/src/injectors/hooks/InjectHook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InjectHook.d.ts","sourceRoot":"","sources":["../../../../src/injectors/hooks/InjectHook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU5C,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,EAChE,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,GAAG,GAAG,KAAK,MAAM,EACtC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAChC,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAE5C;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,EAC9C,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,EAChC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAChC,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAEvC"}
+{"version":3,"file":"InjectHook.d.ts","sourceRoot":"","sources":["../../../../src/injectors/hooks/InjectHook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU5C,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,EAAE,EAChE,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,GAAG,GAAG,KAAK,MAAM,EACtC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,GAC9C,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAE5C;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,EAC9C,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,EAChC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,GAC9C,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAEvC"}

package/dist/src/injectors/hooks/InjectHook.js

@@ -10,12 +10,12 @@ const hookInjector = new HookInjector_1.default();
 // As a workaround, we provide two injection functions with an almost identical signature.
 // 1. injectHookWithArguments: Should be used when a hook requires parameters in addition to the injected dependencies.
 // 2. injectHook: Should be used when a hook does not require parameters.
-function injectHookWithArguments(hook, Graph) {
-    return hookInjector.inject(hook, Graph);
+function injectHookWithArguments(hook, keyOrGraph) {
+    return hookInjector.inject(hook, keyOrGraph);
 }
 exports.injectHookWithArguments = injectHookWithArguments;
-function injectHook(hook, Graph) {
-    return hookInjector.inject(hook, Graph);
+function injectHook(hook, keyOrGraph) {
+    return hookInjector.inject(hook, keyOrGraph);
 }
 exports.injectHook = injectHook;
 //# sourceMappingURL=InjectHook.js.map

package/dist/src/injectors/hooks/InjectHook.js.map

@@ -1 +1 @@
-{"version":3,"file":"InjectHook.js","sourceRoot":"","sources":["../../../../src/injectors/hooks/InjectHook.ts"],"names":[],"mappings":";;;;;;AAGA,kEAA0C;AAE1C,MAAM,YAAY,GAAG,IAAI,sBAAY,EAAE,CAAC;AAExC,6HAA6H;AAC7H,0FAA0F;AAC1F,uHAAuH;AACvH,yEAAyE;AAEzE,SAAgB,uBAAuB,CACrC,IAAsC,EACtC,KAAiC;IAEjC,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAA+C,CAAC;AACxF,CAAC;AALD,0DAKC;AAED,SAAgB,UAAU,CACxB,IAAgC,EAChC,KAAiC;IAEjC,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAC1C,CAAC;AALD,gCAKC"}
+{"version":3,"file":"InjectHook.js","sourceRoot":"","sources":["../../../../src/injectors/hooks/InjectHook.ts"],"names":[],"mappings":";;;;;;AAGA,kEAA0C;AAE1C,MAAM,YAAY,GAAG,IAAI,sBAAY,EAAE,CAAC;AAExC,6HAA6H;AAC7H,0FAA0F;AAC1F,uHAAuH;AACvH,yEAAyE;AAEzE,SAAgB,uBAAuB,CACrC,IAAsC,EACtC,UAA+C;IAE/C,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,CAA+C,CAAC;AAC7F,CAAC;AALD,0DAKC;AAED,SAAgB,UAAU,CACxB,IAAgC,EAChC,UAA+C;IAE/C,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;AAC/C,CAAC;AALD,gCAKC"}

package/dist/src/utils/isString.d.ts

@@ -0,0 +1,2 @@
+export declare function isString(value: any): value is string;
+//# sourceMappingURL=isString.d.ts.map

package/dist/src/utils/isString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.d.ts","sourceRoot":"","sources":["../../../src/utils/isString.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAEpD"}

package/dist/src/utils/isString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = void 0;
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+//# sourceMappingURL=isString.js.map

package/dist/src/utils/isString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.js","sourceRoot":"","sources":["../../../src/utils/isString.ts"],"names":[],"mappings":";;;AAAA,SAAgB,QAAQ,CAAC,KAAU;IACjC,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACnC,CAAC;AAFD,4BAEC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-obsidian",
-  "version": "2.11.3",
+  "version": "2.12.0",
   "description": "Dependency injection framework for React and React Native applications",
   "scripts": {
     "prepack": "npm run lint && tsc --project tsconfig.prod.json",
@@ -47,7 +47,7 @@
     "eslint-plugin-import": "^2.25.2",
     "eslint-plugin-import-newlines": "^1.1.5",
     "eslint-plugin-jest-formatting": "^3.1.0",
-    "eslint-plugin-obsidian": "2.11.3",
+    "eslint-plugin-obsidian": "2.12.0",
     "eslint-plugin-react": "^7.26.1",
     "eslint-plugin-react-hooks": "^4.2.0",
     "eslint-plugin-unused-imports": "3.1.x",

package/src/Obsidian.ts

@@ -1,20 +1,24 @@
 import graphRegistry from './graph/registry/GraphRegistry';
 import { ObjectGraph } from './graph/ObjectGraph';
-import { GraphInternals, ServiceLocator } from './types';
+import { GraphInternals, ServiceLocator, type Constructable } from './types';
 import { GraphMiddleware } from './graph/registry/GraphMiddleware';
 import lateInjector from './injectors/class/LateInjector';
 import serviceLocatorFactory from './graph/ServiceLocatorFactory';
 
 export default class Obsidian {
-  obtain<T extends ObjectGraph<P>, P>(
-    Graph: new(...args: P[]) => T,
+  registerGraph(key: string, generator: () => Constructable<ObjectGraph>) {
+    graphRegistry.registerGraphGenerator(key, generator);
+  }
+
+  obtain<T extends ObjectGraph<P>, P = unknown>(
+    keyOrGraph: string | (new(...args: P[]) => T),
     props?: P,
   ): ServiceLocator<Omit<T, GraphInternals>> {
-    return serviceLocatorFactory.fromGraph(Graph, props);
+    return serviceLocatorFactory.fromGraph(keyOrGraph, props);
   }
 
-  inject<T extends object>(target: T, graph?: ObjectGraph) {
-    return lateInjector.inject(target, graph);
+  inject<T extends object>(target: T, keyOrGraph?: string | ObjectGraph) {
+    return lateInjector.inject(target, keyOrGraph);
   }
 
   addGraphMiddleware(middleware: GraphMiddleware) {

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,5 +1,4 @@
 import { uniqueId } from '../utils/uniqueId';
-import Memoize from '../decorators/Memoize';
 import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
@@ -9,9 +8,13 @@ import { CircularDependenciesDetector } from './CircularDependenciesDetector';
 export abstract class ObjectGraph<T = unknown> implements Graph {
   private propertyRetriever = new PropertyRetriever(this);
 
-  @Memoize()
   get name(): string {
-    return uniqueId(this.constructor.name);
+    if (Reflect.hasMetadata('memoizedName', this)) {
+      return Reflect.getMetadata('memoizedName', this);
+    }
+    const name = uniqueId(this.constructor.name);
+    Reflect.defineMetadata('memoizedName', name, this);
+    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,7 @@ import { Middleware } from './Middleware';
 import GraphMiddlewareChain from './GraphMiddlewareChain';
 import { ObtainLifecycleBoundGraphException } from './ObtainLifecycleBoundGraphException';
 import { getGlobal } from '../../utils/getGlobal';
+import { isString } from '../../utils/isString';
 
 export class GraphRegistry {
   private readonly constructorToInstance = new Map<Constructable<Graph>, Set<Graph>>();
@@ -13,12 +14,21 @@ 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>>();
 
   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);
   }
@@ -34,12 +44,15 @@ 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 {
-    if ((this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph, injectionToken)) {
+    const Graph = isString(keyOrGraph) ?
+      this.getGraphConstructorByKey<T>(keyOrGraph) :
+      keyOrGraph as Constructable<T>;
+    if (( this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph, injectionToken)) {
       return this.isComponentScopedLifecycleBound(Graph) ?
         this.getByInjectionToken(Graph, injectionToken) :
         this.getFirst(Graph);
@@ -52,6 +65,15 @@ export class GraphRegistry {
     return graph as T;
   }
 
+  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;
@@ -133,6 +155,18 @@ export class GraphRegistry {
       this.injectionTokenToInstance.delete(token);
       this.instanceToInjectionToken.delete(graph);
     }
+
+    this.clearGraphsRegisteredByKey(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,6 +183,8 @@ export class GraphRegistry {
     this.nameToInstance.clear();
     this.injectionTokenToInstance.clear();
     this.instanceToInjectionToken.clear();
+    this.keyToGenerator.clear();
+    this.keyToGraph.clear();
   }
 }
 

package/src/injectors/class/ClassInjector.ts

@@ -11,14 +11,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> {
@@ -26,7 +26,7 @@ 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);
         }

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 InjectionMetadata from './InjectionMetadata';
@@ -5,16 +6,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 = Reflect.getMetadata(GRAPH_INSTANCE_NAME_KEY, target.constructor);
     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,5 +1,6 @@
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
+import { isString } from '../../utils/isString';
 import ComponentInjector from './ComponentInjector';
 
 interface Discriminator {
@@ -13,18 +14,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,14 +5,14 @@ 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

@@ -12,14 +12,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/isString.ts

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

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

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-export default function Memoize(): (_Clazz: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-//# 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":"AACA,OAAO,kBAAkB,CAAC;AAE1B,MAAM,CAAC,OAAO,UAAU,OAAO,aACG,GAAG,eAAe,MAAM,cAAc,kBAAkB,wBAazF"}

package/dist/src/decorators/Memoize.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-param-reassign */
-require("reflect-metadata");
-function Memoize() {
-    return function provide(_Clazz, propertyKey, descriptor) {
-        const originalGet = descriptor.get;
-        descriptor.get = function get() {
-            const key = `memoized${propertyKey}`;
-            if (Reflect.hasMetadata(key, this)) {
-                return Reflect.getMetadata(key, this);
-            }
-            const value = originalGet.call(this);
-            Reflect.defineMetadata(key, value, this);
-            return value;
-        };
-        return descriptor;
-    };
-}
-exports.default = Memoize;
-//# 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,sCAAsC;AACtC,4BAA0B;AAE1B,SAAwB,OAAO;IAC7B,OAAO,SAAS,OAAO,CAAC,MAAW,EAAE,WAAmB,EAAE,UAA8B;QACtF,MAAM,WAAW,GAAG,UAAU,CAAC,GAAI,CAAC;QACpC,UAAU,CAAC,GAAG,GAAG,SAAS,GAAG;YAC3B,MAAM,GAAG,GAAG,WAAW,WAAW,EAAE,CAAC;YACrC,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE;gBAClC,OAAO,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;aACvC;YACD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YACzC,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;QACF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC;AAdD,0BAcC"}

package/src/decorators/Memoize.ts

@@ -1,18 +0,0 @@
-/* eslint-disable no-param-reassign */
-import 'reflect-metadata';
-
-export default function Memoize() {
-  return function provide(_Clazz: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    const originalGet = descriptor.get!;
-    descriptor.get = function get() {
-      const key = `memoized${propertyKey}`;
-      if (Reflect.hasMetadata(key, this)) {
-        return Reflect.getMetadata(key, this);
-      }
-      const value = originalGet.call(this);
-      Reflect.defineMetadata(key, value, this);
-      return value;
-    };
-    return descriptor;
-  };
-}