自定义实现eslint 规则 检查菜单是否重复

把如下js文件 放置一个根文件夹eslint-rules内 关键调试 哪个create方法体内
执行命令：
npm run lint

 "scripts": {
    "lint": "eslint  需要检查的某个文件.js  --rulesdir eslint-rules/"
  },

"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
let globalMark=[];
function checkMark(nextChild) {
    let bl=true;
    // if(!nextChild.mark || nextChild.mark===""){bl=false}
            if(nextChild.mark===null){return true}
            if(globalMark.indexOf(nextChild.mark)>-1){
                bl=false
            }else{
                globalMark.push(nextChild.mark)
            }
            return bl;
}
function getStaticPropertyName(node) {
    let prop;

    switch (node && node.type) {
        case "Property":
        case "MethodDefinition":
            if(node.key.name!=='mark'){
                return null
            }
            prop = node.value;
            break;

        case "MemberExpression":
            prop = node.property;
            break;

        // no default
    }

    switch (prop && prop.type) {
        case "Literal":
            return String(prop.value);

        case "TemplateLiteral":
            if (prop.expressions.length === 0 && prop.quasis.length === 1) {
                return prop.quasis[0].value.cooked;
            }
            break;

        case "Identifier":
            if (!node.computed) {
                return prop.value;
            }
            break;

        // no default
    }

    return null;
}

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

const GET_KIND = /^(?:init|get)$/u;
const SET_KIND = /^(?:init|set)$/u;

/**
 * The class which stores properties' information of an object.
 */
class ObjectInfo {

    /**
     * @param {ObjectInfo|null} upper - The information of the outer object.
     * @param {ASTNode} node - The ObjectExpression node of this information.
     */
    constructor(upper, node) {
        this.upper = upper;
        this.node = node;
        this.properties = new Map();
    }

    /**
     * Gets the information of the given Property node.
     * @param {ASTNode} node - The Property node to get.
     * @returns {{get: boolean, set: boolean}} The information of the property.
     */
    getPropertyInfo(node) {
        const name = getStaticPropertyName(node);

        if (!this.properties.has(name)) {
            this.properties.set(name, { get: false, set: false });
        }
        return this.properties.get(name);
    }

    /**
     * Checks whether the given property has been defined already or not.
     * @param {ASTNode} node - The Property node to check.
     * @returns {boolean} `true` if the property has been defined.
     */
    isPropertyDefined(node) {
        const entry = this.getPropertyInfo(node);

        return (
            (GET_KIND.test(node.kind) && entry.get) ||
            (SET_KIND.test(node.kind) && entry.set)
        );
    }

    /**
     * Defines the given property.
     * @param {ASTNode} node - The Property node to define.
     * @returns {void}
     */
    defineProperty(node) {
        const entry = this.getPropertyInfo(node);

        if (GET_KIND.test(node.kind)) {
            entry.get = true;
        }
        if (SET_KIND.test(node.kind)) {
            entry.set = true;
        }
    }
}

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

module.exports = {
    meta: {
        type: "problem",

        docs: {
            description: "disallow duplicate values in object literals",
            category: "Possible Errors",
            recommended: true,
            url: ""
        },

        schema: [],

        messages: {
            unexpected: "Duplicate values '{{name}}'."
        }
    },

    create(context) {
        let info = null;

        return {
            ObjectExpression(node) {
                info = new ObjectInfo(info, node);
            },
            "ObjectExpression:exit"() {
                info = info.upper;
            },

            Property(node) {
                const name = getStaticPropertyName(node);
                if (!checkMark({mark:name})) {
                    context.report({
                        node: info.node,
                        loc: node.key.loc,
                        messageId: "unexpected",
                        data: { name }
                    });
                }
                // console.log(name);
                // console.log("======");

                // Skip destructuring.
                if (node.parent.type !== "ObjectExpression") {
                    return;
                }

                // Skip if the name is not static.
                if (!name) {
                    return;
                }

                // Reports if the name is defined already.
                // if (info.isPropertyDefined(node)) {
                //     context.report({
                //         node: info.node,
                //         loc: node.key.loc,
                //         messageId: "unexpected",
                //         data: { name }
                //     });
                // }


                // Update info.
                info.defineProperty(node);
            }
        };
    }
};