From 6b12b661300d5b792b97ffcb039a3f4be8342907 Mon Sep 17 00:00:00 2001
From: RWOverdijk <r.w.overdijk@gmail.com>
Date: Sat, 22 Sep 2018 20:27:58 +0200
Subject: [PATCH] feat(ServiceManager): fix typings and add support for
 shareable services

---
 .../ServiceManager/FactoryInterface.ts        |  2 +-
 src/Library/ServiceManager/ServiceManager.ts  | 28 ++++++++++++++-----
 .../ServiceManagerConfigInterface.ts          | 10 +++----
 3 files changed, 27 insertions(+), 13 deletions(-)

diff --git a/src/Library/ServiceManager/FactoryInterface.ts b/src/Library/ServiceManager/FactoryInterface.ts
index ad356fa..078cc29 100644
--- a/src/Library/ServiceManager/FactoryInterface.ts
+++ b/src/Library/ServiceManager/FactoryInterface.ts
@@ -1,2 +1,2 @@
-export interface FactoryInterface {
+export interface FactoryInterface extends Function {
 }
diff --git a/src/Library/ServiceManager/ServiceManager.ts b/src/Library/ServiceManager/ServiceManager.ts
index fb8055d..20d3a5d 100644
--- a/src/Library/ServiceManager/ServiceManager.ts
+++ b/src/Library/ServiceManager/ServiceManager.ts
@@ -1,6 +1,7 @@
 import { ServiceManagerInterface } from './ServiceManagerInterface';
-import { ServicesMapType, FactoriesMapType, AliasesType, ServiceKeyType, ServiceFactoryType, SharedMapType, ServiceManagerConfigType, ServiceType } from './ServiceManagerConfigInterface';
+import { ServicesMapType, FactoriesMapType, AliasesType, ServiceKeyType, ServiceFactoryType, SharedMapType, ServiceManagerConfigType } from './ServiceManagerConfigInterface';
 import { NotFoundError } from '../Error';
+import { Instantiable } from '../Core/Types';
 
 /**
  * @export
@@ -29,7 +30,7 @@ export class ServiceManager implements ServiceManagerInterface {
   }
 
   public get<T>(Service: ServiceKeyType<T>, forceTransient: boolean = false): T {
-    const resolvedName = this.resolveName(Service) as ServiceType<T>;
+    const resolvedName = this.resolveName(Service) as ServiceKeyType<T>;
 
     if (!this.has(resolvedName)) {
       throw new NotFoundError(`Unable to locate service "${typeof Service === 'string' ? Service : Service.name}".`);
@@ -37,9 +38,10 @@ export class ServiceManager implements ServiceManagerInterface {
 
     if (forceTransient || !this.services.has(resolvedName)) {
       const service = this.factories.get(resolvedName)(this.creationContext) as T;
+      const shared  = this.shared.has(resolvedName) ? this.shared.get(resolvedName) : this.sharedByDefault;
 
       // We just needed a new instance or we don't want our instances to be shared.. Return service.
-      if (forceTransient || (!this.sharedByDefault && !this.shared.has(resolvedName))) {
+      if (forceTransient || !shared) {
         return service;
       }
 
@@ -50,7 +52,7 @@ export class ServiceManager implements ServiceManagerInterface {
   }
 
   has<T>(Service: ServiceKeyType<T>): boolean {
-    const resolvedName = this.resolveName(Service) as ServiceType<T>;
+    const resolvedName = this.resolveName(Service) as ServiceKeyType<T>;
 
     return this.services.has(resolvedName) || this.factories.has(resolvedName);
   }
@@ -81,15 +83,15 @@ export class ServiceManager implements ServiceManagerInterface {
     }
 
     if (config.shared instanceof Map) {
-      config.shared.forEach((value, key: Function | string) => this.shared.set(key, value));
+      config.shared.forEach((value, key: ServiceKeyType<Object>) => this.shared.set(key, value));
     }
 
     if (config.services instanceof Map) {
-      config.services.forEach((value, key: Function | string) => this.services.set(key, value));
+      config.services.forEach((value, key: ServiceKeyType<Object>) => this.services.set(key, value));
     }
 
     if (config.invokables instanceof Map) {
-      config.invokables.forEach((value, key: Function | string) => {
+      config.invokables.forEach((value: Instantiable<Object>, key: ServiceKeyType<Object>) => {
         this.factories.set(key, () => new value);
       });
     }
@@ -105,6 +107,18 @@ export class ServiceManager implements ServiceManagerInterface {
     return this;
   }
 
+  public registerAliases(aliases: AliasesType): this {
+    Object.assign(this.aliases, aliases);
+
+    return this;
+  }
+
+  public registerAlias(alias: string, to: string | Function): this {
+    this.aliases[alias] = to;
+
+    return this;
+  }
+
   private resolveName<T>(name: ServiceKeyType<T>): ServiceKeyType<T> {
     if (typeof name !== 'string') {
       return name;
diff --git a/src/Library/ServiceManager/ServiceManagerConfigInterface.ts b/src/Library/ServiceManager/ServiceManagerConfigInterface.ts
index cc24d8c..00f0965 100644
--- a/src/Library/ServiceManager/ServiceManagerConfigInterface.ts
+++ b/src/Library/ServiceManager/ServiceManagerConfigInterface.ts
@@ -1,20 +1,20 @@
 import { ServiceManagerInterface } from './ServiceManagerInterface';
-
-export interface ServiceType<T> extends Function { new (...args: any[]): T; }
+import { Instantiable } from '../Core/Types';
+import { FactoryInterface } from './FactoryInterface';
 
 export interface ServiceFactoryType<T> extends Function { (sm?: ServiceManagerInterface): T; }
 
-export type FactoriesMapType = Map<Function | string, ServiceFactoryType<Object>>;
+export type FactoriesMapType = Map<Function | string, FactoryInterface>;
 
 export type ServicesMapType = Map<Function | string, Object>;
 
-export type InvokablesMapType<T> = Map<Function | string, { new (...args: any[]): T; }>;
+export type InvokablesMapType<T> = Map<Instantiable<Object> | string, Instantiable<T>>;
 
 export type AliasesType = { [alias: string]: string | Function };
 
 export type SharedMapType = Map<Function | string, Object>;
 
-export type ServiceKeyType<T> = ServiceType<T> | string;
+export type ServiceKeyType<T> = Instantiable<T> | string;
 
 export type ServiceManagerConfigType = Partial<{
   sharedByDefault: boolean;