astro-eslint-parser 0.4.5 → 0.6.0

package/lib/astro/index.js

@@ -1,357 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.skipSpaces = exports.calcCommentEndOffset = exports.getEndTag = exports.getSelfClosingTag = exports.calcContentEndOffset = exports.getEndOffset = exports.calcAttributeValueStartOffset = exports.calcAttributeEndOffset = exports.calcStartTagEndOffset = exports.walk = exports.walkElements = exports.isParent = exports.isTag = void 0;
-const errors_1 = require("../errors");
-/**
- * Checks if the given node is TagLikeNode
- */
-function isTag(node) {
-    return (node.type === "element" ||
-        node.type === "custom-element" ||
-        node.type === "component" ||
-        node.type === "fragment");
-}
-exports.isTag = isTag;
-/**
- * Checks if the given node is ParentNode
- */
-function isParent(node) {
-    return Array.isArray(node.children);
-}
-exports.isParent = isParent;
-/** walk element nodes */
-function walkElements(parent, code, enter, leave, parents = []) {
-    const children = getSortedChildren(parent, code);
-    const currParents = [parent, ...parents];
-    for (const node of children) {
-        enter(node, currParents);
-        if (isParent(node)) {
-            walkElements(node, code, enter, leave, currParents);
-        }
-        leave(node, currParents);
-    }
-}
-exports.walkElements = walkElements;
-/** walk nodes */
-function walk(parent, code, enter, leave) {
-    walkElements(parent, code, (node, parents) => {
-        enter(node, parents);
-        if (isTag(node)) {
-            const attrParents = [node, ...parents];
-            for (const attr of node.attributes) {
-                enter(attr, attrParents);
-                leave(attr, attrParents);
-            }
-        }
-    }, leave);
-}
-exports.walk = walk;
-/**
- * Get end offset of start tag
- */
-function calcStartTagEndOffset(node, ctx) {
-    const lastAttr = node.attributes[node.attributes.length - 1];
-    let beforeCloseIndex;
-    if (lastAttr) {
-        beforeCloseIndex = calcAttributeEndOffset(lastAttr, ctx);
-    }
-    else {
-        const info = getTokenInfo(ctx, [`<${node.name}`], node.position.start.offset);
-        beforeCloseIndex = info.index + info.match.length;
-    }
-    const info = getTokenInfo(ctx, [[">", "/>"]], beforeCloseIndex);
-    return info.index + info.match.length;
-}
-exports.calcStartTagEndOffset = calcStartTagEndOffset;
-/**
- * Get end offset of attribute
- */
-function calcAttributeEndOffset(node, ctx) {
-    let info;
-    if (node.kind === "empty") {
-        info = getTokenInfo(ctx, [node.name], node.position.start.offset);
-    }
-    else if (node.kind === "quoted") {
-        info = getTokenInfo(ctx, [[`"${node.value}"`, `'${node.value}'`, node.value]], calcAttributeValueStartOffset(node, ctx));
-    }
-    else if (node.kind === "expression") {
-        info = getTokenInfo(ctx, ["{", node.value, "}"], calcAttributeValueStartOffset(node, ctx));
-    }
-    else if (node.kind === "shorthand") {
-        info = getTokenInfo(ctx, ["{", node.name, "}"], node.position.start.offset);
-    }
-    else if (node.kind === "spread") {
-        info = getTokenInfo(ctx, ["{", "...", node.name, "}"], node.position.start.offset);
-    }
-    else if (node.kind === "template-literal") {
-        info = getTokenInfo(ctx, [`\`${node.value}\``], calcAttributeValueStartOffset(node, ctx));
-    }
-    else {
-        throw new errors_1.ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
-    }
-    return info.index + info.match.length;
-}
-exports.calcAttributeEndOffset = calcAttributeEndOffset;
-/**
- * Get start offset of attribute value
- */
-function calcAttributeValueStartOffset(node, ctx) {
-    let info;
-    if (node.kind === "quoted") {
-        info = getTokenInfo(ctx, [node.name, "=", [`"`, `'`, node.value]], node.position.start.offset);
-    }
-    else if (node.kind === "expression") {
-        info = getTokenInfo(ctx, [node.name, "=", "{"], node.position.start.offset);
-    }
-    else if (node.kind === "template-literal") {
-        info = getTokenInfo(ctx, [node.name, "=", "`"], node.position.start.offset);
-    }
-    else {
-        throw new errors_1.ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
-    }
-    return info.index;
-}
-exports.calcAttributeValueStartOffset = calcAttributeValueStartOffset;
-/**
- * Get end offset of tag
- */
-function getEndOffset(node, ctx) {
-    if (node.position.end?.offset != null) {
-        return node.position.end.offset;
-    }
-    if (isTag(node))
-        return calcTagEndOffset(node, ctx);
-    if (node.type === "expression")
-        return calcExpressionEndOffset(node, ctx);
-    if (node.type === "comment")
-        return calcCommentEndOffset(node, ctx);
-    if (node.type === "frontmatter") {
-        const start = node.position.start.offset;
-        return ctx.code.indexOf("---", start + 3) + 3;
-    }
-    if (node.type === "doctype") {
-        const start = node.position.start.offset;
-        return ctx.code.indexOf(">", start) + 1;
-    }
-    if (node.type === "text") {
-        const start = node.position.start.offset;
-        return start + node.value.length;
-    }
-    if (node.type === "root") {
-        return ctx.code.length;
-    }
-    throw new Error(`unknown type: ${node.type}`);
-}
-exports.getEndOffset = getEndOffset;
-/**
- * Get content end offset
- */
-function calcContentEndOffset(parent, ctx) {
-    const code = ctx.code;
-    if (isTag(parent)) {
-        const end = getEndOffset(parent, ctx);
-        if (code[end - 1] !== ">") {
-            return end;
-        }
-        const index = code.lastIndexOf("</", end - 1);
-        if (index >= 0 &&
-            code.slice(index + 2, end - 1).trim() === parent.name) {
-            return index;
-        }
-        return end;
-    }
-    else if (parent.type === "expression") {
-        const end = getEndOffset(parent, ctx);
-        return code.lastIndexOf("}", end);
-    }
-    else if (parent.type === "root") {
-        return code.length;
-    }
-    throw new Error(`unknown type: ${parent.type}`);
-}
-exports.calcContentEndOffset = calcContentEndOffset;
-/**
- * If the given tag is a self-close tag, get the self-closing tag.
- */
-function getSelfClosingTag(node, ctx) {
-    if (node.children.length > 0) {
-        return null;
-    }
-    const code = ctx.code;
-    const startTagEndOffset = calcStartTagEndOffset(node, ctx);
-    if (code.startsWith("/>", startTagEndOffset - 2)) {
-        return {
-            offset: startTagEndOffset,
-            end: "/>",
-        };
-    }
-    if (code.startsWith(`</${node.name}`, startTagEndOffset)) {
-        return null;
-    }
-    return {
-        offset: startTagEndOffset,
-        end: ">",
-    };
-}
-exports.getSelfClosingTag = getSelfClosingTag;
-/**
- * If the given tag has a end tag, get the end tag.
- */
-function getEndTag(node, ctx) {
-    let beforeIndex;
-    if (node.children.length) {
-        const lastChild = node.children[node.children.length - 1];
-        beforeIndex = getEndOffset(lastChild, ctx);
-    }
-    else {
-        beforeIndex = calcStartTagEndOffset(node, ctx);
-    }
-    beforeIndex = skipSpaces(ctx.code, beforeIndex);
-    if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-        const offset = beforeIndex;
-        beforeIndex = beforeIndex + 2 + node.name.length;
-        const info = getTokenInfo(ctx, [">"], beforeIndex);
-        const end = info.index + info.match.length;
-        return {
-            offset,
-            tag: ctx.code.slice(offset, end),
-        };
-    }
-    return null;
-}
-exports.getEndTag = getEndTag;
-/**
- * Get end offset of comment
- */
-function calcCommentEndOffset(node, ctx) {
-    const info = getTokenInfo(ctx, ["<!--", node.value, "-->"], node.position.start.offset);
-    return info.index + info.match.length;
-}
-exports.calcCommentEndOffset = calcCommentEndOffset;
-/**
- * Get end offset of tag
- */
-function calcTagEndOffset(node, ctx) {
-    let beforeIndex;
-    if (node.children.length) {
-        const lastChild = node.children[node.children.length - 1];
-        beforeIndex = getEndOffset(lastChild, ctx);
-    }
-    else {
-        beforeIndex = calcStartTagEndOffset(node, ctx);
-    }
-    beforeIndex = skipSpaces(ctx.code, beforeIndex);
-    if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-        beforeIndex = beforeIndex + 2 + node.name.length;
-        const info = getTokenInfo(ctx, [">"], beforeIndex);
-        return info.index + info.match.length;
-    }
-    return beforeIndex;
-}
-/**
- * Get end offset of Expression
- */
-function calcExpressionEndOffset(node, ctx) {
-    if (node.children.length) {
-        const lastChild = node.children[node.children.length - 1];
-        const beforeIndex = getEndOffset(lastChild, ctx);
-        const info = getTokenInfo(ctx, ["}"], beforeIndex);
-        return info.index + info.match.length;
-    }
-    const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
-    return info.index + info.match.length;
-}
-/**
- * Get token info
- */
-function getTokenInfo(ctx, tokens, position) {
-    let lastMatch;
-    for (const t of tokens) {
-        const index = lastMatch
-            ? lastMatch.index + lastMatch.match.length
-            : position;
-        const m = typeof t === "string"
-            ? matchOfStr(t, index)
-            : matchOfForMulti(t, index);
-        if (m == null) {
-            throw new errors_1.ParseError(`Unknown token at ${index}, expected: ${JSON.stringify(t)}, actual: ${JSON.stringify(ctx.code.slice(index, index + 10))}`, index, ctx);
-        }
-        lastMatch = m;
-    }
-    return lastMatch;
-    /**
-     * For string
-     */
-    function matchOfStr(search, position) {
-        const index = search.trim() === search ? skipSpaces(ctx.code, position) : position;
-        if (ctx.code.startsWith(search, index)) {
-            return {
-                match: search,
-                index,
-            };
-        }
-        return null;
-    }
-    /**
-     * For multi
-     */
-    function matchOfForMulti(search, position) {
-        for (const s of search) {
-            const m = matchOfStr(s, position);
-            if (m) {
-                return m;
-            }
-        }
-        return null;
-    }
-}
-/**
- * Skip spaces
- */
-function skipSpaces(string, position) {
-    const re = /\s*/g;
-    re.lastIndex = position;
-    const match = re.exec(string);
-    if (match) {
-        return match.index + match[0].length;
-    }
-    return position;
-}
-exports.skipSpaces = skipSpaces;
-/**
- * Get children
- */
-function getSortedChildren(parent, code) {
-    if (parent.type === "root" && parent.children[0]?.type === "frontmatter") {
-        // The order of comments and frontmatter may be changed.
-        const children = [...parent.children];
-        if (children.every((n) => n.position)) {
-            return children.sort((a, b) => a.position.start.offset - b.position.start.offset);
-        }
-        let start = skipSpaces(code, 0);
-        if (code.startsWith("<!", start)) {
-            const frontmatter = children.shift();
-            const before = [];
-            let first;
-            while ((first = children.shift())) {
-                start = skipSpaces(code, start);
-                if (first.type === "comment" &&
-                    code.startsWith("<!--", start)) {
-                    start = code.indexOf("-->", start + 4) + 3;
-                    before.push(first);
-                }
-                else if (first.type === "doctype" &&
-                    code.startsWith("<!", start)) {
-                    start = code.indexOf(">", start + 2) + 1;
-                    before.push(first);
-                }
-                else {
-                    children.unshift(first);
-                    break;
-                }
-            }
-            return [...before, frontmatter, ...children];
-        }
-    }
-    return parent.children;
-}

