astro-eslint-parser 0.0.0

package/lib/parser/index.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = exports.parseForESLint = void 0;
+const visitor_keys_1 = require("../visitor-keys");
+const context_1 = require("../context");
+const types_1 = require("@typescript-eslint/types");
+const script_1 = require("./script");
+const sort_1 = require("./sort");
+const errors_1 = require("../errors");
+const parse_1 = require("./astro-parser/parse");
+const script_2 = require("../context/script");
+/**
+ * Parse source code
+ */
+function parseForESLint(code, options) {
+    const parserOptions = Object.assign({ ecmaVersion: 2020, sourceType: "module", loc: true, range: true, raw: true, tokens: true, comment: true, eslintVisitorKeys: true, eslintScopeManager: true }, (options || {}));
+    parserOptions.ecmaFeatures = Object.assign(Object.assign({}, (parserOptions.ecmaFeatures || {})), { jsx: true });
+    parserOptions.sourceType = "module";
+    if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
+        parserOptions.ecmaVersion = 2015;
+    }
+    const ctx = new context_1.Context(code, parserOptions);
+    const resultTemplate = parseTemplate(ctx.code, ctx);
+    const scriptContext = (0, script_2.processTemplate)(ctx, resultTemplate);
+    const resultScript = (0, script_1.parseScript)(scriptContext.script, ctx);
+    scriptContext.restore(resultScript);
+    (0, sort_1.sort)(resultScript.ast.comments);
+    (0, sort_1.sort)(resultScript.ast.tokens);
+    extractTokens(resultScript, ctx);
+    resultScript.services = Object.assign(resultScript.services || {}, {
+        isAstro: true,
+        getAstroAst() {
+            return resultTemplate.ast;
+        },
+    });
+    resultScript.visitorKeys = Object.assign({}, visitor_keys_1.KEYS, resultScript.visitorKeys);
+    ctx.remapCR(resultScript);
+    return resultScript;
+}
+exports.parseForESLint = parseForESLint;
+/** Extract tokens */
+function extractTokens(ast, ctx) {
+    if (!ast.ast.tokens) {
+        return;
+    }
+    const useRanges = (0, sort_1.sort)([
+        ...ast.ast.tokens,
+        ...(ast.ast.comments || []),
+    ]).map((t) => t.range);
+    let range = useRanges.shift();
+    for (let index = 0; index < ctx.code.length; index++) {
+        while (range && range[1] <= index) {
+            range = useRanges.shift();
+        }
+        if (range && range[0] <= index) {
+            index = range[1] - 1;
+            continue;
+        }
+        const c = ctx.code[index];
+        if (!c.trim()) {
+            continue;
+        }
+        if (isPunctuator(c)) {
+            ast.ast.tokens.push(ctx.buildToken(types_1.AST_TOKEN_TYPES.Punctuator, [index, index + 1]));
+        }
+        else {
+            // unknown
+            // It is may be a bug.
+            ast.ast.tokens.push(ctx.buildToken(types_1.AST_TOKEN_TYPES.Identifier, [index, index + 1]));
+        }
+    }
+    (0, sort_1.sort)(ast.ast.tokens);
+    /**
+     * Checks if the given char is punctuator
+     */
+    function isPunctuator(c) {
+        return /^[^\w$]$/iu.test(c);
+    }
+}
+/**
+ * Parse for template
+ */
+function parseTemplate(code, ctx) {
+    try {
+        return (0, parse_1.parse)(code);
+    }
+    catch (e) {
+        if (typeof e.pos === "number") {
+            const err = new errors_1.ParseError(e.message, e.pos, ctx);
+            err.astroCompilerError = e;
+            throw err;
+        }
+        throw e;
+    }
+}
+exports.parseTemplate = parseTemplate;

package/lib/parser/resolve-parser.d.ts

