@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/out/breakpoint/store/core.js

@@ -1,416 +1,416 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchReturn = exports.fetchFrontendVariable = exports.fetchBackendObject = exports.fetchBackendReturn = exports.fetchBackendPage = exports.stepOverBreakpoint = exports.stepOverBreakpointToFrontend = exports.stepOverBreakpointToBackend = exports.resolveBreakpoint = exports.resolveByPath = exports.resolveBreakpointToFrontend = exports.resolveBreakpointToBackend = exports.findFromStack = exports.removeBreakpointForTemporary = exports.recoverBreakpointAfterTemporary = exports.addBreakpointNodesFromApp = exports.addBreakpointNodesFromNode = exports.removeBreakpointNode = exports.disableBreakpointNode = exports.enableBreakpointNode = exports.addBreakpointNode = exports.syncBreakpointsToFrontend = exports.store = exports.reactive = void 0;
-const debounce_1 = __importDefault(require("lodash/debounce"));
-const constants_1 = require("../shared/constants");
-const socket = __importStar(require("../shared/socket"));
-const operations_1 = require("../shared/operations");
-const utils_1 = require("../shared/utils");
-let original = {
-    enable: true,
-    nodes: [],
-    stack: [],
-    connections: [],
-    activePath: '',
-    activeStackItem: {},
-    echoStackItem: {},
-};
-Object.defineProperty(original, 'activePath', {
-    get: () => {
-        const { activeStackItem = {} } = original;
-        const { operation = {} } = activeStackItem;
-        const { path = '' } = operation;
-        return path;
-    },
-});
-const reactive = (callback) => {
-    original = callback(original);
-    return original;
-};
-exports.reactive = reactive;
-exports.store = new Proxy({}, {
-    get: (_, key) => original[key],
-    set: (_, key, value) => Reflect.set(original, key, value),
-});
-const isUseful = (node) => {
-    if (!node) {
-        return false;
-    }
-    const { app, nodePath } = node;
-    if (!app || !nodePath) {
-        return false;
-    }
-    return app.findNodeByPath(nodePath);
-};
-const clean = (0, debounce_1.default)(() => {
-    const set = new Set();
-    for (let i = 0; i < exports.store.nodes.length; i += 1) {
-        const current = exports.store.nodes[i];
-        const { id } = current;
-        const repeated = set.has(id);
-        const useless = !isUseful(current);
-        if (useless || repeated) {
-            exports.store.nodes.splice(i, 1);
-            i -= 1;
-        }
-        else {
-            set.add(id);
-        }
-    }
-}, 300);
-exports.syncBreakpointsToFrontend = (0, debounce_1.default)(() => {
-    const { nodes = [] } = exports.store;
-    const filter = (node) => node.breakpoint === constants_1.STATUS_ENABLED;
-    const map = (node) => node.nodePath;
-    const paths = nodes.filter(filter).map(map);
-    socket.emitToFrontend({
-        eventType: constants_1.EVENT_TYPE_SYNC_BREAKPOINTS,
-        paths,
-    });
-});
-const creater = (node) => {
-    if (!node?.breakpoint) {
-        return;
-    }
-    exports.store.nodes.push(node);
-    clean();
-    (0, exports.syncBreakpointsToFrontend)();
-};
-const deleter = (node) => {
-    const index = exports.store.nodes.indexOf(node);
-    index > -1 && exports.store.nodes.splice(index, 1);
-    (0, exports.syncBreakpointsToFrontend)();
-};
-const isFrontend = (node) => {
-    if (!node) {
-        return;
-    }
-    const { getAncestor } = node;
-    return getAncestor && getAncestor.call(node, 'View');
-};
-const updateToBackend = (node) => {
-    node = (0, utils_1.getRealNode)(node);
-    if (!node) {
-        return;
-    }
-    const frontend = isFrontend(node);
-    const { breakpoint, nodePath: path } = node;
-    if (!breakpoint) {
-        return;
-    }
-    if (frontend) {
-        return;
-    }
-    socket.emitToBackend({
-        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
-        breakpoint: { path, breakpointStatus: breakpoint },
-    });
-};
-const updater = (node) => {
-    if (!node) {
-        return;
-    }
-    const { breakpoint } = node;
-    const { nodes = [] } = exports.store;
-    const included = nodes.includes(node);
-    if (breakpoint) {
-        included ? updateToBackend(node) : creater(node);
-    }
-    else {
-        included && deleter(node);
-    }
-    (0, exports.syncBreakpointsToFrontend)();
-};
-(0, operations_1.setCreate)(creater);
-(0, operations_1.setUpdate)(updater);
-(0, operations_1.setDelete)(deleter);
-const addBreakpointNode = (node) => {
-    node = (0, utils_1.getRealNode)(node);
-    if (!node) {
-        return;
-    }
-    const frontend = isFrontend(node);
-    const backendData = {
-        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
-        breakpoint: {
-            path: node.nodePath,
-            breakpointStatus: constants_1.STATUS_ENABLED,
-        },
-    };
-    node.update({ breakpoint: constants_1.STATUS_ENABLED });
-    !frontend && socket.emitToBackend(backendData);
-    creater(node);
-};
-exports.addBreakpointNode = addBreakpointNode;
-const enableBreakpointNode = (node) => {
-    node = (0, utils_1.getRealNode)(node);
-    if (!node) {
-        return;
-    }
-    node.update({ breakpoint: constants_1.STATUS_ENABLED });
-};
-exports.enableBreakpointNode = enableBreakpointNode;
-const disableBreakpointNode = (node) => {
-    node = (0, utils_1.getRealNode)(node);
-    if (!node) {
-        return;
-    }
-    node.update({ breakpoint: constants_1.STATUS_DISABLED });
-};
-exports.disableBreakpointNode = disableBreakpointNode;
-const removeBreakpointNode = (node) => {
-    node = (0, utils_1.getRealNode)(node);
-    if (!node) {
-        return;
-    }
-    const frontend = isFrontend(node);
-    const connected = socket.isConnected();
-    const backendData = {
-        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
-        breakpoint: {
-            path: node.nodePath,
-            breakpointStatus: constants_1.STATUS_DELETED,
-        },
-    };
-    if (connected && !frontend) {
-        node.breakpoint = null;
-    }
-    else {
-        node.update({ breakpoint: null });
-    }
-    !frontend && socket.emitToBackend(backendData);
-    deleter(node);
-};
-exports.removeBreakpointNode = removeBreakpointNode;
-const addBreakpointNodesFromNode = (source) => {
-    (0, utils_1.traverseBreakpointOnNode)(source, creater);
-};
-exports.addBreakpointNodesFromNode = addBreakpointNodesFromNode;
-const addBreakpointNodesFromApp = (source) => {
-    exports.store.nodes = [];
-    setTimeout(() => (0, utils_1.traverseBreakpointOnApp)(source, creater));
-};
-exports.addBreakpointNodesFromApp = addBreakpointNodesFromApp;
-let temporaryNodes = [];
-const recoverBreakpointAfterTemporary = () => {
-    temporaryNodes.forEach((node) => {
-        if (node) {
-            node.breakpoint = constants_1.STATUS_ENABLED;
-        }
-    });
-};
-exports.recoverBreakpointAfterTemporary = recoverBreakpointAfterTemporary;
-const removeBreakpointForTemporary = async () => {
-    temporaryNodes = exports.store.nodes || [];
-    temporaryNodes.forEach((node) => {
-        if (node && 'breakpoint' in node) {
-            delete node.breakpoint;
-        }
-    });
-    await Promise.resolve(temporaryNodes);
-    (0, exports.recoverBreakpointAfterTemporary)();
-};
-exports.removeBreakpointForTemporary = removeBreakpointForTemporary;
-const findFromStack = (targetPath = exports.store.activePath) => {
-    const { stack = [], activeStackItem = {} } = exports.store;
-    const { operation: { path: activeStackItemPath = '' } = {} } = activeStackItem;
-    if (activeStackItemPath === targetPath) {
-        return activeStackItem;
-    }
-    return stack.find((item = {}) => {
-        const { operation: { path = '' } = {} } = item;
-        return targetPath === path;
-    });
-};
-exports.findFromStack = findFromStack;
-const resolveBreakpointToBackend = (path = exports.store.activePath) => {
-    const eventType = constants_1.EVENT_TYPE_RESOLVE;
-    const data = { eventType, path };
-    path && socket.emitToBackend(data);
-};
-exports.resolveBreakpointToBackend = resolveBreakpointToBackend;
-const resolveBreakpointToFrontend = (path = exports.store.activePath) => {
-    const eventType = constants_1.EVENT_TYPE_RESOLVE;
-    const data = { eventType, path };
-    path && socket.emitToFrontend(data);
-};
-exports.resolveBreakpointToFrontend = resolveBreakpointToFrontend;
-const resolveByPath = (path = exports.store.activePath) => {
-    const { activePath, stack = [] } = exports.store;
-    const found = (0, exports.findFromStack)(path);
-    const nextStack = stack.filter((item) => item !== found);
-    if (activePath === path) {
-        // eslint-disable-next-line prefer-destructuring
-        exports.store.activeStackItem = nextStack[0];
-    }
-    exports.store.stack = nextStack;
-};
-exports.resolveByPath = resolveByPath;
-const resolveBreakpoint = (path = exports.store.activePath) => {
-    const found = (0, exports.findFromStack)();
-    if (!found) {
-        return;
-    }
-    const { target } = found;
-    switch (target) {
-        case constants_1.TARGET_BACKEND: {
-            (0, exports.resolveBreakpointToBackend)(path);
-            break;
-        }
-        case constants_1.TARGET_FRONTEND: {
-            (0, exports.resolveBreakpointToFrontend)(path);
-            break;
-        }
-    }
-    exports.store.echoStackItem = found;
-    (0, exports.resolveByPath)();
-};
-exports.resolveBreakpoint = resolveBreakpoint;
-const stepOverBreakpointToBackend = () => {
-    const { activePath } = exports.store;
-    activePath && socket.emitToBackend({
-        eventType: constants_1.EVENT_TYPE_STEP_OVER,
-        path: exports.store.activePath,
-    });
-};
-exports.stepOverBreakpointToBackend = stepOverBreakpointToBackend;
-const stepOverBreakpointToFrontend = (data = {}) => {
-    const { activePath } = exports.store;
-    activePath && socket.emitToFrontend({
-        eventType: constants_1.EVENT_TYPE_STEP_OVER,
-        path: exports.store.activePath,
-        ...data,
-    });
-};
-exports.stepOverBreakpointToFrontend = stepOverBreakpointToFrontend;
-const stepOverBreakpoint = (data = {}) => {
-    const found = (0, exports.findFromStack)();
-    if (!found) {
-        return;
-    }
-    const { target } = found;
-    switch (target) {
-        case constants_1.TARGET_BACKEND: {
-            (0, exports.stepOverBreakpointToBackend)();
-            break;
-        }
-        case constants_1.TARGET_FRONTEND: {
-            (0, exports.stepOverBreakpointToFrontend)(data);
-            break;
-        }
-    }
-    exports.store.echoStackItem = found;
-    (0, exports.resolveByPath)();
-};
-exports.stepOverBreakpoint = stepOverBreakpoint;
-const fetchBackendPage = (source = {}) => socket.emitToBackend({
-    eventType: constants_1.EVENT_TYPE_PAGE_INFO,
-    ...source,
-});
-exports.fetchBackendPage = fetchBackendPage;
-const fetchBackendReturn = (source = {}) => socket.emitToBackend({
-    eventType: constants_1.EVENT_TYPE_RETURN_INFO,
-    ...source,
-});
-exports.fetchBackendReturn = fetchBackendReturn;
-const fetchBackendObject = (source = {}) => socket.emitToBackend({
-    eventType: constants_1.EVENT_TYPE_OBJECT_INFO,
-    ...source,
-});
-exports.fetchBackendObject = fetchBackendObject;
-let variableNodes = [];
-let variablesPromise;
-let resolveVariablesPromise;
-const nodeToCode = (node) => {
-    let code;
-    try {
-        if ('toJS' in node) {
-            code = node.toJS();
-        }
-    }
-    catch (e) {
-        console.error(e);
-        code = '';
-    }
-    return code;
-};
-const fetchVariables = (0, debounce_1.default)(async () => {
-    const { activePath } = exports.store;
-    const resolve = resolveVariablesPromise;
-    const codes = variableNodes.map(nodeToCode);
-    variableNodes = [];
-    variablesPromise = undefined;
-    resolveVariablesPromise = undefined;
-    const result = await socket.emitToFrontend({
-        eventType: constants_1.EVENT_TYPE_PARSE,
-        path: activePath,
-        codes,
-    });
-    resolve && resolve(result);
-}, 0, { leading: false, trailing: true });
-const getVariablesPromise = () => {
-    variablesPromise = variablesPromise || new Promise((resolve) => {
-        resolveVariablesPromise = resolve;
-    });
-    fetchVariables();
-    return variablesPromise;
-};
-const fetchFrontendVariable = async (node) => {
-    const { length } = variableNodes;
-    variableNodes = variableNodes.concat(node);
-    const promise = getVariablesPromise();
-    const result = await promise;
-    return result && result[length];
-};
-exports.fetchFrontendVariable = fetchFrontendVariable;
-const fetchReturn = async (node) => {
-    const { nodePath: path } = node;
-    if (!path) {
-        return;
-    }
-    const found = (0, exports.findFromStack)();
-    if (!found) {
-        return;
-    }
-    const { target } = found;
-    const data = { path };
-    switch (target) {
-        case constants_1.TARGET_BACKEND: {
-            return (0, exports.fetchBackendReturn)(data);
-        }
-        case constants_1.TARGET_FRONTEND: {
-            const eventType = constants_1.EVENT_TYPE_CACHE;
-            const options = { eventType, ...data };
-            return socket.emitToFrontend(options);
-        }
-    }
-};
-exports.fetchReturn = fetchReturn;
-exports.default = exports.store;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReturn = exports.fetchFrontendVariable = exports.fetchBackendObject = exports.fetchBackendReturn = exports.fetchBackendPage = exports.stepOverBreakpoint = exports.stepOverBreakpointToFrontend = exports.stepOverBreakpointToBackend = exports.resolveBreakpoint = exports.resolveByPath = exports.resolveBreakpointToFrontend = exports.resolveBreakpointToBackend = exports.findFromStack = exports.removeBreakpointForTemporary = exports.recoverBreakpointAfterTemporary = exports.addBreakpointNodesFromApp = exports.addBreakpointNodesFromNode = exports.removeBreakpointNode = exports.disableBreakpointNode = exports.enableBreakpointNode = exports.addBreakpointNode = exports.syncBreakpointsToFrontend = exports.store = exports.reactive = void 0;
+const debounce_1 = __importDefault(require("lodash/debounce"));
+const constants_1 = require("../shared/constants");
+const socket = __importStar(require("../shared/socket"));
+const operations_1 = require("../shared/operations");
+const utils_1 = require("../shared/utils");
+let original = {
+    enable: true,
+    nodes: [],
+    stack: [],
+    connections: [],
+    activePath: '',
+    activeStackItem: {},
+    echoStackItem: {},
+};
+Object.defineProperty(original, 'activePath', {
+    get: () => {
+        const { activeStackItem = {} } = original;
+        const { operation = {} } = activeStackItem;
+        const { path = '' } = operation;
+        return path;
+    },
+});
+const reactive = (callback) => {
+    original = callback(original);
+    return original;
+};
+exports.reactive = reactive;
+exports.store = new Proxy({}, {
+    get: (_, key) => original[key],
+    set: (_, key, value) => Reflect.set(original, key, value),
+});
+const isUseful = (node) => {
+    if (!node) {
+        return false;
+    }
+    const { app, nodePath } = node;
+    if (!app || !nodePath) {
+        return false;
+    }
+    return app.findNodeByPath(nodePath);
+};
+const clean = (0, debounce_1.default)(() => {
+    const set = new Set();
+    for (let i = 0; i < exports.store.nodes.length; i += 1) {
+        const current = exports.store.nodes[i];
+        const { id } = current;
+        const repeated = set.has(id);
+        const useless = !isUseful(current);
+        if (useless || repeated) {
+            exports.store.nodes.splice(i, 1);
+            i -= 1;
+        }
+        else {
+            set.add(id);
+        }
+    }
+}, 300);
+exports.syncBreakpointsToFrontend = (0, debounce_1.default)(() => {
+    const { nodes = [] } = exports.store;
+    const filter = (node) => node.breakpoint === constants_1.STATUS_ENABLED;
+    const map = (node) => node.nodePath;
+    const paths = nodes.filter(filter).map(map);
+    socket.emitToFrontend({
+        eventType: constants_1.EVENT_TYPE_SYNC_BREAKPOINTS,
+        paths,
+    });
+});
+const creater = (node) => {
+    if (!node?.breakpoint) {
+        return;
+    }
+    exports.store.nodes.push(node);
+    clean();
+    (0, exports.syncBreakpointsToFrontend)();
+};
+const deleter = (node) => {
+    const index = exports.store.nodes.indexOf(node);
+    index > -1 && exports.store.nodes.splice(index, 1);
+    (0, exports.syncBreakpointsToFrontend)();
+};
+const isFrontend = (node) => {
+    if (!node) {
+        return;
+    }
+    const { getAncestor } = node;
+    return getAncestor && getAncestor.call(node, 'View');
+};
+const updateToBackend = (node) => {
+    node = (0, utils_1.getRealNode)(node);
+    if (!node) {
+        return;
+    }
+    const frontend = isFrontend(node);
+    const { breakpoint, nodePath: path } = node;
+    if (!breakpoint) {
+        return;
+    }
+    if (frontend) {
+        return;
+    }
+    socket.emitToBackend({
+        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
+        breakpoint: { path, breakpointStatus: breakpoint },
+    });
+};
+const updater = (node) => {
+    if (!node) {
+        return;
+    }
+    const { breakpoint } = node;
+    const { nodes = [] } = exports.store;
+    const included = nodes.includes(node);
+    if (breakpoint) {
+        included ? updateToBackend(node) : creater(node);
+    }
+    else {
+        included && deleter(node);
+    }
+    (0, exports.syncBreakpointsToFrontend)();
+};
+(0, operations_1.setCreate)(creater);
+(0, operations_1.setUpdate)(updater);
+(0, operations_1.setDelete)(deleter);
+const addBreakpointNode = (node) => {
+    node = (0, utils_1.getRealNode)(node);
+    if (!node) {
+        return;
+    }
+    const frontend = isFrontend(node);
+    const backendData = {
+        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
+        breakpoint: {
+            path: node.nodePath,
+            breakpointStatus: constants_1.STATUS_ENABLED,
+        },
+    };
+    node.update({ breakpoint: constants_1.STATUS_ENABLED });
+    !frontend && socket.emitToBackend(backendData);
+    creater(node);
+};
+exports.addBreakpointNode = addBreakpointNode;
+const enableBreakpointNode = (node) => {
+    node = (0, utils_1.getRealNode)(node);
+    if (!node) {
+        return;
+    }
+    node.update({ breakpoint: constants_1.STATUS_ENABLED });
+};
+exports.enableBreakpointNode = enableBreakpointNode;
+const disableBreakpointNode = (node) => {
+    node = (0, utils_1.getRealNode)(node);
+    if (!node) {
+        return;
+    }
+    node.update({ breakpoint: constants_1.STATUS_DISABLED });
+};
+exports.disableBreakpointNode = disableBreakpointNode;
+const removeBreakpointNode = (node) => {
+    node = (0, utils_1.getRealNode)(node);
+    if (!node) {
+        return;
+    }
+    const frontend = isFrontend(node);
+    const connected = socket.isConnected();
+    const backendData = {
+        eventType: constants_1.EVENT_TYPE_BREAKPOINT,
+        breakpoint: {
+            path: node.nodePath,
+            breakpointStatus: constants_1.STATUS_DELETED,
+        },
+    };
+    if (connected && !frontend) {
+        node.breakpoint = null;
+    }
+    else {
+        node.update({ breakpoint: null });
+    }
+    !frontend && socket.emitToBackend(backendData);
+    deleter(node);
+};
+exports.removeBreakpointNode = removeBreakpointNode;
+const addBreakpointNodesFromNode = (source) => {
+    (0, utils_1.traverseBreakpointOnNode)(source, creater);
+};
+exports.addBreakpointNodesFromNode = addBreakpointNodesFromNode;
+const addBreakpointNodesFromApp = (source) => {
+    exports.store.nodes = [];
+    setTimeout(() => (0, utils_1.traverseBreakpointOnApp)(source, creater));
+};
+exports.addBreakpointNodesFromApp = addBreakpointNodesFromApp;
+let temporaryNodes = [];
+const recoverBreakpointAfterTemporary = () => {
+    temporaryNodes.forEach((node) => {
+        if (node) {
+            node.breakpoint = constants_1.STATUS_ENABLED;
+        }
+    });
+};
+exports.recoverBreakpointAfterTemporary = recoverBreakpointAfterTemporary;
+const removeBreakpointForTemporary = async () => {
+    temporaryNodes = exports.store.nodes || [];
+    temporaryNodes.forEach((node) => {
+        if (node && 'breakpoint' in node) {
+            delete node.breakpoint;
+        }
+    });
+    await Promise.resolve(temporaryNodes);
+    (0, exports.recoverBreakpointAfterTemporary)();
+};
+exports.removeBreakpointForTemporary = removeBreakpointForTemporary;
+const findFromStack = (targetPath = exports.store.activePath) => {
+    const { stack = [], activeStackItem = {} } = exports.store;
+    const { operation: { path: activeStackItemPath = '' } = {} } = activeStackItem;
+    if (activeStackItemPath === targetPath) {
+        return activeStackItem;
+    }
+    return stack.find((item = {}) => {
+        const { operation: { path = '' } = {} } = item;
+        return targetPath === path;
+    });
+};
+exports.findFromStack = findFromStack;
+const resolveBreakpointToBackend = (path = exports.store.activePath) => {
+    const eventType = constants_1.EVENT_TYPE_RESOLVE;
+    const data = { eventType, path };
+    path && socket.emitToBackend(data);
+};
+exports.resolveBreakpointToBackend = resolveBreakpointToBackend;
+const resolveBreakpointToFrontend = (path = exports.store.activePath) => {
+    const eventType = constants_1.EVENT_TYPE_RESOLVE;
+    const data = { eventType, path };
+    path && socket.emitToFrontend(data);
+};
+exports.resolveBreakpointToFrontend = resolveBreakpointToFrontend;
+const resolveByPath = (path = exports.store.activePath) => {
+    const { activePath, stack = [] } = exports.store;
+    const found = (0, exports.findFromStack)(path);
+    const nextStack = stack.filter((item) => item !== found);
+    if (activePath === path) {
+        // eslint-disable-next-line prefer-destructuring
+        exports.store.activeStackItem = nextStack[0];
+    }
+    exports.store.stack = nextStack;
+};
+exports.resolveByPath = resolveByPath;
+const resolveBreakpoint = (path = exports.store.activePath) => {
+    const found = (0, exports.findFromStack)();
+    if (!found) {
+        return;
+    }
+    const { target } = found;
+    switch (target) {
+        case constants_1.TARGET_BACKEND: {
+            (0, exports.resolveBreakpointToBackend)(path);
+            break;
+        }
+        case constants_1.TARGET_FRONTEND: {
+            (0, exports.resolveBreakpointToFrontend)(path);
+            break;
+        }
+    }
+    exports.store.echoStackItem = found;
+    (0, exports.resolveByPath)();
+};
+exports.resolveBreakpoint = resolveBreakpoint;
+const stepOverBreakpointToBackend = () => {
+    const { activePath } = exports.store;
+    activePath && socket.emitToBackend({
+        eventType: constants_1.EVENT_TYPE_STEP_OVER,
+        path: exports.store.activePath,
+    });
+};
+exports.stepOverBreakpointToBackend = stepOverBreakpointToBackend;
+const stepOverBreakpointToFrontend = (data = {}) => {
+    const { activePath } = exports.store;
+    activePath && socket.emitToFrontend({
+        eventType: constants_1.EVENT_TYPE_STEP_OVER,
+        path: exports.store.activePath,
+        ...data,
+    });
+};
+exports.stepOverBreakpointToFrontend = stepOverBreakpointToFrontend;
+const stepOverBreakpoint = (data = {}) => {
+    const found = (0, exports.findFromStack)();
+    if (!found) {
+        return;
+    }
+    const { target } = found;
+    switch (target) {
+        case constants_1.TARGET_BACKEND: {
+            (0, exports.stepOverBreakpointToBackend)();
+            break;
+        }
+        case constants_1.TARGET_FRONTEND: {
+            (0, exports.stepOverBreakpointToFrontend)(data);
+            break;
+        }
+    }
+    exports.store.echoStackItem = found;
+    (0, exports.resolveByPath)();
+};
+exports.stepOverBreakpoint = stepOverBreakpoint;
+const fetchBackendPage = (source = {}) => socket.emitToBackend({
+    eventType: constants_1.EVENT_TYPE_PAGE_INFO,
+    ...source,
+});
+exports.fetchBackendPage = fetchBackendPage;
+const fetchBackendReturn = (source = {}) => socket.emitToBackend({
+    eventType: constants_1.EVENT_TYPE_RETURN_INFO,
+    ...source,
+});
+exports.fetchBackendReturn = fetchBackendReturn;
+const fetchBackendObject = (source = {}) => socket.emitToBackend({
+    eventType: constants_1.EVENT_TYPE_OBJECT_INFO,
+    ...source,
+});
+exports.fetchBackendObject = fetchBackendObject;
+let variableNodes = [];
+let variablesPromise;
+let resolveVariablesPromise;
+const nodeToCode = (node) => {
+    let code;
+    try {
+        if ('toJS' in node) {
+            code = node.toJS();
+        }
+    }
+    catch (e) {
+        console.error(e);
+        code = '';
+    }
+    return code;
+};
+const fetchVariables = (0, debounce_1.default)(async () => {
+    const { activePath } = exports.store;
+    const resolve = resolveVariablesPromise;
+    const codes = variableNodes.map(nodeToCode);
+    variableNodes = [];
+    variablesPromise = undefined;
+    resolveVariablesPromise = undefined;
+    const result = await socket.emitToFrontend({
+        eventType: constants_1.EVENT_TYPE_PARSE,
+        path: activePath,
+        codes,
+    });
+    resolve && resolve(result);
+}, 0, { leading: false, trailing: true });
+const getVariablesPromise = () => {
+    variablesPromise = variablesPromise || new Promise((resolve) => {
+        resolveVariablesPromise = resolve;
+    });
+    fetchVariables();
+    return variablesPromise;
+};
+const fetchFrontendVariable = async (node) => {
+    const { length } = variableNodes;
+    variableNodes = variableNodes.concat(node);
+    const promise = getVariablesPromise();
+    const result = await promise;
+    return result && result[length];
+};
+exports.fetchFrontendVariable = fetchFrontendVariable;
+const fetchReturn = async (node) => {
+    const { nodePath: path } = node;
+    if (!path) {
+        return;
+    }
+    const found = (0, exports.findFromStack)();
+    if (!found) {
+        return;
+    }
+    const { target } = found;
+    const data = { path };
+    switch (target) {
+        case constants_1.TARGET_BACKEND: {
+            return (0, exports.fetchBackendReturn)(data);
+        }
+        case constants_1.TARGET_FRONTEND: {
+            const eventType = constants_1.EVENT_TYPE_CACHE;
+            const options = { eventType, ...data };
+            return socket.emitToFrontend(options);
+        }
+    }
+};
+exports.fetchReturn = fetchReturn;
+exports.default = exports.store;
 //# sourceMappingURL=core.js.map