package/lib/astro-tools/index.d.ts

@@ -1,21 +0,0 @@
-import type { ParseResult } from "@astrojs/compiler";
-import type { AttributeNode, Node, ParentNode } from "@astrojs/compiler/types";
-export interface ParseTemplateResult {
-    result: ParseResult;
-    getEndOffset: (node: Node) => number;
-    calcAttributeValueStartOffset: (node: AttributeNode) => number;
-    calcAttributeEndOffset: (node: AttributeNode) => number;
-    walk: (parent: ParentNode, enter: (n: Node | AttributeNode, parents: ParentNode[]) => void, leave?: (n: Node | AttributeNode, parents: ParentNode[]) => void) => void;
-    getLocFromIndex: (index: number) => {
-        line: number;
-        column: number;
-    };
-    getIndexFromLoc: (loc: {
-        line: number;
-        column: number;
-    }) => number;
-}
-/**
- * Parse the astro component template.
- */
-export declare function parseTemplate(code: string): ParseTemplateResult;

package/lib/astro-tools/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTemplate = void 0;
-const template_1 = require("../parser/template");
-const astro_1 = require("../astro");
-/**
- * Parse the astro component template.
- */
-function parseTemplate(code) {
-    const parsed = (0, template_1.parseTemplate)(code);
-    return {
-        result: parsed.result,
-        getEndOffset: (node) => (0, astro_1.getEndOffset)(node, parsed.context),
-        calcAttributeValueStartOffset: (node) => (0, astro_1.calcAttributeValueStartOffset)(node, parsed.context),
-        calcAttributeEndOffset: (node) => (0, astro_1.calcAttributeEndOffset)(node, parsed.context),
-        walk(parent, enter, leave) {
-            (0, astro_1.walk)(parent, code, enter, leave ||
-                (() => {
-                    /* noop */
-                }));
-        },
-        getLocFromIndex: (index) => parsed.context.getLocFromIndex(index),
-        getIndexFromLoc: (loc) => parsed.context.locs.getIndexFromLoc(loc),
-    };
-}
-exports.parseTemplate = parseTemplate;

