octoparse-cli 0.1.14

package/node_modules/@octopus/engine/dist/actions/LoopStartAction.js

@@ -0,0 +1,607 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LoopStartConfig_1 = __importDefault(require("../configs/LoopStartConfig"));
+const enums_1 = require("../enums");
+const actionItem_1 = require("../models/actionItem");
+const Operations_1 = require("../utils/Operations");
+const BaseAction_1 = __importDefault(require("./BaseAction"));
+class LoopStartAction extends BaseAction_1.default {
+    constructor() {
+        super(...arguments);
+        this.loopXpathNextWait = new Map();
+    }
+    async readLoopItemText(actionItem, timeout = 0) {
+        // 保持旧语义：优先走 page / Puppeteer 提取。
+        // bridge 只作为 fallback，用来兜住 rebrowser context 短暂不可用的窗口。
+        if (timeout > 0) {
+            await (0, Operations_1.queryElement)(actionItem, this.page, timeout);
+        }
+        try {
+            return await (0, Operations_1.processElement)(actionItem, this.page, '$eval', (ele) => ele.innerText);
+        }
+        catch (error) {
+            if (!(0, Operations_1.isTransientContextError)(error) || !this.useExtensionBridge) {
+                throw error;
+            }
+            const tabId = await this.getTabIdForPage(this.page);
+            if (tabId !== undefined) {
+                const result = await this.browserProxy.extensionBridge.sendActionCommand({
+                    action: 'extract',
+                    tabId,
+                    frame: actionItem.IsIFrame
+                        ? {
+                            isIframe: true,
+                            iframeXpath: actionItem.IFrameAbsXPath
+                        }
+                        : { isIframe: false },
+                    target: {
+                        type: 'xpath',
+                        xpath: actionItem.AbsXpath
+                    },
+                    payload: {
+                        mode: 'text'
+                    }
+                });
+                if (!result.success) {
+                    throw new Error('error' in result ? result.error : 'bridge extract failed');
+                }
+                const data = result.data;
+                const value = typeof (data === null || data === void 0 ? void 0 : data.value) === 'string' ? data.value : '';
+                return value;
+            }
+            throw error;
+        }
+    }
+    async loopElementExists(actionItem, timeout = 0) {
+        // 先按原来 page / Puppeteer 的方式判断存在性；
+        // 只有 queryElement 因 execution context 抖动失败时，才退到 bridge 探针。
+        try {
+            const element = await (0, Operations_1.queryElement)(actionItem, this.page, timeout);
+            return !!element;
+        }
+        catch (error) {
+            if (!(0, Operations_1.isTransientContextError)(error) || !this.useExtensionBridge) {
+                throw error;
+            }
+            if (timeout > 0) {
+                const bridgeExists = await this.bridgeElementExists(this.page, actionItem, timeout);
+                if (bridgeExists !== undefined) {
+                    return bridgeExists;
+                }
+            }
+            const tabId = await this.getTabIdForPage(this.page);
+            if (tabId !== undefined) {
+                const result = await this.browserProxy.extensionBridge.sendActionCommand({
+                    action: 'extract',
+                    tabId,
+                    frame: actionItem.IsIFrame
+                        ? {
+                            isIframe: true,
+                            iframeXpath: actionItem.IFrameAbsXPath
+                        }
+                        : { isIframe: false },
+                    target: {
+                        type: 'xpath',
+                        xpath: actionItem.AbsXpath
+                    },
+                    payload: {
+                        mode: 'text'
+                    }
+                });
+                if (result.success) {
+                    return true;
+                }
+                const errorMessage = 'error' in result ? result.error : 'bridge exists failed';
+                const bridgeExists = errorMessage.includes('Element not found')
+                    ? false
+                    : undefined;
+                if (bridgeExists !== undefined) {
+                    return bridgeExists;
+                }
+            }
+            throw error;
+        }
+    }
+    parseConfig() {
+        return new LoopStartConfig_1.default(this.execution.activity.$attrs);
+    }
+    async wait() {
+        if (!this.getIsOnlySkipOneLoop() && this.getIsSkipCurrentLoop()) {
+            this.finish();
+            return;
+        }
+        // 设置子循环是否跳过
+        this.setIsSkipActionUtilNextLoop(this.getNodeId(), false);
+        // 仅跳过一次，需要清除本次不跳过
+        this.resetIsOnlySkipOneLoop();
+        // this.task = task
+        // let loopConfig = this.basicConfig as LoopStartConfig
+        // 获取任务parentid，本次循环的id
+        const parentid = this.activity.parentContext.id;
+        // 从中获取一条循环元素
+        const line = this.popLoopValue(parentid);
+        // 循环增加一次
+        this.addLoopCount(parentid);
+        if (!line) {
+            this.setIsSkipCurrentLoop(parentid, true);
+            this.error(enums_1.LogKey.Loop.Error, this.name);
+            this.finish();
+            return;
+        }
+        if (this.config.loopType !== "FixedItem" /* LoopType.FixedItem */ &&
+            this.config.loopType !== "ScrollWeb" /* LoopType.ScrollWeb */) {
+            this.log(enums_1.LogKey.Loop.Action, this.name, this.getLoopCount(parentid));
+        }
+        // 设置为不跳过
+        this.setIsSkipCurrentLoop(parentid, false);
+        this.page = await this.getCurrentPage();
+        switch (this.config.loopType) {
+            case "FixedItem" /* LoopType.FixedItem */:
+                {
+                    this.setCurrentLoopValue(parentid, line);
+                    if (this.browserProxy.navigateType == "OpenJson" /* NavigateType.OpenJson */) {
+                        // JSON 模式：使用 jsonParser 检查节点是否存在
+                        const nextnode = this.browserProxy.jsonParser.getNode(line.AbsXpath);
+                        if (nextnode) {
+                            this.pushLoopValue(parentid, line);
+                        }
+                    }
+                    else {
+                        try {
+                            const ele = await (0, Operations_1.queryElement)(line, this.page, this.shouldWait ? 1500 : 0);
+                            if (ele)
+                                this.pushLoopValue(parentid, line);
+                        }
+                        catch (error) {
+                            await this.checkPause();
+                            console.log('固定元素当前循环', error === null || error === void 0 ? void 0 : error.message);
+                        }
+                        // 停止无效点击翻页判断
+                        await this.stopInvalidClickPage(parentid, this.config, this.page);
+                    }
+                }
+                break;
+            case "FixedItemList" /* LoopType.FixedItemList */:
+            case "URLList" /* LoopType.URLList */:
+            case "TextList" /* LoopType.TextList */:
+                {
+                    this.setCurrentLoopValue(parentid, line);
+                }
+                break;
+            case "VarilableItemList" /* LoopType.VarilableItemList */:
+                {
+                    if (this.browserProxy.navigateType == "OpenJson" /* NavigateType.OpenJson */) {
+                        // JSON 模式处理
+                        let startIndex = line.AbsXpath.lastIndexOf('[*]');
+                        if (startIndex < 0) {
+                            startIndex = line.AbsXpath.length;
+                        }
+                        // 当前循环项的 JSONPath
+                        const thisXpath = line.AbsXpath.substring(0, startIndex) +
+                            '[' +
+                            this.variables.index +
+                            ']';
+                        this.setCurrentLoopValue(parentid, new actionItem_1.ActionItem(thisXpath, line.IsIFrame, line.IFrameAbsXPath));
+                        // 判断下一个循环的 JSONPath 对应节点是否存在
+                        const nextXpath = line.AbsXpath.substring(0, startIndex) +
+                            '[' +
+                            (this.variables.index + 1) +
+                            ']';
+                        const nextnode = this.browserProxy.jsonParser.getNode(nextXpath);
+                        if (nextnode) {
+                            this.pushLoopValue(parentid, line);
+                        }
+                    }
+                    else {
+                        // 网页模式处理
+                        const loopOffset = this.getNextLoopOffset(parentid) || 0;
+                        const eleIndex = this.variables.index +
+                            this.getIdentifiedEachLoopExtractDataCount(parentid) +
+                            1 +
+                            loopOffset;
+                        const currentItem = `(${line.AbsXpath})[${eleIndex}]`;
+                        try {
+                            const sampleCurrentItem = new actionItem_1.ActionItem(currentItem, line.IsIFrame, line.IFrameAbsXPath);
+                            // 当前项读取成功之后，说明本轮索引已经稳定，
+                            // 要清掉之前因为瞬时上下文异常留下的偏移量，避免一直向负方向漂移。
+                            const sample = await this.readLoopItemText(sampleCurrentItem, this.shouldWait ? 1500 : 0);
+                            if (loopOffset !== 0) {
+                                this.resetNextLoopOffset(parentid);
+                            }
+                            this.setCurrentLoopValue(parentid, new actionItem_1.ActionItem(currentItem, line.IsIFrame, line.IFrameAbsXPath));
+                            if (sample) {
+                                this.countSomeLoopExtractDataNum(parentid);
+                                this.setSamplingElementsMap(parentid, new Map([[eleIndex, sample]])); // 将抽样数据记录下来
+                            }
+                        }
+                        catch (er) {
+                            await this.checkPause();
+                            if ((0, Operations_1.isTransientContextError)(er)) {
+                                this.setIsSkipActionUtilNextLoop(parentid, true);
+                                this.pushLoopValue(parentid, line);
+                            }
+                            else {
+                                this.setIsSkipCurrentLoop(parentid, true);
+                            }
+                            break;
+                        }
+                        try {
+                            const nextElement = eleIndex + 1;
+                            const lineActionItem = new actionItem_1.ActionItem(`(${line.AbsXpath})[${nextElement}]`, line.IsIFrame, line.IFrameAbsXPath);
+                            const existNextElement = await this.loopElementExists(lineActionItem, this.shouldWait ? 1500 : 0);
+                            if (existNextElement) {
+                                this.pushLoopValue(parentid, line);
+                            }
+                            else {
+                                this.saveSampedLoopRecord({
+                                    parentid,
+                                    AbsXpath: line.AbsXpath,
+                                    IsIFrame: line.IsIFrame,
+                                    IFrameAbsXPath: line.IFrameAbsXPath
+                                });
+                                await this.cacheCurLoopSampleElenemts({
+                                    AbsXpath: line.AbsXpath,
+                                    IsIFrame: line.IsIFrame,
+                                    IFrameAbsXPath: line.IFrameAbsXPath,
+                                    nodeId: parentid,
+                                    newXpathStartIndex: nextElement
+                                }, this.page);
+                            }
+                        }
+                        catch (er) {
+                            await this.checkPause();
+                            if ((0, Operations_1.isTransientContextError)(er)) {
+                                // 当前项已经成功解析，这里只是不确定“下一项是否存在”。
+                                // 保留当前项给后续提取步骤使用，并把基列表项压回去，
+                                // 让下一轮从自然递增的索引继续，不再写负 offset。
+                                this.pushLoopValue(parentid, line);
+                            }
+                        }
+                    }
+                }
+                break;
+            case "ScrollWeb" /* LoopType.ScrollWeb */:
+                {
+                    try {
+                        const { scrollType, scrollTime, scrollInterval, scrollXPath, IfStopScroll } = this.config;
+                        const loopCount = this.getLoopCount(parentid);
+                        if (loopCount === 1) {
+                            this.initContinuousScrollTopFixedWebCount(parentid);
+                            this.setWebScrollTopTemp(parentid, 0);
+                        }
+                        if (scrollXPath) {
+                            await (0, Operations_1.queryElement)(scrollXPath, this.page, this.shouldWait ? 1500 : 0);
+                            await (0, Operations_1.processElement)(scrollXPath, this.page, '$eval', (ele, scrollScreen) => {
+                                scrollScreen
+                                    ? ele.scrollBy(0, ele.offsetHeight)
+                                    : ele.scrollTo({ top: ele.scrollHeight });
+                            }, scrollType == 1 /* ScrollType.ScrollOneScreen */);
+                            // await this.page.$eval(
+                            //   `::-p-xpath(${scrollXPath.AbsXpath})`,
+                            //   (ele, scrollScreen) => {
+                            //     scrollScreen ? (ele as HTMLElement).scrollBy(0, (ele as HTMLElement).offsetHeight) : ele.scrollTo({ top: ele.scrollHeight })
+                            //   },
+                            //   scrollType == ScrollType.ScrollOneScreen
+                            // )
+                            scrollType == 1 /* ScrollType.ScrollOneScreen */
+                                ? this.log(enums_1.LogKey.Common.Scroll.Local.Screen, this.name, loopCount)
+                                : this.log(enums_1.LogKey.Common.Scroll.Local.Bottom, this.name, loopCount);
+                        }
+                        else {
+                            await this.page.evaluate((scrollScreen) => {
+                                scrollScreen
+                                    ? document.scrollingElement.scrollBy(0, globalThis.window.innerHeight)
+                                    : document.scrollingElement.scrollTo({
+                                        top: globalThis.document.body.scrollHeight,
+                                        behavior: 'auto'
+                                    });
+                            }, scrollType == 1 /* ScrollType.ScrollOneScreen */);
+                            scrollType == 1 /* ScrollType.ScrollOneScreen */
+                                ? this.log(enums_1.LogKey.Common.Scroll.Global.Screen, this.name, loopCount)
+                                : this.log(enums_1.LogKey.Common.Scroll.Global.Bottom, this.name, loopCount);
+                        }
+                        /** 下一次滚动间隔时间，如果只滚动一次就不需要多余等待了 */
+                        if (scrollInterval > 0 && scrollTime > 1) {
+                            await this.sleep(scrollInterval);
+                            await this.checkPause();
+                        }
+                        /** 判定无内容更新时结束滚动，通过判断滑动高度无变化 3 次，则认为无内容更新 */
+                        if (IfStopScroll) {
+                            const scrollHeight = this.getWebScrollTopTemp(parentid);
+                            let scrollTop = await this.page.evaluate(() => {
+                                return Math.max(document.documentElement.scrollTop, (document.body && document.body.scrollTop) || 0);
+                            });
+                            if (scrollXPath === null || scrollXPath === void 0 ? void 0 : scrollXPath.AbsXpath) {
+                                // scrollTop = await this.page.$eval(`::-p-xpath(${scrollXPath.AbsXpath})`, (ele) => ele.scrollTop)
+                                scrollTop = await (0, Operations_1.processElement)(scrollXPath, this.page, '$eval', (ele) => ele.scrollTop);
+                            }
+                            if (scrollHeight === scrollTop) {
+                                this.addContinuousScrollTopFixedWebCount(parentid);
+                                if (this.getContinuousScrollTopFixedWebCount(parentid) > 3)
+                                    break;
+                            }
+                            this.setWebScrollTopTemp(parentid, scrollTop);
+                        }
+                        if (loopCount < scrollTime)
+                            this.pushLoopValue(parentid, ['ScrollWeb']);
+                    }
+                    catch (error) {
+                        await this.checkPause();
+                        console.log('未找到元素');
+                    }
+                }
+                break;
+        }
+        this.finish();
+    }
+    isWaitPathByMaxIndex(key, currentIndex) {
+        let currentMax = this.loopXpathNextWait.get(key);
+        if (currentMax === undefined) {
+            currentMax = -1;
+        }
+        if (currentMax === -1) {
+            this.loopXpathNextWait.set(key, currentIndex);
+            return true;
+        }
+        if (currentMax > currentIndex) {
+            return true;
+        }
+        else if (currentMax < currentIndex) {
+            this.loopXpathNextWait.set(key, currentIndex);
+        }
+        return false;
+    }
+    /**
+     * 停止无效点击翻页判断
+     * @param parentid
+     * @param loopConfig
+     */
+    async stopInvalidClickPage(parentid, loopConfig, page) {
+        // 每次点击一个循环大概是69毫秒，如果是多个的话是倍速关系s
+        if (this.parent && this.browserProxy.workflowSetting) {
+            const parentLoopActionConfig = this.parent.config;
+            const parentLoopCount = this.getLoopCount(this.parent.id);
+            if (parentLoopActionConfig.checkedJumpLoopClick &&
+                parentLoopCount > this.browserProxy.workflowSetting.repeatPageLoopCount) {
+                const location = await page.evaluate(() => {
+                    return globalThis.location;
+                });
+                const referrer = await page.evaluate(() => {
+                    return globalThis.document.referrer;
+                });
+                const currentUrl = location.href;
+                let isCurrentAndReferrer = false;
+                //两个页面的链接相同
+                if (referrer !== '' &&
+                    referrer === currentUrl &&
+                    location.hash === '') {
+                    isCurrentAndReferrer = true;
+                    this.setLoopValues(parentid, []);
+                }
+                // 如果是一页的情况，那么会出现不能终止的问题
+                // else{
+                //   this.initContinuousInvalidPageCount(parentid);
+                // }
+                const sampedLoopRecord = this.getSampedLoopRecord();
+                if (sampedLoopRecord &&
+                    Object.keys(sampedLoopRecord) &&
+                    Object.keys(sampedLoopRecord).length !== 0) {
+                    let stopLoop = true;
+                    for (const key in sampedLoopRecord) {
+                        const configOptions = {
+                            AbsXpath: sampedLoopRecord[key].AbsXpath,
+                            IsIFrame: sampedLoopRecord[key].IsIFrame,
+                            IFrameAbsXPath: sampedLoopRecord[key].IFrameAbsXPath,
+                            newXpathStartIndex: this.getSomeLoopExtractDataCount(key)
+                        };
+                        const nextElement = await this.ifNextElement(configOptions, page);
+                        let diff = false;
+                        if (this.getCurrentLoopUrl(key)) {
+                            const url = page.url();
+                            if (this.getCurrentLoopUrl(key) != url) {
+                                diff = true;
+                            }
+                        }
+                        const loopConfig = sampedLoopRecord[key];
+                        if (loopConfig && loopConfig.AbsXpath) {
+                            const sample = this.getSamplingElementsMap(key);
+                            if (sample.size > 0) {
+                                for (const [key, value] of sample) {
+                                    const thisElement = {
+                                        ...this.config.variableList,
+                                        AbsXpath: '(' + loopConfig.AbsXpath + ')[' + key + ']'
+                                    };
+                                    const isExist = await (0, Operations_1.queryElement)(thisElement, this.page, this.shouldWait ? 1500 : 0);
+                                    if (!isExist) {
+                                        continue;
+                                    }
+                                    const text = await (0, Operations_1.processElement)(thisElement, this.page, '$eval', (ele) => (ele === null || ele === void 0 ? void 0 : ele.innerText) || ele.textContent);
+                                    if (this.similar(value.replace(/[\r\n\s]/g, ''), text.replace(/[\r\n\s]/g, ''), 2) < 0.95) {
+                                        diff = true; //说明前面的列表数据有变化
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (nextElement || diff) {
+                            stopLoop = false;
+                            break;
+                        }
+                    }
+                    if (stopLoop) {
+                        this.addContinuousInvalidPageCount(parentid);
+                    }
+                    else {
+                        //初始化之后不做判断
+                        this.initContinuousInvalidPageCount(parentid);
+                        return;
+                    }
+                    const invalidPageCount = this.getContinuousInvalidPageCount(parentid);
+                    if ((stopLoop &&
+                        invalidPageCount >=
+                            this.browserProxy.workflowSetting.continuousJudgeCount) ||
+                        (isCurrentAndReferrer && stopLoop)) {
+                        this.setIsSkipCurrentLoop(parentid, true);
+                    }
+                }
+            }
+            const element = await (0, Operations_1.queryElement)(loopConfig.fixedItem, page);
+            const isVisible = await (element === null || element === void 0 ? void 0 : element.isVisible());
+            if (!isVisible) {
+                this.setLoopValues(parentid, []);
+            }
+        }
+    }
+    /**
+     * 生成随机采样数据需要的数据坐标
+     * @param currentIndex  抽样前多少条数据条目（数据模板）
+     * @param m  抽样的数据条目
+     */
+    getRandomArrayElements(currentIndex, m = 5) {
+        if (currentIndex <= 0) {
+            return [];
+        }
+        if (currentIndex === 1) {
+            return [currentIndex];
+        }
+        const array = [...new Array(currentIndex).keys()];
+        array.shift();
+        const result = [];
+        const ranNum = Math.min(currentIndex, m);
+        for (let i = 0; i < ranNum; i++) {
+            const ran = Math.floor(Math.random() * (array.length - i));
+            result.push(array[ran]);
+            array[ran] = array[array.length - i - 1];
+        }
+        return result;
+    }
+    /**
+     * 指定循环采集数据步骤完成后进行数据采样并存储
+     * @param params
+     */
+    async cacheCurLoopSampleElenemts(params, page) {
+        const AbsXpath = params.AbsXpath;
+        const IsIFrame = params.IsIFrame;
+        const IFrameAbsXPath = params.IFrameAbsXPath;
+        const newmap = new Map();
+        const needle = this.getRandomArrayElements(params.newXpathStartIndex, 4);
+        if (needle.length > 0) {
+            for (const index of needle) {
+                const thisXpath = '(' + AbsXpath + ')[' + index + ']';
+                const text = await this.readLoopItemText(new actionItem_1.ActionItem(thisXpath, IsIFrame, IFrameAbsXPath));
+                newmap.set(index, text);
+            }
+            this.setSamplingElementsMap(params.nodeId, newmap); // 将抽样数据记录下来
+            try {
+                this.setCurrentLoopUrl(params.nodeId, page.url());
+            }
+            catch {
+                // processEventCenter.publish(PROCESS_EVENT.Action.Loop, this.id, this.actionType, '获取当前的url失败')
+            }
+        }
+    }
+    /**
+     * 对比指定的不固定循环列表元素是否变化
+     * @param nodeId
+     * @param loopConfig
+     */
+    async diffSamplingElements(nodeId, loopConfig) {
+        if (this.getCurrentLoopUrl(nodeId)) {
+            // var url = this.workflow.browser.getURL()
+            // if (this.getCurrentLoopUrl(nodeId) != url) {
+            //   return true
+            // }
+        }
+        const AbsXpath = loopConfig.AbsXpath;
+        const IsIFrame = loopConfig.IsIFrame;
+        const IFrameAbsXPath = loopConfig.IFrameAbsXPath;
+        const flag = false;
+        const samplingElementsMap = this.getSamplingElementsMap(nodeId);
+        // if (samplingElementsMap.size > 0) {
+        //   for (const [key, value] of samplingElementsMap) {
+        //     const xpath = `(${AbsXpath})[${key}]`
+        //     const actionItem = new ActionItem(xpath, IsIFrame, IFrameAbsXPath)
+        //     const currentText = await this.workflow.browser.getInnerText(actionItem)
+        //     /** 相似度比对  */
+        //     if (this.similar(value.replace(/[\r\n\s]/g, ''), currentText.replace(/[\r\n\s]/g, ''), 2) < 0.95) {
+        //       // 说明前面遍历过的元素有变动，将该轮循环的偏移量置零
+        //       // console.log(value.replace(/[\r\n]/g,'') +'--------不相同-------'+ curVal.replace(/[\r\n]/g,''))
+        //       falg = true //说明前面的列表数据有变化
+        //       break
+        //     }
+        //     /** 全比对  */
+        //     // if(value.replace(/[\r\n]/g,'') != curVal.replace(/[\r\n]/g,'')){
+        //     //     // 说明前面遍历过的元素有变动，将该轮循环的偏移量置零
+        //     //     console.log(value.replace(/[\r\n]/g,'') +'--------不相同-------'+ curVal.replace(/[\r\n]/g,''))
+        //     //     falg = true //说明前面的列表数据有变化
+        //     //     break;
+        //     // }
+        //   }
+        // }
+        return flag;
+    }
+    /**
+     * 辅助判断当前循环列表所依赖的列表元素是否有增加
+     * @param loopConfig
+     */
+    async ifNextElement(loopConfig, page) {
+        const AbsXpath = loopConfig.AbsXpath;
+        const IsIFrame = loopConfig.IsIFrame;
+        const IFrameAbsXPath = loopConfig.IFrameAbsXPath;
+        const newXpathStartIndex = loopConfig.newXpathStartIndex;
+        //判断下一个循环的xpath对应元素是否存在，存在则把line重新压入队列中以使循环能够继续执行
+        const nextXpath = '(' + AbsXpath + ')[' + (newXpathStartIndex + 1) + ']';
+        const isExist = await this.loopElementExists(new actionItem_1.ActionItem(nextXpath, IsIFrame, IFrameAbsXPath));
+        return isExist;
+    }
+    /**
+     * 辅助判断字符串相似度
+     * @param s 字符串1
+     * @param t 字符串1
+     * @param f 精确度：保留几位小数
+     */
+    similar(s, t, f) {
+        if (!s || !t) {
+            return 0;
+        }
+        const l = s.length > t.length ? s.length : t.length;
+        const n = s.length;
+        const m = t.length;
+        const d = [];
+        f = f || 3;
+        const min = function (a, b, c) {
+            return a < b ? (a < c ? a : c) : b < c ? b : c;
+        };
+        let i, j, si, tj, cost;
+        if (n === 0)
+            return m;
+        if (m === 0)
+            return n;
+        for (i = 0; i <= n; i++) {
+            d[i] = [];
+            d[i][0] = i;
+        }
+        for (j = 0; j <= m; j++) {
+            d[0][j] = j;
+        }
+        for (i = 1; i <= n; i++) {
+            si = s.charAt(i - 1);
+            for (j = 1; j <= m; j++) {
+                tj = t.charAt(j - 1);
+                if (si === tj) {
+                    cost = 0;
+                }
+                else {
+                    cost = 1;
+                }
+                d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            }
+        }
+        const res = 1 - d[n][m] / l;
+        return res.toFixed(f);
+    }
+}
+exports.default = LoopStartAction;

package/node_modules/@octopus/engine/dist/actions/MouseOverAction.d.ts

@@ -0,0 +1,8 @@
+import MouseOverConfig from '../configs/MouseOverConfig';
+import BaseAction from './BaseAction';
+export default class MouseOverAction extends BaseAction {
+    config: MouseOverConfig;
+    private page;
+    protected parseConfig(config: any): MouseOverConfig;
+    wait(): Promise<void>;
+}

package/node_modules/@octopus/engine/dist/actions/MouseOverAction.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const MouseOverConfig_1 = __importDefault(require("../configs/MouseOverConfig"));
+const enums_1 = require("../enums");
+const actionItem_1 = require("../models/actionItem");
+const BaseAction_1 = __importDefault(require("./BaseAction"));
+class MouseOverAction extends BaseAction_1.default {
+    parseConfig(config) {
+        return new MouseOverConfig_1.default(config);
+    }
+    async wait() {
+        if (this.getIsSkipCurrentLoop() || this.getIsSkipActionUtilNextLoop(this.getNodeId())) {
+            this.finish();
+            return;
+        }
+        await super.wait();
+        let actionItem = this.config.elementXPath;
+        if (this.config.useLoopItem) {
+            const { AbsXpath, IsIFrame, IFrameAbsXPath } = this.getCurrentLoopValue();
+            actionItem = new actionItem_1.ActionItem(AbsXpath + actionItem.AbsXpath, IsIFrame, IFrameAbsXPath);
+        }
+        this.page = await this.getCurrentPage();
+        (await this.locator(this.page, actionItem)).hover();
+        this.log(enums_1.LogKey.MouseOver.Begin, this.name, actionItem.AbsXpath);
+        // await this.workflow.browser.scrollIntoView(actionItem)
+        // await this.workflow.browser.mouseOver(actionItem)
+        await this.ajax();
+        this.finish();
+    }
+}
+exports.default = MouseOverAction;