feat: add injector service

projects/logger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-ru/logger",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "license": "MIT",
   "homepage": "https://github.com/Angular-RU/angular-logger",
   "repository": "https://github.com/Angular-RU/angular-logger",

projects/logger/src/lib/decorators/debug.decorator.ts

@@ -1,14 +1,15 @@
 import { Type } from '@angular/core';
 
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function DebugLog(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().debug;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).debug;
             }
         });
     };

projects/logger/src/lib/decorators/error.decorator.ts

@@ -1,13 +1,14 @@
 import { Type } from '@angular/core';
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function ErrorLog(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().error;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).error;
             }
         });
     };

projects/logger/src/lib/decorators/groups/group.common.ts

@@ -3,7 +3,7 @@ import { LoggerService } from '../../logger.service';
 import { GroupLevel, LoggerLevel } from '../../logger.config';
 import { Any, Callback, Fn, GroupMethod } from '../../logger.interfaces';
 import { GroupFactory } from '../../services/group-factory.service';
-import { LoggerModule } from '../../logger.module';
+import { LoggerInjector } from '../../logger.injector';
 
 export function groupDecoratorFactory(
     level: LoggerLevel,
@@ -14,8 +14,8 @@ export function groupDecoratorFactory(
     target: Type<unknown>
 ): unknown {
     let result: unknown;
-    const logger: LoggerService = LoggerModule.logger();
-    const groupFactory: GroupFactory = LoggerModule.groupFactory();
+    const logger: LoggerService = LoggerInjector.getInjector().get<LoggerService>(LoggerService);
+    const groupFactory: GroupFactory = LoggerInjector.getInjector().get<GroupFactory>(GroupFactory);
     const groupMethod: GroupMethod = groupFactory[groupType].bind(groupFactory);
     const label: string = typeof title === 'string' ? title : title(...args);
 

projects/logger/src/lib/decorators/info.decorator.ts

@@ -1,14 +1,15 @@
 import { Type } from '@angular/core';
 
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function InfoLog(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().info;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).info;
             }
         });
     };

projects/logger/src/lib/decorators/log.decorator.ts

@@ -1,14 +1,15 @@
 import { Type } from '@angular/core';
 
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function Log(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().log;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).log;
             }
         });
     };

projects/logger/src/lib/decorators/logger.decorator.ts

@@ -1,14 +1,14 @@
 import { Type } from '@angular/core';
 
 import { LoggerService } from '../logger.service';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
 
 export function Logger(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LoggerService {
-                return LoggerModule.logger();
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService);
             }
         });
     };

projects/logger/src/lib/decorators/timer.decorator.ts

@@ -2,7 +2,8 @@ import { Type } from '@angular/core';
 
 import { LoggerLevel } from '../logger.config';
 import { Any, DecoratorMethod, Fn, TimerInfo, TimerLevels } from '../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function TimerLog(
     title: string,
@@ -13,9 +14,13 @@ export function TimerLog(
         let result: PropertyDescriptor;
         const method: Fn = descriptor.value;
         descriptor.value = function(...args: Any[]): PropertyDescriptor {
-            const info: TimerInfo | null = LoggerModule.logger().startTime(title, level);
+            const info: TimerInfo | null = LoggerInjector.getInjector()
+                .get<LoggerService>(LoggerService)
+                .startTime(title, level);
             result = method.apply(this, args);
-            LoggerModule.logger().endTime(info, level, isMillisecond);
+            LoggerInjector.getInjector()
+                .get<LoggerService>(LoggerService)
+                .endTime(info, level, isMillisecond);
             return result;
         };
         return descriptor;

projects/logger/src/lib/decorators/trace.decorator.ts

@@ -1,14 +1,15 @@
 import { Type } from '@angular/core';
 
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function TraceLog(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().trace;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).trace;
             }
         });
     };

projects/logger/src/lib/decorators/warn.decorator.ts

@@ -1,14 +1,15 @@
 import { Type } from '@angular/core';
 
 import { LogFn } from './../logger.interfaces';