package/lib/context/index.d.ts

@@ -1,55 +0,0 @@
-import type { TSESTree } from "@typescript-eslint/types";
-declare type RangeAndLoc = {
-    range: TSESTree.Range;
-    loc: TSESTree.SourceLocation;
-};
-export declare class Context {
-    readonly code: string;
-    readonly locs: LinesAndColumns;
-    private readonly locsMap;
-    private readonly state;
-    constructor(code: string);
-    getLocFromIndex(index: number): {
-        line: number;
-        column: number;
-    };
-    /**
-     * Get the location information of the given indexes.
-     */
-    getLocations(start: number, end: number): RangeAndLoc;
-    /**
-     * Build token
-     */
-    buildToken(type: TSESTree.Token["type"], range: TSESTree.Range): TSESTree.Token;
-    /**
-     * get text
-     */
-    getText(range: TSESTree.Range): string;
-    get originalAST(): any;
-    set originalAST(originalAST: any);
-}
-export declare class LinesAndColumns {
-    private readonly lineStartIndices;
-    private readonly normalizedLineFeed;
-    constructor(origCode: string);
-    getLocFromIndex(index: number): {
-        line: number;
-        column: number;
-    };
-    getIndexFromLoc(loc: {
-        line: number;
-        column: number;
-    }): number;
-    getNormalizedLineFeed(): NormalizedLineFeed;
-}
-export declare class NormalizedLineFeed {
-    readonly code: string;
-    private readonly offsets;
-    get needRemap(): boolean;
-    /**
-     * Remap index
-     */
-    readonly remapIndex: (index: number) => number;
-    constructor(code: string, offsets: number[]);
-}
-export {};

