2 files changed, 76 insertions, 28 deletions

diff --git a/client/src/app/core/plugins/hooks.service.ts b/client/src/app/core/plugins/hooks.service.ts
new file mode 100644
index 000000000..80c57869c
--- /dev/null
+++ b/client/src/app/core/plugins/hooks.service.ts
@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core'
+import { PluginService } from '@app/core/plugins/plugin.service'
+import { ClientActionHookName, ClientFilterHookName } from '@shared/models/plugins/client-hook.model'
+import { from, Observable } from 'rxjs'
+import { mergeMap, switchMap } from 'rxjs/operators'
+import { ServerService } from '@app/core/server'
+import { PluginClientScope } from '@shared/models/plugins/plugin-client-scope.type'
+
+type RawFunction<U, T> = (params: U) => T
+type ObservableFunction<U, T> = RawFunction<U, Observable<T>>
+
+@Injectable()
+export class HooksService {
+  constructor (
+    private server: ServerService,
+    private pluginService: PluginService
+  ) { }
+
+  wrapObject<T, U extends ClientFilterHookName> (result: T, hookName: U) {
+    return this.pluginService.runHook(hookName, result)
+  }
+
+  wrapObsFun
+    <P, R, H1 extends ClientFilterHookName, H2 extends ClientFilterHookName>
+    (fun: ObservableFunction<P, R>, params: P, scope: PluginClientScope, hookParamName: H1, hookResultName: H2) {
+    return from(this.pluginService.ensurePluginsAreLoaded(scope))
+      .pipe(
+        mergeMap(() => this.wrapObject(params, hookParamName)),
+        switchMap(params => fun(params)),
+        mergeMap(result => this.pluginService.runHook(hookResultName, result, params))
+      )
+  }
+
+  async wrapFun<U, T, V extends ClientFilterHookName> (fun: RawFunction<U, T>, params: U, hookName: V) {
+    const result = fun(params)
+
+    return this.pluginService.runHook(hookName, result, params)
+  }
+
+  runAction<T, U extends ClientActionHookName> (hookName: U, params?: T) {
+    this.pluginService.runHook(hookName, params)
+                 .catch((err: any) => console.error('Fatal hook error.', { err }))
+  }
+}
diff --git a/client/src/app/core/plugins/plugin.service.ts b/client/src/app/core/plugins/plugin.service.ts
index af330c2eb..14310f093 100644
--- a/client/src/app/core/plugins/plugin.service.ts
+++ b/client/src/app/core/plugins/plugin.service.ts
@@ -3,11 +3,13 @@ import { Router } from '@angular/router'
 import { ServerConfigPlugin } from '@shared/models'
 import { ServerService } from '@app/core/server/server.service'
 import { ClientScript } from '@shared/models/plugins/plugin-package-json.model'
-import { PluginScope } from '@shared/models/plugins/plugin-scope.type'
 import { environment } from '../../../environments/environment'
 import { RegisterHookOptions } from '@shared/models/plugins/register-hook.model'
 import { ReplaySubject } from 'rxjs'
 import { first, shareReplay } from 'rxjs/operators'
+import { getHookType, internalRunHook } from '@shared/core-utils/plugins/hooks'
+import { ClientHook, ClientHookName } from '@shared/models/plugins/client-hook.model'
+import { PluginClientScope } from '@shared/models/plugins/plugin-client-scope.type'
 
 interface HookStructValue extends RegisterHookOptions {
   plugin: ServerConfigPlugin
@@ -21,14 +23,18 @@ type PluginInfo = {
 }
 
 @Injectable()
-export class PluginService {
-  pluginsLoaded = new ReplaySubject<boolean>(1)
+export class PluginService implements ClientHook {
+  pluginsBuilt = new ReplaySubject<boolean>(1)
+
+  pluginsLoaded: { [ scope in PluginClientScope ]: ReplaySubject<boolean> } = {
+    common: new ReplaySubject<boolean>(1),
+    'video-watch': new ReplaySubject<boolean>(1)
+  }
 
   private plugins: ServerConfigPlugin[] = []
   private scopes: { [ scopeName: string ]: PluginInfo[] } = {}
-  private loadedPlugins: { [ name: string ]: boolean } = {}
   private loadedScripts: { [ script: string ]: boolean } = {}
-  private loadedScopes: PluginScope[] = []
+  private loadedScopes: PluginClientScope[] = []
 
   private hooks: { [ name: string ]: HookStructValue[] } = {}
 
@@ -45,12 +51,18 @@ export class PluginService {
 
         this.buildScopeStruct()
 
-        this.pluginsLoaded.next(true)
+        this.pluginsBuilt.next(true)
       })
   }
 
-  ensurePluginsAreLoaded () {
-    return this.pluginsLoaded.asObservable()
+  ensurePluginsAreBuilt () {
+    return this.pluginsBuilt.asObservable()
+               .pipe(first(), shareReplay())
+               .toPromise()
+  }
+
+  ensurePluginsAreLoaded (scope: PluginClientScope) {
+    return this.pluginsLoaded[scope].asObservable()
                .pipe(first(), shareReplay())
                .toPromise()
   }
@@ -90,9 +102,9 @@ export class PluginService {
     }
   }
 
-  async loadPluginsByScope (scope: PluginScope, isReload = false) {
+  async loadPluginsByScope (scope: PluginClientScope, isReload = false) {
     try {
-      await this.ensurePluginsAreLoaded()
+      await this.ensurePluginsAreBuilt()
 
       if (!isReload) this.loadedScopes.push(scope)
 
@@ -111,32 +123,24 @@ export class PluginService {
       }
 
       await Promise.all(promises)
+
+      this.pluginsLoaded[scope].next(true)
     } catch (err) {
       console.error('Cannot load plugins by scope %s.', scope, err)
     }
   }
 
-  async runHook (hookName: string, param?: any) {
-    let result = param
-
-    if (!this.hooks[hookName]) return result
+  async runHook <T> (hookName: ClientHookName, result?: T, params?: any): Promise<T> {
+    if (!this.hooks[hookName]) return Promise.resolve(result)
 
-    const wait = hookName.startsWith('static:')
+    const hookType = getHookType(hookName)
 
     for (const hook of this.hooks[hookName]) {
-      try {
-        const p = hook.handler(param)
-
-        if (wait) {
-          result = await p
-        } else if (p.catch) {
-          p.catch((err: Error) => {
-            console.error('Cannot run hook %s of script %s of plugin %s.', hookName, hook.plugin, hook.clientScript, err)
-          })
-        }
-      } catch (err) {
-        console.error('Cannot run hook %s of script %s of plugin %s.', hookName, hook.plugin, hook.clientScript, err)
-      }
+      console.log('Running hook %s of plugin %s.', hookName, hook.plugin.name)
+
+      result = await internalRunHook(hook.handler, hookType, result, params, err => {
+        console.error('Cannot run hook %s of script %s of plugin %s.', hookName, hook.clientScript.script, hook.plugin.name, err)
+      })
     }
 
     return result