-import { LoggerModule } from '../logger.module';
+import { LoggerInjector } from '../logger.injector';
+import { LoggerService } from '../logger.service';
 
 export function WarnLog(): PropertyDecorator {
     return (target: Type<unknown>, propertyName: string): void => {
         Object.defineProperty(target, propertyName, {
             configurable: false,
             get(): LogFn {
-                return LoggerModule.logger().warn;
+                return LoggerInjector.getInjector().get<LoggerService>(LoggerService).warn;
             }
         });
     };

projects/logger/src/lib/logger.injector.ts

@@ -0,0 +1,18 @@
+import { Injectable, Injector } from '@angular/core';
+
+@Injectable()
+export class LoggerInjector {
+    private static injector: Injector | null = null;
+
+    constructor(injector: Injector) {
+        LoggerInjector.injector = injector;
+    }
+
+    public static getInjector(): never | Injector {
+        if (!LoggerInjector.injector) {
+            throw new Error(`You've forgotten to import \`LoggerModule\``);
+        }
+
+        return LoggerInjector.injector;
+    }
+}

projects/logger/src/lib/logger.module.ts

@@ -1,4 +1,4 @@
-import { InjectionToken, Injector, ModuleWithProviders, NgModule } from '@angular/core';
+import { InjectionToken, ModuleWithProviders, NgModule, Self } from '@angular/core';
 
 import { LoggerService } from './logger.service';
 import { LoggerFactory } from './services/factory.service';
@@ -10,6 +10,7 @@ import { JsonFactory } from './services/json-factory.service';
 import { ClipboardFactory } from './services/clipboard-factory.service';
 import { TimerFactory } from './services/timer-factory.service';
 import { LoggerOptionsImpl } from './logger.options';
+import { LoggerInjector } from './logger.injector';
 
 @NgModule({
     providers: [
@@ -20,24 +21,14 @@ import { LoggerOptionsImpl } from './logger.options';
         CssFactory,
         JsonFactory,
         ClipboardFactory,
-        TimerFactory
+        TimerFactory,
+        LoggerInjector
     ]
 })
 export class LoggerModule {
-    public static injector: Injector = undefined;
     private static readonly ROOT_OPTIONS: InjectionToken<string> = new InjectionToken<string>('ROOT_OPTIONS');
 
-    constructor(injector: Injector) {
-        LoggerModule.injector = injector;
-    }
-
-    public static logger(): LoggerService {
-        return LoggerModule.injector.get(LoggerService);
-    }
-
-    public static groupFactory(): GroupFactory {
-        return LoggerModule.injector.get(GroupFactory);
-    }
+    constructor(@Self() public loggerInjector: LoggerInjector) {}
 
     public static forRoot(config: Partial<LoggerOptions> = {}): ModuleWithProviders {
         return {
@@ -56,7 +47,7 @@ export class LoggerModule {
         };
     }
 
-    private static loggerConfigFactory(config: Partial<LoggerOptions>): unknown {
-        return new LoggerOptionsImpl().options(config);
+    private static loggerConfigFactory(config: Partial<LoggerOptions>): LoggerOptionsImpl {
+        return Object.assign(new LoggerOptionsImpl(), config);
     }
 }

projects/logger/src/lib/logger.options.ts

@@ -24,8 +24,4 @@ export class LoggerOptionsImpl implements LoggerOptions {
         [LoggerLevel.WARN]: LABELS.WARN,
         [LoggerLevel.ERROR]: LABELS.ERROR
     };
-
-    public options(config: Partial<LoggerOptions>): LoggerOptions {
-        return Object.assign(new LoggerOptionsImpl(), config);
-    }
 }

projects/logger/src/public-api.ts

@@ -9,8 +9,9 @@ export * from './lib/logger.interfaces';
 export * from './lib/decorators/logger.decorator';
 export * from './lib/decorators/trace.decorator';
 export * from './lib/decorators/debug.decorator';
-export * from './lib/decorators/info.decorator';
 export * from './lib/decorators/error.decorator';
+export * from './lib/decorators/log.decorator';
+export * from './lib/decorators/info.decorator';
 export * from './lib/decorators/warn.decorator';
 export * from './lib/decorators/groups/group.decorator';
 export * from './lib/decorators/timer.decorator';

projects/logger/tests/decorators.spec.ts

@@ -4,7 +4,7 @@ import { LoggerService } from '../src/lib/logger.service';
 import { MyTestComponent } from '../../../helpers/test.component';
 import { LoggerLevel } from '../src/lib/logger.config';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { Fn } from '@angular-ru/logger';
+import { Fn } from '../src/lib/logger.interfaces';
 
 describe('[TEST]: Decorator API', () => {
     let logger: LoggerService;

projects/logger/tsconfig.lib.json

@@ -17,12 +17,12 @@
         "lib": ["dom", "es2018"]
     },
     "angularCompilerOptions": {
-        "annotateForClosureCompiler": true,
-        "skipTemplateCodegen": true,
-        "strictMetadataEmit": true,
         "fullTemplateTypeCheck": true,
+        "annotateForClosureCompiler": true,
         "strictInjectionParameters": true,
-        "enableResourceInlining": true
+        "skipTemplateCodegen": true,
+        "preserveWhitespaces": true,
+        "skipMetadataEmit": true
     },
     "exclude": ["**/*.spec.ts"]
 }

src/app/app.component.ts

@@ -8,13 +8,13 @@ import {
     LogFn,
     Logger,
     LoggerLevel,
+    Log,
     LoggerService,
     TimerLog,
     TraceLog,
     WarnLog
 } from '@angular-ru/logger';
 import * as devtools from 'devtools-detect';
-import { Log } from '../../projects/logger/src/lib/decorators/log.decorator';
 
 @Component({
     selector: 'app-root',

tsconfig.json

@@ -18,7 +18,7 @@
         "typeRoots": ["node_modules/@types"],
         "lib": ["es2018", "dom"],
         "paths": {
-            "@angular-ru/logger": ["./projects/logger/src/public-api"]
+            "@angular-ru/logger": ["./dist/logger"]
         }
     }
 }