eslint-plugin-json-schema-validator/lib/utils/ast/yaml.js

ESLint plugin that validates data using JSON Schema Validator.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getYAMLNodeFromPath = void 0;
const yaml_eslint_parser_1 = require("yaml-eslint-parser");
const TRAVERSE_TARGET_TYPE = new Set([
    "Program",
    "YAMLDocument",
    "YAMLMapping",
    "YAMLSequence",
    "YAMLAlias",
    "YAMLWithMeta",
]);
const GET_YAML_NODES = {
    Program(node, paths) {
        if (node.body.length <= 1) {
            return { value: node.body[0] };
        }
        const path = String(paths.shift());
        for (let index = 0; index < node.body.length; index++) {
            if (String(index) !== path) {
                continue;
            }
            return { value: node.body[index] };
        }
        throw new Error(`${"Unexpected state: ["}${[path, ...paths].join(", ")}]`);
    },
    YAMLDocument(node, _paths) {
        if (node.content) {
            return { value: node.content };
        }
        return {
            key: () => {
                return node.range;
            },
            value: null,
        };
    },
    YAMLMapping(node, paths) {
        const path = String(paths.shift());
        for (const pair of node.pairs) {
            const key = String(pair.key ? yaml_eslint_parser_1.getStaticYAMLValue(pair.key) : null);
            if (key === path) {
                return {
                    key: (sourceCode) => {
                        if (pair.key) {
                            return pair.key.range;
                        }
                        return sourceCode.getFirstToken(pair).range;
                    },
                    value: pair.value,
                };
            }
        }
        throw new Error(`${"Unexpected state: ["}${[path, ...paths].join(", ")}]`);
    },
    YAMLSequence(node, paths) {
        const path = String(paths.shift());
        for (let index = 0; index < node.entries.length; index++) {
            if (String(index) !== path) {
                continue;
            }
            const entry = node.entries[index];
            if (entry) {
                return { value: entry };
            }
            return {
                key: (sourceCode) => {
                    const before = node.entries
                        .slice(0, index)
                        .reverse()
                        .find((n) => n != null);
                    let tokenIndex = before ? node.entries.indexOf(before) : -1;
                    let token = before
                        ? sourceCode.getTokenAfter(before)
                        : sourceCode.getFirstToken(node);
                    while (tokenIndex < index) {
                        tokenIndex++;
                        token = sourceCode.getTokenAfter(token);
                    }
                    return [
                        sourceCode.getTokenBefore(token).range[1],
                        token.range[0],
                    ];
                },
                value: null,
            };
        }
        throw new Error(`${"Unexpected state: ["}${[path, ...paths].join(", ")}]`);
    },
    YAMLAlias(node, paths) {
        paths.length = 0;
        return { value: node };
    },
    YAMLWithMeta(node, paths) {
        if (node.value) {
            return { value: node.value };
        }
        throw new Error(`${"Unexpected state: ["}${paths.join(", ")}]`);
    },
};
function getYAMLNodeFromPath(node, [...paths]) {
    let data = {
        key: (sourceCode) => {
            if (node.body.length > 1) {
                return sourceCode.getFirstToken(node.body[0]).range;
            }
            const dataNode = node.body[0].content;
            if (dataNode == null) {
                return sourceCode.getFirstToken(node.body[0]).range;
            }
            if (dataNode.type === "YAMLMapping" ||
                dataNode.type === "YAMLSequence") {
                return sourceCode.getFirstToken(dataNode).range;
            }
            return dataNode.range;
        },
        value: node,
    };
    while (paths.length && data.value) {
        if (!isTraverseTarget(data.value)) {
            throw new Error(`Unexpected node type: ${data.value.type}`);
        }
        data = GET_YAML_NODES[data.value.type](data.value, paths);
    }
    return data;
}
exports.getYAMLNodeFromPath = getYAMLNodeFromPath;
function isTraverseTarget(node) {
    return TRAVERSE_TARGET_TYPE.has(node.type);
}