context 添加steps

Author: imingyu

package.json

@@ -1,6 +1,6 @@
 {
     "name": "forgiving-xml-parser",
-    "version": "1.2.0",
+    "version": "1.2.1",
     "description": "An forgiving XML/HTML parser and serializer for JavaScript.",
     "main": "dist/index.cjs.js",
     "module": "dist/index.esm.js",

src/option.ts

@@ -38,6 +38,7 @@ export const boundStepsToContext = (
     let eventNode: FxNode = context.currentNode;
     for (let index = 0, len = steps.length; index < len; index++) {
         const currentStepItem = steps[index] as FxNodeTryStep;
+        context && context.steps.push(currentStepItem);
         currentStepItem.target = eventNode;
         const { step, cursor, data } = currentStepItem;
         setContextMaxCursor(context, cursor);

src/parse.ts

@@ -15,6 +15,7 @@ import {
     findNodeParser,
     isFunc,
     filterOptions,
+    stepToJSON,
 } from "./util";
 import { TextParser } from "./node/text";
 import { DEFAULT_PARSE_OPTIONS } from "./var";
@@ -30,6 +31,7 @@ export const parse = (xml: string, options?: FxParseOptions): FxParseResult => {
         lineNumber: 1,
         column: 1,
         nodes: [],
+        steps: [],
         options,
     };
     try {
@@ -54,6 +56,7 @@ export const parse = (xml: string, options?: FxParseOptions): FxParseResult => {
             maxLine: context.maxLineNumber,
             maxCol: context.maxColumn,
             nodes: context.nodes,
+            steps: context.steps,
         } as FxParseResult;
     } catch (error) {
         return {
@@ -80,6 +83,11 @@ export const parseResultToJSON = (
     pick("maxLine", res, parseResult, options);
     pick("maxCol", res, parseResult, options);
     pick("xml", res, parseResult, options);
+    if (parseResult.steps && options.steps) {
+        res.steps = parseResult.steps.map((step) => {
+            return stepToJSON(step, options);
+        });
+    }
     if (!parseResult.error) {
         res.nodes = parseResult.nodes.map((node) => {
             if (hasFilter) {

src/types.ts

@@ -76,6 +76,7 @@ export interface FxParseContext extends FxCursorPosition {
     xmlLength: number;
     xml: string;
     nodes: FxNode[];
+    steps: FxTryStep[];
     maxLineNumber: number;
     maxColumn: number;
     currentNode?: FxNode;
@@ -270,13 +271,15 @@ export interface FxParseResultJSON {
     maxLine?: number;
     maxCol?: number;
     xml?: string;
+    steps?: FxTryStep[];
     nodes?: FxNodeJSON[];
     error?: FxWrong;
 }
 export interface FxParseResult extends FxParseResultJSON {
     maxLine: number;
     maxCol: number;
     xml: string;
+    steps?: FxNodeTryStep[];
     nodes?: FxNode[];
 }
 export interface FxBoundStepsLoopCallback {

src/util.ts

@@ -19,6 +19,7 @@ import {
     FxStartTagCompare,
     FxNodeLocationInfo,
     FxLocation,
+    FxNodeTryStep,
 } from "./types";
 import { REX_SPACE } from "./var";
 
@@ -110,6 +111,40 @@ export const pick = (
         res[prop] = parseResult[prop];
     }
 };
+export const stepToJSON = (step: FxNodeTryStep, options: FxToJSONOptions): FxTryStep => {
+    const hasFilter = isFunc(options.dataFilter);
+    const res = {
+        ...step,
+    };
+    delete res.target;
+    if (Array.isArray(res.data)) {
+        let [nodeType, closeType, customType] = res.data;
+        if (typeof nodeType === "object") {
+            const np = nodeType as FxNodeAdapter;
+            customType = customType || np.nodeCustomType;
+            nodeType = np.nodeType;
+        }
+        const data = [nodeType, closeType, customType];
+        if (!data[2]) {
+            data.splice(2, 1);
+        }
+        res.data = data as FxTryStepData;
+    } else if (typeof res.data === "object") {
+        const np = res.data as FxNodeAdapter;
+        res.data = [
+            np.nodeType,
+            step.step === FxEventType.nodeEnd ? FxNodeCloseType.fullClosed : undefined,
+            np.nodeCustomType,
+        ];
+        if (!res.data[2]) {
+            res.data.pop();
+        }
+        if (!res.data[1]) {
+            res.data.splice(1, 1);
+        }
+    }
+    return hasFilter ? (options.dataFilter(step, res) as FxTryStep) : res;
+};
 export const nodeToJSON = (node: FxNode, options: FxToJSONOptions): FxNodeJSON => {
     const res = {} as FxNodeJSON;
     const hasFilter = isFunc(options.dataFilter);
@@ -118,39 +153,7 @@ export const nodeToJSON = (node: FxNode, options: FxToJSONOptions): FxNodeJSON =
             if (prop === "steps") {
                 if (options.steps) {
                     res[prop] = node[prop].map((step) => {
-                        const res = {
-                            ...step,
-                        };
-                        delete res.target;
-                        if (Array.isArray(res.data)) {
-                            let [nodeType, closeType, customType] = res.data;
-                            if (typeof nodeType === "object") {
-                                const np = nodeType as FxNodeAdapter;
-                                customType = customType || np.nodeCustomType;
-                                nodeType = np.nodeType;
-                            }
-                            const data = [nodeType, closeType, customType];
-                            if (!data[2]) {
-                                data.splice(2, 1);
-                            }
-                            res.data = data as FxTryStepData;
-                        } else if (typeof res.data === "object") {
-                            const np = res.data as FxNodeAdapter;
-                            res.data = [
-                                np.nodeType,
-                                step.step === FxEventType.nodeEnd
-                                    ? FxNodeCloseType.fullClosed
-                                    : undefined,
-                                np.nodeCustomType,
-                            ];
-                            if (!res.data[2]) {
-                                res.data.pop();
-                            }
-                            if (!res.data[1]) {
-                                res.data.splice(1, 1);
-                            }
-                        }
-                        return hasFilter ? (options.dataFilter(step, res) as FxTryStep) : res;
+                        return stepToJSON(step, options);
                     });
                 }
             } else if (prop === "closeType") {