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

package/src/breakpoint/store/core.ts

@@ -3,18 +3,20 @@ import debounce from 'lodash/debounce';
 import { BaseNode, App } from '../../concepts';
 
 import {
-    STATUS_DISABLED,
-    STATUS_ENABLED,
-    STATUS_DELETED,
-    TARGET_BACKEND,
-    TARGET_FRONTEND,
-    EVENT_TYPE_OBJECT_INFO,
-    EVENT_TYPE_PAGE_INFO,
-    EVENT_TYPE_PARSE,
-    EVENT_TYPE_RESOLVE,
-    EVENT_TYPE_STEP_OVER,
-    EVENT_TYPE_BREAKPOINT,
-    EVENT_TYPE_SYNC_BREAKPOINTS,
+  STATUS_DISABLED,
+  STATUS_ENABLED,
+  STATUS_DELETED,
+  TARGET_BACKEND,
+  TARGET_FRONTEND,
+  EVENT_TYPE_OBJECT_INFO,
+  EVENT_TYPE_RETURN_INFO,
+  EVENT_TYPE_PAGE_INFO,
+  EVENT_TYPE_CACHE,
+  EVENT_TYPE_PARSE,
+  EVENT_TYPE_RESOLVE,
+  EVENT_TYPE_STEP_OVER,
+  EVENT_TYPE_BREAKPOINT,
+  EVENT_TYPE_SYNC_BREAKPOINTS,
 } from '../shared/constants';
 
 import * as socket from '../shared/socket';
@@ -23,396 +25,393 @@ import { setCreate, setUpdate, setDelete } from '../shared/operations';
 import { getRealNode, traverseBreakpointOnNode, traverseBreakpointOnApp } from '../shared/utils';
 
 type Store = {
-    enable?: Boolean,
-    activePath?: string;
-    activeStackItem?: any;
-    echoStackItem?: any,
-    nodes?: BaseNode[];
-    stack?: any[],
-    connections?: string[];
+  enable?: Boolean,
+  activePath?: string;
+  activeStackItem?: any;
+  echoStackItem?: any,
+  nodes?: BaseNode[];
+  stack?: any[],
+  connections?: string[];
+  [key: string]: any;
 };
 
 type StepOverData = Parameters<typeof socket.emitToFrontend>[0];
 
