feat: add flags for node modules, globals, and optional

closes #75

CHANGELOG.md

@@ -2,6 +2,8 @@ Change Log
 ==========
 ### 4.0.0
 - global dependencies such as `Window` and `Document` are now automatically resolved (unless you register your own dependency of the same name)
+- you can now control dependency resolution with config flags `nodeModules` and `globals`
+- you can also specify whether dependencies should be optional-by-default with an `optional` flag
 
 ### 3.5.1
 - building with webpack was giving warnings about `require` being used which meant it couldn't make optimizations

src/Jpex.ts

@@ -1,7 +1,6 @@
 import {
   JpexInstance as IJpex,
   AnyFunction,
-  Dependency,
   Factory,
   SetupConfig,
 } from './types';
@@ -13,20 +12,17 @@ import {
   factory,
   service,
   alias as createAlias,
-} from './deps';
+} from './registers';
 import {
   resolve,
-  resolveDependencies,
-  allResolved,
   getFactory,
 } from './resolver';
-import {
-  extractParameters,
-} from './utils';
+import encase from './encase';
+import clearCache from './clearCache';
 
 class Jpex implements IJpex {
   decorate: any;
-  $$defaultLifecycle: Lifecycle;
+  $$config: IJpex['$$config'];
   $$parent: IJpex;
   $$factories: {
     [key: string]: Factory,
@@ -38,11 +34,17 @@ class Jpex implements IJpex {
   constructor(options: SetupConfig = {}, parent?: IJpex) {
     const {
       inherit = true,
-      lifecycle = (inherit ? parent?.$$defaultLifecycle : void 0) ?? Lifecycle.CLASS,
+      ...config
     } = options;
 
     this.$$parent = parent;
-    this.$$defaultLifecycle = lifecycle;
+    this.$$config = {
+      lifecycle: inherit ? parent?.$$config.lifecycle : void 0 ?? Lifecycle.CLASS,
+      globals: true,
+      nodeModules: true,
+      optional: false,
+      ...config,
+    };
 
     if (parent && inherit) {
       this.$$factories = Object.create(parent.$$factories);
@@ -76,45 +78,12 @@ class Jpex implements IJpex {
     return getFactory(this, name, false).fn;
   }
 
-  encase<F extends AnyFunction, G extends AnyFunction<F>>(_deps: any, _fn?: any): any {
-    const [ dependencies, fn ] = ((): [ Dependency[], G ] => {
-      if (typeof _deps === 'function') {
-        return [ extractParameters(_deps), _deps ];
-      }
-      return [ _deps, _fn ];
-    })();
-    let result: AnyFunction;
-    const jpex = this;
-
-    const encased = function(...args: Parameters<F>) {
-      /* eslint-disable no-invalid-this */
-      if (result && allResolved(jpex, dependencies)) {
-        return result.apply(this, args);
-      }
-      const deps = resolveDependencies(jpex, { dependencies });
-
-      result = fn.apply(this, deps);
-
-      return result.apply(this, args);
-      /* eslint-enable */
-    };
-    encased.encased = fn;
-
-    return encased;
+  encase<F extends AnyFunction, G extends AnyFunction<F>>(deps: any, fn?: any): any {
+    return encase(this, deps, fn);
   }
 
   clearCache(names?: any): any {
-    names = [].concat(names || []);
-    for (const key in this.$$factories) {
-      if (!names.length || names.indexOf(key) > -1) {
-        this.$$factories[key].resolved = false;
-      }
-    }
-    for (const key in this.$$resolved) {
-      if (!names.length || names.indexOf(key) > -1) {
-        delete this.$$resolved[key];
-      }
-    }
+    return clearCache(this, names);
   }
 
   infer() {

src/clearCache.ts

@@ -0,0 +1,17 @@
+import { JpexInstance } from './types';
+
+const clearCache = (jpex: JpexInstance, names?: any): any => {
+  names = [].concat(names || []);
+  for (const key in jpex.$$factories) {
+    if (!names.length || names.indexOf(key) > -1) {
+      jpex.$$factories[key].resolved = false;
+    }
+  }
+  for (const key in jpex.$$resolved) {
+    if (!names.length || names.indexOf(key) > -1) {
+      delete jpex.$$resolved[key];
+    }
+  }
+};
+
+export default clearCache;

src/encase.ts

@@ -0,0 +1,35 @@
+import { JpexInstance, Dependency, AnyFunction } from './types';
+import { extractParameters } from './utils';
+import { allResolved, resolveDependencies } from './resolver';
+
+const encase = (
+  jpex: JpexInstance,
+  _deps: string[],
+  _fn?: any,
+): any => {
+  const [ dependencies, fn ] = ((): [ Dependency[], any ] => {
+    if (typeof _deps === 'function') {
+      return [ extractParameters(_deps), _deps ];
+    }
+    return [ _deps, _fn ];
+  })();
+  let result: AnyFunction;
+
+  const encased = function(...args: Parameters<any>) {
+    /* eslint-disable no-invalid-this */
+    if (result && allResolved(jpex, dependencies)) {
+      return result.apply(this, args);
+    }
+    const deps = resolveDependencies(jpex, { dependencies });
+
+    result = fn.apply(this, deps);
+
+    return result.apply(this, args);
+    /* eslint-enable */
+  };
+  encased.encased = fn;
+
+  return encased;
+};
+
+export default encase;

src/index.ts

@@ -1,5 +1,5 @@
 import Jpex from './Jpex';
-import { resolve as registerResolveFactory } from './factories';
+import { resolve as registerResolveFactory } from './built-ins';
 import type {
   JpexInstance,
   SetupConfig,

src/deps/factory.ts → src/registers/factory.ts

@@ -30,7 +30,7 @@ function factory(
   const f: Factory = {
     fn,
     dependencies,
-    lifecycle: jpex.$$defaultLifecycle,
+    lifecycle: jpex.$$config.lifecycle,
   };
   jpex.$$factories[name as string] = f;
 

src/resolver/resolve.ts

@@ -34,7 +34,7 @@ export const resolveOne = <R extends any>(
   }
 
   // Optional dependencies
-  let optional = false;
+  let optional = jpex.$$config.optional;
   const optionalCheck = checkOptional(name);
   if (optionalCheck) {
     console.warn('jpex: __ optional syntax has been deprecated and will be removed in v4.0.0');

src/resolver/utils.ts

@@ -31,6 +31,9 @@ const getFromNodeModules = (jpex: JpexInstance, target: string): Factory => {
   if (!isNode) {
     return;
   }
+  if (!jpex.$$config.nodeModules) {
+    return;
+  }
 
   try {
     const value = unsafeRequire(target);
@@ -75,6 +78,10 @@ const getGlobalProperty = (name: string) => {
   }
 };
 const getFromGlobal = (jpex: JpexInstance, name: string): Factory => {
+  if (!jpex.$$config.globals) {
+    return;
+  }
+
   const value = getGlobalProperty(name);
 
   if (value !== void 0) {
@@ -87,12 +94,12 @@ export const getFactory = (jpex: JpexInstance, name: string, optional: boolean)
   if (typeof name !== 'string') {
     throw new JpexError(`Name must be a string, but recevied ${typeof name}`);
   }
-  let factory: Factory = jpex.$$resolved[name as string];
+  let factory: Factory = jpex.$$resolved[name];
   if (isValidFactory(factory)) {
     return factory;
   }
 
-  factory = jpex.$$factories[name as string];
+  factory = jpex.$$factories[name];
   if (isValidFactory(factory)) {
     return factory;
   }
@@ -102,7 +109,7 @@ export const getFactory = (jpex: JpexInstance, name: string, optional: boolean)
     return factory;
   }
 
-  factory = getFromNodeModules(jpex, name as string);
+  factory = getFromNodeModules(jpex, name);
   if (isValidFactory(factory)) {
     return factory;
   }

src/types/JpexInstance.ts

@@ -1,5 +1,5 @@
 import { Lifecycle } from '../constants';
-import { Wrapper } from '../deps/wrapper';
+import { Wrapper } from '../registers/wrapper';
 import {
   AnyFunction,
   Dependency,
@@ -62,11 +62,16 @@ export interface JpexInstance {
   infer<T>(): string,
 
   $$parent: JpexInstance,
-  $$defaultLifecycle: Lifecycle,
   $$factories: {
     [key: string]: Factory,
   },
   $$resolved: {
     [key: string]: any,
   },
+  $$config: {
+    lifecycle: Lifecycle,
+    optional: boolean,
+    nodeModules: boolean,
+    globals: boolean,
+  },
 }

src/types/index.ts

@@ -8,8 +8,11 @@ export interface AnyConstructor<T = any> {
 }
 
 export interface SetupConfig {
-  lifecycle?: Lifecycle,
   inherit?: boolean,
+  lifecycle?: Lifecycle,
+  optional?: boolean,
+  nodeModules?: boolean,
+  globals?: boolean,
 }
 
 export type Dependency = string | { [key: string]: any };