@@ -0,0 +1,16 @@
+import type { ESLintExtendedProgram } from ".";
+/**
+ * The interface of a result of ESLint custom parser.
+ */
+export declare type ESLintCustomParserResult = ESLintExtendedProgram["ast"] | ESLintExtendedProgram;
+/**
+ * The interface of ESLint custom parsers.
+ */
+export interface ESLintCustomParser {
+    parse(code: string, options: any): ESLintCustomParserResult;
+    parseForESLint?(code: string, options: any): ESLintCustomParserResult;
+}
+/** Get parser name */
+export declare function getParserName(attrs: Record<string, string | undefined>, parser: any): string;
+/** Get parser */
+export declare function getParser(attrs: Record<string, string | undefined>, parser: any): ESLintCustomParser;

package/lib/parser/resolve-parser.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParser = exports.getParserName = void 0;
+const espree_1 = require("./espree");
+/** Get parser name */
+function getParserName(attrs, parser) {
+    if (parser) {
+        if (typeof parser === "string" && parser !== "espree") {
+            return parser;
+        }
+        else if (typeof parser === "object") {
+            const name = parser[attrs.lang || "js"];
+            if (typeof name === "string") {
+                return getParserName(attrs, name);
+            }
+        }
+    }
+    return "espree";
+}
+exports.getParserName = getParserName;
+/** Get parser */
+function getParser(attrs, parser) {
+    const name = getParserName(attrs, parser);
+    if (name !== "espree") {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- ignore
+        return require(name);
+    }
+    return (0, espree_1.getEspree)();
+}
+exports.getParser = getParser;

package/lib/parser/script.d.ts

@@ -0,0 +1,6 @@
+import type { ESLintExtendedProgram } from ".";
+import type { Context } from "../context";
+/**
+ * Parse for script
+ */
+export declare function parseScript(code: string, ctx: Context): ESLintExtendedProgram;

package/lib/parser/script.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScript = void 0;
+const resolve_parser_1 = require("./resolve-parser");
+const fs_1 = __importDefault(require("fs"));
+const debug_1 = require("../debug");
+/**
+ * Parse for script
+ */
+function parseScript(code, ctx) {
+    var _a, _b, _c;
+    const parser = (0, resolve_parser_1.getParser)({}, ctx.parserOptions.parser);
+    let removeFile = null;
+    try {
+        const scriptOption = Object.assign({}, ctx.parserOptions);
+        if (ctx.isTypeScript() && scriptOption.filePath) {
+            scriptOption.filePath += ".tsx";
+            if (!fs_1.default.existsSync(scriptOption.filePath)) {
+                fs_1.default.writeFileSync(scriptOption.filePath, "/* temp for astro-eslint-parser */");
+                removeFile = scriptOption.filePath;
+            }
+        }
+        const result = (_b = (_a = parser.parseForESLint) === null || _a === void 0 ? void 0 : _a.call(parser, code, scriptOption)) !== null && _b !== void 0 ? _b : (_c = parser.parse) === null || _c === void 0 ? void 0 : _c.call(parser, code, scriptOption);
+        if ("ast" in result && result.ast != null) {
+            return result;
+        }
+        return { ast: result };
+    }
+    catch (e) {
+        (0, debug_1.debug)("[script] parsing error:", e.message, `@ ${JSON.stringify(code)}`);
+        throw e;
+    }
+    finally {
+        if (removeFile)
+            fs_1.default.unlinkSync(removeFile);
+    }
+}
+exports.parseScript = parseScript;

package/lib/parser/sort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sort tokens
+ */
+export declare function sort<T extends {
+    range: [number, number];
+}>(tokens: T[]): T[];

package/lib/parser/sort.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sort = void 0;
+/**
+ * Sort tokens
+ */
+function sort(tokens) {
+    return tokens.sort((a, b) => {
+        if (a.range[0] !== b.range[0]) {
+            return a.range[0] - b.range[0];
+        }
+        return a.range[1] - b.range[1];
+    });
+}
+exports.sort = sort;

package/lib/traverse.d.ts

