react-obsidian 0.0.40 → 0.0.42

package/documentation/package.json

@@ -19,6 +19,7 @@
     "@docusaurus/preset-classic": "2.2.0",
     "@mdx-js/react": "^1.6.22",
     "clsx": "^1.2.1",
+    "enhancedocs-search": "^0.1.5",
     "prism-react-renderer": "^1.3.5",
     "react": "^17.0.2",
     "react-dom": "^17.0.2"

package/documentation/src/theme/SearchBar.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import EnhancedSearch from 'enhancedocs-search';
+
+import 'enhancedocs-search/dist/style.css';
+
+export default function SearchBarWrapper(props) {
+  return (
+    <EnhancedSearch
+      config={{
+        enhancedSearch: {
+          projectId: '642ef48a9b7dab8fff36a55b',
+          accessToken: 'pk_b6c6de86cb63d0857b2a96b3f90ec2906be49358981ac67f'
+        }
+      }}
+      theme={{
+        primaryColor: '#B94BEE'
+      }}
+      {...props}
+    />
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-obsidian",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "Dependency injection framework for React and React Native applications",
   "scripts": {
     "prepack": "npm run lint && tsc --project tsconfig.prod.json",
@@ -8,7 +8,7 @@
     "pretest": "tsc",
     "test": "npx jest"
   },
-  "main": "src/index.ts",
+  "main": "dist/src/index.js",
   "directories": {
     "test": "test"
   },

package/src/graph/CircularDependenciesDetector.ts

@@ -0,0 +1,23 @@
+import { VisitedNodes } from './VisitedNodes';
+
+export class CircularDependenciesDetector {
+  private visitedNodes = new VisitedNodes();
+
+  constructor(public graphName: string) {}
+
+  public visit(graphName: string, dependencyName: string): boolean {
+    return this.visitedNodes.visit(graphName, dependencyName);
+  }
+
+  public hasCircularDependencies(): boolean {
+    return this.visitedNodes.isCircularPath();
+  }
+
+  public getDependencies(): string[] {
+    return this.visitedNodes.getNodes();
+  }
+
+  public get firstDependencyName(): string {
+    return this.visitedNodes.getNodes()[0];
+  }
+}

package/src/graph/ObjectGraph.ts

@@ -4,6 +4,7 @@ import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
 import { Constructable } from '../types';
+import { CircularDependenciesDetector } from './CircularDependenciesDetector';
 
 export abstract class ObjectGraph<T = unknown> implements Graph {
   private propertyRetriever = new PropertyRetriever(this);
@@ -17,8 +18,12 @@ export abstract class ObjectGraph<T = unknown> implements Graph {
     bindProviders(this);
   }
 
-  retrieve<Dependency>(property: string, receiver?: unknown): Dependency | undefined {
-    return this.propertyRetriever.retrieve(property, receiver) as Dependency | undefined;
+  retrieve<Dependency>(
+    property: string,
+    receiver?: unknown,
+    detector?: CircularDependenciesDetector,
+  ): Dependency | undefined {
+    return this.propertyRetriever.retrieve(property, receiver, detector) as Dependency | undefined;
   }
 
   onBind(_target: any) {

package/src/graph/PropertyRetriever.ts

@@ -1,22 +1,41 @@
 import graphRegistry from './registry/GraphRegistry';
 import { Graph } from './Graph';
 import providedPropertiesStore from '../ProvidedPropertiesStore';
+import { CircularDependenciesDetector } from './CircularDependenciesDetector';
 
 export default class PropertyRetriever {
   constructor(private graph: Graph) { }
 
-  retrieve(property: string, receiver?: unknown): unknown | undefined {
+  retrieve(
+    property: string,
+    receiver?: unknown,
+    maybeDetector?: CircularDependenciesDetector,
+  ): unknown | undefined {
     const mangledPropertyKey = providedPropertiesStore.getMangledProperty(this.graph, property);
-    if (mangledPropertyKey && mangledPropertyKey in this.graph) {
+    const circularDependenciesDetector = maybeDetector ?? new CircularDependenciesDetector(this.graph.name);
+
+    if (
+      mangledPropertyKey
+      && mangledPropertyKey in this.graph
+      && circularDependenciesDetector.visit(this.graph.name, property)
+    ) {
       const proxiedGraph = new Proxy(this.graph, {
         get(graph: Graph, dependencyName: string) {
-          return graph.retrieve(dependencyName);
+          return graph.retrieve(dependencyName, receiver, circularDependenciesDetector);
         },
       });
       return Reflect.get(this.graph, mangledPropertyKey, receiver)(proxiedGraph);
     }
 
-    const results = this.getFromSubgraphs(property, receiver);
+    if (circularDependenciesDetector.hasCircularDependencies()) {
+      throw new Error(
+        `Could not resolve ${circularDependenciesDetector.firstDependencyName}`
+         + ` from ${circularDependenciesDetector.graphName} because of a circular dependency:`
+         + ` ${circularDependenciesDetector.getDependencies().join(' -> ')}`,
+      );
+    }
+
+    const results = this.getFromSubgraphs(property, circularDependenciesDetector, receiver);
     if (results.length === 1) return results[0];
     if (results.length > 1) {
       throw new Error(
@@ -27,10 +46,14 @@ export default class PropertyRetriever {
     return undefined;
   }
 
-  private getFromSubgraphs(property: string, receiver: unknown): unknown[] {
+  private getFromSubgraphs(
+    property: string,
+    circularDependenciesDetector: CircularDependenciesDetector,
+    receiver: unknown,
+  ): unknown[] {
     const subgraphs = graphRegistry.getSubgraphs(this.graph);
     return subgraphs
-      .map((subgraph: Graph) => subgraph.retrieve(property, receiver))
+      .map((subgraph: Graph) => subgraph.retrieve(property, receiver, circularDependenciesDetector))
       .filter((result) => result !== undefined);
   }
 }

package/src/graph/PropertyRetrieverDelegate.ts

@@ -1,5 +1,11 @@
+import { CircularDependenciesDetector } from './CircularDependenciesDetector';
+
 interface PropertyRetrieverDelegate {
-  retrieve: (property: string, receiver?: unknown) => unknown | undefined;
+  retrieve: (
+    property: string,
+    receiver?: unknown,
+    circularDependenciesDetector?: CircularDependenciesDetector
+  ) => unknown | undefined;
 }
 
 export default PropertyRetrieverDelegate;

package/src/graph/VisitedNodes.ts

@@ -0,0 +1,25 @@
+export class VisitedNodes {
+  private visitedNodes = new Set<`${string}.${string}`>();
+  private visitPath: string[] = [];
+
+  public visit(graphName: string, dependencyName: string): boolean {
+    this.visitPath.push(dependencyName);
+    if (this.canVisit(graphName, dependencyName)) {
+      this.visitedNodes.add(`${graphName}.${dependencyName}`);
+      return true;
+    }
+    return false;
+  }
+
+  public canVisit(graphName: string, dependencyName: string) {
+    return !this.visitedNodes.has(`${graphName}.${dependencyName}`);
+  }
+
+  public isCircularPath(): boolean {
+    return this.visitedNodes.size < this.visitPath.length;
+  }
+
+  getNodes(): string[] {
+    return this.visitPath;
+  }
+}

package/tsconfig.base.json

@@ -10,7 +10,7 @@
     "dist"
   ],
   "compilerOptions": {
-    "target": "es5",
+    "target": "es2018",
     "module": "commonjs",
     "lib": [
       "ES6",