@vue/language-plugin-pug 3.2.1 → 3.2.2

package/index.js

@@ -1,39 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 const source_map_1 = require("@volar/source-map");
-const pug = __importStar(require("volar-service-pug/lib/languageService"));
+const baseParse_1 = require("./lib/baseParse");
 const classRegex = /^class\s*=/;
 const plugin = ({ modules }) => {
     const CompilerDOM = modules['@vue/compiler-dom'];
@@ -72,74 +39,68 @@ const plugin = ({ modules }) => {
         },
         compileSFCTemplate(lang, template, options) {
             if (lang === 'pug') {
-                let pugFile;
+                let parsed;
                 let baseOffset = 0;
                 const minIndent = calculateMinIndent(template);
                 if (minIndent === 0) {
-                    pugFile = pug.baseParse(template);
+                    parsed = (0, baseParse_1.baseParse)(template);
                 }
                 else {
-                    pugFile = pug.baseParse(`template\n${template}`);
+                    parsed = (0, baseParse_1.baseParse)(`template\n${template}`);
                     baseOffset = 'template\n'.length;
-                    pugFile.htmlCode = ' '.repeat('<template>'.length)
-                        + pugFile.htmlCode.slice('<template>'.length, -'</template>'.length)
+                    parsed.htmlCode = ' '.repeat('<template>'.length)
+                        + parsed.htmlCode.slice('<template>'.length, -'</template>'.length)
                         + ' '.repeat('</template>'.length);
                 }
-                const map = new source_map_1.SourceMap(pugFile.mappings);
-                const ast = CompilerDOM.parse(pugFile.htmlCode, {
+                const map = new source_map_1.SourceMap(parsed.mappings);
+                let ast = CompilerDOM.parse(parsed.htmlCode, {
                     ...options,
                     comments: true,
                     onWarn(warning) {
-                        options.onWarn?.(createProxyObject(warning));
+                        if (warning.loc) {
+                            warning.loc.start.offset = toPugOffset(warning.loc.start.offset);
+                            warning.loc.end.offset = toPugOffset(warning.loc.end.offset);
+                        }
+                        options.onWarn?.(warning);
                     },
                     onError(error) {
                         // #5099
                         if (error.code === 2
-                            && classRegex.test(pugFile.htmlCode.slice(error.loc?.start.offset))) {
+                            && classRegex.test(parsed.htmlCode.slice(error.loc?.start.offset))) {
                             return;
                         }
-                        options.onError?.(createProxyObject(error));
+                        if (error.loc) {
+                            error.loc.start.offset = toPugOffset(error.loc.start.offset);
+                            error.loc.end.offset = toPugOffset(error.loc.end.offset);
+                        }
+                        options.onError?.(error);
                     },
                 });
                 CompilerDOM.transform(ast, options);
+                const visited = new Set();
+                visit(ast);
                 return {
-                    ast: createProxyObject(ast),
+                    ast,
                     code: '',
                     preamble: '',
                 };
-                function createProxyObject(target) {
-                    const proxys = new WeakMap();
-                    return new Proxy(target, {
-                        get(target, prop, receiver) {
-                            if (prop === 'getClassOffset') {
-                                // div.foo#baz.bar
-                                //     ^^^     ^^^
-                                // class=" foo bar"
-                                //         ^^^ ^^^
-                                // NOTE: we need to expose source offset getter
-                                return function (startOffset) {
-                                    return getOffset(target.offset + startOffset);
-                                };
+                function visit(obj) {
+                    for (const key in obj) {
+                        const value = obj[key];
+                        if (value && typeof value === 'object') {
+                            if (visited.has(value)) {
+                                continue;
                             }
-                            if (prop === 'offset') {
-                                return getOffset(target.offset);
+                            visited.add(value);
+                            if ('offset' in value && typeof value.offset === 'number') {
+                                const originalOffset = value.offset;
+                                value.offset = toPugOffset(originalOffset);
                             }
-                            const value = Reflect.get(target, prop, receiver);
-                            if (typeof value === 'object' && value !== null) {
-                                let proxyed = proxys.get(value);
-                                if (proxyed) {
-                                    return proxyed;
-                                }
-                                proxyed = createProxyObject(value);
-                                proxys.set(value, proxyed);
-                                return proxyed;
-                            }
-                            return value;
-                        },
-                    });
+                            visit(value);
+                        }
+                    }
                 }
-                function getOffset(offset) {
-                    const htmlOffset = offset;
+                function toPugOffset(htmlOffset) {
                     const nums = [];
                     for (const mapped of map.toSourceLocation(htmlOffset)) {
                         nums.push(mapped[0] - baseOffset);

package/lib/baseParse.d.ts

@@ -0,0 +1,67 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function baseParse(pugCode: string): {
+    htmlCode: string;
+    mappings: import("@volar/source-map").Mapping<any>[];
+    pugTextDocument: TextDocument;
+    error: {
+        code: string;
+        msg: string;
+        line: number;
+        column: number;
+        filename: string;
+    } | undefined;
+    ast: Node | undefined;
+    emptyLineEnds: number[];
+};
+export type Node = BlockNode | MixinNode | TagNode | TextNode | CommentNode | BlockCommentNode;
+export interface BlockNode {
+    type: 'Block';
+    nodes: Node[];
+    line: number;
+}
+export interface TagNode {
+    type: 'Tag';
+    name: string;
+    selfClosing: boolean;
+    block: BlockNode;
+    attrs: {
+        name: string;
+        val: string | true;
+        line: number;
+        column: number;
+        mustEscape: boolean;
+    }[];
+    attributeBlocks: {}[];
+    isInline: boolean;
+    line: number;
+    column: number;
+}
+export interface TextNode {
+    type: 'Text';
+    val: string;
+    line: number;
+    column: number;
+}
+export interface CommentNode {
+    type: 'Comment';
+    val: string;
+    buffer: boolean;
+    line: number;
+    column: number;
+}
+export interface BlockCommentNode {
+    type: 'BlockComment';
+    block: BlockNode;
+    val: string;
+    buffer: boolean;
+    line: number;
+    column: number;
+}
+export interface MixinNode {
+    type: 'Mixin';
+    name: string;
+    args: null;
+    block: BlockNode | null;
+    line: number;
+    column: number;
+}

package/lib/baseParse.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseParse = baseParse;
+const muggle_string_1 = require("muggle-string");
+const pug_lexer_1 = __importDefault(require("pug-lexer"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const buildMappings_1 = require("./buildMappings");
+const pugParser = require('pug-parser');
+function baseParse(pugCode) {
+    const fileName = 'file.pug';
+    const pugTextDocument = vscode_languageserver_textdocument_1.TextDocument.create('file:///file.pug', 'pug', 0, pugCode);
+    const codes = [];
+    let error;
+    let emptyLineEnds = [];
+    let attrsBlocks;
+    let ast;
+    try {
+        const tokens = (0, pug_lexer_1.default)(pugCode, { filename: fileName });
+        emptyLineEnds = collectEmptyLineEnds(tokens);
+        attrsBlocks = collectAttrsBlocks(tokens);
+        ast = pugParser(tokens, { filename: fileName, src: pugCode });
+        visitNode(ast, undefined, undefined);
+        codes.push([
+            '',
+            undefined,
+            pugCode.trimEnd().length,
+        ]);
+    }
+    catch (e) {
+        const _error = e;
+        error = {
+            ..._error,
+            line: _error.line - 1,
+            column: _error.column - 1,
+        };
+    }
+    return {
+        htmlCode: (0, muggle_string_1.toString)(codes),
+        mappings: (0, buildMappings_1.buildMappings)(codes),
+        pugTextDocument,
+        error,
+        ast,
+        emptyLineEnds,
+    };
+    function visitNode(node, next, parent) {
+        if (node.type === 'Block') {
+            for (let i = 0; i < node.nodes.length; i++) {
+                visitNode(node.nodes[i], node.nodes[i + 1], node);
+            }
+        }
+        else if (node.type === 'Mixin') {
+            if (node.block) {
+                visitNode(node.block, undefined, node);
+            }
+        }
+        else if (node.type === 'Tag') {
+            const pugTagRange = getDocRange(node.line, node.column, node.name.length);
+            codes.push([
+                '',
+                undefined,
+                pugTagRange.start,
+            ]);
+            const selfClosing = node.block.nodes.length === 0;
+            addStartTag(node, selfClosing);
+            if (!selfClosing) {
+                visitNode(node.block, next, parent);
+                addEndTag(node, next, parent);
+            }
+            codes.push([
+                '',
+                undefined,
+                pugTagRange.start,
+            ]);
+        }
+        else if (node.type === 'Text') {
+            codes.push([
+                node.val,
+                undefined,
+                getDocOffset(node.line, node.column),
+            ]);
+        }
+    }
+    function addStartTag(node, selfClosing) {
+        codes.push([
+            '',
+            undefined,
+            getDocOffset(node.line, node.column),
+        ]);
+        codes.push('<');
+        const tagRange = getDocRange(node.line, node.column, node.name.length);
+        if (pugCode.substring(tagRange.start, tagRange.end) === node.name) {
+            codes.push([
+                node.name,
+                undefined,
+                tagRange.start,
+            ]);
+        }
+        else {
+            codes.push(node.name);
+        }
+        for (const attr of node.attrs.filter(attr => !attr.mustEscape)) {
+            codes.push(' ');
+            if (attr.name === 'class' || attr.name === 'id') {
+                const offset = getDocOffset(attr.line, attr.column);
+                for (const char of attr.name) {
+                    codes.push([
+                        char,
+                        undefined,
+                        offset,
+                    ]);
+                }
+            }
+            else {
+                codes.push(attr.name);
+            }
+            if (typeof attr.val !== 'boolean') {
+                codes.push('=');
+                codes.push([
+                    attr.val,
+                    undefined,
+                    getDocOffset(attr.line, attr.column),
+                ]);
+            }
+        }
+        const attrsBlock = attrsBlocks.get(getDocOffset(node.line, node.column)); // support attr auto-complete in spaces
+        if (attrsBlock) {
+            codes.push(' ');
+            codes.push([
+                attrsBlock.text,
+                undefined,
+                attrsBlock.offset,
+            ]);
+        }
+        if (selfClosing) {
+            codes.push(' />');
+        }
+        else {
+            codes.push('>');
+        }
+    }
+    function addEndTag(node, next, parent) {
+        let nextStart;
+        if (next) {
+            if (next.type === 'Block') {
+                nextStart = getDocOffset(next.line, 1);
+            }
+            else {
+                nextStart = getDocOffset(next.line, next.column);
+            }
+        }
+        else if (!parent) {
+            nextStart = pugCode.length;
+        }
+        if (nextStart !== undefined) {
+            codes.push([
+                '',
+                undefined,
+                nextStart,
+            ]);
+        }
+        codes.push(`</${node.name}>`);
+    }
+    function collectEmptyLineEnds(tokens) {
+        const ends = [];
+        for (const token of tokens) {
+            if (token.type === 'newline' || token.type === 'outdent') {
+                let currentLine = token.loc.start.line - 2;
+                let prevLine = getLineText(pugTextDocument, currentLine);
+                while (prevLine.trim() === '') {
+                    ends.push(pugTextDocument.offsetAt({ line: currentLine + 1, character: 0 }) - 1);
+                    if (currentLine <= 0) {
+                        break;
+                    }
+                    currentLine--;
+                    prevLine = getLineText(pugTextDocument, currentLine);
+                }
+            }
+        }
+        return ends.sort((a, b) => a - b);
+    }
+    function collectAttrsBlocks(tokens) {
+        const blocks = new Map();
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.type === 'start-attributes') {
+                let tagStart = token;
+                for (let j = i - 1; j >= 0; j--) {
+                    const prevToken = tokens[j];
+                    if (prevToken.type === 'newline'
+                        || prevToken.type === 'indent'
+                        || prevToken.type === 'outdent'
+                        || prevToken.type === ':') {
+                        break;
+                    }
+                    tagStart = prevToken;
+                    if (prevToken.type === 'tag') {
+                        break;
+                    }
+                }
+                let prevToken = token;
+                let text = '';
+                for (i++; i < tokens.length; i++) {
+                    const attrToken = tokens[i];
+                    addPrevSpace(attrToken);
+                    if (attrToken.type === 'attribute') {
+                        let attrText = pugCode.substring(getDocOffset(attrToken.loc.start.line, attrToken.loc.start.column), getDocOffset(attrToken.loc.end.line, attrToken.loc.end.column));
+                        if (typeof attrToken.val === 'string' && attrText.indexOf('=') >= 0) {
+                            let valText = attrToken.val;
+                            if (valText.startsWith('`') && valText.endsWith('`')) {
+                                if (valText.indexOf('"') === -1) {
+                                    valText = `"${valText.slice(1, -1)}"`;
+                                }
+                                else {
+                                    valText = `'${valText.slice(1, -1)}'`;
+                                }
+                            }
+                            valText = valText.replace(/ \\\n/g, '//\n');
+                            text += attrText.substring(0, attrText.lastIndexOf(attrToken.val)) + valText;
+                        }
+                        else {
+                            text += attrText;
+                        }
+                    }
+                    else if (attrToken.type === 'end-attributes') {
+                        blocks.set(getDocOffset(tagStart.loc.start.line, tagStart.loc.start.column), {
+                            offset: getDocOffset(token.loc.end.line, token.loc.end.column),
+                            text,
+                        });
+                        break;
+                    }
+                    prevToken = attrToken;
+                }
+                function addPrevSpace(currentToken) {
+                    text += pugCode.substring(getDocOffset(prevToken.loc.end.line, prevToken.loc.end.column), getDocOffset(currentToken.loc.start.line, currentToken.loc.start.column)).replace(/,/g, '\n');
+                }
+            }
+        }
+        return blocks;
+    }
+    function getDocOffset(pugLine, pugColumn) {
+        return pugTextDocument.offsetAt({ line: pugLine - 1, character: pugColumn - 1 });
+    }
+    function getDocRange(pugLine, pugColumn, length) {
+        const start = getDocOffset(pugLine, pugColumn);
+        const end = start + length;
+        return {
+            start,
+            end,
+        };
+    }
+}
+function getLineText(document, line) {
+    const endOffset = document.offsetAt({ line: line + 1, character: 0 });
+    const end = document.positionAt(endOffset);
+    const text = document.getText({
+        start: { line: line, character: 0 },
+        end: end.line === line ? end : document.positionAt(endOffset - 1),
+    });
+    return text;
+}
+//# sourceMappingURL=baseParse.js.map

package/lib/buildMappings.d.ts

@@ -0,0 +1,3 @@
+import type { Mapping } from '@volar/source-map';
+import type { Segment } from 'muggle-string';
+export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];

package/lib/buildMappings.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMappings = buildMappings;
+function buildMappings(chunks) {
+    let length = 0;
+    const mappings = [];
+    for (const segment of chunks) {
+        if (typeof segment === 'string') {
+            length += segment.length;
+        }
+        else {
+            mappings.push({
+                sourceOffsets: [segment[2]],
+                generatedOffsets: [length],
+                lengths: [segment[0].length],
+                data: segment[3],
+            });
+            length += segment[0].length;
+        }
+    }
+    return mappings;
+}
+//# sourceMappingURL=buildMappings.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-plugin-pug",
-	"version": "3.2.1",
+	"version": "3.2.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -14,12 +14,15 @@
 	},
 	"dependencies": {
 		"@volar/source-map": "2.4.27",
-		"volar-service-pug": "0.0.68"
+		"muggle-string": "^0.4.1",
+		"pug-lexer": "^5.0.1",
+		"pug-parser": "^6.0.0",
+		"vscode-languageserver-textdocument": "^1.0.11"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.4",
 		"@vue/compiler-dom": "^3.5.0",
-		"@vue/language-core": "3.2.1"
+		"@vue/language-core": "3.2.2"
 	},
-	"gitHead": "fad5a89205579e6a0902d7ee5bae3db7b510e2f4"
+	"gitHead": "17394f4e80c2267e8b7159468ab40c948ea37d65"
 }