@@ -0,0 +1,27 @@
+import type { VisitorKeys } from "eslint-visitor-keys";
+import type { TSESTree } from "@typescript-eslint/types";
+import type { AstroNode } from "./ast";
+/**
+ * Get the keys of the given node to traverse it.
+ * @param node The node to get.
+ * @returns The keys to traverse.
+ */
+export declare function getFallbackKeys(node: any): string[];
+/**
+ * Get the keys of the given node to traverse it.
+ * @param node The node to get.
+ * @returns The keys to traverse.
+ */
+export declare function getKeys(node: any, visitorKeys?: VisitorKeys): string[];
+/**
+ * Get the nodes of the given node.
+ * @param node The node to get.
+ */
+export declare function getNodes(node: any, key: string): IterableIterator<AstroNode | TSESTree.Node>;
+export interface Visitor<N> {
+    visitorKeys?: VisitorKeys;
+    enterNode(node: N, parent: N | null): void;
+    leaveNode(node: N, parent: N | null): void;
+}
+export declare function traverseNodes(node: AstroNode, visitor: Visitor<AstroNode | TSESTree.Node>): void;
+export declare function traverseNodes(node: TSESTree.Node, visitor: Visitor<TSESTree.Node>): void;

package/lib/traverse.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseNodes = exports.getNodes = exports.getKeys = exports.getFallbackKeys = void 0;
+const visitor_keys_1 = require("./visitor-keys");
+/**
+ * Check that the given key should be traversed or not.
+ * @this {Traversable}
+ * @param key The key to check.
+ * @returns `true` if the key should be traversed.
+ */
+function fallbackKeysFilter(key) {
+    let value = null;
+    return (key !== "comments" &&
+        key !== "leadingComments" &&
+        key !== "loc" &&
+        key !== "parent" &&
+        key !== "range" &&
+        key !== "tokens" &&
+        key !== "trailingComments" &&
+        (value = this[key]) !== null &&
+        typeof value === "object" &&
+        (typeof value.type === "string" || Array.isArray(value)));
+}
+/**
+ * Get the keys of the given node to traverse it.
+ * @param node The node to get.
+ * @returns The keys to traverse.
+ */
+function getFallbackKeys(node) {
+    return Object.keys(node).filter(fallbackKeysFilter, node);
+}
+exports.getFallbackKeys = getFallbackKeys;
+/**
+ * Get the keys of the given node to traverse it.
+ * @param node The node to get.
+ * @returns The keys to traverse.
+ */
+function getKeys(node, visitorKeys) {
+    const keys = (visitorKeys || visitor_keys_1.KEYS)[node.type] || getFallbackKeys(node);
+    return keys.filter((key) => !getNodes(node, key).next().done);
+}
+exports.getKeys = getKeys;
+/**
+ * Get the nodes of the given node.
+ * @param node The node to get.
+ */
+function* getNodes(node, key) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+        for (const c of child) {
+            if (isNode(c)) {
+                yield c;
+            }
+        }
+    }
+    else if (isNode(child)) {
+        yield child;
+    }
+}
+exports.getNodes = getNodes;
+/**
+ * Check whether a given value is a node.
+ * @param x The value to check.
+ * @returns `true` if the value is a node.
+ */
+function isNode(x) {
+    return x !== null && typeof x === "object" && typeof x.type === "string";
+}
+/**
+ * Traverse the given node.
+ * @param node The node to traverse.
+ * @param parent The parent node.
+ * @param visitor The node visitor.
+ */
+function traverse(node, parent, visitor) {
+    visitor.enterNode(node, parent);
+    const keys = getKeys(node, visitor.visitorKeys);
+    for (const key of keys) {
+        for (const child of getNodes(node, key)) {
+            traverse(child, node, visitor);
+        }
+    }
+    visitor.leaveNode(node, parent);
+}
+/**
+ * Traverse the given AST tree.
+ * @param node Root node to traverse.
+ * @param visitor Visitor.
+ */
+function traverseNodes(node, visitor) {
+    traverse(node, null, visitor);
+}
+exports.traverseNodes = traverseNodes;

package/lib/visitor-keys.d.ts

@@ -0,0 +1,2 @@
+import type { SourceCode } from "eslint";
+export declare const KEYS: SourceCode.VisitorKeys;

package/lib/visitor-keys.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYS = void 0;
+const eslint_visitor_keys_1 = require("eslint-visitor-keys");
+const astroKeys = {
+    Program: ["body"],
+    AstroRootFragment: ["children"],
+    AstroHTMLComment: [],
+    AstroDoctype: [],
+    AstroShorthandAttribute: ["name", "value"],
+    AstroTemplateLiteralAttribute: ["name", "value"],
+};
+exports.KEYS = (0, eslint_visitor_keys_1.unionWith)(astroKeys);

