assistsx-js 0.0.2049 → 0.0.2051

package/dist/Step.d.ts

@@ -1,4 +1,5 @@
 import { Node } from "./Node";
+import { StepError } from "./StepError";
 import { StepAsync } from "./StepAsync";
 export type StepResult = Step | undefined;
 export type StepImpl = (step: Step) => Promise<StepResult>;
@@ -16,6 +17,10 @@ export declare class Step {
      * 步骤拦截器列表
      */
     private static _interceptors;
+    /**
+     * 步骤异常变量，默认为空
+     */
+    static exception: StepError | undefined;
     /**
      * 运行步骤实现
      * @param impl 步骤实现函数
@@ -46,8 +51,9 @@ export declare class Step {
     static assignIdsToNodes(nodes: Node[], stepId: string | undefined): void;
     /**
      * 停止当前步骤执行
+     * @param exception 可选的异常对象，如果传入则使用该异常，否则使用默认的StepStopError
      */
-    static stop(): void;
+    static stop(exception?: StepError): void;
     /**
      * 添加步骤拦截器
      * @param interceptor 拦截器函数

package/dist/Step.js

@@ -5,7 +5,7 @@
 import { AssistsX } from "./AssistsX";
 import { useStepStore } from "./StepStateStore";
 import { generateUUID } from "./Utils";
-import { StepError } from "./StepError";
+import { StepError, StepStopError } from "./StepError";
 import { StepAsync } from "./StepAsync";
 export class Step {
     /**
@@ -17,6 +17,7 @@ export class Step {
      */
     static async run(impl, { stepId, tag, data, delayMs = Step.delayMsDefault, } = {}) {
         var _a, _b, _c, _d, _e, _f;
+        this.exception = undefined;
         const stepStore = useStepStore();
         let implnName = impl.name;
         let currentStep;
@@ -131,7 +132,7 @@ export class Step {
                 error: (_f = e === null || e === void 0 ? void 0 : e.message) !== null && _f !== void 0 ? _f : String(e),
             });
             stepStore.setError(errorMsg);
-            throw new StepError(errorMsg, implnName, tag, data, e, currentStep || undefined);
+            throw e;
         }
         //步骤执行结束
         stepStore.completeStep();
