@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/sentry/index.ts

@@ -10,17 +10,18 @@ export const TS_WORKER_MESSAGER = 'ts-worker-messager';
 
 export const getAxios = () => axios;
 
-type ClassType = { new(...args: any[]): any };
+type ClassType = { new (...args: any[]): any };
+type FunctionType = (...args: any[]) => any;
 
 type Source = {
-    instance: any;
-    hook: string;
-    name: string;
-    params: any[];
-    result?: any;
+  instance: any;
+  hook: string;
+  name: string;
+  params: any[];
+  result?: any;
 };
 
-type Listener = (source: Source) => Function | void;
+type Listener = (source: Source) => FunctionType | void;
 
 type Monitor = (key: string) => <T extends ClassType>(SourceClass: T) => T;
 
@@ -29,154 +30,158 @@ const developing = process.env.NODE_ENV === 'development';
 const flag = '__monitor__';
 const passthroughProperties = ['constructor', 'getClassName', 'getAncestor'];
 
-const classStore: { [key:string]: ClassType } = {};
-const listenersStore: { [key:string]: Listener[] } = {};
+const classStore: { [key: string]: ClassType } = {};
+const listenersStore: { [key: string]: Listener[] } = {};
 
 const isPromise = (obj: any) => obj && typeof obj.then === 'function';
 const isUsefulProperty = (SourceClass: ClassType) => (property: string) => {
-    if (!SourceClass || !property) {
-        return;
-    }
+  if (!SourceClass || !property) {
+    return;
+  }
 
-    if (passthroughProperties.includes(property)) {
-        return false;
-    }
+  if (passthroughProperties.includes(property)) {
+    return false;
+  }
 
-    if (typeof SourceClass.prototype[property] !== 'function') {
-        return false;
-    }
+  if (typeof SourceClass.prototype[property] !== 'function') {
+    return false;
+  }
 
-    return !SourceClass.prototype[property][flag];
+  return !SourceClass.prototype[property][flag];
 };
 
 export const removeListener = (key: string) => (listener: Listener) => {
-    listenersStore[key] = listenersStore[key] || [];
-    listenersStore[key] = listenersStore[key].filter((item) => item !== listener);
+  listenersStore[key] = listenersStore[key] || [];
+  listenersStore[key] = listenersStore[key].filter((item) => item !== listener);
 };
 
-export const addListener = (key: string) => (listener: Listener, capture = false) => {
+export const addListener =
+  (key: string) =>
+  (listener: Listener, capture = false) => {
     listenersStore[key] = listenersStore[key] || [];
 
     if (capture) {
-        listenersStore[key] = [listener, ...listenersStore[key]];
+      listenersStore[key] = [listener, ...listenersStore[key]];
     } else {
-        listenersStore[key] = listenersStore[key].concat(listener);
+      listenersStore[key] = listenersStore[key].concat(listener);
     }
 
     return () => removeListener(key)(listener);
-};
+  };
 