-export const store: Store = {
-    enable: true,
-    nodes: [],
-    stack: [],
-    connections: [],
-    activePath: '',
-    activeStackItem: {},
-    echoStackItem: {},
+let original: Store = {
+  enable: true,
+  nodes: [],
+  stack: [],
+  connections: [],
+  activePath: '',
+  activeStackItem: {},
+  echoStackItem: {},
 };
 
-Object.defineProperty(store, 'activePath', {
-    get: () => {
-        const { activeStackItem = {} } = store;
-        const { operation = {} } = activeStackItem;
-        const { path = '' } = operation;
+Object.defineProperty(original, 'activePath', {
+  get: () => {
+    const { activeStackItem = {} } = original;
+    const { operation = {} } = activeStackItem;
+    const { path = '' } = operation;
 
-        return path;
-    },
+    return path;
+  },
+});
+
+export const reactive = (callback: <T>(arg: T) => T) => {
+  original = callback(original);
+  return original;
+};
+
+export const store = new Proxy<Store>({}, {
+  get: (_, key: string) => original[key],
+  set: (_, key: string, value: any) => Reflect.set(original, key, value),
 });
 
 const isUseful = (node: BaseNode) => {
-    if (!node) {
-        return false;
-    }
+  if (!node) {
+    return false;
+  }
 
-    const { app, nodePath } = (node as any);
+  const { app, nodePath } = (node as any);
 
-    if (!app || !nodePath) {
-        return false;
-    }
+  if (!app || !nodePath) {
+    return false;
+  }
 
-    return app.findNodeByPath(nodePath);
+  return app.findNodeByPath(nodePath);
 };
 
 const clean = debounce(() => {
-    const set = new Set();
+  const set = new Set();
 
-    for (let i = 0; i < store.nodes.length; i += 1) {
-        const current = store.nodes[i];
-        const { id } = current;
+  for (let i = 0; i < store.nodes.length; i += 1) {
+    const current = store.nodes[i];
+    const { id } = current;
 
-        const repeated = set.has(id);
-        const useless = !isUseful(current);
+    const repeated = set.has(id);
+    const useless = !isUseful(current);
 
-        if (useless || repeated) {
-            store.nodes.splice(i, 1);
-            i -= 1;
-        } else {
-            set.add(id);
-        }
+    if (useless || repeated) {
+      store.nodes.splice(i, 1);
+      i -= 1;
+    } else {
+      set.add(id);
     }
+  }
 }, 300);
 
 export const syncBreakpointsToFrontend = debounce(() => {
-    const { nodes = [] } = store;
+  const { nodes = [] } = store;
 
-    const filter = (node: BaseNode) => node.breakpoint === STATUS_ENABLED;
-    const map = (node: BaseNode) => node.nodePath;
-    const paths = nodes.filter(filter).map(map);
+  const filter = (node: BaseNode) => node.breakpoint === STATUS_ENABLED;
+  const map = (node: BaseNode) => node.nodePath;
+  const paths = nodes.filter(filter).map(map);
 
-    socket.emitToFrontend({
-        eventType: EVENT_TYPE_SYNC_BREAKPOINTS,
-        paths,
-    });
+  socket.emitToFrontend({
+    eventType: EVENT_TYPE_SYNC_BREAKPOINTS,
+    paths,
+  });
 });
 
 const creater = (node: BaseNode) => {
-    if (!node?.breakpoint) {
-        return;
-    }
+  if (!node?.breakpoint) {
+    return;
+  }
 
-    store.nodes.push(node);
-    clean();
+  store.nodes.push(node);
+  clean();
 
-    syncBreakpointsToFrontend();
+  syncBreakpointsToFrontend();
 };
 
 const deleter = (node: BaseNode) => {
-    const index = store.nodes.indexOf(node);
-    index > -1 && store.nodes.splice(index, 1);
+  const index = store.nodes.indexOf(node);
+  index > -1 && store.nodes.splice(index, 1);
 
-    syncBreakpointsToFrontend();
+  syncBreakpointsToFrontend();
+};
+
+const isFrontend = (node: BaseNode) => {
+  if (!node) {
+    return;
+  }
+
+  const { getAncestor } = node;
+
+  return getAncestor && getAncestor.call(node, 'View');
 };
 
 const updateToBackend = (node: BaseNode) => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
 
-    const frontend = isFrontend(node);
-    const { breakpoint, nodePath: path } = node;
+  const frontend = isFrontend(node);
+  const { breakpoint, nodePath: path } = node;
 
-    if (!breakpoint) {
-        return;
-    }
+  if (!breakpoint) {
+    return;
+  }
 
-    if (frontend) {
-        return;
-    }
+  if (frontend) {
+    return;
+  }
 
-    socket.emitToBackend({
-        eventType: EVENT_TYPE_BREAKPOINT,
-        breakpoint: { path, breakpointStatus: breakpoint },
-    });
+  socket.emitToBackend({
+    eventType: EVENT_TYPE_BREAKPOINT,
+    breakpoint: { path, breakpointStatus: breakpoint },
+  });
 };
 
 const updater = (node: BaseNode) => {
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
 
-    const { breakpoint } = node;
-    const { nodes = [] } = store;
+  const { breakpoint } = node;
+  const { nodes = [] } = store;
 
-    const included = nodes.includes(node);
+  const included = nodes.includes(node);
 
-    if (breakpoint) {
-        included ? updateToBackend(node) : creater(node);
-    } else {
-        included && deleter(node);
-    }
+  if (breakpoint) {
+    included ? updateToBackend(node) : creater(node);
+  } else {
+    included && deleter(node);
+  }
 
-    syncBreakpointsToFrontend();
+  syncBreakpointsToFrontend();
 };
 
 setCreate(creater);
 setUpdate(updater);
 setDelete(deleter);
 
-const isFrontend = (node: BaseNode) => {
-    if (!node) {
-        return;
-    }
-
-    const { getAncestor } = node;
-
-    return getAncestor && getAncestor.call(node, 'View');
-};
-
 export const addBreakpointNode = (node: BaseNode) => {
-    node = getRealNode(node);
-
-    if (!node) {
-        return;
-    }
-
-    const frontend = isFrontend(node);
-    const backendData = {
-        eventType: EVENT_TYPE_BREAKPOINT,
-        breakpoint: {
-            path: node.nodePath,
-            breakpointStatus: STATUS_ENABLED,
-        },
-    };
+  node = getRealNode(node);
+
+  if (!node) {
+    return;
+  }
+
+  const frontend = isFrontend(node);
+  const backendData = {
+    eventType: EVENT_TYPE_BREAKPOINT,
+    breakpoint: {
+      path: node.nodePath,
+      breakpointStatus: STATUS_ENABLED,
+    },
+  };
 
-    node.update({ breakpoint: STATUS_ENABLED });
-    !frontend && socket.emitToBackend(backendData);
+  node.update({ breakpoint: STATUS_ENABLED });
+  !frontend && socket.emitToBackend(backendData);
 
-    creater(node);
+  creater(node);
 };
 
 export const enableBreakpointNode = (node: BaseNode) => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
 
-    node.update({ breakpoint: STATUS_ENABLED });
+  node.update({ breakpoint: STATUS_ENABLED });
 };
 
 export const disableBreakpointNode = (node: BaseNode) => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
 
-    node.update({ breakpoint: STATUS_DISABLED });
+  node.update({ breakpoint: STATUS_DISABLED });
 };
 
 export const removeBreakpointNode = (node: BaseNode) => {
-    node = getRealNode(node);
+  node = getRealNode(node);
 
-    if (!node) {
-        return;
-    }
+  if (!node) {
+    return;
+  }
+
+  const frontend = isFrontend(node);
+  const connected = socket.isConnected();
 
-    const frontend = isFrontend(node);
-    const backendData = {
-        eventType: EVENT_TYPE_BREAKPOINT,
-        breakpoint: {
-            path: node.nodePath,
-            breakpointStatus: STATUS_DELETED,
-        },
-    };
+  const backendData = {
+    eventType: EVENT_TYPE_BREAKPOINT,
+    breakpoint: {
+      path: node.nodePath,
+      breakpointStatus: STATUS_DELETED,
+    },
+  };
 
+  if (connected && !frontend) {
+    node.breakpoint = null;
+  } else {
     node.update({ breakpoint: null });
-    !frontend && socket.emitToBackend(backendData);
+  }
 
-    deleter(node);
+  !frontend && socket.emitToBackend(backendData);
+  deleter(node);
 };
 
 export const addBreakpointNodesFromNode = (source: BaseNode) => {
-    traverseBreakpointOnNode(source, creater);
+  traverseBreakpointOnNode(source, creater);
 };
 
 export const addBreakpointNodesFromApp = (source: App) => {
-    store.nodes = [];
-    setTimeout(() => traverseBreakpointOnApp(source, creater));
+  store.nodes = [];
+  setTimeout(() => traverseBreakpointOnApp(source, creater));
 };
 
 let temporaryNodes: BaseNode[] = [];
 
 export const recoverBreakpointAfterTemporary = () => {
-    temporaryNodes.forEach((node) => {
-        if (node) {
-            node.breakpoint = STATUS_ENABLED;
-        }
-    });
+  temporaryNodes.forEach((node) => {
+    if (node) {
+      node.breakpoint = STATUS_ENABLED;
+    }
+  });
 };
 
 export const removeBreakpointForTemporary = async () => {
-    temporaryNodes = store.nodes || [];
-    temporaryNodes.forEach((node) => {
-        if (node && 'breakpoint' in node) {
-            delete node.breakpoint;
-        }
-    });
-
-    await Promise.resolve(temporaryNodes);
-    recoverBreakpointAfterTemporary();
+  temporaryNodes = store.nodes || [];
+  temporaryNodes.forEach((node) => {
+    if (node && 'breakpoint' in node) {
+      delete node.breakpoint;
+    }
+  });
+
+  await Promise.resolve(temporaryNodes);
+  recoverBreakpointAfterTemporary();
 };
 
 export const findFromStack = (targetPath = store.activePath) => {
-    const { stack = [], activeStackItem = {} } = store;
-    const { operation: { path: activeStackItemPath = '' } = {} } = activeStackItem;
+  const { stack = [], activeStackItem = {} } = store;
+  const { operation: { path: activeStackItemPath = '' } = {} } = activeStackItem;
 
-    if (activeStackItemPath === targetPath) {
-        return activeStackItem;
-    }
+  if (activeStackItemPath === targetPath) {
+    return activeStackItem;
+  }
 
-    return stack.find((item = {}) => {
-        const { operation: { path = '' } = {} } = item;
+  return stack.find((item = {}) => {
+    const { operation: { path = '' } = {} } = item;
 
-        return targetPath === path;
-    });
+    return targetPath === path;
+  });
 };
 
 export const resolveBreakpointToBackend = (path = store.activePath) => {
-    const eventType = EVENT_TYPE_RESOLVE;
-    const data = { eventType, path };
+  const eventType = EVENT_TYPE_RESOLVE;
+  const data = { eventType, path };
 
-    path && socket.emitToBackend(data);
+  path && socket.emitToBackend(data);
 };
 
 export const resolveBreakpointToFrontend = (path = store.activePath) => {
-    const eventType = EVENT_TYPE_RESOLVE;
-    const data = { eventType, path };
+  const eventType = EVENT_TYPE_RESOLVE;
+  const data = { eventType, path };
 
-    path && socket.emitToFrontend(data);
+  path && socket.emitToFrontend(data);
 };
 
 export const resolveByPath = (path = store.activePath) => {
-    const { activePath, stack = [] } = store;
+  const { activePath, stack = [] } = store;
 
-    const found = findFromStack(path);
-    const nextStack = stack.filter((item) => item !== found);
+  const found = findFromStack(path);
+  const nextStack = stack.filter((item) => item !== found);
 
-    if (activePath === path) {
-        store.activeStackItem = nextStack[0];
-    }
+  if (activePath === path) {
+    // eslint-disable-next-line prefer-destructuring
+    store.activeStackItem = nextStack[0];
+  }
 
-    store.stack = nextStack;
+  store.stack = nextStack;
 };
 
 export const resolveBreakpoint = (path = store.activePath) => {
-    const found = findFromStack();
+  const found = findFromStack();
 
-    if (!found) {
-        return;
-    }
+  if (!found) {
+    return;
+  }
 
-    const { target } = found;
-
-    switch (target) {
-        case TARGET_BACKEND: {
-            resolveBreakpointToBackend(path);
-            break;
-        }
-        case TARGET_FRONTEND: {
-            resolveBreakpointToFrontend(path);
-            break;
-        }
+  const { target } = found;
+
+  switch (target) {
+    case TARGET_BACKEND: {
+      resolveBreakpointToBackend(path);
+      break;
+    }
+    case TARGET_FRONTEND: {
+      resolveBreakpointToFrontend(path);
+      break;
     }
+  }
 
-    store.echoStackItem = found;
-    resolveByPath();
+  store.echoStackItem = found;
+  resolveByPath();
 };
 
 const stepOverBreakpointToBackend = () => {
-    const { activePath } = store;
+  const { activePath } = store;
 
-    activePath && socket.emitToBackend({
-        eventType: EVENT_TYPE_STEP_OVER,
-        path: store.activePath,
-    });
+  activePath && socket.emitToBackend({
+    eventType: EVENT_TYPE_STEP_OVER,
+    path: store.activePath,
+  });
 };
 
 const stepOverBreakpointToFrontend = (data: StepOverData = {}) => {
-    const { activePath } = store;
+  const { activePath } = store;
 
-    activePath && socket.emitToFrontend({
-        eventType: EVENT_TYPE_STEP_OVER,
-        path: store.activePath,
-        ...data,
-    });
+  activePath && socket.emitToFrontend({
+    eventType: EVENT_TYPE_STEP_OVER,
+    path: store.activePath,
+    ...data,
+  });
 };
 
 export const stepOverBreakpoint = (data: StepOverData = {}) => {
-    const found = findFromStack();
+  const found = findFromStack();
 
-    if (!found) {
-        return;
-    }
-
-    const { target } = found;
-
-    switch (target) {
-        case TARGET_BACKEND: {
-            stepOverBreakpointToBackend();
-            break;
-        }
-        case TARGET_FRONTEND: {
-            stepOverBreakpointToFrontend(data);
-            break;
-        }
-    }
-
-    store.echoStackItem = found;
-    resolveByPath();
-};
-
-const CACHE_KEY = 'activePath';
-const cacher = new Map();
+  if (!found) {
+    return;
+  }
 
-const clearBeforeEmit = () => {
-    const { activePath: storeActivePath } = store;
-    const cacheActivePath = cacher.get(CACHE_KEY);
+  const { target } = found;
 
-    const empty = !cacheActivePath;
-    const different = storeActivePath !== cacheActivePath;
-
-    empty && cacher.clear();
-    different && cacher.clear();
+  switch (target) {
+    case TARGET_BACKEND: {
+      stepOverBreakpointToBackend();
+      break;
+    }
+    case TARGET_FRONTEND: {
+      stepOverBreakpointToFrontend(data);
+      break;
+    }
+  }
 
-    cacher.set(CACHE_KEY, storeActivePath);
+  store.echoStackItem = found;
+  resolveByPath();
 };
 
-const emitToBackendWithCache = (source: Record<string, any> = {}) => {
-    clearBeforeEmit();
-
-    const key = JSON.stringify(source);
-    const cache = cacher.get(key) || socket.emitToBackend(source);
-
-    cacher.set(key, cache);
-    return cache;
-};
+export const fetchBackendPage = (source: Record<string, any> = {}) => socket.emitToBackend({
+  eventType: EVENT_TYPE_PAGE_INFO,
+  ...source,
+});
 
-export const fetchBackendPage = (source: Record<string, any> = {}) => emitToBackendWithCache({
-    eventType: EVENT_TYPE_PAGE_INFO,
-    ...source,
+export const fetchBackendReturn = (source: Record<string, any> = {}) => socket.emitToBackend({
+  eventType: EVENT_TYPE_RETURN_INFO,
+  ...source,
 });
 
-export const fetchBackendObject = (source: Record<string, any> = {}) => emitToBackendWithCache({
-    eventType: EVENT_TYPE_OBJECT_INFO,
-    ...source,
+export const fetchBackendObject = (source: Record<string, any> = {}) => socket.emitToBackend({
+  eventType: EVENT_TYPE_OBJECT_INFO,
+  ...source,
 });
 
 let variableNodes: BaseNode[] = [];
@@ -420,57 +419,87 @@ let variablesPromise: Promise<any>;
 let resolveVariablesPromise: (arg: any) => void;
 
 const nodeToCode = (node: BaseNode) => {
-    let code;
-
-    try {
-        if ('toJS' in node) {
-            code = (node as any).toJS();
-        }
-    } catch (e) {
-        console.error(e);
-        code = '';
+  let code;
+
+  try {
+    if ('toJS' in node) {
+      code = (node as any).toJS();
     }
+  } catch (e) {
+    console.error(e);
+    code = '';
+  }
 
-    return code;
+  return code;
 };
 
 const fetchVariables = debounce(async () => {
-    const { activePath } = store;
+  const { activePath } = store;
 
-    const resolve = resolveVariablesPromise;
-    const codes = variableNodes.map(nodeToCode);
+  const resolve = resolveVariablesPromise;
+  const codes = variableNodes.map(nodeToCode);
 
-    variableNodes = [];
-    variablesPromise = undefined;
-    resolveVariablesPromise = undefined;
+  variableNodes = [];
+  variablesPromise = undefined;
+  resolveVariablesPromise = undefined;
 
-    const result = await socket.emitToFrontend({
-        eventType: EVENT_TYPE_PARSE,
-        path: activePath,
-        codes,
-    });
+  const result = await socket.emitToFrontend({
+    eventType: EVENT_TYPE_PARSE,
+    path: activePath,
+    codes,
+  });
 
-    resolve && resolve(result);
+  resolve && resolve(result);
 }, 0, { leading: false, trailing: true });
 
 const getVariablesPromise = () => {
-    variablesPromise = variablesPromise || new Promise((resolve) => {
-        resolveVariablesPromise = resolve;
-    });
+  variablesPromise = variablesPromise || new Promise((resolve) => {
+    resolveVariablesPromise = resolve;
+  });
 
-    fetchVariables();
-    return variablesPromise;
+  fetchVariables();
+  return variablesPromise;
 };
 
 export const fetchFrontendVariable = async (node: BaseNode) => {
-    const { length } = variableNodes;
+  const { length } = variableNodes;
+
+  variableNodes = variableNodes.concat(node);
 
-    variableNodes = variableNodes.concat(node);
+  const promise = getVariablesPromise();
+  const result = await promise;
+
+  return result && result[length];
+};
 
-    const promise = getVariablesPromise();
-    const result = await promise;
+export const fetchReturn = async (node: BaseNode) => {
+  const { nodePath: path } = node;
 
-    return result && result[length];
+  if (!path) {
+    return;
+  }
+
+  const found = findFromStack();
+
+  if (!found) {
+    return;
+  }
+
+  const { target } = found;
+
+  const data = { path };
+
+  switch (target) {
+    case TARGET_BACKEND: {
+      return fetchBackendReturn(data);
+    }
+    case TARGET_FRONTEND: {
+      const eventType = EVENT_TYPE_CACHE;
+      const options = { eventType, ...data };
+
+      return socket.emitToFrontend(options);
+    }
+  }
 };
 
 export default store;