@@ -148,11 +149,12 @@ export class Step {
      * @param stepId 要验证的步骤ID
      */
     static assert(stepId) {
+        // 检查异常变量，如果不为空则直接抛出
+        if (Step.exception) {
+            throw Step.exception;
+        }
         if (stepId && Step.stepId != stepId) {
-            if (Step.stepId === "STEP_STOP") {
-                throw new Error("主动中断步骤");
-            }
-            throw new Error("StepId mismatch");
+            throw new StepError("StepId mismatch", { stepId, currentStepId: Step.stepId });
         }
     }
     /**
@@ -169,9 +171,16 @@ export class Step {
     }
     /**
      * 停止当前步骤执行
+     * @param exception 可选的异常对象，如果传入则使用该异常，否则使用默认的StepStopError
      */
-    static stop() {
+    static stop(exception) {
         this._stepId = "STEP_STOP";
+        if (exception) {
+            this.exception = exception;
+        }
+        else {
+            this.exception = new StepStopError("主动中断步骤", { stepId: this._stepId });
+        }
     }
     /**
      * 添加步骤拦截器
@@ -622,3 +631,7 @@ Step._stepId = undefined;
  * 步骤拦截器列表
  */
 Step._interceptors = [];
+/**
+ * 步骤异常变量，默认为空
+ */
+Step.exception = undefined;

package/dist/StepError.d.ts

@@ -1,27 +1,35 @@
 /**
  * 步骤执行错误类
  * 用于携带步骤执行过程中的错误信息和当前步骤对象
+ * 支持传入可选数据：message，data任何类型的数据
  */
 export declare class StepError extends Error {
     /**
      * 步骤实现函数名
      */
-    readonly impl: string;
+    readonly impl?: string;
     /**
      * 步骤标签
      */
-    readonly tag: string | undefined;
+    readonly tag?: string | undefined;
     /**
-     * 步骤数据
+     * 步骤数据，可以是任何类型
      */
-    readonly data: any | undefined;
+    readonly data?: any;
     /**
      * 原始错误
      */
-    readonly originalError: any;
+    readonly originalError?: any;
     /**
      * 当前步骤对象
      */
-    readonly currentStep: any | undefined;
-    constructor(message: string, impl: string, tag: string | undefined, data: any | undefined, originalError: any, currentStep: any | undefined);
+    readonly currentStep?: any;
+    constructor(message?: string, data?: any, impl?: string, tag?: string | undefined, originalError?: any, currentStep?: any | undefined);
+}
+/**
+ * 主动停止异常类
+ * 用于表示步骤被主动停止执行
+ */
+export declare class StepStopError extends StepError {
+    constructor(message?: string, data?: any);
 }

package/dist/StepError.js

@@ -1,15 +1,26 @@
 /**
  * 步骤执行错误类
  * 用于携带步骤执行过程中的错误信息和当前步骤对象
+ * 支持传入可选数据：message，data任何类型的数据
  */
 export class StepError extends Error {
-    constructor(message, impl, tag, data, originalError, currentStep) {
+    constructor(message, data, impl, tag, originalError, currentStep) {
         super(message);
         this.name = "StepError";
+        this.data = data;
         this.impl = impl;
         this.tag = tag;
-        this.data = data;
         this.originalError = originalError;
         this.currentStep = currentStep;
     }
 }
+/**
+ * 主动停止异常类
+ * 用于表示步骤被主动停止执行
+ */
+export class StepStopError extends StepError {
+    constructor(message, data) {
+        super(message || "主动中断步骤", data);
+        this.name = "StepStopError";
+    }
+}

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export * from "./StepAsync";
 export * from "./AccessibilityEventFilter";
 export * from "./AppInfo";
 export * from "./DeviceInfo";
+export * from "./StepError";

package/dist/index.js

@@ -14,3 +14,4 @@ export * from "./StepAsync";
 export * from "./AccessibilityEventFilter";
 export * from "./AppInfo";
 export * from "./DeviceInfo";
+export * from "./StepError";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "assistsx-js",
-    "version": "0.0.2049",
+    "version": "0.0.2051",
     "description": "assistsx-js自动化开发SDK",
     "main": "dist/index.js",
     "module": "dist/index.js",

package/src/Step.ts

@@ -7,7 +7,7 @@ import { Node } from "./Node";
 import { CallMethod } from "./CallMethod";
 import { useStepStore } from "./StepStateStore";
 import { generateUUID } from "./Utils";
-import { StepError } from "./StepError";
+import { StepError, StepStopError } from "./StepError";
 import { StepAsync } from "./StepAsync";
 
 // 步骤结果类型，可以是Step实例或undefined
@@ -35,6 +35,11 @@ export class Step {
      */
     private static _interceptors: StepInterceptor[] = [];
 
+    /**
+     * 步骤异常变量，默认为空
+     */
+    public static exception: StepError | undefined = undefined;
+
     /**
      * 运行步骤实现
      * @param impl 步骤实现函数
@@ -56,6 +61,7 @@ export class Step {
             delayMs?: number;
         } = {}
     ): Promise<Step | undefined> {
+        this.exception = undefined;
         const stepStore = useStepStore();
         let implnName = impl.name;
         let currentStep: Step | undefined;
@@ -180,14 +186,7 @@ export class Step {
                 error: e?.message ?? String(e),
             });
             stepStore.setError(errorMsg);
-            throw new StepError(
-                errorMsg,
-                implnName,
-                tag,
-                data,
-                e,
-                currentStep || undefined
-            );
+            throw e
         }
         //步骤执行结束
         stepStore.completeStep();
@@ -206,11 +205,12 @@ export class Step {
      * @param stepId 要验证的步骤ID
      */
     static assert(stepId: string | undefined) {
+        // 检查异常变量，如果不为空则直接抛出
+        if (Step.exception) {
+            throw Step.exception;
+        }
         if (stepId && Step.stepId != stepId) {
-            if (Step.stepId === "STEP_STOP") {
-                throw new Error("主动中断步骤");
-            }
-            throw new Error("StepId mismatch");
+            throw new StepError("StepId mismatch", { stepId, currentStepId: Step.stepId });
         }
     }
 
@@ -229,9 +229,15 @@ export class Step {
 
     /**
      * 停止当前步骤执行
+     * @param exception 可选的异常对象，如果传入则使用该异常，否则使用默认的StepStopError
      */
-    static stop(): void {
+    static stop(exception?: StepError): void {
         this._stepId = "STEP_STOP";
+        if (exception) {
+            this.exception = exception;
+        } else {
+            this.exception = new StepStopError("主动中断步骤", { stepId: this._stepId });
+        }
     }
 
     /**

package/src/StepAsync.ts

@@ -12,354 +12,354 @@ import { AssistsXAsync } from "./AssistsXAsync";
 import { Step } from "./Step";
 
 export class StepAsync {
-  private step: Step;
+    private step: Step;
 
-  /**
-   * 构造函数
-   * @param step Step实例
-   */
-  constructor(step: Step) {
-    this.step = step;
-  }
+    /**
+     * 构造函数
+     * @param step Step实例
+     */
+    constructor(step: Step) {
+        this.step = step;
+    }
 
-  /**
-   * 对单个节点进行截图
-   * @param node 目标节点
-   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
-   * @returns 截图路径
-   */
-  public async takeScreenshotByNode(
-    node: Node,
-    overlayHiddenScreenshotDelayMillis: number = 250
-  ): Promise<string> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.takeScreenshotNodes(
-      [node],
-      overlayHiddenScreenshotDelayMillis
-    );
-    Step.assert(this.step.stepId);
-    return result[0];
-  }
+    /**
+     * 对单个节点进行截图
+     * @param node 目标节点
+     * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+     * @returns 截图路径
+     */
+    public async takeScreenshotByNode(
+        node: Node,
+        overlayHiddenScreenshotDelayMillis: number = 250
+    ): Promise<string> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.takeScreenshotNodes(
+            [node],
+            overlayHiddenScreenshotDelayMillis
+        );
+        Step.assert(this.step.stepId);
+        return result[0];
+    }
 
-  /**
-   * 对多个节点进行截图
-   * @param nodes 目标节点数组
-   * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
-   * @returns 截图路径数组
-   */
-  public async takeScreenshotNodes(
-    nodes: Node[],
-    overlayHiddenScreenshotDelayMillis: number = 250
-  ): Promise<string[]> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.takeScreenshotNodes(
-      nodes,
-      overlayHiddenScreenshotDelayMillis
-    );
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 对多个节点进行截图
+     * @param nodes 目标节点数组
+     * @param overlayHiddenScreenshotDelayMillis 截图延迟时间(毫秒)
+     * @returns 截图路径数组
+     */
+    public async takeScreenshotNodes(
+        nodes: Node[],
+        overlayHiddenScreenshotDelayMillis: number = 250
+    ): Promise<string[]> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.takeScreenshotNodes(
+            nodes,
+            overlayHiddenScreenshotDelayMillis
+        );
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 获取所有符合条件的节点
-   * @param filterClass 类名过滤
-   * @param filterViewId 视图ID过滤
-   * @param filterDes 描述过滤
-   * @param filterText 文本过滤
-   * @returns 节点数组
-   */
-  public async getAllNodes({
-    filterClass,
-    filterViewId,
-    filterDes,
-    filterText,
-  }: {
-    filterClass?: string;
-    filterViewId?: string;
-    filterDes?: string;
-    filterText?: string;
-  } = {}): Promise<Node[]> {
-    Step.assert(this.step.stepId);
-    const nodes = await AssistsXAsync.getAllNodes({
-      filterClass,
-      filterViewId,
-      filterDes,
-      filterText,
-    });
-    Step.assert(this.step.stepId);
-    Step.assignIdsToNodes(nodes, this.step.stepId);
-    return nodes;
-  }
+    /**
+     * 获取所有符合条件的节点
+     * @param filterClass 类名过滤
+     * @param filterViewId 视图ID过滤
+     * @param filterDes 描述过滤
+     * @param filterText 文本过滤
+     * @returns 节点数组
+     */
+    public async getAllNodes({
+        filterClass,
+        filterViewId,
+        filterDes,
+        filterText,
+    }: {
+        filterClass?: string;
+        filterViewId?: string;
+        filterDes?: string;
+        filterText?: string;
+    } = {}): Promise<Node[]> {
+        Step.assert(this.step.stepId);
+        const nodes = await AssistsXAsync.getAllNodes({
+            filterClass,
+            filterViewId,
+            filterDes,
+            filterText,
+        });
+        Step.assert(this.step.stepId);
+        Step.assignIdsToNodes(nodes, this.step.stepId);
+        return nodes;
+    }
 
-  /**
-   * 启动应用
-   * @param packageName 应用包名
-   * @returns 是否启动成功
-   */
-  public async launchApp(packageName: string): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.launchApp(packageName);
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 启动应用
+     * @param packageName 应用包名
+     * @returns 是否启动成功
+     */
+    public async launchApp(packageName: string): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.launchApp(packageName);
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 获取当前应用包名
-   * @returns 包名
-   */
-  public async getPackageName(): Promise<string> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.getPackageName();
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 获取当前应用包名
+     * @returns 包名
+     */
+    public async getPackageName(): Promise<string> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.getPackageName();
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 通过ID查找节点
-   * @param id 节点ID
-   * @param filterClass 类名过滤
-   * @param filterText 文本过滤
-   * @param filterDes 描述过滤
-   * @returns 节点数组
-   */
-  public async findById(
-    id: string,
-    {
-      filterClass,
-      filterText,
-      filterDes,
-    }: { filterClass?: string; filterText?: string; filterDes?: string } = {}
-  ): Promise<Node[]> {
-    Step.assert(this.step.stepId);
-    const nodes = await AssistsXAsync.findById(id, {
-      filterClass,
-      filterText,
-      filterDes,
-    });
-    Step.assert(this.step.stepId);
-    Step.assignIdsToNodes(nodes, this.step.stepId);
-    return nodes;
-  }
+    /**
+     * 通过ID查找节点
+     * @param id 节点ID
+     * @param filterClass 类名过滤
+     * @param filterText 文本过滤
+     * @param filterDes 描述过滤
+     * @returns 节点数组
+     */
+    public async findById(
+        id: string,
+        {
+            filterClass,
+            filterText,
+            filterDes,
+        }: { filterClass?: string; filterText?: string; filterDes?: string } = {}
+    ): Promise<Node[]> {
+        Step.assert(this.step.stepId);
+        const nodes = await AssistsXAsync.findById(id, {
+            filterClass,
+            filterText,
+            filterDes,
+        });
+        Step.assert(this.step.stepId);
+        Step.assignIdsToNodes(nodes, this.step.stepId);
+        return nodes;
+    }
 
-  /**
-   * 通过文本查找节点
-   * @param text 要查找的文本
-   * @param filterClass 类名过滤
-   * @param filterViewId 视图ID过滤
-   * @param filterDes 描述过滤
-   * @returns 节点数组
-   */
-  public async findByText(
-    text: string,
-    {
-      filterClass,
-      filterViewId,
-      filterDes,
-    }: { filterClass?: string; filterViewId?: string; filterDes?: string } = {}
-  ): Promise<Node[]> {
-    Step.assert(this.step.stepId);
-    const nodes = await AssistsXAsync.findByText(text, {
-      filterClass,
-      filterViewId,
-      filterDes,
-    });
-    Step.assert(this.step.stepId);
-    Step.assignIdsToNodes(nodes, this.step.stepId);
-    return nodes;
-  }
+    /**
+     * 通过文本查找节点
+     * @param text 要查找的文本
+     * @param filterClass 类名过滤
+     * @param filterViewId 视图ID过滤
+     * @param filterDes 描述过滤
+     * @returns 节点数组
+     */
+    public async findByText(
+        text: string,
+        {
+            filterClass,
+            filterViewId,
+            filterDes,
+        }: { filterClass?: string; filterViewId?: string; filterDes?: string } = {}
+    ): Promise<Node[]> {
+        Step.assert(this.step.stepId);
+        const nodes = await AssistsXAsync.findByText(text, {
+            filterClass,
+            filterViewId,
+            filterDes,
+        });
+        Step.assert(this.step.stepId);
+        Step.assignIdsToNodes(nodes, this.step.stepId);
+        return nodes;
+    }
 
-  /**
-   * 通过标签查找节点
-   * @param className 类名
-   * @param filterText 文本过滤
-   * @param filterViewId 视图ID过滤
-   * @param filterDes 描述过滤
-   * @returns 节点数组
-   */
-  public async findByTags(
-    className: string,
-    {
-      filterText,
-      filterViewId,
-      filterDes,
-    }: { filterText?: string; filterViewId?: string; filterDes?: string } = {}
-  ): Promise<Node[]> {
-    Step.assert(this.step.stepId);
-    const nodes = await AssistsXAsync.findByTags(className, {
-      filterText,
-      filterViewId,
-      filterDes,
-    });
-    Step.assert(this.step.stepId);
-    Step.assignIdsToNodes(nodes, this.step.stepId);
-    return nodes;
-  }
+    /**
+     * 通过标签查找节点
+     * @param className 类名
+     * @param filterText 文本过滤
+     * @param filterViewId 视图ID过滤
+     * @param filterDes 描述过滤
+     * @returns 节点数组
+     */
+    public async findByTags(
+        className: string,
+        {
+            filterText,
+            filterViewId,
+            filterDes,
+        }: { filterText?: string; filterViewId?: string; filterDes?: string } = {}
+    ): Promise<Node[]> {
+        Step.assert(this.step.stepId);
+        const nodes = await AssistsXAsync.findByTags(className, {
+            filterText,
+            filterViewId,
+            filterDes,
+        });
+        Step.assert(this.step.stepId);
+        Step.assignIdsToNodes(nodes, this.step.stepId);
+        return nodes;
+    }
 
-  /**
-   * 查找所有匹配文本的节点
-   * @param text 要查找的文本
-   * @returns 节点数组
-   */
-  public async findByTextAllMatch(text: string): Promise<Node[]> {
-    Step.assert(this.step.stepId);
-    const nodes = await AssistsXAsync.findByTextAllMatch(text);
-    Step.assert(this.step.stepId);
-    Step.assignIdsToNodes(nodes, this.step.stepId);
-    return nodes;
-  }
+    /**
+     * 查找所有匹配文本的节点
+     * @param text 要查找的文本
+     * @returns 节点数组
+     */
+    public async findByTextAllMatch(text: string): Promise<Node[]> {
+        Step.assert(this.step.stepId);
+        const nodes = await AssistsXAsync.findByTextAllMatch(text);
+        Step.assert(this.step.stepId);
+        Step.assignIdsToNodes(nodes, this.step.stepId);
+        return nodes;
+    }
 
-  /**
-   * 检查是否包含指定文本
-   * @param text 要检查的文本
-   * @returns 是否包含
-   */
-  public async containsText(text: string): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.containsText(text);
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 检查是否包含指定文本
+     * @param text 要检查的文本
+     * @returns 是否包含
+     */
+    public async containsText(text: string): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.containsText(text);
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 获取所有文本
-   * @returns 文本数组
-   */
-  public async getAllText(): Promise<string[]> {
-    Step.assert(this.step.stepId);
-    const texts = await AssistsXAsync.getAllText();
-    Step.assert(this.step.stepId);
-    return texts;
-  }
+    /**
+     * 获取所有文本
+     * @returns 文本数组
+     */
+    public async getAllText(): Promise<string[]> {
+        Step.assert(this.step.stepId);
+        const texts = await AssistsXAsync.getAllText();
+        Step.assert(this.step.stepId);
+        return texts;
+    }
 
-  /**
-   * 执行点击手势
-   * @param x 横坐标
-   * @param y 纵坐标
-   * @param duration 持续时间(毫秒)
-   * @returns 是否成功
-   */
-  public async clickByGesture(
-    x: number,
-    y: number,
-    duration: number
-  ): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.clickByGesture(x, y, duration);
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 执行点击手势
+     * @param x 横坐标
+     * @param y 纵坐标
+     * @param duration 持续时间(毫秒)
+     * @returns 是否成功
+     */
+    public async clickByGesture(
+        x: number,
+        y: number,
+        duration: number
+    ): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.clickByGesture(x, y, duration);
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  public async longPressGestureAutoPaste(
-    point: { x: number; y: number },
-    text: string,
-    {
-      matchedPackageName,
-      matchedText,
-      timeoutMillis,
-      longPressDuration,
-    }: {
-      matchedPackageName?: string;
-      matchedText?: string;
-      timeoutMillis?: number;
-      longPressDuration?: number;
-    } = { matchedText: "粘贴", timeoutMillis: 1500, longPressDuration: 600 }
-  ): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.longPressGestureAutoPaste(point, text, {
-      matchedPackageName,
-      matchedText,
-      timeoutMillis,
-      longPressDuration,
-    });
-    Step.assert(this.step.stepId);
-    return result;
-  }
-  public async getAppInfo(packageName: string): Promise<any> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.getAppInfo(packageName);
-    Step.assert(this.step.stepId);
-    return result;
-  }
-  public async performLinearGesture(
-    startPoint: { x: number; y: number },
-    endPoint: { x: number; y: number },
-    { duration }: { duration?: number } = {}
-  ): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.performLinearGesture(
-      startPoint,
-      endPoint,
-      {
-        duration,
-      }
-    );
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    public async longPressGestureAutoPaste(
+        point: { x: number; y: number },
+        text: string,
+        {
+            matchedPackageName,
+            matchedText,
+            timeoutMillis,
+            longPressDuration,
+        }: {
+            matchedPackageName?: string;
+            matchedText?: string;
+            timeoutMillis?: number;
+            longPressDuration?: number;
+        } = { matchedText: "粘贴", timeoutMillis: 1500, longPressDuration: 600 }
+    ): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.longPressGestureAutoPaste(point, text, {
+            matchedPackageName,
+            matchedText,
+            timeoutMillis,
+            longPressDuration,
+        });
+        Step.assert(this.step.stepId);
+        return result;
+    }
+    public async getAppInfo(packageName: string): Promise<any> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.getAppInfo(packageName);
+        Step.assert(this.step.stepId);
+        return result;
+    }
+    public async performLinearGesture(
+        startPoint: { x: number; y: number },
+        endPoint: { x: number; y: number },
+        { duration }: { duration?: number } = {}
+    ): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.performLinearGesture(
+            startPoint,
+            endPoint,
+            {
+                duration,
+            }
+        );
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 返回操作
-   * @returns 是否成功
-   */
-  public async back(): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.back();
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 返回操作
+     * @returns 是否成功
+     */
+    public async back(): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.back();
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 回到主页
-   * @returns 是否成功
-   */
-  public async home(): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.home();
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 回到主页
+     * @returns 是否成功
+     */
+    public async home(): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.home();
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 打开通知栏
-   * @returns 是否成功
-   */
-  public async notifications(): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.notifications();
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 打开通知栏
+     * @returns 是否成功
+     */
+    public async notifications(): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.notifications();
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 显示最近应用
-   * @returns 是否成功
-   */
-  public async recentApps(): Promise<boolean> {
-    Step.assert(this.step.stepId);
-    const result = await AssistsXAsync.recentApps();
-    Step.assert(this.step.stepId);
-    return result;
-  }
+    /**
+     * 显示最近应用
+     * @returns 是否成功
+     */
+    public async recentApps(): Promise<boolean> {
+        Step.assert(this.step.stepId);
+        const result = await AssistsXAsync.recentApps();
+        Step.assert(this.step.stepId);
+        return result;
+    }
 