-const fireListeners = (key: string) => (source: Source): Function => {
+const fireListeners =
+  (key: string) =>
+  (source: Source): FunctionType => {
     const { [key]: listeners = [] } = listenersStore;
     const effects = listeners.map((listener) => listener(source));
 
     return () => effects.forEach((effect) => effect && effect());
-};
+  };
 
 const monitor = (key: string, SourceClass: ClassType, TargetClass: ClassType) => (name: string) => {
-    if (!TargetClass || !SourceClass) {
-        return;
-    }
-
-    if (!key || !name) {
-        return;
-    }
+  if (!TargetClass || !SourceClass) {
+    return;
+  }
 
-    const { [name]: callback } = SourceClass.prototype;
-
-    TargetClass.prototype[name] = function (...params: any[]) {
-        const effect = fireListeners(key)({
-            hook: BEFORE_HOOK,
-            instance: this,
-            name,
-            params,
-        });
+  if (!key || !name) {
+    return;
+  }
 
-        const result = callback.apply(this, params);
+  const { [name]: callback } = SourceClass.prototype;
 
-        if (isPromise(result)) {
-            return result.then((data: any) => {
-                fireListeners(key)({
-                    hook: AFTER_HOOK,
-                    instance: this,
-                    result: data,
-                    params,
-                    name,
-                });
+  TargetClass.prototype[name] = function (...params: any[]) {
+    const effect = fireListeners(key)({
+      hook: BEFORE_HOOK,
+      instance: this,
+      name,
+      params,
+    });
 
-                effect && effect();
-                return data;
-            });
-        }
+    const result = callback.apply(this, params);
 
+    if (isPromise(result)) {
+      return result.then((data: any) => {
         fireListeners(key)({
-            hook: AFTER_HOOK,
-            instance: this,
-            name,
-            params,
-            result,
+          hook: AFTER_HOOK,
+          instance: this,
+          result: data,
+          params,
+          name,
         });
 
         effect && effect();
-        return result;
-    };
+        return data;
+      });
+    }
 
-    TargetClass.prototype[name][flag] = true;
-};
+    fireListeners(key)({
+      hook: AFTER_HOOK,
+      instance: this,
+      name,
+      params,
+      result,
+    });
 
-export const sentryMonitor: Monitor = (key) => (SourceClass) => {
-    if (developing) {
-        return SourceClass;
-    }
+    effect && effect();
+    return result;
+  };
 
-    if (!key || !SourceClass) {
-        return SourceClass;
-    }
+  TargetClass.prototype[name][flag] = true;
+};
 
-    class TargetClass extends SourceClass {
-        constructor(...params: any[]) {
-            super(...params);
-
-            fireListeners(key)({
-                hook: CONSTRUCTOR_HOOK,
-                name: 'constructor',
-                instance: this,
-                result: this,
-                params,
-            });
-        }
+export const sentryMonitor: Monitor = (key) => (SourceClass) => {
+  if (developing) {
+    return SourceClass;
+  }
+
+  if (!key || !SourceClass) {
+    return SourceClass;
+  }
+
+  class TargetClass extends SourceClass {
+    constructor(...params: any[]) {
+      super(...params);
+
+      fireListeners(key)({
+        hook: CONSTRUCTOR_HOOK,
+        name: 'constructor',
+        instance: this,
+        result: this,
+        params,
+      });
     }
+  }
 
-    const properties = Object.getOwnPropertyNames(SourceClass.prototype);
-    const names = properties.filter(isUsefulProperty(SourceClass));
+  const properties = Object.getOwnPropertyNames(SourceClass.prototype);
+  const names = properties.filter(isUsefulProperty(SourceClass));
 
-    classStore[key] = SourceClass;
-    names.forEach(monitor(key, SourceClass, TargetClass));
+  classStore[key] = SourceClass;
+  names.forEach(monitor(key, SourceClass, TargetClass));
 
-    return TargetClass;
+  return TargetClass;
 };
 
 export const extendSentryMonitor: Monitor = (key) => (SourceClass) => {
-    if (developing) {
-        return SourceClass;
-    }
+  if (developing) {
+    return SourceClass;
+  }
 
-    if (!key || !SourceClass) {
-        return SourceClass;
-    }
+  if (!key || !SourceClass) {
+    return SourceClass;
+  }
 
-    const { [key]: TargetClass } = classStore;
+  const { [key]: TargetClass } = classStore;
 
-    if (!TargetClass) {
-        return SourceClass;
-    }
+  if (!TargetClass) {
+    return SourceClass;
+  }
 
-    const properties = Object.getOwnPropertyNames(SourceClass.prototype);
-    const names = properties.filter(isUsefulProperty(SourceClass));
+  const properties = Object.getOwnPropertyNames(SourceClass.prototype);
+  const names = properties.filter(isUsefulProperty(SourceClass));
 
-    names.forEach(monitor(key, SourceClass, TargetClass));
+  names.forEach(monitor(key, SourceClass, TargetClass));
 
-    return TargetClass as typeof SourceClass;
+  return TargetClass as typeof SourceClass;
 };
 
 export const addListenerToNaslNode = addListener(NASL_NODE);