🎉 initiate project *astro_rewrite*

node_modules/vscode-html-languageservice/lib/esm/services/htmlSelectionRange.js

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import { TokenType, Range, SelectionRange } from '../htmlLanguageTypes';
+export class HTMLSelectionRange {
+    constructor(htmlParser) {
+        this.htmlParser = htmlParser;
+    }
+    getSelectionRanges(document, positions) {
+        const htmlDocument = this.htmlParser.parseDocument(document);
+        return positions.map(p => this.getSelectionRange(p, document, htmlDocument));
+    }
+    getSelectionRange(position, document, htmlDocument) {
+        const applicableRanges = this.getApplicableRanges(document, position, htmlDocument);
+        let prev = undefined;
+        let current = undefined;
+        for (let index = applicableRanges.length - 1; index >= 0; index--) {
+            const range = applicableRanges[index];
+            if (!prev || range[0] !== prev[0] || range[1] !== prev[1]) {
+                current = SelectionRange.create(Range.create(document.positionAt(applicableRanges[index][0]), document.positionAt(applicableRanges[index][1])), current);
+            }
+            prev = range;
+        }
+        if (!current) {
+            current = SelectionRange.create(Range.create(position, position));
+        }
+        return current;
+    }
+    getApplicableRanges(document, position, htmlDoc) {
+        const currOffset = document.offsetAt(position);
+        const currNode = htmlDoc.findNodeAt(currOffset);
+        let result = this.getAllParentTagRanges(currNode);
+        // Self-closing or void elements
+        if (currNode.startTagEnd && !currNode.endTagStart) {
+            // THe rare case of unmatching tag pairs like <div></div1>
+            if (currNode.startTagEnd !== currNode.end) {
+                return [[currNode.start, currNode.end]];
+            }
+            const closeRange = Range.create(document.positionAt(currNode.startTagEnd - 2), document.positionAt(currNode.startTagEnd));
+            const closeText = document.getText(closeRange);
+            // Self-closing element
+            if (closeText === '/>') {
+                result.unshift([currNode.start + 1, currNode.startTagEnd - 2]);
+            }
+            // Void element
+            else {
+                result.unshift([currNode.start + 1, currNode.startTagEnd - 1]);
+            }
+            const attributeLevelRanges = this.getAttributeLevelRanges(document, currNode, currOffset);
+            result = attributeLevelRanges.concat(result);
+            return result;
+        }
+        if (!currNode.startTagEnd || !currNode.endTagStart) {
+            return result;
+        }
+        /**
+         * For html like
+         * `<div class="foo">bar</div>`
+         */
+        result.unshift([currNode.start, currNode.end]);
+        /**
+         * Cursor inside `<div class="foo">`
+         */
+        if (currNode.start < currOffset && currOffset < currNode.startTagEnd) {
+            result.unshift([currNode.start + 1, currNode.startTagEnd - 1]);
+            const attributeLevelRanges = this.getAttributeLevelRanges(document, currNode, currOffset);
+            result = attributeLevelRanges.concat(result);
+            return result;
+        }
+        /**
+         * Cursor inside `bar`
+         */
+        else if (currNode.startTagEnd <= currOffset && currOffset <= currNode.endTagStart) {
+            result.unshift([currNode.startTagEnd, currNode.endTagStart]);
+            return result;
+        }
+        /**
+         * Cursor inside `</div>`
+         */
+        else {
+            // `div` inside `</div>`
+            if (currOffset >= currNode.endTagStart + 2) {
+                result.unshift([currNode.endTagStart + 2, currNode.end - 1]);
+            }
+            return result;
+        }
+    }
+    getAllParentTagRanges(initialNode) {
+        let currNode = initialNode;
+        const result = [];
+        while (currNode.parent) {
+            currNode = currNode.parent;
+            this.getNodeRanges(currNode).forEach(r => result.push(r));
+        }
+        return result;
+    }
+    getNodeRanges(n) {
+        if (n.startTagEnd && n.endTagStart && n.startTagEnd < n.endTagStart) {
+            return [
+                [n.startTagEnd, n.endTagStart],
+                [n.start, n.end]
+            ];
+        }
+        return [
+            [n.start, n.end]
+        ];
+    }
+    ;
+    getAttributeLevelRanges(document, currNode, currOffset) {
+        const currNodeRange = Range.create(document.positionAt(currNode.start), document.positionAt(currNode.end));
+        const currNodeText = document.getText(currNodeRange);
+        const relativeOffset = currOffset - currNode.start;
+        /**
+         * Tag level semantic selection
+         */
+        const scanner = createScanner(currNodeText);
+        let token = scanner.scan();
+        /**
+         * For text like
+         * <div class="foo">bar</div>
+         */
+        const positionOffset = currNode.start;
+        const result = [];
+        let isInsideAttribute = false;
+        let attrStart = -1;
+        while (token !== TokenType.EOS) {
+            switch (token) {
+                case TokenType.AttributeName: {
+                    if (relativeOffset < scanner.getTokenOffset()) {
+                        isInsideAttribute = false;
+                        break;
+                    }
+                    if (relativeOffset <= scanner.getTokenEnd()) {
+                        // `class`
+                        result.unshift([scanner.getTokenOffset(), scanner.getTokenEnd()]);
+                    }
+                    isInsideAttribute = true;
+                    attrStart = scanner.getTokenOffset();
+                    break;
+                }
+                case TokenType.AttributeValue: {
+                    if (!isInsideAttribute) {
+                        break;
+                    }
+                    const valueText = scanner.getTokenText();
+                    if (relativeOffset < scanner.getTokenOffset()) {
+                        // `class="foo"`
+                        result.push([attrStart, scanner.getTokenEnd()]);
+                        break;
+                    }
+                    if (relativeOffset >= scanner.getTokenOffset() && relativeOffset <= scanner.getTokenEnd()) {
+                        // `"foo"`
+                        result.unshift([scanner.getTokenOffset(), scanner.getTokenEnd()]);
+                        // `foo`
+                        if ((valueText[0] === `"` && valueText[valueText.length - 1] === `"`) || (valueText[0] === `'` && valueText[valueText.length - 1] === `'`)) {
+                            if (relativeOffset >= scanner.getTokenOffset() + 1 && relativeOffset <= scanner.getTokenEnd() - 1) {
+                                result.unshift([scanner.getTokenOffset() + 1, scanner.getTokenEnd() - 1]);
+                            }
+                        }
+                        // `class="foo"`
+                        result.push([attrStart, scanner.getTokenEnd()]);
+                    }
+                    break;
+                }
+            }
+            token = scanner.scan();
+        }
+        return result.map(pair => {
+            return [pair[0] + positionOffset, pair[1] + positionOffset];
+        });
+    }
+}