@markuplint/astro-parser 3.12.0 → 4.0.0-alpha.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 Yusuke Hirao
+Copyright (c) 2017-2024 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/astro-parser.d.ts

@@ -1,11 +1,3 @@
-import type { RootNode } from '@astrojs/compiler';
-export type {
-	RootNode,
-	ElementNode,
-	CustomElementNode,
-	ComponentNode,
-	FragmentNode,
-	AttributeNode,
-	Node,
-} from '@astrojs/compiler';
+import type { RootNode } from '@astrojs/compiler/types';
+export type { RootNode, ElementNode, CustomElementNode, ComponentNode, FragmentNode, AttributeNode, Node, } from '@astrojs/compiler/types';
 export declare function astroParse(code: string): RootNode;

package/lib/astro-parser.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.astroParse = void 0;
-const parser_utils_1 = require("@markuplint/parser-utils");
-const astro_eslint_parser_1 = require("astro-eslint-parser");
-function astroParse(code) {
-    const { result } = (0, astro_eslint_parser_1.parseTemplate)(code);
+import { ParserError } from '@markuplint/parser-utils';
+import { parseTemplate } from 'astro-eslint-parser';
+export function astroParse(code) {
+    const { result } = parseTemplate(code);
     if (result.diagnostics[0]) {
         const error = result.diagnostics[0];
-        throw new parser_utils_1.ParserError(error.text, {
+        throw new ParserError(error.text, {
             line: error.location.line,
             col: error.location.column,
         });
     }
     return result.ast;
 }
-exports.astroParse = astroParse;

package/lib/index.d.ts

@@ -1,2 +1 @@
-export { parse } from './parse';
-export declare const endTag = 'xml';
+export { parser } from './parser.js';

package/lib/index.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.endTag = exports.parse = void 0;
-var parse_1 = require("./parse");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } });
-exports.endTag = 'xml';
+export { parser } from './parser.js';

package/lib/parser.d.ts

