astro-eslint-parser 0.2.0 → 0.3.0

package/README.md

@@ -17,7 +17,7 @@ You can check it on [Online DEMO](https://ota-meshi.github.io/astro-eslint-parse
 
 This parser is in the ***experimental stages*** of development.
 
-At least it works fine with a [fork of the `astro.build` repository](https://github.com/ota-meshi/astro.build/tree/eslint).
+At least it works fine with a [withastro/docs](https://github.com/withastro/docs) repository.
 
 [@astrojs/compiler]: https://github.com/withastro/compiler
 
@@ -33,8 +33,6 @@ This parser allows us to lint the script of `.astro` files.
 
 ESLint plugin for Astro component.  
 
-[eslint-plugin-astro]: https://ota-meshi.github.io/eslint-plugin-astro/
-
 ## 💿 Installation
 
 ```bash
@@ -128,6 +126,48 @@ module.exports = {
 }
 ```
 
+### parserOptions.astroFeatures
+
+You can use `parserOptions.astroFeatures` property to specify how to parse related to Astro component features. For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "astroFeatures": {
+            "syntax": "auto",
+        }
+    }
+}
+```
+
+### parserOptions.vueFeatures.syntax
+
+You can use `parserOptions.vueFeatures.syntax` property to choose whether to parse as Astro Component (`*.astro`) or Astro Markdown Page (`*.md`).  
+If `"astro"` is specified, it will be parsed as `*.astro`. If `"markdown"` is specified, it will be parsed as `*.md`. If `"auto"` is specified, it will be automatically selected from the file extensions.  
+For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "astroFeatures": {
+            "syntax": "auto", // or "astro", or "markdown"
+        }
+    }
+}
+```
+
+#### Known Limitations on Markdown Pages
+
+There are some known limitations when parsing Markdown Pages for ESLint integration.
+
+- Incompatible with ESLint's [indent] rule. Turn off the [indent] rule in the markdown file. Otherwise the file syntax will be broken.
+- Incompatible with [eslint-plugin-markdown]. eslint-plugin-markdown separates the contents of markdown by the processor. So using this parser doesn't work because the parser doesn't know the whole markdown.
+
+[indent]: https://eslint.org/docs/rules/indent
+[eslint-plugin-markdown]: https://github.com/eslint/eslint-plugin-markdown
+
 ## :computer: Editor Integrations
 
 ### Visual Studio Code
@@ -167,11 +207,11 @@ See also [`@typescript-eslint/parser` readme](https://github.com/typescript-esli
 
 ## :hammer_and_wrench: Usage for Custom Rules / Plugins
 
+<!-- - [AST.md](./docs/AST.md) is AST specification. You can check it on the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). -->
+
 - TBA
 - You can check the AST in the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). However, AST is subject to major changes in the future.