-  /**
-   * 获取屏幕尺寸
-   * @returns 屏幕尺寸对象
-   */
-  public async getScreenSize(): Promise<any> {
-    Step.assert(this.step.stepId);
-    const data = await AssistsXAsync.getScreenSize();
-    Step.assert(this.step.stepId);
-    return data;
-  }
+    /**
+     * 获取屏幕尺寸
+     * @returns 屏幕尺寸对象
+     */
+    public async getScreenSize(): Promise<any> {
+        Step.assert(this.step.stepId);
+        const data = await AssistsXAsync.getScreenSize();
+        Step.assert(this.step.stepId);
+        return data;
+    }
 
-  /**
-   * 获取应用窗口尺寸
-   * @returns 应用窗口尺寸对象
-   */
-  public async getAppScreenSize(): Promise<any> {
-    Step.assert(this.step.stepId);
-    const data = await AssistsXAsync.getAppScreenSize();
-    Step.assert(this.step.stepId);
-    return data;
-  }
+    /**
+     * 获取应用窗口尺寸
+     * @returns 应用窗口尺寸对象
+     */
+    public async getAppScreenSize(): Promise<any> {
+        Step.assert(this.step.stepId);
+        const data = await AssistsXAsync.getAppScreenSize();
+        Step.assert(this.step.stepId);
+        return data;
+    }
 }