@@ -0,0 +1,51 @@
+import type { Node } from './astro-parser.js';
+import type { MLASTParentNode, MLASTNodeTreeItem } from '@markuplint/ml-ast';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import { Parser } from '@markuplint/parser-utils';
+type State = {
+    scopeNS: string;
+};
+declare class AstroParser extends Parser<Node, State> {
+    #private;
+    constructor();
+    tokenize(): {
+        ast: Node[];
+        isFragment: boolean;
+    };
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    visitElement(token: ChildToken, childNodes: readonly Node[]): readonly MLASTNodeTreeItem[];
+    visitChildren(children: readonly Node[], parentNode: MLASTParentNode | null): never[];
+    visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
+        __rightText?: string | undefined;
+    }) | {
+        isDynamicValue: true | undefined;
+        isDirective: true | undefined;
+        potentialName: string | undefined;
+        type: "attr";
+        nodeName: string;
+        spacesBeforeName: import("@markuplint/ml-ast").MLASTToken;
+        name: import("@markuplint/ml-ast").MLASTToken;
+        spacesBeforeEqual: import("@markuplint/ml-ast").MLASTToken;
+        equal: import("@markuplint/ml-ast").MLASTToken;
+        spacesAfterEqual: import("@markuplint/ml-ast").MLASTToken;
+        startQuote: import("@markuplint/ml-ast").MLASTToken;
+        value: import("@markuplint/ml-ast").MLASTToken;
+        endQuote: import("@markuplint/ml-ast").MLASTToken;
+        potentialValue?: string | undefined;
+        valueType?: "string" | "number" | "boolean" | "code" | undefined;
+        candidate?: string | undefined;
+        isDuplicatable: boolean;
+        uuid: string;
+        raw: string;
+        startOffset: number;
+        endOffset: number;
+        startLine: number;
+        endLine: number;
+        startCol: number;
+        endCol: number;
+        __rightText?: string | undefined;
+    };
+}
+export declare const parser: AstroParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,214 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AstroParser_instances, _AstroParser_updateScopeNS;
+import { AttrState, Parser, ParserError } from '@markuplint/parser-utils';
+import { astroParse } from './astro-parser.js';
+class AstroParser extends Parser {
+    constructor() {
+        super({
+            endTagType: 'xml',
+            selfCloseType: 'html+xml',
+        }, {
+            scopeNS: 'http://www.w3.org/1999/xhtml',
+        });
+        _AstroParser_instances.add(this);
+    }
+    tokenize() {
+        return {
+            ast: astroParse(this.rawCode).children,
+            isFragment: true,
+        };
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        if (!originNode.position) {
+            throw new TypeError("Node doesn't have position");
+        }
+        const startOffset = originNode.position.start.offset;
+        const endOffset = originNode.position.end?.offset;
+        const token = this.sliceFragment(startOffset, endOffset);
+        __classPrivateFieldGet(this, _AstroParser_instances, "m", _AstroParser_updateScopeNS).call(this, originNode, parentNode);
+        switch (originNode.type) {
+            case 'doctype': {
+                return this.visitDoctype({
+                    ...token,
+                    depth,
+                    parentNode,
+                    name: originNode.value,
+                    publicId: '',
+                    systemId: '',
+                });
+            }
+            case 'text': {
+                if (parentNode?.type === 'psblock') {
+                    return [];
+                }
+                return this.visitText({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'component':
+            case 'custom-element':
+            case 'fragment':
+            case 'element': {
+                const tagToken = token.raw ? token : this.sliceFragment(0);
+                return this.visitElement({
+                    ...tagToken,
+                    depth,
+                    parentNode,
+                }, originNode.children);
+            }
+            case 'expression': {
+                const firstChild = originNode.children.at(0);
+                const lastChild = originNode.children.at(-1);
+                let startExpressionRaw = token.raw;
+                let startExpressionStartLine = token.startLine;
+                let startExpressionStartCol = token.startCol;
+                const nodes = [];
+                if (firstChild && lastChild && firstChild !== lastChild) {
+                    const startExpressionEndOffset = firstChild.position?.end?.offset ?? endOffset ?? startOffset;
+                    const startExpressionLocation = this.sliceFragment(startOffset, startExpressionEndOffset);
+                    startExpressionRaw = startExpressionLocation.raw;
+                    startExpressionStartLine = startExpressionLocation.startLine;
+                    startExpressionStartCol = startExpressionLocation.startCol;
+                    const closeExpressionLocation = this.sliceFragment(lastChild.position?.start.offset ?? startOffset, endOffset);
+                    nodes.push(...this.visitPsBlock({
+                        ...closeExpressionLocation,
+                        depth,
+                        parentNode,
+                        nodeName: 'MustacheTag',
+                    }));
+                }
+                nodes.push(...this.visitPsBlock({
+                    raw: startExpressionRaw,
+                    startOffset,
+                    startLine: startExpressionStartLine,
+                    startCol: startExpressionStartCol,
+                    depth,
+                    parentNode,
+                    nodeName: 'MustacheTag',
+                }, originNode.children));
+                return nodes;
+            }
+            default: {
+                return [];
+            }
+        }
+    }
+    afterFlattenNodes(nodeList) {
+        return super.afterFlattenNodes(nodeList, {
+            exposeInvalidNode: false,
+        });
+    }
+    visitElement(token, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    childNodes) {
+        const parsedNodes = this.parseCodeFragment(token);
+        const startTagNode = parsedNodes.at(0);
+        if (!startTagNode || startTagNode.type !== 'starttag') {
+            throw new ParserError('Not found start tag', startTagNode ?? token);
+        }
+        return super.visitElement(startTagNode, childNodes, {
+            overwriteProps: {
+                namespace: this.state.scopeNS,
+            },
+            createEndTagToken: () => {
+                if (startTagNode.selfClosingSolidus?.raw === '/') {
+                    return null;
+                }
+                const endTagNode = parsedNodes.at(-1);
+                if (endTagNode?.type !== 'endtag') {
+                    return null;
+                }
+                return endTagNode ?? null;
+            },
+        });
+    }
+    visitChildren(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    children, parentNode) {
+        const siblings = super.visitChildren(children, parentNode);
+        if (siblings.length > 0) {
+            throw new ParserError('Discovered child nodes with differing hierarchy levels', siblings[0]);
+        }
+        return [];
+    }
+    visitAttr(token) {
+        const attr = super.visitAttr(token, {
+            quoteSet: [
+                { start: '"', end: '"' },
+                { start: "'", end: "'" },
+                { start: '{', end: '}' },
+            ],
+            quoteInValueChars: [
+                { start: '"', end: '"' },
+                { start: "'", end: "'" },
+                { start: '`', end: '`' },
+                { start: '${', end: '}' },
+            ],
+            startState: 
+            // is shorthand attribute
+            token.raw.trim().startsWith('{') ? AttrState.BeforeValue : AttrState.BeforeName,
+        });
+        if (attr.type === 'spread') {
+            return attr;
+        }
+        const isDynamicValue = attr.startQuote.raw === '{' || undefined;
+        let potentialName;
+        let isDirective;
+        if (isDynamicValue && attr.name.raw === '') {
+            potentialName = attr.value.raw;
+        }
+        /**
+         * Detects Template Directive
+         *
+         * @see https://docs.astro.build/en/reference/directives-reference/
+         */
+        const [, directive] = attr.name.raw.match(/^([^:]+):([^:]+)$/) ?? [];
+        if (directive) {
+            const lowerCaseDirectiveName = directive.toLowerCase();
+            switch (lowerCaseDirectiveName) {
+                case 'class': {
+                    potentialName = lowerCaseDirectiveName;
+                    break;
+                }
+                default: {
+                    isDirective = true;
+                }
+            }
+        }
+        return {
+            ...attr,
+            isDynamicValue,
+            isDirective,
+            potentialName,
+        };
+    }
+}
+_AstroParser_instances = new WeakSet(), _AstroParser_updateScopeNS = function _AstroParser_updateScopeNS(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+originNode, parentNode) {
+    const parentNS = this.state.scopeNS;
+    if (parentNS === 'http://www.w3.org/1999/xhtml' &&
+        originNode.type === 'element' &&
+        originNode.name?.toLowerCase() === 'svg') {
+        this.state.scopeNS = 'http://www.w3.org/2000/svg';
+    }
+    else if (parentNS === 'http://www.w3.org/2000/svg' && parentNode && parentNode.nodeName === 'foreignObject') {
+        this.state.scopeNS = 'http://www.w3.org/1999/xhtml';
+    }
+};
+export const parser = new AstroParser();

package/package.json

@@ -1,13 +1,18 @@
 {
 	"name": "@markuplint/astro-parser",
-	"version": "3.12.0",
+	"version": "4.0.0-alpha.10",
 	"description": "astro parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"private": false,
-	"main": "lib/index.js",
-	"types": "lib/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js"
+		}
+	},
+	"types": "./lib/index.d.ts",
 	"publishConfig": {
 		"access": "public"
 	},
@@ -16,12 +21,12 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@astrojs/parser": "0.22.2",
-		"@markuplint/html-parser": "3.13.0",
-		"@markuplint/ml-ast": "3.2.0",
-		"@markuplint/parser-utils": "3.13.0",
-		"astro-eslint-parser": "^0.16.0",
-		"tslib": "^2.6.2"
+		"@markuplint/ml-ast": "4.0.0-alpha.10",
+		"@markuplint/parser-utils": "4.0.0-alpha.10",
+		"astro-eslint-parser": "^0.16.2"
+	},
+	"devDependencies": {
+		"@astrojs/compiler": "^2.5.1"
 	},
-	"gitHead": "b37b749d7ac0f9e6cbd022ee7031bc020c6677d3"
+	"gitHead": "b41153ea665aa8f091daf6114a06047f4ccb8350"
 }

