astro-eslint-parser 0.0.12 → 0.0.13

package/lib/ast.d.ts

@@ -1,5 +1,5 @@
 import type { TSESTree } from "@typescript-eslint/types";
-export declare type AstroNode = AstroProgram | AstroRootFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText;
+export declare type AstroNode = AstroProgram | AstroRootFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText | AstroFragment;
 /** Node of Astro program root */
 export interface AstroProgram extends Omit<TSESTree.Program, "type" | "body"> {
     type: "Program";
@@ -45,3 +45,9 @@ export interface AstroRawText extends Omit<TSESTree.JSXText, "type" | "parent">
     type: "AstroRawText";
     parent: AstroRootFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
 }
+/** Node of Astro fragment expression */
+export interface AstroFragment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
+    type: "AstroFragment";
+    children: TSESTree.JSXFragment["children"];
+    parent: TSESTree.JSXFragment["parent"];
+}

package/lib/astro/index.d.ts

@@ -1,4 +1,4 @@
-import type { AttributeNode, CommentNode, Node, ParentNode, TagLikeNode } from "@astrojs/compiler/types";
+import type { AttributeNode, CommentNode, ExpressionNode, Node, ParentNode, TagLikeNode } from "@astrojs/compiler/types";
 import type { Context } from "../context";
 /**
  * Checks if the given node is TagLikeNode
@@ -9,13 +9,21 @@ export declare function isTag(node: Node): node is Node & TagLikeNode;
  */
 export declare function isParent(node: Node): node is ParentNode;
 /** walk element nodes */
-export declare function walkElements(parent: ParentNode, code: string, cb: (n: Node, parent: ParentNode) => void): void;
+export declare function walkElements(parent: ParentNode, code: string, cb: (n: Node, parents: ParentNode[]) => void, parents?: ParentNode[]): void;
 /** walk nodes */
-export declare function walk(parent: ParentNode, code: string, enter: (n: Node | AttributeNode, parent: ParentNode) => void, leave?: (n: Node | AttributeNode, parent: ParentNode) => void): void;
+export declare function walk(parent: ParentNode, code: string, enter: (n: Node | AttributeNode, parents: ParentNode[]) => void, leave?: (n: Node | AttributeNode, parents: ParentNode[]) => void, parents?: ParentNode[]): void;
 /**
  * Get end offset of start tag
  */
 export declare function getStartTagEndOffset(node: TagLikeNode, ctx: Context): number;
+/**
+ * Get end offset of tag
+ */
+export declare function getTagEndOffset(node: TagLikeNode, parents: ParentNode[], ctx: Context): number;
+/**
+ * Get end offset of Expression
+ */
+export declare function getExpressionEndOffset(node: ExpressionNode, parents: ParentNode[], ctx: Context): number;
 /**
  * Get end offset of attribute
  */