package/lib/context/index.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalizedLineFeed = exports.LinesAndColumns = exports.Context = void 0;
-class Context {
-    constructor(code) {
-        this.locsMap = new Map();
-        this.state = {};
-        this.locs = new LinesAndColumns(code);
-        this.code = code;
-    }
-    getLocFromIndex(index) {
-        let loc = this.locsMap.get(index);
-        if (!loc) {
-            loc = this.locs.getLocFromIndex(index);
-            this.locsMap.set(index, loc);
-        }
-        return {
-            line: loc.line,
-            column: loc.column,
-        };
-    }
-    /**
-     * Get the location information of the given indexes.
-     */
-    getLocations(start, end) {
-        return {
-            range: [start, end],
-            loc: {
-                start: this.getLocFromIndex(start),
-                end: this.getLocFromIndex(end),
-            },
-        };
-    }
-    /**
-     * Build token
-     */
-    buildToken(type, range) {
-        return {
-            type,
-            value: this.getText(range),
-            ...this.getLocations(...range),
-        };
-    }
-    /**
-     * get text
-     */
-    getText(range) {
-        return this.code.slice(range[0], range[1]);
-    }
-    get originalAST() {
-        return this.state.originalAST;
-    }
-    set originalAST(originalAST) {
-        this.state.originalAST = originalAST;
-    }
-}
-exports.Context = Context;
-class LinesAndColumns {
-    constructor(origCode) {
-        const len = origCode.length;
-        const lineStartIndices = [0];
-        const crs = [];
-        let normalizedCode = "";
-        for (let index = 0; index < len;) {
-            const c = origCode[index++];
-            if (c === "\r") {
-                const next = origCode[index++] || "";
-                if (next === "\n") {
-                    normalizedCode += next;
-                    crs.push(index - 2);
-                    lineStartIndices.push(index);
-                }
-                else {
-                    normalizedCode += `\n${next}`;
-                    lineStartIndices.push(index - 1);
-                }
-            }
-            else {
-                normalizedCode += c;
-                if (c === "\n") {
-                    lineStartIndices.push(index);
-                }
-            }
-        }
-        this.lineStartIndices = lineStartIndices;
-        //
-        this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
-    }
-    getLocFromIndex(index) {
-        const lineNumber = sortedLastIndex(this.lineStartIndices, index);
-        return {
-            line: lineNumber,
-            column: index - this.lineStartIndices[lineNumber - 1],
-        };
-    }
-    getIndexFromLoc(loc) {
-        const lineStartIndex = this.lineStartIndices[loc.line - 1];
-        const positionIndex = lineStartIndex + loc.column;
-        return positionIndex;
-    }
-    getNormalizedLineFeed() {
-        return this.normalizedLineFeed;
-    }
-}
-exports.LinesAndColumns = LinesAndColumns;
-class NormalizedLineFeed {
-    constructor(code, offsets) {
-        this.code = code;
-        this.offsets = offsets;
-        if (offsets.length) {
-            const cache = {};
-            this.remapIndex = (index) => {
-                let result = cache[index];
-                if (result != null) {
-                    return result;
-                }
-                result = index;
-                for (const offset of offsets) {
-                    if (offset < result) {
-                        result++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                return (cache[index] = result);
-            };
-        }
-        else {
-            this.remapIndex = (i) => i;
-        }
-    }
-    get needRemap() {
-        return this.offsets.length > 0;
-    }
-}
-exports.NormalizedLineFeed = NormalizedLineFeed;
-/**
- * Uses a binary search to determine the highest index at which value should be inserted into array in order to maintain its sort order.
- */
-function sortedLastIndex(array, value) {
-    let lower = 0;
-    let upper = array.length;
-    while (lower < upper) {
-        const mid = Math.floor(lower + (upper - lower) / 2);
-        const target = array[mid];
-        if (target < value) {
-            lower = mid + 1;
-        }
-        else if (target > value) {
-            upper = mid;
-        }
-        else {
-            return mid + 1;
-        }
-    }
-    return upper;
-}

package/lib/context/parser-options.d.ts

@@ -1,8 +0,0 @@
-import type { ESLintCustomParser } from "../types";
-export declare class ParserOptionsContext {
-    readonly parserOptions: any;
-    private readonly state;
-    constructor(options: any);
-    getParser(): ESLintCustomParser;
-    isTypeScript(): boolean;
-}

package/lib/context/parser-options.js

@@ -1,71 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserOptionsContext = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const resolve_parser_1 = require("./resolve-parser");
-class ParserOptionsContext {
-    constructor(options) {
-        this.state = {};
-        const parserOptions = {
-            ecmaVersion: 2020,
-            sourceType: "module",
-            loc: true,
-            range: true,
-            raw: true,
-            tokens: true,
-            comment: true,
-            eslintVisitorKeys: true,
-            eslintScopeManager: true,
-            ...(options || {}),
-        };
-        parserOptions.ecmaFeatures = {
-            ...(parserOptions.ecmaFeatures || {}),
-            jsx: true,
-        };
-        parserOptions.sourceType = "module";
-        if (parserOptions.ecmaVersion <= 5 ||
-            parserOptions.ecmaVersion == null) {
-            parserOptions.ecmaVersion = 2015;
-        }
-        this.parserOptions = parserOptions;
-    }
-    getParser() {
-        return (0, resolve_parser_1.getParser)({}, this.parserOptions.parser);
-    }
-    isTypeScript() {
-        if (this.state.isTypeScript != null) {
-            return this.state.isTypeScript;
-        }
-        const parserName = (0, resolve_parser_1.getParserName)({}, this.parserOptions?.parser);
-        if (parserName === "@typescript-eslint/parser") {
-            return (this.state.isTypeScript = true);
-        }
-        if (parserName.includes("@typescript-eslint/parser")) {
-            let targetPath = parserName;
-            while (targetPath) {
-                const pkgPath = path_1.default.join(targetPath, "package.json");
-                if (fs_1.default.existsSync(pkgPath)) {
-                    try {
-                        return (this.state.isTypeScript =
-                            JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"))
-                                ?.name === "@typescript-eslint/parser");
-                    }
-                    catch {
-                        return (this.state.isTypeScript = false);
-                    }
-                }
-                const parent = path_1.default.dirname(targetPath);
-                if (targetPath === parent) {
-                    break;
-                }
-                targetPath = parent;
-            }
-        }
-        return (this.state.isTypeScript = false);
-    }
-}
-exports.ParserOptionsContext = ParserOptionsContext;