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

package/src/breakpoint/shared/utils.ts

@@ -1,241 +1,261 @@
-import { App, View, ViewElement, BaseNode } from '../../concepts';
+import {
+  App,
+  View,
+  BaseNode,
+  ViewElement,
+} from '../../concepts';
 
 import {
-    STATUS_ENABLED,
-    STATUS_DISABLED,
-    TRAVERSE_NODE_KEYS,
-    BREAKPOINT_CONCEPTS,
-    DEFAULT_ACTIVE_DEBUGGER,
+  STATUS_ENABLED,
+  STATUS_DISABLED,
+  TRAVERSE_NODE_KEYS,
+  BREAKPOINT_CONCEPTS,
+  DEFAULT_ACTIVE_DEBUGGER,
 } from './constants';
 
 type Callback = (node: BaseNode) => void;
 
 type HistoryInApp = {
-    _historyIndex?: number,
-    _historyList?: Array<{
-        list?: Array<{
-            action?: 'delete' | 'create' | 'update',
-            object?: null | Record<string, any>,
-            oldObject?: null | Record<string, any>,
-        }>,
+  _historyIndex?: number,
+  _historyList?: Array<{
+    list?: Array<{
+      action?: 'delete' | 'create' | 'update',
+      object?: null | Record<string, any>,
+      oldObject?: null | Record<string, any>,
     }>,
+  }>,
 };
 
 const neatKeys = [
-    'breakpoint',
-    'offsetX',
-    'offsetY',
+  'breakpoint',
+  'offsetX',
+  'offsetY',
 ];
 
 export const isAppDirty = (app: HistoryInApp = {}) => {
-    if (!app) {
-        return false;
-    }
+  if (!app) {
+    return false;
+  }
 
-    const {
-        _historyIndex = 0,
-        _historyList = [],
-    } = app;
+  const {
+    _historyIndex = 0,
+    _historyList = [],
+  } = app;
 
-    const historyList = _historyList.slice(0, _historyIndex);
+  const historyList = _historyList.slice(0, _historyIndex);
 
-    return historyList.some((item = {}) => {
-        const { list = [] } = item;
+  return historyList.some((item = {}) => {
+    const { list = [] } = item;
 
-        return list.some((current = {}) => {
-            const { action, oldObject } = current;
+    return list.some((current = {}) => {
+      const { action, oldObject } = current;
 
-            if (action !== 'update') {
-                return true;
-            }
+      if (action !== 'update') {
+        return true;
+      }
 
-            if (!oldObject) {
-                return false;
-            }
+      if (!oldObject) {
+        return false;
+      }
 
-            const keys = Object.keys(oldObject);
-            const filter = (key: string) => !neatKeys.includes(key);
-            const dirtyKeys = keys.filter(filter);
+      const keys = Object.keys(oldObject);
+      const filter = (key: string) => !neatKeys.includes(key);
+      const dirtyKeys = keys.filter(filter);
 
-            return dirtyKeys.length > 0;
-        });
+      return dirtyKeys.length > 0;
     });
+  });
 };
 
 export const getRealNode = (node: BaseNode): BaseNode => {
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
 
-    const { concept, object } = (node as any);
+  const { concept, object } = (node as any);
 
-    if (concept === 'MemberExpression') {
-        return getRealNode(object as BaseNode);
-    }
+  if (concept === 'MemberExpression') {
+    return getRealNode(object as BaseNode);
+  }
 
-    return node;
+  return node;
 };
 
 const unbrakableAncestors = [
-    'Process',
-    'BindAttribute',
-    'OverriddenLogic',
-    'CallAuthInterface',
+  'Process',
+  'BindAttribute',
+  'OverriddenLogic',
+  'CallAuthInterface',
 ] as const;
 
 const isBreakableByAncestors = (node: BaseNode): Boolean => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return false;
-    }
+  if (!node) {
+    return false;
+  }
 
-    return unbrakableAncestors.every((ancestor) => !node.getAncestor(ancestor));
+  const useful = node instanceof BaseNode;
+
+  if (!useful) {
+    return false;
+  }
+
+  return unbrakableAncestors.every((ancestor) => !node.getAncestor(ancestor));
 };
 
 const isBreakableByCurrent = (node: BaseNode): Boolean => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return false;
-    }
+  if (!node) {
+    return false;
+  }
 
-    const { concept } = node;
+  const { concept } = node;
 
-    return BREAKPOINT_CONCEPTS.includes(concept);
+  return BREAKPOINT_CONCEPTS.includes(concept);
 };
 
 export const isBreakable = (node: BaseNode): Boolean => {
-    const a = isBreakableByCurrent(node);
-    const b = isBreakableByAncestors(node);
+  const a = isBreakableByCurrent(node);
+  const b = isBreakableByAncestors(node);
 
-    return a && b;
+  return a && b;
 };
 
 export const isActive = (store: any = {}) => {
-    const lcapPreference = store?.state?.lcapPreference;
-    const { activeDebugger = DEFAULT_ACTIVE_DEBUGGER } = lcapPreference || {};
+  const lcapPreference = store?.lcapPreference;
+  const { activeDebugger = DEFAULT_ACTIVE_DEBUGGER } = lcapPreference || {};
 
-    return activeDebugger;
+  return activeDebugger;
 };
 
 export const isEnabled = (node: BaseNode): Boolean => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return false;