@@ -28,6 +36,13 @@ export declare function getAttributeValueStartOffset(node: AttributeNode, ctx: C
  * Get end offset of comment
  */
 export declare function getCommentEndOffset(node: CommentNode, ctx: Context): number;
+/**
+ * If the given tag is a void tag, get the self-closing tag.
+ */
+export declare function getSelfClosingTag(node: TagLikeNode, parents: ParentNode[], ctx: Context): null | {
+    offset: number;
+    end: "/>" | ">";
+};
 /**
  * Skip spaces
  */

package/lib/astro/index.js

@@ -1,6 +1,6 @@
 "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;
+exports.skipSpaces = exports.getSelfClosingTag = exports.getCommentEndOffset = exports.getAttributeValueStartOffset = exports.getAttributeEndOffset = exports.getExpressionEndOffset = exports.getTagEndOffset = exports.getStartTagEndOffset = exports.walk = exports.walkElements = exports.isParent = exports.isTag = void 0;
 const errors_1 = require("../errors");
 /**
  * Checks if the given node is TagLikeNode
@@ -20,31 +20,34 @@ function isParent(node) {
 }
 exports.isParent = isParent;
 /** walk element nodes */
-function walkElements(parent, code, cb) {
+function walkElements(parent, code, cb, parents = []) {
     const children = getSortedChildren(parent, code);
+    const currParents = [parent, ...parents];
     for (const node of children) {
-        cb(node, parent);
+        cb(node, currParents);
         if (isParent(node)) {
-            walkElements(node, code, cb);
+            walkElements(node, code, cb, currParents);
         }
     }
 }
 exports.walkElements = walkElements;
 /** walk nodes */
-function walk(parent, code, enter, leave) {
+function walk(parent, code, enter, leave, parents = []) {
     const children = getSortedChildren(parent, code);
+    const currParents = [parent, ...parents];
     for (const node of children) {
-        enter(node, parent);
+        enter(node, currParents);
         if (isTag(node)) {
+            const attrParents = [node, ...currParents];
             for (const attr of node.attributes) {
-                enter(attr, node);
-                leave === null || leave === void 0 ? void 0 : leave(attr, node);
+                enter(attr, attrParents);
+                leave === null || leave === void 0 ? void 0 : leave(attr, attrParents);
             }
         }
         if (isParent(node)) {
-            walk(node, code, enter, leave);
+            walk(node, code, enter, leave, currParents);
         }
-        leave === null || leave === void 0 ? void 0 : leave(node, parent);
+        leave === null || leave === void 0 ? void 0 : leave(node, currParents);
     }
 }
 exports.walk = walk;
@@ -65,6 +68,80 @@ function getStartTagEndOffset(node, ctx) {
     return info.index + info.match.length;
 }
 exports.getStartTagEndOffset = getStartTagEndOffset;
+/**
+ * Get end offset of tag
+ */
+function getTagEndOffset(node, parents, ctx) {
+    var _a;
+    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
+        return node.position.end.offset;
+    }
+    if (node.children.length) {
+        const code = ctx.code;
+        let nextElementIndex = code.length;
+        const parent = parents[0];
+        const childIndex = parent.children.indexOf(node);
+        if (childIndex === parent.children.length - 1) {
+            // last
+            if (isTag(parent)) {
+                nextElementIndex = getTagEndOffset(parent, parents.slice(1), ctx);
+                nextElementIndex = code.lastIndexOf("</", nextElementIndex);
+            }
+            else if (parent.type === "expression") {
+                nextElementIndex = getExpressionEndOffset(parent, parents.slice(1), ctx);
+                nextElementIndex = code.lastIndexOf("}", nextElementIndex);
+            }
+        }
+        else {
+            const next = parent.children[childIndex + 1];
+            nextElementIndex = next.position.start.offset;
+        }
+        return code.lastIndexOf(">", nextElementIndex);
+    }
+    let beforeIndex = getStartTagEndOffset(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 ctx.code.length;
+}
+exports.getTagEndOffset = getTagEndOffset;
+/**
+ * Get end offset of Expression
+ */
+function getExpressionEndOffset(node, parents, ctx) {
+    var _a;
+    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
+        return node.position.end.offset;
+    }
+    if (node.children.length) {
+        const code = ctx.code;
+        let nextElementIndex = code.length;
+        const parent = parents[0];
+        const childIndex = parent.children.indexOf(node);
+        if (childIndex === parent.children.length - 1) {
+            // last
+            if (isTag(parent)) {
+                nextElementIndex = getTagEndOffset(parent, parents.slice(1), ctx);
+                nextElementIndex = code.lastIndexOf("</", nextElementIndex);
+            }
+            else if (parent.type === "expression") {
+                nextElementIndex = getExpressionEndOffset(parent, parents.slice(1), ctx);
+                nextElementIndex = code.lastIndexOf("}", nextElementIndex);
+            }
+        }
+        else {
+            const next = parent.children[childIndex + 1];
+            nextElementIndex = next.position.start.offset;
+        }
+        return code.lastIndexOf("}", nextElementIndex);
+    }
+    const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
+    return info.index + info.match.length;
+}
+exports.getExpressionEndOffset = getExpressionEndOffset;
 /**
  * Get end offset of attribute
  */
@@ -122,6 +199,44 @@ function getCommentEndOffset(node, ctx) {
     return info.index + info.match.length;
 }
 exports.getCommentEndOffset = getCommentEndOffset;
+/**
+ * If the given tag is a void tag, get the self-closing tag.
+ */
+function getSelfClosingTag(node, parents, ctx) {
+    const children = node.children.filter((c) => c.type !== "text" || c.value.trim());
+    if (children.length > 0) {
+        return null;
+    }
+    const parent = parents[0];
+    const code = ctx.code;
+    let nextElementIndex = code.length;
+    const childIndex = parent.children.indexOf(node);
+    if (childIndex === parent.children.length - 1) {
+        // last
+        if (isTag(parent)) {
+            nextElementIndex = getTagEndOffset(parent, parents.slice(1), ctx);
+            nextElementIndex = code.lastIndexOf("</", nextElementIndex);
+        }
+        else if (parent.type === "expression") {
+            nextElementIndex = getExpressionEndOffset(parent, parents.slice(1), ctx);
+            nextElementIndex = code.lastIndexOf("}", nextElementIndex);
+        }
+    }
+    else {
+        const next = parent.children[childIndex + 1];
+        nextElementIndex = next.position.start.offset;
+    }
+    const endOffset = getStartTagEndOffset(node, ctx);
+    if (code.slice(endOffset, nextElementIndex).trim()) {
+        // has end tag
+        return null;
+    }
+    return {
+        offset: endOffset,
+        end: code.slice(endOffset - 2, endOffset) === "/>" ? "/>" : ">",
+    };
+}
+exports.getSelfClosingTag = getSelfClosingTag;
 /**
  * Get token info
  */

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

@@ -50,6 +50,7 @@ function parseByService(code) {
         return { ast };
     }
     catch (_a) {
+        // FIXME: Workaround for escape bugs
         // Adjust because may get the wrong escape as JSON.
         const ast = JSON.parse(jsonAst.replace(/\\./gu, (m) => {
             try {
@@ -119,7 +120,7 @@ function fixLocations(node, ctx) {
     let start = 0;
     (0, astro_1.walk)(node, ctx.code, 
     // eslint-disable-next-line complexity -- X(
-    (node, parent) => {
+    (node, [parent]) => {
         if (node.type === "frontmatter") {
             start = node.position.start.offset = tokenIndex(ctx, "---", start);
             start = node.position.end.offset =
@@ -155,7 +156,7 @@ function fixLocations(node, ctx) {
                 if (start < 0) {
                     start = ctx.code.length;
                 }
-                // Workaround for escape bugs
+                // FIXME: Workaround for escape bugs
                 node.value = ctx.code.slice(node.position.start.offset, start);
             }
             else {
@@ -165,24 +166,25 @@ function fixLocations(node, ctx) {
                     start += node.value.length;
                 }
                 else {
-                    // Workaround for escape bugs
+                    // FIXME: Workaround for escape bugs
                     node.position.start.offset = start;
-                    for (const token of node.value.split(/\s+/u)) {
-                        const index = tokenIndexSafe(ctx.code, token, start);
+                    const value = node.value.replace(/\s+/gu, "");
+                    for (let charIndex = 0; charIndex < value.length; charIndex++) {
+                        const char = value[charIndex];
+                        const index = tokenIndexSafe(ctx.code, char, start);
                         if (index != null) {
-                            start = index + token.length;
+                            start = index + 1;
                             continue;
                         }
                         start = (0, astro_1.skipSpaces)(ctx.code, start);
-                        let t = token;
                         if (ctx.code.startsWith("\\", start)) {
-                            const char = JSON.parse(`"\\${ctx.code[start + 1]}"`);
-                            if (char.trim()) {
-                                t = t.slice(1);
-                            }
+                            const codeChar = JSON.parse(`"\\${ctx.code[start + 1]}"`);
                             start += 2;
+                            if (codeChar === char) {
+                                continue;
+                            }
                         }
-                        start = tokenIndex(ctx, t, start) + t.length;
+                        start = tokenIndex(ctx, char, start) + 1;
                     }
                     start = (0, astro_1.skipSpaces)(ctx.code, start);
                     node.value = ctx.code.slice(node.position.start.offset, start);
@@ -208,7 +210,7 @@ function fixLocations(node, ctx) {
         else if (node.type === "root") {
             // noop
         }
-    }, (node, parent) => {
+    }, (node, [parent]) => {
         if (node.type === "attribute") {
             const attributes = parent.attributes;
             if (attributes[attributes.length - 1] === node) {

package/lib/parser/process-template.js

@@ -18,7 +18,36 @@ function processTemplate(ctx, resultTemplate) {
         fragmentOpened = true;
     }
     // eslint-disable-next-line complexity -- X(
-    (0, astro_1.walkElements)(resultTemplate.ast, ctx.code, (node, parent) => {
+    (0, astro_1.walkElements)(resultTemplate.ast, ctx.code, (node, parents) => {
+        const parent = parents[0];
+        if ((0, astro_1.isTag)(node) && parent.type === "expression") {
+            const index = parent.children.indexOf(node);
+            const before = parent.children[index - 1];
+            if (!before || !(0, astro_1.isTag)(before)) {
+                const after = parent.children[index + 1];
+                if (after && ((0, astro_1.isTag)(after) || after.type === "comment")) {
+                    const start = node.position.start.offset;
+                    script.appendOriginal(start);
+                    script.appendScript("<>");
+                    script.addRestoreNodeProcess((scriptNode) => {
+                        if (scriptNode.range[0] === start &&
+                            scriptNode.type === types_1.AST_NODE_TYPES.JSXFragment) {
+                            delete scriptNode.openingFragment;
+                            delete scriptNode.closingFragment;
+                            const fragmentNode = scriptNode;
+                            fragmentNode.type = "AstroFragment";
+                            const last = fragmentNode.children[fragmentNode.children.length - 1];
+                            if (fragmentNode.range[1] < last.range[1]) {
+                                fragmentNode.range[1] = last.range[1];
+                                fragmentNode.loc.end = ctx.getLocFromIndex(fragmentNode.range[1]);
+                            }
+                            return true;
+                        }
+                        return false;
+                    });
+                }
+            }
+        }
         if (node.type === "frontmatter") {
             const start = node.position.start.offset;
             script.appendOriginal(start);
@@ -140,7 +169,7 @@ function processTemplate(ctx, resultTemplate) {
                     });
                 }
             }
-            const end = getVoidSelfClosingTag(node, parent, ctx);
+            const end = (0, astro_1.getSelfClosingTag)(node, parents, ctx);
             if (end && end.end === ">") {
                 script.appendOriginal(end.offset - 1);
                 script.appendScript("/");
@@ -176,15 +205,17 @@ function processTemplate(ctx, resultTemplate) {
             script.appendOriginal(start);
             let targetType;
             if (fragmentOpened) {
-                script.appendScript(`<></>`);
+                script.appendOriginal(start + 1);
+                script.appendScript(`></`);
+                script.skipOriginalOffset(length - 2);
                 targetType = types_1.AST_NODE_TYPES.JSXFragment;
             }
             else {
                 script.appendScript(`0;`);
                 targetType = types_1.AST_NODE_TYPES.ExpressionStatement;
+                script.skipOriginalOffset(length);
             }
-            script.skipOriginalOffset(length);
-            script.addRestoreNodeProcess((scriptNode) => {
+            script.addRestoreNodeProcess((scriptNode, result) => {
                 if (scriptNode.range[0] === start &&
                     scriptNode.type === targetType) {
                     delete scriptNode.children;
@@ -194,6 +225,27 @@ function processTemplate(ctx, resultTemplate) {
                     const commentNode = scriptNode;
                     commentNode.type = "AstroHTMLComment";
                     commentNode.value = node.value;
+                    if (fragmentOpened) {
+                        const removeTokenSet = new Set([
+                            (token) => token.value === "<" &&
+                                token.range[0] === scriptNode.range[0],
+                            (token) => token.value === ">" &&
+                                token.range[1] === scriptNode.range[1],
+                        ]);
+                        const tokens = result.ast.tokens || [];
+                        for (let index = tokens.length - 1; index >= 0; index--) {
+                            const token = tokens[index];
+                            for (const rt of removeTokenSet) {
+                                if (rt(token)) {
+                                    tokens.splice(index, 1);
+                                    removeTokenSet.delete(rt);
+                                    if (!removeTokenSet.size) {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
                     return true;
                 }
                 return false;
@@ -232,6 +284,21 @@ function processTemplate(ctx, resultTemplate) {
             });
             script.addToken("HTMLDocType", [start, end]);
         }
+        if (((0, astro_1.isTag)(node) || node.type === "comment") &&
+            parent.type === "expression") {
+            const index = parent.children.indexOf(node);
+            const after = parent.children[index + 1];
+            if (!after || (!(0, astro_1.isTag)(after) && after.type !== "comment")) {
+                const before = parent.children[index - 1];
+                if (before && ((0, astro_1.isTag)(before) || before.type === "comment")) {
+                    const end = (0, astro_1.isTag)(node)
+                        ? (0, astro_1.getTagEndOffset)(node, parents, ctx)
+                        : (0, astro_1.getCommentEndOffset)(node, ctx);
+                    script.appendOriginal(end);
+                    script.appendScript("</>");
+                }
+            }
+        }
     });
     script.appendOriginal(ctx.code.length);
     script.appendScript("</>");
@@ -249,36 +316,3 @@ function processTemplate(ctx, resultTemplate) {
     }
 }
 exports.processTemplate = processTemplate;
-/**
- * If the given tag is a void tag, get the self-closing tag.
- */
-function getVoidSelfClosingTag(node, parent, ctx) {
-    var _a;
-    const children = node.children.filter((c) => c.type !== "text" || c.value.trim());
-    if (children.length > 0) {
-        return false;
-    }
-    const code = ctx.code;
-    let nextElementIndex = code.length;
-    const childIndex = parent.children.indexOf(node);
-    if (childIndex === parent.children.length - 1) {
-        // last
-        if ((_a = parent.position) === null || _a === void 0 ? void 0 : _a.end) {
-            nextElementIndex = parent.position.end.offset;
-            nextElementIndex = code.lastIndexOf("</", nextElementIndex);
-        }
-    }
-    else {
-        const next = parent.children[childIndex + 1];
-        nextElementIndex = next.position.start.offset;
-    }
-    const endOffset = (0, astro_1.getStartTagEndOffset)(node, ctx);
-    if (code.slice(endOffset, nextElementIndex).trim()) {
-        // has end tag
-        return null;
-    }
-    return {
-        offset: endOffset,
-        end: code.slice(endOffset - 2, endOffset) === "/>" ? "/>" : ">",
-    };
-}

package/lib/visitor-keys.js

@@ -10,5 +10,6 @@ const astroKeys = {
     AstroShorthandAttribute: ["name", "value"],
     AstroTemplateLiteralAttribute: ["name", "value"],
     AstroRawText: [],
+    AstroFragment: ["children"],
 };
 exports.KEYS = (0, eslint_visitor_keys_1.unionWith)(astroKeys);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "astro-eslint-parser",
-    "version": "0.0.12",
+    "version": "0.0.13",
     "description": "Astro parser for ESLint",
     "main": "lib/index.js",
     "files": [