package/src/StepError.ts

@@ -1,47 +1,59 @@
 /**
  * 步骤执行错误类
  * 用于携带步骤执行过程中的错误信息和当前步骤对象
+ * 支持传入可选数据：message，data任何类型的数据
  */
 export class StepError extends Error {
-  /**
-   * 步骤实现函数名
-   */
-  readonly impl: string;
+    /**
+     * 步骤实现函数名
+     */
+    readonly impl?: string;
 
-  /**
-   * 步骤标签
-   */
-  readonly tag: string | undefined;
+    /**
+     * 步骤标签
+     */
+    readonly tag?: string | undefined;
 
-  /**
-   * 步骤数据
-   */
-  readonly data: any | undefined;
+    /**
+     * 步骤数据，可以是任何类型
+     */
+    readonly data?: any;
 
-  /**
-   * 原始错误
-   */
-  readonly originalError: any;
+    /**
+     * 原始错误
+     */
+    readonly originalError?: any;
 
-  /**
-   * 当前步骤对象
-   */
-  readonly currentStep: any | undefined;
+    /**
+     * 当前步骤对象
+     */
+    readonly currentStep?: any;
 
-  constructor(
-    message: string,
-    impl: string,
-    tag: string | undefined,
-    data: any | undefined,
-    originalError: any,
-    currentStep: any | undefined
-  ) {
-    super(message);
-    this.name = "StepError";
-    this.impl = impl;
-    this.tag = tag;
-    this.data = data;
-    this.originalError = originalError;
-    this.currentStep = currentStep;
-  }
+    constructor(
+        message?: string,
+        data?: any,
+        impl?: string,
+        tag?: string | undefined,
+        originalError?: any,
+        currentStep?: any | undefined
+    ) {
+        super(message);
+        this.name = "StepError";
+        this.data = data;
+        this.impl = impl;
+        this.tag = tag;
+        this.originalError = originalError;
+        this.currentStep = currentStep;
+    }
+}
+
+/**
+ * 主动停止异常类
+ * 用于表示步骤被主动停止执行
+ */
+export class StepStopError extends StepError {
+    constructor(message?: string, data?: any) {
+        super(message || "主动中断步骤", data);
+        this.name = "StepStopError";
+    }
 }

package/src/index.ts

@@ -14,3 +14,4 @@ export * from "./StepAsync";
 export * from "./AccessibilityEventFilter";
 export * from "./AppInfo";
 export * from "./DeviceInfo";
+export * from "./StepError";