react-obsidian 0.0.11 → 0.0.15

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 '../utils/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,11 @@
+/* eslint-disable no-param-reassign */
+import providedPropertiesStore from '../ProvidedPropertiesStore';
+import { Graph } from './Graph';
+
+export function bindProviders(graph: Graph & Record<string, any>) {
+  providedPropertiesStore.getMangledProperties(graph)
+    .filter((method) => graph[method])
+    .forEach((method) => {
+      graph[method] = graph[method].bind(graph);
+    });
+}

package/src/graph/registry/GraphRegistry.ts

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

package/src/index.ts

@@ -8,11 +8,13 @@ import { Constructable } from './types';
 export * from './types';
 
 export { Graph } from './decorators/Graph';
+export { Singleton } from './decorators/Singleton';
 export { ObjectGraph } from './graph/ObjectGraph';
 export { Graph as IGraph } from './graph/Graph';
 export { Provides } from './decorators/provides/Provides';
-export { Injectable } from './decorators/injectClass';
-export { Inject } from './decorators/injectClass';
+export { Injectable } from './decorators/inject/Injectable';
+export { Inject } from './decorators/inject/Inject';
+export { LazyInject } from './decorators/inject/LazyInject';
 export { GraphMiddleware } from './graph/registry/GraphMiddleware';
 export { GraphResolveChain as ResolveChain } from './graph/registry/GraphResolveChain';
 export const Obsidian = new _Obsidian();

package/src/injectors/class/ClassInjector.ts

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

package/src/injectors/class/ConstructorArgs.ts

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

package/src/injectors/class/InjectionMetadata.ts

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

package/src/injectors/class/LazyInjector.ts

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

package/src/injectors/components/ComponentInjector.tsx

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

package/src/types/index.ts

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

package/testkit/index.ts

@@ -1,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

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

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

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

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

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

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

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

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

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

package/dist/src/ScopedValuesRegistry.d.ts

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

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

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

package/dist/src/ScopedValuesRegistry.js

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

package/dist/src/ScopedValuesRegistry.js.map

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

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

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

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

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

package/dist/src/decorators/injectClass.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Inject = exports.Injectable = void 0;
-var GraphRegistry_1 = __importDefault(require("../graph/registry/GraphRegistry"));
-var injectionMetadataKey = 'injectionMetadata';
-function Injectable(Graph) {
-    return function (Target) {
-        var proxy = {
-            construct: function (target, args, newTarget) {
-                var _a;
-                var keysToInject = (_a = Reflect.getMetadata(injectionMetadataKey, target)) !== null && _a !== void 0 ? _a : [];
-                var createdObject = Reflect.construct(target, args, newTarget);
-                var graph = GraphRegistry_1.default.resolve(Graph);
-                for (var _i = 0, keysToInject_1 = keysToInject; _i < keysToInject_1.length; _i++) {
-                    var key = keysToInject_1[_i];
-                    Reflect.set(createdObject, key, graph.retrieve(key));
-                }
-                return createdObject;
-            },
-        };
-        return new Proxy(Target, proxy);
-    };
-}
-exports.Injectable = Injectable;
-function Inject(target, propertyKey) {
-    var _a;
-    var keysToInject = (_a = Reflect.getMetadata(injectionMetadataKey, target.constructor)) !== null && _a !== void 0 ? _a : new Set();
-    Reflect.defineMetadata(injectionMetadataKey, keysToInject.add(propertyKey), target.constructor);
-}
-exports.Inject = Inject;
-//# sourceMappingURL=injectClass.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectClass.js","sourceRoot":"","sources":["../../../src/decorators/injectClass.ts"],"names":[],"mappings":";;;;;;AACA,kFAA4D;AAG5D,IAAM,oBAAoB,GAAG,mBAAmB,CAAC;AAEjD,SAAgB,UAAU,CAAyC,KAAiC;IAClG,OAAO,UAAC,MAAS;QACf,IAAM,KAAK,GAAG;YACZ,SAAS,EAAT,UAAU,MAAW,EAAE,IAAW,EAAE,SAAc;;gBAChD,IAAM,YAAY,GAAa,MAAA,OAAO,CAAC,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,mCAAI,EAAE,CAAC;gBAEvF,IAAM,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;gBACjE,IAAM,KAAK,GAAG,uBAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC3C,KAAkB,UAAY,EAAZ,6BAAY,EAAZ,0BAAY,EAAZ,IAAY,EAAE;oBAA3B,IAAM,GAAG,qBAAA;oBACZ,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;iBACtD;gBACD,OAAO,aAAa,CAAC;YACvB,CAAC;SACF,CAAC;QACF,OAAO,IAAI,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC,CAAC;AACJ,CAAC;AAhBD,gCAgBC;AAED,SAAgB,MAAM,CAAC,MAAc,EAAE,WAAmB;;IACxD,IAAM,YAAY,GAAG,MAAA,OAAO,CAAC,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,WAAW,CAAC,mCAAI,IAAI,GAAG,EAAE,CAAC;IAChG,OAAO,CAAC,cAAc,CAAC,oBAAoB,EAAE,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;AAClG,CAAC;AAHD,wBAGC"}

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

@@ -1,2 +0,0 @@
-export declare function autobind(target: Record<string, any>): void;
-//# sourceMappingURL=autobind.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"autobind.d.ts","sourceRoot":"","sources":["../../../src/utils/autobind.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QAQnD"}

package/dist/src/utils/autobind.js

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autobind = void 0;
-var lodash_1 = __importDefault(require("lodash"));
-/* eslint-disable no-param-reassign */
-function autobind(target) {
-    var methods = Object.getOwnPropertyNames(Object.getPrototypeOf(target));
-    methods
-        .filter(function (method) { return (method !== 'constructor'); })
-        .filter(function (method) { return lodash_1.default.isFunction(target[method]); })
-        .forEach(function (method) {
-        target[method] = target[method].bind(target);
-    });
-}
-exports.autobind = autobind;
-//# sourceMappingURL=autobind.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"autobind.js","sourceRoot":"","sources":["../../../src/utils/autobind.ts"],"names":[],"mappings":";;;;;;AAAA,kDAAuB;AAEvB,sCAAsC;AACtC,SAAgB,QAAQ,CAAC,MAA2B;IAClD,IAAM,OAAO,GAAG,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1E,OAAO;SACJ,MAAM,CAAC,UAAC,MAAM,IAAK,OAAA,CAAC,MAAM,KAAK,aAAa,CAAC,EAA1B,CAA0B,CAAC;SAC9C,MAAM,CAAC,UAAC,MAAM,IAAK,OAAA,gBAAC,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAA5B,CAA4B,CAAC;SAChD,OAAO,CAAC,UAAC,MAAM;QACd,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;AACP,CAAC;AARD,4BAQC"}

package/dist/transformers/babel-plugin-obsidian-provide/helpers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../transformers/babel-plugin-obsidian-provide/helpers/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,WAAW,EACX,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,cAAc,CAAC;AAGtB,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAWhE;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,QAOjF;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS,GAAG,gBAAgB,GAAG,SAAS,CAKvF;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAGvD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAE3G;AAED,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAE1E;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,EAAE,GAAG,aAAa,CAI3F"}