astro-eslint-parser 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Yosuke Ota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# astro-eslint-parser
+
+[Astro] parser for [ESLint].  
+You can check it on [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/playground).
+
+[![NPM license](https://img.shields.io/npm/l/astro-eslint-parser.svg)](https://www.npmjs.com/package/astro-eslint-parser)
+[![NPM version](https://img.shields.io/npm/v/astro-eslint-parser.svg)](https://www.npmjs.com/package/astro-eslint-parser)
+[![NPM downloads](https://img.shields.io/badge/dynamic/json.svg?label=downloads&colorB=green&suffix=/day&query=$.downloads&uri=https://api.npmjs.org//downloads/point/last-day/astro-eslint-parser&maxAge=3600)](http://www.npmtrends.com/astro-eslint-parser)
+[![NPM downloads](https://img.shields.io/npm/dw/astro-eslint-parser.svg)](http://www.npmtrends.com/astro-eslint-parser)
+[![NPM downloads](https://img.shields.io/npm/dm/astro-eslint-parser.svg)](http://www.npmtrends.com/astro-eslint-parser)
+[![NPM downloads](https://img.shields.io/npm/dy/astro-eslint-parser.svg)](http://www.npmtrends.com/astro-eslint-parser)
+[![NPM downloads](https://img.shields.io/npm/dt/astro-eslint-parser.svg)](http://www.npmtrends.com/astro-eslint-parser)
+[![Build Status](https://github.com/ota-meshi/astro-eslint-parser/workflows/CI/badge.svg?branch=main)](https://github.com/ota-meshi/astro-eslint-parser/actions?query=workflow%3ACI)
+
+This parser is in the ***experimental stages*** of development.
+
+<!--
+### ESLint Plugins Using astro-eslint-parser
+
+#### [@ota-meshi/eslint-plugin-astro](https://ota-meshi.github.io/eslint-plugin-astro/)
+
+ESLint plugin for Astro.  
+It provides many unique check rules by using the template AST.
+-->
+
+## 💿 Installation
+
+```bash
+npm install --save-dev eslint astro-eslint-parser
+```
+
+## 📖 Usage
+
+1. Write `overrides.parser` option into your `.eslintrc.*` file.
+2. Use glob patterns or `--ext .astro` CLI option.
+
+```json
+{
+    "extends": "eslint:recommended",
+    "overrides": [
+        {
+            "files": ["*.astro"],
+            "parser": "astro-eslint-parser"
+        }
+    ]
+}
+```
+
+```console
+$ eslint "src/**/*.{js,astro}"
+# or
+$ eslint src --ext .astro
+```
+
+## 🔧 Options
+
+`parserOptions` has the same properties as what [espree](https://github.com/eslint/espree#usage), the default parser of ESLint, is supporting.
+For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "sourceType": "module",
+        "ecmaVersion": 2021,
+        "ecmaFeatures": {
+            "globalReturn": false,
+            "impliedStrict": false,
+            "jsx": false
+        }
+    }
+}
+```
+
+### parserOptions.parser
+
+You can use `parserOptions.parser` property to specify a custom parser to parse `<script>` tags.
+Other properties than parser would be given to the specified parser.
+For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "parser": "@typescript-eslint/parser"
+    }
+}
+```
+
+For example, if you are using the `"@typescript-eslint/parser"`, and if you want to use TypeScript in `<script>` of `.astro`, you need to add more `parserOptions` configuration.
+
+```js
+module.exports = {
+  // ...
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    // ...
+    project: "path/to/your/tsconfig.json",
+    extraFileExtensions: [".astro"], // This is a required setting in `@typescript-eslint/parser` v4.24.0.
+  },
+  overrides: [
+    {
+      files: ["*.astro"],
+      parser: "astro-eslint-parser",
+      // Parse the `<script>` in `.astro` as TypeScript by adding the following configuration.
+      parserOptions: {
+        parser: "@typescript-eslint/parser",
+      },
+    },
+    // ...
+  ],
+  // ...
+}
+```
+
+## :computer: Editor Integrations
+
+### Visual Studio Code
+
+Use the [dbaeumer.vscode-eslint](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) extension that Microsoft provides officially.
+
+You have to configure the `eslint.validate` option of the extension to check `.astro` files, because the extension targets only `*.js` or `*.jsx` files by default.
+
+Example **.vscode/settings.json**:
+
+```json
+{
+    "eslint.validate": [
+        "javascript",
+        "javascriptreact",
+        "astro"
+    ]
+}
+```
+
+## Usage for Custom Rules / Plugins
+
+- TBD
+
+<!-- - [AST.md](./docs/AST.md) is AST specification. You can check it on the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). -->
+<!-- - I have already [implemented some rules] in the [`@ota-meshi/eslint-plugin-astro`]. The source code for these rules will be helpful to you. -->
+
+## :beers: Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+## :lock: License
+
+See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
+
+[Astro]: https://astro.build/
+[ESLint]: https://eslint.org/

package/lib/ast.d.ts

@@ -0,0 +1,42 @@
+import type { TSESTree } from "@typescript-eslint/types";
+export declare type AstroNode = AstroProgram | AstroRootFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute;
+/** Node of Astro program root */
+export interface AstroProgram extends Omit<TSESTree.Program, "type" | "body"> {
+    type: "Program";
+    body: (TSESTree.Program["body"][number] | AstroRootFragment | AstroHTMLComment)[];
+    sourceType: "script" | "module";
+    comments: TSESTree.Comment[];
+    tokens: TSESTree.Token[];
+    parent: undefined;
+}
+/** Node of Astro fragment root */
+export interface AstroRootFragment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
+    type: "AstroRootFragment";
+    children: TSESTree.JSXFragment["children"];
+    parent: AstroProgram;
+}
+/** Node of Astro html comment */
+export interface AstroHTMLComment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
+    type: "AstroHTMLComment";
+    value: string;
+    parent: AstroRootFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
+}
+/** Node of Astro doctype */
+export interface AstroDoctype extends Omit<TSESTree.BaseNode, "type" | "parent"> {
+    type: "AstroDoctype";
+    parent: AstroRootFragment;
+}
+/** Node of Astro shorthand attribute */
+export interface AstroShorthandAttribute extends Omit<TSESTree.JSXAttribute, "type" | "parent"> {
+    type: "AstroShorthandAttribute";
+    value: TSESTree.JSXExpressionContainer;
+    parent: TSESTree.JSXElement | TSESTree.JSXFragment;
+}
+/** Node of Astro template-literal attribute */
+export interface AstroTemplateLiteralAttribute extends Omit<TSESTree.JSXAttribute, "type" | "parent"> {
+    type: "AstroTemplateLiteralAttribute";
+    value: TSESTree.JSXExpressionContainer & {
+        expression: TSESTree.TemplateLiteral;
+    };
+    parent: TSESTree.JSXElement | TSESTree.JSXFragment;
+}

package/lib/ast.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/astro/index.d.ts

@@ -0,0 +1,33 @@
+import type { AttributeNode, CommentNode, Node, ParentNode, TagLikeNode } from "@astrojs/compiler/types";
+/**
+ * Checks if the given node is TagLikeNode
+ */
+export declare function isTag(node: Node): node is Node & TagLikeNode;
+/**
+ * Checks if the given node is ParentNode
+ */
+export declare function isParent(node: Node): node is ParentNode;
+/** walk element nodes */
+export declare function walkElements(parent: ParentNode, cb: (n: Node, parent: ParentNode) => void): void;
+/** walk nodes */
+export declare function walk(parent: ParentNode, enter: (n: Node | AttributeNode, parent: ParentNode) => void, leave?: (n: Node | AttributeNode, parent: ParentNode) => void): void;
+/**
+ * Get end offset of start tag
+ */
+export declare function getStartTagEndOffset(node: TagLikeNode, code: string): number;
+/**
+ * Get end offset of attribute
+ */
+export declare function getAttributeEndOffset(node: AttributeNode, code: string): number;
+/**
+ * Get start offset of attribute value
+ */
+export declare function getAttributeValueStartOffset(node: AttributeNode, code: string): number;
+/**
+ * Get end offset of comment
+ */
+export declare function getCommentEndOffset(node: CommentNode, code: string): number;
+/**
+ * Skip spaces
+ */
+export declare function skipSpaces(string: string, position: number): number;

package/lib/astro/index.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipSpaces = exports.getCommentEndOffset = exports.getAttributeValueStartOffset = exports.getAttributeEndOffset = exports.getStartTagEndOffset = exports.walk = exports.walkElements = exports.isParent = exports.isTag = void 0;
+/**
+ * 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, cb) {
+    let children = parent.children;
+    if (parent.type === "root" && children.every((n) => n.position)) {
+        // The order of comments and frontmatter may be changed.
+        children = [...children].sort((a, b) => a.position.start.offset - b.position.start.offset);
+    }
+    for (const node of children) {
+        cb(node, parent);
+        if (isParent(node)) {
+            walkElements(node, cb);
+        }
+    }
+}
+exports.walkElements = walkElements;
+/** walk nodes */
+function walk(parent, enter, leave) {
+    let children = parent.children;
+    if (parent.type === "root" && children.every((n) => n.position)) {
+        // The order of comments and frontmatter may be changed.
+        children = [...children].sort((a, b) => a.position.start.offset - b.position.start.offset);
+    }
+    for (const node of children) {
+        enter(node, parent);
+        if (isTag(node)) {
+            for (const attr of node.attributes) {
+                enter(attr, node);
+                leave === null || leave === void 0 ? void 0 : leave(attr, node);
+            }
+        }
+        if (isParent(node)) {
+            walk(node, enter, leave);
+        }
+        leave === null || leave === void 0 ? void 0 : leave(node, parent);
+    }
+}
+exports.walk = walk;
+/**
+ * Get end offset of start tag
+ */
+function getStartTagEndOffset(node, code) {
+    const lastAttr = node.attributes[node.attributes.length - 1];
+    let beforeCloseIndex;
+    if (lastAttr) {
+        beforeCloseIndex = getAttributeEndOffset(lastAttr, code);
+    }
+    else {
+        const info = getTokenInfo(code, [`<${node.name}`], node.position.start.offset);
+        beforeCloseIndex = info.index + info.match.length;
+    }
+    const info = getTokenInfo(code, [[">", "/>"]], beforeCloseIndex);
+    return info.index + info.match.length;
+}
+exports.getStartTagEndOffset = getStartTagEndOffset;
+/**
+ * Get end offset of attribute
+ */
+function getAttributeEndOffset(node, code) {
+    let info;
+    if (node.kind === "empty") {
+        info = getTokenInfo(code, [node.name], node.position.start.offset);
+    }
+    else if (node.kind === "quoted") {
+        info = getTokenInfo(code, [[`"${node.value}"`, `'${node.value}'`, node.value]], getAttributeValueStartOffset(node, code));
+    }
+    else if (node.kind === "expression") {
+        info = getTokenInfo(code, ["{", node.value, "}"], getAttributeValueStartOffset(node, code));
+    }
+    else if (node.kind === "shorthand") {
+        info = getTokenInfo(code, ["{", node.name, "}"], node.position.start.offset);
+    }
+    else if (node.kind === "spread") {
+        info = getTokenInfo(code, ["{", "...", node.name, "}"], node.position.start.offset);
+    }
+    else if (node.kind === "template-literal") {
+        info = getTokenInfo(code, [`\`${node.value}\``], getAttributeValueStartOffset(node, code));
+    }
+    else {
+        throw new Error(`Unknown attr kind: ${node.kind}`);
+    }
+    return info.index + info.match.length;
+}
+exports.getAttributeEndOffset = getAttributeEndOffset;
+/**
+ * Get start offset of attribute value
+ */
+function getAttributeValueStartOffset(node, code) {
+    let info;
+    if (node.kind === "quoted") {
+        info = getTokenInfo(code, [node.name, "=", [`"`, `'`, node.value]], node.position.start.offset);
+    }
+    else if (node.kind === "expression") {
+        info = getTokenInfo(code, [node.name, "=", "{"], node.position.start.offset);
+    }
+    else if (node.kind === "template-literal") {
+        info = getTokenInfo(code, [node.name, "=", "`"], node.position.start.offset);
+    }
+    else {
+        throw new Error(`Unknown attr kind: ${node.kind}`);
+    }
+    return info.index;
+}
+exports.getAttributeValueStartOffset = getAttributeValueStartOffset;
+/**
+ * Get end offset of comment
+ */
+function getCommentEndOffset(node, code) {
+    const info = getTokenInfo(code, ["<!--", node.value, "-->"], node.position.start.offset);
+    return info.index + info.match.length;
+}
+exports.getCommentEndOffset = getCommentEndOffset;
+/**
+ * Get token info
+ */
+function getTokenInfo(string, 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 Error(`Unknown token at ${index}, expected: ${JSON.stringify(t)}, actual: ${JSON.stringify(string.slice(index, index + 10))}`);
+        }
+        lastMatch = m;
+    }
+    return lastMatch;
+    /**
+     * For string
+     */
+    function matchOfStr(search, position) {
+        const index = search.trim() === search ? skipSpaces(string, position) : position;
+        if (string.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;

package/lib/context/index.d.ts

@@ -0,0 +1,48 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { ESLintExtendedProgram } from "../parser";
+declare type RangeAndLoc = {
+    range: TSESTree.Range;
+    loc: TSESTree.SourceLocation;
+};
+export declare class Context {
+    readonly code: string;
+    readonly parserOptions: any;
+    readonly locs: LinesAndColumns;
+    private readonly locsMap;
+    private state;
+    constructor(code: string, parserOptions: any);
+    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;
+    isTypeScript(): boolean;
+    remapCR({ ast, visitorKeys }: ESLintExtendedProgram): void;
+}
+export declare class LinesAndColumns {
+    readonly code: string;
+    private readonly crs;
+    private readonly lineStartIndices;
+    constructor(origCode: string);
+    getLocFromIndex(index: number): {
+        line: number;
+        column: number;
+    };
+    getIndexFromLoc(loc: {
+        line: number;
+        column: number;
+    }): number;
+    getCRs(): number[];
+}
+export {};

package/lib/context/index.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinesAndColumns = exports.Context = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const resolve_parser_1 = require("../parser/resolve-parser");
+const traverse_1 = require("../traverse");
+class Context {
+    constructor(code, parserOptions) {
+        this.locsMap = new Map();
+        this.state = {};
+        this.locs = new LinesAndColumns(code);
+        this.code = this.locs.code;
+        this.parserOptions = parserOptions;
+    }
+    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 Object.assign({ type, value: this.getText(range) }, this.getLocations(...range));
+    }
+    /**
+     * get text
+     */
+    getText(range) {
+        return this.code.slice(range[0], range[1]);
+    }
+    isTypeScript() {
+        var _a, _b;
+        if (this.state.isTypeScript != null) {
+            return this.state.isTypeScript;
+        }
+        const parserName = (0, resolve_parser_1.getParserName)({}, (_a = this.parserOptions) === null || _a === void 0 ? void 0 : _a.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 =
+                            ((_b = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"))) === null || _b === void 0 ? void 0 : _b.name) === "@typescript-eslint/parser");
+                    }
+                    catch (_c) {
+                        return (this.state.isTypeScript = false);
+                    }
+                }
+                const parent = path_1.default.dirname(targetPath);
+                if (targetPath === parent) {
+                    break;
+                }
+                targetPath = parent;
+            }
+        }
+        return (this.state.isTypeScript = false);
+    }
+    remapCR({ ast, visitorKeys }) {
+        const crs = this.locs.getCRs();
+        if (!crs.length) {
+            return;
+        }
+        const cache = {};
+        /**
+         * Remap index
+         */
+        function remapIndex(index) {
+            let result = cache[index];
+            if (result != null) {
+                return result;
+            }
+            result = index;
+            for (const cr of crs) {
+                if (cr < result) {
+                    result++;
+                }
+                else {
+                    break;
+                }
+            }
+            return (cache[index] = result);
+        }
+        /**
+         * Remap range
+         */
+        function remapRange(range) {
+            return [remapIndex(range[0]), remapIndex(range[1])];
+        }
+        (0, traverse_1.traverseNodes)(ast, {
+            visitorKeys,
+            enterNode(node) {
+                node.range = remapRange(node.range);
+            },
+            leaveNode() {
+                // ignore
+            },
+        });
+        for (const token of ast.tokens || []) {
+            token.range = remapRange(token.range);
+        }
+        for (const comment of ast.comments || []) {
+            comment.range = remapRange(comment.range);
+        }
+    }
+}
+exports.Context = Context;
+class LinesAndColumns {
+    constructor(origCode) {
+        const len = origCode.length;
+        const lineStartIndices = [0];
+        const crs = [];
+        let code = "";
+        for (let index = 0; index < len;) {
+            const c = origCode[index++];
+            if (c === "\r") {
+                const next = origCode[index++] || "";
+                if (next === "\n") {
+                    code += next;
+                    crs.push(index - 2);
+                }
+                else {
+                    code += `\n${next}`;
+                }
+                lineStartIndices.push(code.length);
+            }
+            else {
+                code += c;
+                if (c === "\n") {
+                    lineStartIndices.push(code.length);
+                }
+            }
+        }
+        this.lineStartIndices = lineStartIndices;
+        this.code = code;
+        this.crs = 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;
+    }
+    getCRs() {
+        return this.crs;
+    }
+}
+exports.LinesAndColumns = LinesAndColumns;
+/**
+ * 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;
+}