@herb-tools/core 0.7.4 → 0.8.0

package/dist/herb-core.umd.js

@@ -7,8 +7,16 @@
     class Position {
         line;
         column;
-        static from(position) {
-            return new Position(position.line, position.column);
+        static from(positionOrLine, column) {
+            if (typeof positionOrLine === "number") {
+                return new Position(positionOrLine, column);
+            }
+            else {
+                return new Position(positionOrLine.line, positionOrLine.column);
+            }
+        }
+        static get zero() {
+            return new Position(0, 0);
         }
         constructor(line, column) {
             this.line = line;
@@ -34,10 +42,20 @@
     class Location {
         start;
         end;
-        static from(location) {
-            const start = Position.from(location.start);
-            const end = Position.from(location.end);
-            return new Location(start, end);
+        static from(locationOrLine, column, endLine, endColumn) {
+            if (typeof locationOrLine === "number") {
+                const start = Position.from(locationOrLine, column);
+                const end = Position.from(endLine, endColumn);
+                return new Location(start, end);
+            }
+            else {
+                const start = Position.from(locationOrLine.start);
+                const end = Position.from(locationOrLine.end);
+                return new Location(start, end);
+            }
+        }
+        static get zero() {
+            return new Location(Position.zero, Position.zero);
         }
         constructor(start, end) {
             this.start = start;
@@ -69,8 +87,16 @@
     class Range {
         start;
         end;
-        static from(range) {
-            return new Range(range[0], range[1]);
+        static from(rangeOrStart, end) {
+            if (typeof rangeOrStart === "number") {
+                return new Range(rangeOrStart, end);
+            }
+            else {
+                return new Range(rangeOrStart[0], rangeOrStart[1]);
+            }
+        }
+        static get zero() {
+            return new Range(0, 0);
         }
         constructor(start, end) {
             this.start = start;
@@ -135,7 +161,7 @@
     }
 
     // NOTE: This file is generated by the templates/template.rb script and should not
-    // be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/errors.ts.erb
+    // be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/errors.ts.erb
     class HerbError {
         type;
         message;
@@ -560,6 +586,84 @@
             return output;
         }
     }
+    class ERBControlFlowScopeError extends HerbError {
+        keyword;
+        static from(data) {
+            return new ERBControlFlowScopeError({
+                type: data.type,
+                message: data.message,
+                location: Location.from(data.location),
+                keyword: data.keyword,
+            });
+        }
+        constructor(props) {
+            super(props.type, props.message, props.location);
+            this.keyword = props.keyword;
+        }
+        toJSON() {
+            return {
+                ...super.toJSON(),
+                type: "ERB_CONTROL_FLOW_SCOPE_ERROR",
+                keyword: this.keyword,
+            };
+        }
+        toMonacoDiagnostic() {
+            return {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            };
+        }
+        treeInspect() {
+            let output = "";
+            output += `@ ERBControlFlowScopeError ${this.location.treeInspectWithLabel()}\n`;
+            output += `├── message: "${this.message}"\n`;
+            output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+            return output;
+        }
+    }
+    class MissingERBEndTagError extends HerbError {
+        keyword;
+        static from(data) {
+            return new MissingERBEndTagError({
+                type: data.type,
+                message: data.message,
+                location: Location.from(data.location),
+                keyword: data.keyword,
+            });
+        }
+        constructor(props) {
+            super(props.type, props.message, props.location);
+            this.keyword = props.keyword;
+        }
+        toJSON() {
+            return {
+                ...super.toJSON(),
+                type: "MISSINGERB_END_TAG_ERROR",
+                keyword: this.keyword,
+            };
+        }
+        toMonacoDiagnostic() {
+            return {
+                line: this.location.start.line,
+                column: this.location.start.column,
+                endLine: this.location.end.line,
+                endColumn: this.location.end.column,
+                message: this.message,
+                severity: 'error'
+            };
+        }
+        treeInspect() {
+            let output = "";
+            output += `@ MissingERBEndTagError ${this.location.treeInspectWithLabel()}\n`;
+            output += `├── message: "${this.message}"\n`;
+            output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+            return output;
+        }
+    }
     function fromSerializedError(error) {
         switch (error.type) {
             case "UNEXPECTED_ERROR": return UnexpectedError.from(error);
@@ -571,6 +675,8 @@
             case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error);
             case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error);
             case "RUBY_PARSE_ERROR": return RubyParseError.from(error);
+            case "ERB_CONTROL_FLOW_SCOPE_ERROR": return ERBControlFlowScopeError.from(error);
+            case "MISSINGERB_END_TAG_ERROR": return MissingERBEndTagError.from(error);
             default:
                 throw new Error(`Unknown node type: ${error.type}`);
         }
@@ -592,7 +698,7 @@
     }
 
     // NOTE: This file is generated by the templates/template.rb script and should not
-    // be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/nodes.ts.erb
+    // be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/nodes.ts.erb
     class Node {
         type;
         location;
@@ -2845,7 +2951,7 @@
     }
 
     // NOTE: This file is generated by the templates/template.rb script and should not
-    // be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/node-type-guards.ts.erb
+    // be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/node-type-guards.ts.erb
     /**
      * Type guard functions for AST nodes.
      * These functions provide type checking by combining both instanceof
@@ -3466,7 +3572,7 @@
      * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
      */
     function isERBOutputNode(node) {
-        if (!isNode(node, ERBContentNode))
+        if (!isERBNode(node))
             return false;
         if (!node.tag_opening?.value)
             return false;
@@ -3738,8 +3844,184 @@
         };
     }
 
+    /*
+     * The following code is derived from the "js-levenshtein" repository,
+     * Copyright (c) 2017 Gustaf Andersson (https://github.com/gustf/js-levenshtein)
+     * Licensed under the MIT License (https://github.com/gustf/js-levenshtein/blob/master/LICENSE).
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in all
+     * copies or substantial portions of the Software.
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+     * SOFTWARE.
+     *
+     * https://github.com/marcoroth/stimulus-lsp/blob/52268d4a4d06504dde6cb81f505a23b5db5d5759/server/src/levenshtein.ts
+     *
+     */
+    function levenshtein(a, b) {
+        function _min(d0, d1, d2, bx, ay) {
+            return d0 < d1 || d2 < d1 ? (d0 > d2 ? d2 + 1 : d0 + 1) : bx === ay ? d1 : d1 + 1;
+        }
+        if (a === b) {
+            return 0;
+        }
+        if (a.length > b.length) {
+            const tmp = a;
+            a = b;
+            b = tmp;
+        }
+        let la = a.length;
+        let lb = b.length;
+        while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
+            la--;
+            lb--;
+        }
+        let offset = 0;
+        while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
+            offset++;
+        }
+        la -= offset;
+        lb -= offset;
+        if (la === 0 || lb < 3) {
+            return lb;
+        }
+        let x = 0;
+        let y;
+        let d0;
+        let d1;
+        let d2;
+        let d3;
+        let dd;
+        let dy;
+        let ay;
+        let bx0;
+        let bx1;
+        let bx2;
+        let bx3;
+        const vector = [];
+        for (y = 0; y < la; y++) {
+            vector.push(y + 1);
+            vector.push(a.charCodeAt(offset + y));
+        }
+        const len = vector.length - 1;
+        for (; x < lb - 3;) {
+            bx0 = b.charCodeAt(offset + (d0 = x));
+            bx1 = b.charCodeAt(offset + (d1 = x + 1));
+            bx2 = b.charCodeAt(offset + (d2 = x + 2));
+            bx3 = b.charCodeAt(offset + (d3 = x + 3));
+            dd = x += 4;
+            for (y = 0; y < len; y += 2) {
+                dy = vector[y];
+                ay = vector[y + 1];
+                d0 = _min(dy, d0, d1, bx0, ay);
+                d1 = _min(d0, d1, d2, bx1, ay);
+                d2 = _min(d1, d2, d3, bx2, ay);
+                dd = _min(d2, d3, dd, bx3, ay);
+                vector[y] = dd;
+                d3 = d2;
+                d2 = d1;
+                d1 = d0;
+                d0 = dy;
+            }
+        }
+        for (; x < lb;) {
+            bx0 = b.charCodeAt(offset + (d0 = x));
+            dd = ++x;
+            for (y = 0; y < len; y += 2) {
+                dy = vector[y];
+                vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
+                d0 = dy;
+            }
+        }
+        return dd;
+    }
+
+    /**
+     * Ranks a list of strings by their Levenshtein distance from the input string.
+     * Items are sorted in ascending order by distance, with closer matches first.
+     *
+     * @param input - The string to compare against
+     * @param list - The list of strings to rank
+     * @returns An array of objects containing the item and its distance score, sorted by score
+     */
+    function rank(input, list) {
+        return list.map(item => {
+            const score = levenshtein(input.toLowerCase(), item.toLowerCase());
+            return { item, score };
+        }).sort((a, b) => a.score - b.score);
+    }
+    /**
+     * Finds the closest matching string from a list using Levenshtein distance.
+     * Performs case-insensitive comparison.
+     *
+     * @param input - The string to match against
+     * @param list - The list of candidate strings to search
+     * @param threshold - Maximum Levenshtein distance to consider a match. If undefined, returns the closest match regardless of distance.
+     * @returns The closest matching string from the list, or null if the list is empty or no match is within the threshold
+     *
+     * @example
+     * ```ts
+     * didyoumean('speling', ['spelling', 'writing', 'reading']) // Returns 'spelling'
+     * didyoumean('test', []) // Returns null
+     * didyoumean('speling', ['spelling', 'writing', 'reading'], 2) // Returns 'spelling' (distance: 1)
+     * didyoumean('xyz', ['spelling', 'writing', 'reading'], 2) // Returns null (all distances > 2)
+     * ```
+     */
+    function didyoumean(input, list, threshold) {
+        if (list.length === 0)
+            return null;
+        const scores = rank(input, list);
+        if (scores.length === 0)
+            return null;
+        const closest = scores[0];
+        if (threshold !== undefined && closest.score > threshold)
+            return null;
+        return closest.item;
+    }
+    /**
+     * Returns all strings from a list ranked by their Levenshtein distance from the input string.
+     * Performs case-insensitive comparison. Results are sorted with closest matches first.
+     *
+     * @param input - The string to match against
+     * @param list - The list of candidate strings to rank
+     * @param threshold - Maximum Levenshtein distance to include in results. If undefined, returns all ranked results.
+     * @returns An array of ranked results with items and scores, or an empty array if the list is empty or no matches are within the threshold
+     *
+     * @example
+     * ```ts
+     * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'])
+     * // Returns [{ item: 'spelling', score: 1 }, { item: 'reading', score: 5 }, { item: 'writing', score: 6 }]
+     *
+     * didyoumeanRanked('speling', ['spelling', 'writing', 'reading'], 2)
+     * // Returns [{ item: 'spelling', score: 1 }]
+     *
+     * didyoumeanRanked('test', []) // Returns []
+     * ```
+     */
+    function didyoumeanRanked(input, list, threshold) {
+        if (list.length === 0)
+            return [];
+        const scores = rank(input, list);
+        if (threshold !== undefined) {
+            return scores.filter(result => result.score <= threshold);
+        }
+        return scores;
+    }
+
     var name = "@herb-tools/core";
-    var version = "0.7.4";
+    var version = "0.8.0";
     var packageJSON = {
     	name: name,
     	version: version};
@@ -3962,7 +4244,7 @@
     }
 
     // NOTE: This file is generated by the templates/template.rb script and should not
-    // be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/visitor.ts.erb
+    // be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/visitor.ts.erb
     class Visitor {
         visit(node) {
             if (!node)
@@ -3975,97 +4257,151 @@
         visitChildNodes(node) {
             node.compactChildNodes().forEach(node => node.accept(this));
         }
+        visitNode(_node) {
+            // Default implementation does nothing
+        }
+        visitERBNode(_node) {
+            // Default implementation does nothing
+        }
         visitDocumentNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitLiteralNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLOpenTagNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLCloseTagNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLElementNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLAttributeValueNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLAttributeNameNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLAttributeNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLTextNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLCommentNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitHTMLDoctypeNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitXMLDeclarationNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitCDATANode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitWhitespaceNode(node) {
+            this.visitNode(node);
             this.visitChildNodes(node);
         }
         visitERBContentNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBEndNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBElseNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBIfNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBBlockNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBWhenNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBCaseNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBCaseMatchNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBWhileNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBUntilNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBForNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBRescueNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBEnsureNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBBeginNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBUnlessNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBYieldNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
         visitERBInNode(node) {
+            this.visitNode(node);
+            this.visitERBNode(node);
             this.visitChildNodes(node);
         }
     }
@@ -4079,6 +4415,7 @@
     exports.ERBCaseMatchNode = ERBCaseMatchNode;
     exports.ERBCaseNode = ERBCaseNode;
     exports.ERBContentNode = ERBContentNode;
+    exports.ERBControlFlowScopeError = ERBControlFlowScopeError;
     exports.ERBElseNode = ERBElseNode;
     exports.ERBEndNode = ERBEndNode;
     exports.ERBEnsureNode = ERBEnsureNode;
@@ -4108,6 +4445,7 @@
     exports.LiteralNode = LiteralNode;
     exports.Location = Location;
     exports.MissingClosingTagError = MissingClosingTagError;
+    exports.MissingERBEndTagError = MissingERBEndTagError;
     exports.MissingOpeningTagError = MissingOpeningTagError;
     exports.NODE_TYPE_GUARDS = NODE_TYPE_GUARDS;
     exports.Node = Node;
@@ -4130,6 +4468,8 @@
     exports._TYPECHECK = _TYPECHECK;
     exports.areAllOfType = areAllOfType;
     exports.convertToUTF8 = convertToUTF8;
+    exports.didyoumean = didyoumean;
+    exports.didyoumeanRanked = didyoumeanRanked;
     exports.ensureLibHerbBackend = ensureLibHerbBackend;
     exports.ensureString = ensureString;
     exports.filterCDATANodes = filterCDATANodes;
@@ -4228,6 +4568,7 @@
     exports.isToken = isToken;
     exports.isWhitespaceNode = isWhitespaceNode;
     exports.isXMLDeclarationNode = isXMLDeclarationNode;
+    exports.levenshtein = levenshtein;
     exports.splitNodesAroundLocation = splitNodesAroundLocation;
     exports.splitNodesAroundPosition = splitNodesAroundPosition;
     exports.toMonacoDiagnostic = toMonacoDiagnostic;