package/lib/attr-tokenizer.d.ts

@@ -1,9 +0,0 @@
-import type { AttributeNode } from './astro-parser';
-import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
-export declare function attrTokenizer(
-	attr: AttributeNode,
-	nextAttr: AttributeNode | null,
-	rawHtml: string,
-	startTag: string,
-	startTagEndOffset: number,
-): MLASTHTMLAttr;

package/lib/attr-tokenizer.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attrTokenizer = void 0;
-const parser_utils_1 = require("@markuplint/parser-utils");
-const mustacheTag = {
-    start: '{',
-    end: '}',
-};
-function attrTokenizer(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attr, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nextAttr, rawHtml, startTag, startTagEndOffset) {
-    var _a, _b, _c;
-    if (!attr.position) {
-        throw new TypeError("Attr doesn't have position");
-    }
-    if (attr.position.end) {
-        throw new TypeError('Node may is an attribute because it has end position');
-    }
-    let nextAttrBeforeSpaceOffset;
-    if (nextAttr) {
-        if (!nextAttr.position) {
-            throw new TypeError("NextAttr doesn't have position");
-        }
-        if (nextAttr.position.end) {
-            throw new TypeError('NextAttr Node may is an attribute because it has end position');
-        }
-        nextAttrBeforeSpaceOffset = (0, parser_utils_1.getSpaceBefore)(nextAttr.position.start.offset, rawHtml).startOffset;
-    }
-    else {
-        const close = (_b = (_a = /(\/?>)$/.exec(startTag)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
-        nextAttrBeforeSpaceOffset = startTagEndOffset - close.length;
-    }
-    const { raw, startOffset } = (0, parser_utils_1.sliceFragment)(rawHtml, attr.position.start.offset, nextAttrBeforeSpaceOffset);
-    const result = (0, parser_utils_1.parseAttr)(raw, startOffset, rawHtml, {
-        valueDelimiters: [...parser_utils_1.defaultValueDelimiters, mustacheTag],
-    });
-    if (result.startQuote.raw === mustacheTag.start) {
-        result.isDynamicValue = true;
-    }
-    /**
-     * Detects Template Directive
-     *
-     * @see https://docs.astro.build/en/reference/directives-reference/
-     */
-    const [, directive] = (_c = result.name.raw.match(/^([^:]+):([^:]+)$/)) !== null && _c !== void 0 ? _c : [];
-    if (directive) {
-        const lowerCaseDirectiveName = directive.toLowerCase();
-        switch (lowerCaseDirectiveName) {
-            case 'class': {
-                result.potentialName = lowerCaseDirectiveName;
-                break;
-            }
-            default: {
-                result.isDirective = true;
-            }
-        }
-    }
-    return result;
-}
-exports.attrTokenizer = attrTokenizer;

package/lib/parse.d.ts

@@ -1,2 +0,0 @@
-import type { Parse } from '@markuplint/ml-ast';
-export declare const parse: Parse;