-
-<!-- - [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. -->
+- I have already [implemented some rules] in the [eslint-plugin-astro]. The source code for these rules will be helpful to you.
 
 ## :beers: Contributing
 
@@ -191,3 +231,5 @@ See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
 
 [Astro]: https://astro.build/
 [ESLint]: https://eslint.org/
+[eslint-plugin-astro]: https://ota-meshi.github.io/eslint-plugin-astro/
+[implemented some rules]: https://ota-meshi.github.io/eslint-plugin-astro/rules/

package/lib/ast/astro.d.ts

@@ -2,7 +2,7 @@ import type { JSXAttribute, JSXElement, JSXExpression, JSXExpressionContainer, J
 import type { TSESTree as ES } from "@typescript-eslint/types";
 import type { BaseNode } from "./base";
 export declare type AstroNode = AstroProgram | AstroFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText;
-export declare type AstroChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment;
+export declare type AstroChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment | AstroRawText;
 export declare type AstroParentNode = JSXElement | JSXFragment | AstroFragment;
 /** Node of Astro program root */
 export interface AstroProgram extends Omit<ES.Program, "type" | "body"> {

package/lib/ast/jsx.d.ts

@@ -1,8 +1,8 @@
 import type { TSESTree as ES } from "@typescript-eslint/types";
-import type { AstroFragment, AstroHTMLComment, AstroShorthandAttribute, AstroTemplateLiteralAttribute } from "./astro";
+import type { AstroFragment, AstroHTMLComment, AstroRawText, AstroShorthandAttribute, AstroTemplateLiteralAttribute } from "./astro";
 import type { BaseNode } from "./base";
 export declare type JSXNode = JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText;
-export declare type JSXChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment;
+export declare type JSXChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment | AstroRawText;
 export declare type JSXParentNode = JSXElement | JSXFragment | AstroFragment;
 export interface JSXElement extends BaseNode {
     type: "JSXElement";

package/lib/context/script.d.ts

@@ -4,8 +4,10 @@ import type { ESLintExtendedProgram } from "../types";
 declare class RestoreNodeProcessContext {
     readonly result: ESLintExtendedProgram;
     readonly removeTokens: Set<(token: TSESTree.Token) => boolean>;
-    constructor(result: ESLintExtendedProgram);
+    private readonly parentMap;
+    constructor(result: ESLintExtendedProgram, parentMap: Map<TSESTree.Node, TSESTree.Node | null>);
     addRemoveToken(test: (token: TSESTree.Token) => boolean): void;
+    getParent(node: TSESTree.Node): TSESTree.Node | null;
 }
 export declare class ScriptContext {
     private readonly ctx;
@@ -16,11 +18,12 @@ export declare class ScriptContext {
     private readonly tokens;
     private readonly restoreNodeProcesses;
     constructor(ctx: Context);
+    get originalCode(): string;
     skipOriginalOffset(offset: number): void;
     appendOriginal(index: number): void;
     appendScript(fragment: string): void;
     addToken(type: TSESTree.Token["type"], range: TSESTree.Range): void;
-    addRestoreNodeProcess(process: (node: TSESTree.Node, context: RestoreNodeProcessContext, parent: TSESTree.Node) => boolean): void;
+    addRestoreNodeProcess(process: (node: TSESTree.Node, context: RestoreNodeProcessContext) => boolean): void;
     /**
      * Restore AST nodes
      */

package/lib/context/script.js

@@ -3,13 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScriptContext = void 0;
 const traverse_1 = require("../traverse");
 class RestoreNodeProcessContext {
-    constructor(result) {
+    constructor(result, parentMap) {
         this.removeTokens = new Set();
         this.result = result;
+        this.parentMap = parentMap;
     }
     addRemoveToken(test) {
         this.removeTokens.add(test);
     }
+    getParent(node) {
+        return this.parentMap.get(node) || null;
+    }
 }
 class ScriptContext {
     constructor(ctx) {
@@ -21,6 +25,9 @@ class ScriptContext {
         this.restoreNodeProcesses = [];
         this.ctx = ctx;
     }
+    get originalCode() {
+        return this.ctx.code;
+    }
     skipOriginalOffset(offset) {
         this.consumedIndex += offset;
     }
@@ -41,6 +48,9 @@ class ScriptContext {
         this.fragments.push({ start, end: this.script.length });
     }
     addToken(type, range) {
+        if (range[0] >= range[1]) {
+            return;
+        }
         this.tokens.push(this.ctx.buildToken(type, range));
     }
     addRestoreNodeProcess(process) {
@@ -76,12 +86,12 @@ class ScriptContext {
         for (const token of result.ast.comments || []) {
             this.remapLocation(token);
         }
-        const context = new RestoreNodeProcessContext(result);
+        const context = new RestoreNodeProcessContext(result, traversed);
         let restoreNodeProcesses = this.restoreNodeProcesses;
         for (const [node, parent] of traversed) {
             if (!parent)
                 continue;
-            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, context, parent));
+            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, context));
         }
         if (context.removeTokens.size) {
             const tokens = result.ast.tokens || [];

package/lib/index.d.ts

@@ -1,9 +1,13 @@
-import { parseForESLint } from "./parser";
+import { parseForESLint as parseAstro } from "./parser";
+import { parseForESLint as parseMarkdown } from "./markdown";
 import { parseTemplate, ParseTemplateResult } from "./astro-tools";
 import * as AST from "./ast";
 import { traverseNodes } from "./traverse";
 import { ParseError } from "./errors";
 export { AST, ParseError };
-export { parseForESLint };
+/**
+ * Parse source code
+ */
+export declare function parseForESLint(code: string, options?: any): ReturnType<typeof parseAstro | typeof parseMarkdown>;
 export declare const VisitorKeys: import("eslint").SourceCode.VisitorKeys;
 export { traverseNodes, parseTemplate, ParseTemplateResult };

package/lib/index.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTemplate = exports.traverseNodes = exports.VisitorKeys = exports.parseForESLint = exports.ParseError = exports.AST = void 0;
 const parser_1 = require("./parser");
-Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } });
+const markdown_1 = require("./markdown");
 const astro_tools_1 = require("./astro-tools");
 Object.defineProperty(exports, "parseTemplate", { enumerable: true, get: function () { return astro_tools_1.parseTemplate; } });
 const AST = __importStar(require("./ast"));
@@ -35,6 +35,18 @@ Object.defineProperty(exports, "traverseNodes", { enumerable: true, get: functio
 const visitor_keys_1 = require("./visitor-keys");
 const errors_1 = require("./errors");
 Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+/**
+ * Parse source code
+ */
+function parseForESLint(code, options) {
+    const syntax = options?.astroFeatures?.syntax ?? "auto";
+    if (syntax === "markdown" ||
+        (syntax === "auto" && options?.filePath?.endsWith(".md"))) {
+        return (0, markdown_1.parseForESLint)(code, options);
+    }
+    return (0, parser_1.parseForESLint)(code, options);
+}
+exports.parseForESLint = parseForESLint;
 // Keys
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ignore
 exports.VisitorKeys = visitor_keys_1.KEYS;

package/lib/markdown/frontmatter.d.ts

@@ -0,0 +1,9 @@
+export declare type MarkdownContent = {
+    range: [number, number];
+    value: string;
+};
+/** Parse frontmatter */
+export declare function parseFrontmatter(code: string): {
+    frontmatter: MarkdownContent | null;
+    content: MarkdownContent;
+};

package/lib/markdown/frontmatter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatter = void 0;
+/** Parse frontmatter */
+function parseFrontmatter(code) {
+    if (!code.startsWith("---") || code[3] === "-") {
+        return {
+            frontmatter: null,
+            content: {
+                range: [0, code.length],
+                value: code,
+            },
+        };
+    }
+    let closeIndex = code.indexOf("\n---", 3);
+    let contentOpenIndex = closeIndex + 4;
+    if (closeIndex === -1) {
+        closeIndex = code.length;
+        contentOpenIndex = code.length;
+    }
+    let openIndex = 3;
+    if (code[openIndex] === "\r") {
+        openIndex++;
+    }
+    if (code[openIndex] === "\n") {
+        openIndex++;
+    }
+    if (openIndex < closeIndex && code[closeIndex] === "\n") {
+        closeIndex--;
+    }
+    if (openIndex < closeIndex && code[closeIndex] === "\r") {
+        closeIndex++;
+    }
+    if (code[contentOpenIndex] === "\r") {
+        contentOpenIndex++;
+    }
+    if (code[contentOpenIndex] === "\n") {
+        contentOpenIndex++;
+    }
+    const frontmatter = code.slice(openIndex, closeIndex + 1);
+    const content = code.slice(contentOpenIndex);
+    return {
+        frontmatter: {
+            range: [openIndex, closeIndex + 1],
+            value: frontmatter,
+        },
+        content: {
+            range: [contentOpenIndex, code.length],
+            value: content,
+        },
+    };
+}
+exports.parseFrontmatter = parseFrontmatter;

package/lib/markdown/index.d.ts

@@ -0,0 +1,19 @@
+import type { ScopeManager } from "eslint-scope";
+import type { AstroProgram } from "../ast";
+import type { ParseResult } from "@astrojs/compiler/node";
+/**
+ * Parse source code
+ */
+export declare function parseForESLint(code: string, options?: any): {
+    ast: AstroProgram;
+    services: Record<string, any> & {
+        isAstro: true;
+        getAstroAst: () => ParseResult;
+        isAstroMarkdown: true;
+        getAstroMarkdownFrontmatter: () => any;
+    };
+    visitorKeys: {
+        [type: string]: string[];
+    };
+    scopeManager: ScopeManager;
+};

package/lib/markdown/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseForESLint = void 0;
+const context_1 = require("../context");
+const mdast_util_from_markdown_service_1 = require("./mdast-util-from-markdown-service");
+const frontmatter_1 = require("./frontmatter");
+const process_markdown_1 = require("./process-markdown");
+const parser_1 = require("../parser");
+const sort_1 = require("../parser/sort");
+const script_1 = require("../context/script");
+const yaml_1 = require("./yaml");
+/**
+ * Parse source code
+ */
+function parseForESLint(code, options) {
+    const { frontmatter, content } = (0, frontmatter_1.parseFrontmatter)(code);
+    const ctx = new context_1.Context(code);
+    const root = (0, mdast_util_from_markdown_service_1.parseMarkdown)(content.value);
+    const scriptContext = new script_1.ScriptContext(ctx);
+    let yamlResult;
+    if (frontmatter) {
+        scriptContext.appendOriginal(frontmatter.range[0]);
+        yamlResult = (0, yaml_1.parseYaml)(frontmatter);
+        if (yamlResult) {
+            scriptContext.skipOriginalOffset(yamlResult.setupValueRange[0] - frontmatter.range[0]);
+            scriptContext.appendOriginal(yamlResult.setupValueRange[1]);
+            scriptContext.skipOriginalOffset(frontmatter.range[1] - yamlResult.setupValueRange[1]);
+            scriptContext.addToken("YAMLToken", [
+                frontmatter.range[0],
+                yamlResult.before,
+            ]);
+            scriptContext.addToken("YAMLToken", [
+                yamlResult.after,
+                frontmatter.range[1],
+            ]);
+        }
+        else {
+            scriptContext.skipOriginalOffset(frontmatter.range[1] - frontmatter.range[0]);
+            scriptContext.addToken("YAMLToken", [
+                frontmatter.range[0],
+                frontmatter.range[1],
+            ]);
+        }
+    }
+    (0, process_markdown_1.processMarkdown)(scriptContext, root, content.range[0]);
+    scriptContext.appendOriginal(code.length);
+    const resultAstro = (0, parser_1.parseForESLint)(scriptContext.script, options);
+    scriptContext.restore(resultAstro);
+    (0, sort_1.sort)(resultAstro.ast.comments);
+    (0, sort_1.sort)(resultAstro.ast.tokens);
+    (0, parser_1.extractTokens)(resultAstro, ctx);
+    resultAstro.services = Object.assign(resultAstro.services || {}, {
+        isAstroMarkdown: true,
+        getAstroMarkdownFrontmatter() {
+            return yamlResult?.getYamlValue();
+        },
+    });
+    return resultAstro;
+}
+exports.parseForESLint = parseForESLint;

package/lib/markdown/mdast-util-from-markdown-service.d.ts

@@ -0,0 +1,5 @@
+import type * as mdast from "mdast";
+/**
+ * Parse code by `mdast-util-from-markdown`
+ */
+export declare function parseMarkdown(code: string): mdast.Root;

package/lib/markdown/mdast-util-from-markdown-service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = void 0;
+const synckit_1 = require("synckit");
+const parseSync = (0, synckit_1.createSyncFn)(require.resolve("./mdast-util-from-markdown-worker"));
+/**
+ * Parse code by `mdast-util-from-markdown`
+ */
+function parseMarkdown(code) {
+    return parseSync(code);
+}
+exports.parseMarkdown = parseMarkdown;

package/lib/markdown/mdast-util-from-markdown-worker.d.ts

@@ -0,0 +1,2 @@
+import type * as mdast from "mdast";
+export declare type ParseSyncFunction = (source: string) => mdast.Root;

package/lib/markdown/mdast-util-from-markdown-worker.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const synckit_1 = require("synckit");
+const dynamicImport = new Function("m", "return import(m)");
+(0, synckit_1.runAsWorker)(async (source) => {
+    const { fromMarkdown } = await dynamicImport("mdast-util-from-markdown");
+    return fromMarkdown(source);
+});

package/lib/markdown/process-markdown.d.ts

@@ -0,0 +1,6 @@
+import type * as mdast from "mdast";
+import type { ScriptContext } from "../context/script";
+/**
+ * Process the markdown ast to generate a ScriptContext.
+ */
+export declare function processMarkdown(script: ScriptContext, root: mdast.Root, offset: number): void;

package/lib/markdown/process-markdown.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMarkdown = void 0;
+const types_1 = require("@typescript-eslint/types");
+/**
+ * Process the markdown ast to generate a ScriptContext.
+ */
+function processMarkdown(script, root, offset) {
+    walk(root, (node) => {
+        const start = node.position.start.offset + offset;
+        const end = node.position.end.offset + offset;
+        script.appendOriginal(start);
+        if (node.type === "code" || node.type === "inlineCode") {
+            script.appendScript(`<></>`);
+            script.skipOriginalOffset(end - start);
+            script.addRestoreNodeProcess((scriptNode, context) => {
+                if (scriptNode.range[0] === start &&
+                    scriptNode.type === types_1.AST_NODE_TYPES.JSXFragment) {
+                    delete scriptNode.openingFragment;
+                    delete scriptNode.closingFragment;
+                    delete scriptNode.expression;
+                    delete scriptNode.children;
+                    const text = script.originalCode.slice(start, end);
+                    const mdNode = scriptNode;
+                    mdNode.type = "AstroRawText";
+                    mdNode.value = text;
+                    mdNode.raw = text;
+                    let parent = context.getParent(scriptNode);
+                    while (parent) {
+                        let update = false;
+                        if (parent.range[0] > scriptNode.range[0]) {
+                            parent.range[0] = scriptNode.range[0];
+                            parent.loc.start = {
+                                line: scriptNode.loc.start.line,
+                                column: scriptNode.loc.start.column,
+                            };
+                            update = true;
+                        }
+                        if (parent.range[1] < scriptNode.range[1]) {
+                            parent.range[1] = scriptNode.range[1];
+                            parent.loc.end = {
+                                line: scriptNode.loc.end.line,
+                                column: scriptNode.loc.end.column,
+                            };
+                            update = true;
+                        }
+                        if (!update) {
+                            break;
+                        }
+                        parent = context.getParent(parent);
+                    }
+                    return true;
+                }
+                return false;
+            });
+            script.addToken(types_1.AST_TOKEN_TYPES.JSXText, [start, end]);
+        }
+    }, (node) => {
+        // const start = node.position!.start.offset! + offset
+        const end = node.position.end.offset + offset;
+        script.appendOriginal(end);
+    });
+    script.addRestoreNodeProcess((scriptNode) => {
+        if (scriptNode.type === "JSXText") {
+            const rawNode = scriptNode;
+            rawNode.type = "AstroRawText";
+        }
+        return false;
+    });
+}
+exports.processMarkdown = processMarkdown;
+/** walk nodes */
+function walk(parent, enter, leave, parents = []) {
+    const currParents = [parent, ...parents];
+    if ("children" in parent) {
+        for (const node of parent.children) {
+            enter(node, currParents);
+            walk(node, enter, leave, currParents);
+            leave(node, currParents);
+        }
+    }
+}

package/lib/markdown/yaml.d.ts

@@ -0,0 +1,9 @@
+import type { MarkdownContent } from "./frontmatter";
+export declare type FrontmatterYAMLResult = {
+    before: number;
+    setupValueRange: [number, number];
+    after: number;
+    getYamlValue: () => any;
+};
+/** Parse for yaml */
+export declare function parseYaml(frontmatter: MarkdownContent): FrontmatterYAMLResult | null;

package/lib/markdown/yaml.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = void 0;
+const yaml_1 = require("yaml");
+/** Parse for yaml */
+function parseYaml(frontmatter) {
+    const doc = (0, yaml_1.parseDocument)(frontmatter.value, { keepSourceTokens: true });
+    const range = getSetupRange(doc);
+    if (!range) {
+        return null;
+    }
+    let before = range[0];
+    let after = range[1];
+    while (isSpace(frontmatter.value[before - 1])) {
+        before--;
+    }
+    while (isSpace(frontmatter.value[after])) {
+        after++;
+    }
+    return {
+        before: before + frontmatter.range[0],
+        setupValueRange: [
+            range[0] + frontmatter.range[0],
+            range[1] + frontmatter.range[0],
+        ],
+        after: after + frontmatter.range[0],
+        getYamlValue: () => doc.toJS(),
+    };
+}
+exports.parseYaml = parseYaml;
+/**  Checks whether the given char is spaces, or not */
+function isSpace(c) {
+    return c && !c.trim();
+}
+/** Get setup range */
+function getSetupRange(ast) {
+    if (!ast.contents) {
+        return null;
+    }
+    if (!(0, yaml_1.isMap)(ast.contents)) {
+        return null;
+    }
+    for (const item of ast.contents.items) {
+        if (!(0, yaml_1.isScalar)(item.key) || !(0, yaml_1.isScalar)(item.value)) {
+            continue;
+        }
+        if (item.key.value !== "setup") {
+            continue;
+        }
+        if (item.value.type === "PLAIN") {
+            return [item.value.range[0], item.value.range[1]];
+        }
+        if (item.value.type === "QUOTE_DOUBLE" ||
+            item.value.type === "QUOTE_SINGLE") {
+            return [item.value.range[0] + 1, item.value.range[1] - 1];
+        }
+        if (item.value.type === "BLOCK_FOLDED" ||
+            item.value.type === "BLOCK_LITERAL") {
+            const cst = item.value.srcToken;
+            let blockStart = cst.offset;
+            for (const token of cst.props) {
+                if (isCommentOrSpace(token) ||
+                    token.type === "block-scalar-header") {
+                    blockStart = token.offset + token.source.length;
+                    continue;
+                }
+                /* istanbul ignore next */
+                throw new Error(`Unknown token:${token.type}`);
+            }
+            return [blockStart, item.value.range[1]];
+        }
+        break;
+    }
+    return null;
+}
+/**
+ * Checks whether the given cst is comments, spaces, or not
+ */
+function isCommentOrSpace(node) {
+    if (node.type === "space" ||
+        node.type === "newline" ||
+        node.type === "comment") {
+        return true;
+    }
+    return false;
+}

package/lib/parser/astro-parser/parse.js

@@ -52,38 +52,44 @@ function adjustHTML(ast, htmlElement, ctx) {
     if (htmlEnd == null) {
         return;
     }
+    const hasTokenAfter = Boolean(ctx.code.slice(htmlEnd + 7).trim());
     const children = [...htmlElement.children];
     for (const child of children) {
         const offset = child.position?.start.offset;
-        if (offset != null) {
+        if (hasTokenAfter && offset != null) {
             if (htmlEnd <= offset) {
                 htmlElement.children.splice(htmlElement.children.indexOf(child), 1);
                 ast.children.push(child);
             }
         }
         if (child.type === "element" && child.name === "body") {
-            adjustHTMLBody(ast, htmlElement, htmlEnd, child, ctx);
+            adjustHTMLBody(ast, htmlElement, htmlEnd, hasTokenAfter, child, ctx);
         }
     }
 }
 /**
  * Adjust <body> element node
  */
-function adjustHTMLBody(ast, htmlElement, htmlEnd, bodyElement, ctx) {
+function adjustHTMLBody(ast, htmlElement, htmlEnd, hasTokenAfterHtmlEnd, bodyElement, ctx) {
     const bodyEnd = ctx.code.indexOf("</body");
     if (bodyEnd == null) {
         return;
     }
+    const hasTokenAfter = Boolean(ctx.code.slice(bodyEnd + 7, htmlEnd).trim());
+    if (!hasTokenAfter && !hasTokenAfterHtmlEnd) {
+        return;
+    }
     const children = [...bodyElement.children];
     for (const child of children) {
         const offset = child.position?.start.offset;
         if (offset != null) {
             if (bodyEnd <= offset) {
-                bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
-                if (htmlEnd <= offset) {
+                if (hasTokenAfterHtmlEnd && htmlEnd <= offset) {
+                    bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
                     ast.children.push(child);
                 }
-                else {
+                else if (hasTokenAfter) {
+                    bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
                     htmlElement.children.push(child);
                 }
             }

package/lib/parser/index.d.ts

@@ -1,6 +1,8 @@
+import type { Context } from "../context";
 import type { AstroProgram } from "../ast";
 import type { ScopeManager } from "eslint-scope";
 import type { ParseResult } from "@astrojs/compiler";
+import type { ESLintExtendedProgram } from "../types";
 /**
  * Parse source code
  */
@@ -15,3 +17,5 @@ export declare function parseForESLint(code: string, options?: any): {
     };
     scopeManager: ScopeManager;
 };
+/** Extract tokens */
+export declare function extractTokens(ast: ESLintExtendedProgram, ctx: Context): void;

package/lib/parser/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseForESLint = void 0;
+exports.extractTokens = exports.parseForESLint = void 0;
 const visitor_keys_1 = require("../visitor-keys");
 const types_1 = require("@typescript-eslint/types");
 const script_1 = require("./script");
@@ -69,3 +69,4 @@ function extractTokens(ast, ctx) {
         return /^[^\w$]$/iu.test(c);
     }
 }
+exports.extractTokens = extractTokens;

package/lib/parser/process-template.js

@@ -328,7 +328,8 @@ function processTemplate(ctx, resultTemplate) {
                     const offset = (0, astro_1.calcContentEndOffset)(node, ctx);
                     script.appendOriginal(offset);
                     script.appendScript(`</${node.name}>`);
-                    script.addRestoreNodeProcess((scriptNode, _result, parent) => {
+                    script.addRestoreNodeProcess((scriptNode, context) => {
+                        const parent = context.getParent(scriptNode);
                         if (scriptNode.range[0] === offset &&
                             scriptNode.type ===
                                 types_1.AST_NODE_TYPES.JSXClosingElement &&

package/lib/parser/ts-patch.js

@@ -11,6 +11,13 @@ const fs_1 = __importDefault(require("fs"));
  * Apply a patch to parse .astro files as TSX.
  */
 function tsPatch(scriptParserOptions) {
+    let targetExt = ".astro";
+    if (scriptParserOptions.filePath) {
+        const ext = path_1.default.extname(scriptParserOptions.filePath);
+        if (ext) {
+            targetExt = ext;
+        }
+    }
     try {
         // Apply a patch to parse .astro files as TSX.
         const cwd = process.cwd();
@@ -20,13 +27,13 @@ function tsPatch(scriptParserOptions) {
         if (typeof ensureScriptKind === "function" &&
             typeof getScriptKindFromFileName === "function") {
             ts.ensureScriptKind = function (fileName, ...args) {
-                if (fileName.endsWith(".astro")) {
+                if (fileName.endsWith(targetExt)) {
                     return ts.ScriptKind.TSX;
                 }
                 return ensureScriptKind.call(this, fileName, ...args);
             };
             ts.getScriptKindFromFileName = function (fileName, ...args) {
-                if (fileName.endsWith(".astro")) {
+                if (fileName.endsWith(targetExt)) {
                     return ts.ScriptKind.TSX;
                 }
                 return getScriptKindFromFileName.call(this, fileName, ...args);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "astro-eslint-parser",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "description": "Astro component parser for ESLint",
     "main": "lib/index.js",
     "files": [
@@ -42,12 +42,14 @@
     },
     "homepage": "https://github.com/ota-meshi/astro-eslint-parser#readme",
     "dependencies": {
-        "@astrojs/compiler": "^0.15.0",
+        "@astrojs/compiler": "^0.16.1",
         "@typescript-eslint/types": "^5.25.0",
         "debug": "^4.3.4",
         "eslint-visitor-keys": "^3.0.0",
         "espree": "^9.0.0",
-        "synckit": "^0.7.1"
+        "mdast-util-from-markdown": "^1.2.0",
+        "synckit": "^0.7.1",
+        "yaml": "^2.1.1"
     },
     "devDependencies": {
         "@ota-meshi/eslint-plugin": "^0.10.0",
@@ -70,10 +72,11 @@
         "eslint": "^8.15.0",
         "eslint-config-prettier": "^8.3.0",
         "eslint-formatter-codeframe": "^7.32.1",
-        "eslint-plugin-astro": "^0.2.0",
+        "eslint-plugin-astro": "^0.12.0",
         "eslint-plugin-eslint-comments": "^3.2.0",
         "eslint-plugin-json-schema-validator": "^3.0.0",
         "eslint-plugin-jsonc": "^2.0.0",
+        "eslint-plugin-jsx-a11y": "^6.5.1",
         "eslint-plugin-node": "^11.1.0",
         "eslint-plugin-node-dependencies": "^0.8.0",
         "eslint-plugin-prettier": "^4.0.0",