chore(workers): remove unreachable code

Author: IKatsuba

README.md

@@ -28,10 +28,10 @@ npm i @ng-web-apis/workers
 
 ## How it use
 
-You can create worker with service and use it in a template with `AsyncPipe`:
+You can create worker and use it in a template with `AsyncPipe`:
 
 ```typescript
-import {WorkerExecutor, WebWorker} from '@ng-web-apis/workers';
+import {WebWorker} from '@ng-web-apis/workers';
 
 function compute(data: number): number {
     return data ** 2;
@@ -47,7 +47,7 @@ function compute(data: number): number {
     `,
 })
 class SomeComponent {
-    readonly worker: WebWorker<number, number> = workerExecutor.createWorker(compute);
+    readonly worker = WebWorker.fromFunction<number, number>(compute);
 }
 ```
 
@@ -78,7 +78,7 @@ import {FormControl} from '@angular/forms';
 class SomeComponent {
     value: string;
 
-    changeData(data: number): number {
+    changeData(data: number): string {
         return `${data} (changed)`;
     }
 }

projects/demo/src/app/app.component.ts

@@ -1,6 +1,6 @@
 import {ChangeDetectionStrategy, Component} from '@angular/core';
-import {WebWorker, WorkerExecutor} from '@ng-web-apis/workers';
-import {Observable, Subject} from 'rxjs';
+import {WebWorker} from '@ng-web-apis/workers';
+import {Subject} from 'rxjs';
 import {map} from 'rxjs/operators';
 
 @Component({
@@ -10,15 +10,9 @@ import {map} from 'rxjs/operators';
     changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class AppComponent {
-    readonly workerThread: WebWorker<void, number>;
-    readonly emitter: Subject<void>;
-    readonly result$: Observable<number>;
-
-    constructor(webWorkerExecutor: WorkerExecutor) {
-        this.workerThread = webWorkerExecutor.createWorker(this.startCompute);
-        this.emitter = new Subject();
-        this.result$ = this.emitter.pipe(map(this.startCompute));
-    }
+    readonly workerThread = WebWorker.fromFunction<void, number>(this.startCompute);
+    readonly emitter = new Subject<void>();
+    readonly result$ = this.emitter.pipe(map(this.startCompute));
 
     startCompute(): number {
         const start = performance.now();

projects/workers/src/worker/classes/web-worker.spec.ts

@@ -58,4 +58,13 @@ describe('WebWorker', () => {
         worker.postMessage('b');
         expect(await promise).toEqual('a');
     });
+
+    it('should run a worker and return a correct data', async () => {
+        const workerPromise: Promise<string> = WebWorker.execute<string, string>(
+            data => Promise.resolve().then(() => data),
+            'some data',
+        );
+
+        expect(await workerPromise).toEqual('some data');
+    }, 10000);
 });

projects/workers/src/worker/classes/web-worker.ts

@@ -1,5 +1,5 @@
 import {fromEvent, Subject} from 'rxjs';
-import {filter, takeWhile} from 'rxjs/operators';
+import {filter, take, takeWhile} from 'rxjs/operators';
 import {WORKER_BLANK_FN} from '../consts/worker-fn-template';
 import {WorkerFunction} from '../types/worker-function';
 
@@ -42,6 +42,15 @@ export class WebWorker<T = any, R = any> extends Subject<R> {
         return new WebWorker<T, R>(WebWorker.createFnUrl(fn), options);
     }
 
+    static execute<T, R>(fn: WorkerFunction<T, R>, data: T): Promise<R> {
+        const worker = WebWorker.fromFunction(fn);
+        const promise = worker.pipe(take(1)).toPromise();
+
+        worker.postMessage(data);
+
+        return promise;
+    }
+
     private static createFnUrl(fn: WorkerFunction): string {
         const script = `(${WORKER_BLANK_FN})(${fn.toString()});`;
 

projects/workers/src/worker/pipes/worker.pipe.spec.ts

@@ -1,12 +1,11 @@
 import {take} from 'rxjs/operators';
-import {WorkerExecutor} from '../services/worker-executor.service';
 import {WorkerPipe} from './worker.pipe';
 
 describe('WorkerPipe', () => {
     let pipe: WorkerPipe;
 
     beforeEach(() => {
-        pipe = new WorkerPipe(new WorkerExecutor());
+        pipe = new WorkerPipe();
     });
 
     it('should emit the first value', async () => {

projects/workers/src/worker/pipes/worker.pipe.ts

@@ -1,7 +1,6 @@
 import {Pipe, PipeTransform} from '@angular/core';
 import {Observable} from 'rxjs';
 import {WebWorker} from '../classes/web-worker';
-import {WorkerExecutor} from '../services/worker-executor.service';
 import {WorkerFunction} from '../types/worker-function';
 
 @Pipe({
@@ -10,10 +9,8 @@ import {WorkerFunction} from '../types/worker-function';
 export class WorkerPipe implements PipeTransform {
     private workers = new WeakMap<WorkerFunction, WebWorker>();
 
-    constructor(private workerExecutor: WorkerExecutor) {}
-
     transform<T, R>(value: T, fn: WorkerFunction<T, R>): Observable<R> {
-        const worker = this.workers.get(fn) || this.workerExecutor.createWorker(fn);
+        const worker = this.workers.get(fn) || WebWorker.fromFunction(fn);
 
         this.workers.set(fn, worker);
 

projects/workers/src/worker/services/worker-executor.service.spec.ts

@@ -1,12 +1,8 @@
-import {CommonModule} from '@angular/common';
 import {NgModule} from '@angular/core';
 import {WorkerPipe} from './pipes/worker.pipe';
-import {WorkerExecutor} from './services/worker-executor.service';
 
 @NgModule({
-    imports: [CommonModule],
     declarations: [WorkerPipe],
     exports: [WorkerPipe],
-    providers: [WorkerExecutor],
 })
 export class WorkerModule {}