package/package.json

@@ -0,0 +1,91 @@
+{
+    "name": "astro-eslint-parser",
+    "version": "0.0.0",
+    "description": "Astro parser for ESLint",
+    "main": "lib/index.js",
+    "files": [
+        "lib"
+    ],
+    "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+    },
+    "scripts": {
+        "prebuild": "npm run -s clean",
+        "build": "tsc --project ./tsconfig.build.json",
+        "clean": "rimraf .nyc_output lib coverage",
+        "lint": "eslint . --ext .js,.ts,.json",
+        "eslint-fix": "npm run lint -- --fix",
+        "test": "mocha --require ts-node/register \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
+        "cover": "nyc --reporter=lcov npm run test",
+        "debug": "mocha --require ts-node/register/transpile-only \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
+        "preversion": "npm run lint && npm test",
+        "update-fixtures": "ts-node --transpile-only ./tools/update-fixtures.ts",
+        "eslint-playground": "eslint tests/fixtures --ext .astro --config .eslintrc-for-playground.js --format codeframe",
+        "benchmark": "ts-node --transpile-only benchmark/index.ts"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ota-meshi/astro-eslint-parser.git"
+    },
+    "keywords": [
+        "astro",
+        "astrojs",
+        "eslint",
+        "parser"
+    ],
+    "author": "Yosuke Ota",
+    "funding": "https://github.com/sponsors/ota-meshi",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/ota-meshi/astro-eslint-parser/issues"
+    },
+    "homepage": "https://github.com/ota-meshi/astro-eslint-parser#readme",
+    "dependencies": {
+        "@astrojs/compiler": "^0.14.2",
+        "debug": "^4.3.4",
+        "eslint-scope": "^7.0.0",
+        "eslint-visitor-keys": "^3.0.0",
+        "espree": "^9.0.0"
+    },
+    "devDependencies": {
+        "@ota-meshi/eslint-plugin": "^0.10.0",
+        "@types/benchmark": "^2.1.1",
+        "@types/chai": "^4.3.0",
+        "@types/debug": "^4.1.7",
+        "@types/eslint": "^8.0.0",
+        "@types/eslint-scope": "^3.7.0",
+        "@types/eslint-visitor-keys": "^1.0.0",
+        "@types/mocha": "^9.0.0",
+        "@types/node": "^16.0.0",
+        "@types/semver": "^7.3.9",
+        "@typescript-eslint/eslint-plugin": "^5.4.0",
+        "@typescript-eslint/parser": "^5.4.0",
+        "benchmark": "^2.1.4",
+        "chai": "^4.3.4",
+        "code-red": "^0.2.3",
+        "eslint": "^8.2.0",
+        "eslint-config-prettier": "^8.3.0",
+        "eslint-formatter-codeframe": "^7.32.1",
+        "eslint-plugin-eslint-comments": "^3.2.0",
+        "eslint-plugin-json-schema-validator": "^2.1.6",
+        "eslint-plugin-jsonc": "^2.0.0",
+        "eslint-plugin-node": "^11.1.0",
+        "eslint-plugin-node-dependencies": "^0.8.0",
+        "eslint-plugin-prettier": "^4.0.0",
+        "eslint-plugin-regexp": "^1.5.0",
+        "eslint-plugin-vue": "^8.0.3",
+        "estree-walker": "^3.0.0",
+        "locate-character": "^2.0.5",
+        "magic-string": "^0.26.0",
+        "mocha": "^9.1.3",
+        "mocha-chai-jest-snapshot": "^1.1.3",
+        "nyc": "^15.1.0",
+        "prettier": "^2.0.5",
+        "prettier-plugin-astro": "^0.0.12",
+        "semver": "^7.3.5",
+        "string-replace-loader": "^3.0.3",
+        "ts-node": "^10.4.0",
+        "typescript": "~4.6.0",
+        "vue-eslint-parser": "^8.0.1"
+    }
+}