-    }
+  if (!node) {
+    return false;
+  }
 
-    return node.breakpoint === STATUS_ENABLED;
+  return node.breakpoint === STATUS_ENABLED;
 };
 
 export const isDisabled = (node: BaseNode): Boolean => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return false;
-    }
+  if (!node) {
+    return false;
+  }
 
-    return node.breakpoint === STATUS_DISABLED;
+  return node.breakpoint === STATUS_DISABLED;
 };
 
 export const getUniqueIdFromNode = (node: BaseNode) => node && node.nodePath;
 
 export const getLogics = (app: App) => {
-    if (!app) {
-        return [];
-    }
+  if (!app) {
+    return [];
+  }
 
-    const { logics = [], frontends = [] } = app;
+  const { logics = [], frontends = [] } = app;
 
-    let result = logics;
+  let result = logics;
 
-    const forViewElement = (viewElement: ViewElement) => {
-        if (!viewElement) {
-            return;
-        }
+  const forViewElement = (viewElement: ViewElement) => {
+    if (!viewElement) {
+      return;
+    }
 
-        const {
-            children: viewElementChildren = [],
-            bindEvents: viewElementBindEvents = [],
-        } = viewElement;
+    const {
+      children: viewElementChildren = [],
+      bindEvents: viewElementBindEvents = [],
+    } = viewElement;
 
-        viewElementBindEvents.forEach((bindEvent) => {
-            const { logics: bindEventLogics = [] } = bindEvent;
+    viewElementBindEvents.forEach((bindEvent) => {
+      const { logics: bindEventLogics = [] } = bindEvent;
 
-            result = result.concat(bindEventLogics);
-        });
+      result = result.concat(bindEventLogics);
+    });
 
-        viewElementChildren.forEach(forViewElement);
-    };
+    viewElementChildren.forEach(forViewElement);
+  };
 
-    const forView = (view: View) => {
-        if (!view) {
-            return;
-        }
+  const forView = (view: View) => {
+    if (!view) {
+      return;
+    }
 
-        const {
-            logics: viewLogics = [],
-            elements: viewElements = [],
-            children: viewChildren = [],
-            bindEvents: viewBindEvents = [],
-        } = view;
+    const {
+      logics: viewLogics = [],
+      elements: viewElements = [],
+      children: viewChildren = [],
+      bindEvents: viewBindEvents = [],
+    } = view;
 
-        result = result.concat(viewLogics);
+    result = result.concat(viewLogics);
 
-        viewBindEvents.forEach((bindEvent) => {
-            const { logics: bindEventLogics = [] } = bindEvent;
+    viewBindEvents.forEach((bindEvent) => {
+      const { logics: bindEventLogics = [] } = bindEvent;
 
-            result = result.concat(bindEventLogics);
-        });
+      result = result.concat(bindEventLogics);
+    });
 
-        viewElements.forEach(forViewElement);
-        viewChildren.forEach(forView);
-    };
+    viewElements.forEach(forViewElement);
+    viewChildren.forEach(forView);
+  };
 
-    frontends.forEach((frontend) => {
-        const { views = [] } = frontend;
+  frontends.forEach((frontend) => {
+    const { views = [] } = frontend;
 
-        views.forEach(forView);
-    });
+    views.forEach(forView);
+  });
 
-    return result;
+  return result;
 };
 
 const hadBreakpoint = (node: BaseNode) => {
-    if (node instanceof BaseNode) {
-        return node.breakpoint;
-    }
+  if (node instanceof BaseNode) {
+    return node.breakpoint;
+  }
 
-    return false;
+  return false;
 };
 
 export const traverseBreakpointOnNode = (node: (BaseNode | any), callback: Callback) => {
-    if (!node) {
-        return;
-    }
-
-    const operate = (item: BaseNode) => hadBreakpoint(item) && callback(item);
-    const forEach = (item: BaseNode) => {
-        operate(item);
-        traverseBreakpointOnNode(item, callback);
-    };
-
-    operate(node);
-    TRAVERSE_NODE_KEYS.forEach((key) => {
-        const { [key]: value } = node;
-        const array = Array.isArray(value) ? value : [value];
-
-        array.forEach(forEach);
-    });
+  if (!node) {
+    return;
+  }
+
+  const operate = (item: BaseNode) => hadBreakpoint(item) && callback(item);
+  const forEach = (item: BaseNode) => {
+    operate(item);
+    traverseBreakpointOnNode(item, callback);
+  };
+
+  operate(node);
+  TRAVERSE_NODE_KEYS.forEach((key) => {
+    const { [key]: value } = node;
+    const array = Array.isArray(value) ? value : [value];
+
+    array.forEach(forEach);
+  });
 };
 
 export const traverseBreakpointOnApp = (app: App, callback: Callback) => {
-    if (!app) {
-        return;
-    }
+  if (!app) {
+    return;
+  }
 
-    const logics = getLogics(app);
+  const logics = getLogics(app);
 
-    logics.forEach((logic) => traverseBreakpointOnNode(logic, callback));
+  logics.forEach((logic) => traverseBreakpointOnNode(logic, callback));
 };
+
+export const toString = (value: any, type: string) => {
+  // eslint-disable-next-line no-new-wrappers
+  const result = new String(value) as any;
+  result.type = type;
+  return result;
+};
+
+export const toStringVoid = () => toString('void', 'undefined');