react-obsidian 0.0.47 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-obsidian",
-  "version": "0.0.47",
+  "version": "1.1.0",
   "description": "Dependency injection framework for React and React Native applications",
   "scripts": {
     "prepack": "npm run lint && tsc --project tsconfig.prod.json",

package/src/Obsidian.ts

@@ -1,13 +1,13 @@
 import graphRegistry from './graph/registry/GraphRegistry';
 import { ObjectGraph } from './graph/ObjectGraph';
-import { Constructable, GraphInternals, ServiceLocator } from './types';
+import { GraphInternals, ServiceLocator } 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 = any>(
-    Graph: Constructable<T>,
+  obtain<T extends ObjectGraph<P>, P>(
+    Graph: new(...args: P[]) => T,
     props?: P,
   ): ServiceLocator<Omit<T, GraphInternals>> {
     return serviceLocatorFactory.fromGraph(Graph, props);

package/src/graph/registry/GraphRegistry.ts

@@ -2,6 +2,7 @@ import { Constructable } from '../../types';
 import { Graph } from '../Graph';
 import { Middleware } from './Middleware';
 import GraphMiddlewareChain from './GraphMiddlewareChain';
+import { NullProps as createNullProps } from './NullProps';
 
 export class GraphRegistry {
   private readonly constructorToInstance = new Map<Constructable<Graph>, Set<Graph>>();
@@ -33,11 +34,18 @@ export class GraphRegistry {
     if ((this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph)) {
       return this.getFirst(Graph);
     }
-    const graph = this.graphMiddlewares.resolve(Graph, props);
+    const graph = this.graphMiddlewares.resolve(Graph, this.ensurePropsIfLifecycleBoundGraph(Graph, props));
     this.set(Graph, graph);
     return graph as T;
   }
 
+  private ensurePropsIfLifecycleBoundGraph<T extends Graph>(Graph: Constructable<T>, props?: any): any {
+    if (this.isBoundToReactLifecycle(Graph)) {
+      return props ?? createNullProps(Graph);
+    }
+    return props;
+  }
+
   private has(Graph: Constructable<Graph>): boolean {
     return (this.constructorToInstance.get(Graph)?.size ?? 0) > 0;
   }

package/src/graph/registry/NullProps.ts

@@ -0,0 +1,23 @@
+import type { Constructable } from '../../types';
+import { isDev } from '../../utils/isDev';
+import type { Graph } from '../Graph';
+
+export function NullProps(Graph: Constructable<Graph>) {
+  return new Proxy({}, new NullPropsProxyHandler(Graph));
+}
+
+class NullPropsProxyHandler implements ProxyHandler<{}> {
+  constructor(private graph: Constructable<Graph>) {}
+
+  get(target: object, property: string, receiver: any) {
+    if (property in target) return Reflect.get(target, property, receiver);
+    throw new Error(this.createErrorMessage(this.graph, property));
+  }
+
+  private createErrorMessage(graph: Constructable<Graph>, property: string) {
+    const graphName = isDev() ? graph.name : '';
+    return `Tried to get prop ${property} in a @LifecycleBound graph ${graphName}, but props were undefined. `
+    + `If you're using Obsidian.obtain(${graphName}) - then you should pass props to it explicitly: `
+    + `Obsidian.obtain(${graphName}, { ${property}: 'value' });`;
+  }
+}

package/src/observable/useObserver.ts

@@ -1,8 +1,19 @@
 /* eslint-disable no-param-reassign */
-import { useCallback, useEffect, useState } from 'react';
-import { Observable } from './types';
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+} from 'react';
+import { Observable } from './Observable';
 
-export function useObserver<T>(observable: Observable<T>): [T, (next: T) => void] {
+type ObservableOrGenerator<T> = Observable<T> | (() => Observable<T>);
+
+export function useObserver<T>(observableOrGenerator: ObservableOrGenerator<T>): [T, (next: T) => void] {
+  const observable = useMemo(
+    () => getOrGenerateObservable(observableOrGenerator),
+    [],
+  );
   const [value, setValue] = useState(observable.value);
   const onNext = useCallback((next: T) => {
     observable.value = next;
@@ -14,3 +25,7 @@ export function useObserver<T>(observable: Observable<T>): [T, (next: T) => void
 
   return [value, onNext];
 }
+
+function getOrGenerateObservable(observableOrGenerator: ObservableOrGenerator<any>) {
+  return observableOrGenerator instanceof Observable ? observableOrGenerator : observableOrGenerator();
+}

package/src/utils/isDev.ts

@@ -0,0 +1,12 @@
+export function isDev(): boolean {
+  return isNodeDev() || isReactNativeDev();
+}
+
+function isNodeDev(): boolean {
+  return ['test', 'development'].includes(process.env['NODE_ENV'] ?? '');
+}
+
+function isReactNativeDev(): boolean {
+  // @ts-ignore
+  return __DEV__ as boolean ?? false;
+}