@herb-tools/core 0.6.0 → 0.6.1

package/dist/types/ast-utils.d.ts

@@ -1,5 +1,6 @@
-import { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode } from "./nodes.js";
-import { Node, ERBContentNode, HTMLAttributeNameNode } from "./nodes.js";
+import { Node, ERBContentNode, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLAttributeNameNode } from "./nodes.js";
+import type { Location } from "./location.js";
+import type { Position } from "./position.js";
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
@@ -72,3 +73,52 @@ export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | HTM
  * Check if a node is a comment (HTML comment or ERB comment)
  */
 export declare function isCommentNode(node: Node): boolean;
+/**
+ * Compares two positions to determine if they are equal
+ * Returns true if pos1 and pos2 are at the same location
+ */
+export declare function isPositionEqual(position1: Position, position2: Position): boolean;
+/**
+ * Compares two positions to determine if the first comes after the second
+ * Returns true if pos1 comes after pos2 in source order
+ * @param inclusive - If true, returns true when positions are equal
+ */
+export declare function isPositionAfter(position1: Position, position2: Position, inclusive?: boolean): boolean;
+/**
+ * Gets nodes that appear before the specified location in source order
+ * Uses line and column positions to determine ordering
+ */
+export declare function getNodesBeforeLocation<T extends Node>(nodes: T[], location: Location): T[];
+/**
+ * Gets nodes that appear after the specified location in source order
+ * Uses line and column positions to determine ordering
+ */
+export declare function getNodesAfterLocation<T extends Node>(nodes: T[], location: Location): T[];
+/**
+ * Splits nodes into before and after the specified location
+ * Returns an object with `before` and `after` arrays
+ */
+export declare function splitNodesAroundLocation<T extends Node>(nodes: T[], location: Location): {
+    before: T[];
+    after: T[];
+};
+/**
+ * Splits nodes at a specific position
+ * Returns nodes that end before the position and nodes that start after the position
+ * More precise than splitNodesAroundLocation as it uses a single position point
+ * Uses the same defaults as the individual functions: before=exclusive, after=inclusive
+ */
+export declare function splitNodesAroundPosition<T extends Node>(nodes: T[], position: Position): {
+    before: T[];
+    after: T[];
+};
+/**
+ * Gets nodes that end before the specified position
+ * @param inclusive - If true, includes nodes that end exactly at the position (default: false, matching half-open interval semantics)
+ */
+export declare function getNodesBeforePosition<T extends Node>(nodes: T[], position: Position, inclusive?: boolean): T[];
+/**
+ * Gets nodes that start after the specified position
+ * @param inclusive - If true, includes nodes that start exactly at the position (default: true, matching typical boundary behavior)
+ */
+export declare function getNodesAfterPosition<T extends Node>(nodes: T[], position: Position, inclusive?: boolean): T[];

package/dist/types/node-type-guards.d.ts

@@ -164,7 +164,7 @@ export declare const NODE_TYPE_GUARDS: Map<new (...args: any[]) => Node, (node:
  *   // node is HTMLTextNode
  * }
  */
-export declare const AST_TYPE_GUARDS: Map<string, (node: Node) => boolean>;
+export declare const AST_TYPE_GUARDS: Map<NodeType, (node: Node) => boolean>;
 type NodeTypeToClass = {
     "AST_DOCUMENT_NODE": DocumentNode;
     "AST_LITERAL_NODE": LiteralNode;
@@ -296,8 +296,8 @@ export declare function filterNodes(nodes: Node[] | undefined | null, ...types:
  *   // node is narrowed to HTMLTextNode
  * }
  */
-export declare function isNode<T extends NodeType>(node: Node, type: T): node is NodeTypeToClass[T];
-export declare function isNode<T extends new (...args: any[]) => Node>(node: Node, type: T): node is ClassToInstance<T>;
+export declare function isNode<T extends NodeType>(node: Node | null | undefined, type: T): node is NodeTypeToClass[T];
+export declare function isNode<T extends new (...args: any[]) => Node>(node: Node | null | undefined, type: T): node is ClassToInstance<T>;
 export declare function isToken(object: any): object is Token;
 export declare function isParseResult(object: any): object is ParseResult;
 /**

package/dist/types/nodes.d.ts

@@ -20,9 +20,16 @@ export declare abstract class Node implements BaseNodeProps {
     readonly location: Location;
     readonly errors: HerbError[];
     static from(node: SerializedNode): Node;
+    static get type(): NodeType;
     constructor(type: NodeType, location: Location, errors: HerbError[]);
     toJSON(): SerializedNode;
     inspect(): string;
+    is<T extends Node>(nodeClass: {
+        new (...args: any[]): T;
+        prototype: T;
+        type: NodeType;
+    }): this is T;
+    isOfType<T extends Node>(type: NodeType): this is T;
     get isSingleLine(): boolean;
     abstract treeInspect(indent?: number): string;
     abstract recursiveErrors(): HerbError[];
@@ -41,6 +48,7 @@ export interface DocumentNodeProps extends BaseNodeProps {
 }
 export declare class DocumentNode extends Node {
     readonly children: Node[];
+    static get type(): NodeType;
     static from(data: SerializedDocumentNode): DocumentNode;
     constructor(props: DocumentNodeProps);
     accept(visitor: Visitor): void;
@@ -59,6 +67,7 @@ export interface LiteralNodeProps extends BaseNodeProps {
 }
 export declare class LiteralNode extends Node {
     readonly content: string;
+    static get type(): NodeType;
     static from(data: SerializedLiteralNode): LiteralNode;
     constructor(props: LiteralNodeProps);
     accept(visitor: Visitor): void;
@@ -89,6 +98,7 @@ export declare class HTMLOpenTagNode extends Node {
     readonly tag_closing: Token | null;
     readonly children: Node[];
     readonly is_void: boolean;
+    static get type(): NodeType;
     static from(data: SerializedHTMLOpenTagNode): HTMLOpenTagNode;
     constructor(props: HTMLOpenTagNodeProps);
     accept(visitor: Visitor): void;
@@ -116,6 +126,7 @@ export declare class HTMLCloseTagNode extends Node {
     readonly tag_name: Token | null;
     readonly children: Node[];
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedHTMLCloseTagNode): HTMLCloseTagNode;
     constructor(props: HTMLCloseTagNodeProps);
     accept(visitor: Visitor): void;
@@ -146,6 +157,7 @@ export declare class HTMLElementNode extends Node {
     readonly body: Node[];
     readonly close_tag: HTMLCloseTagNode | null;
     readonly is_void: boolean;
+    static get type(): NodeType;
     static from(data: SerializedHTMLElementNode): HTMLElementNode;
     constructor(props: HTMLElementNodeProps);
     accept(visitor: Visitor): void;
@@ -173,6 +185,7 @@ export declare class HTMLAttributeValueNode extends Node {
     readonly children: Node[];
     readonly close_quote: Token | null;
     readonly quoted: boolean;
+    static get type(): NodeType;
     static from(data: SerializedHTMLAttributeValueNode): HTMLAttributeValueNode;
     constructor(props: HTMLAttributeValueNodeProps);
     accept(visitor: Visitor): void;
@@ -191,6 +204,7 @@ export interface HTMLAttributeNameNodeProps extends BaseNodeProps {
 }
 export declare class HTMLAttributeNameNode extends Node {
     readonly children: Node[];
+    static get type(): NodeType;
     static from(data: SerializedHTMLAttributeNameNode): HTMLAttributeNameNode;
     constructor(props: HTMLAttributeNameNodeProps);
     accept(visitor: Visitor): void;
@@ -215,6 +229,7 @@ export declare class HTMLAttributeNode extends Node {
     readonly name: HTMLAttributeNameNode | null;
     readonly equals: Token | null;
     readonly value: HTMLAttributeValueNode | null;
+    static get type(): NodeType;
     static from(data: SerializedHTMLAttributeNode): HTMLAttributeNode;
     constructor(props: HTMLAttributeNodeProps);
     accept(visitor: Visitor): void;
@@ -233,6 +248,7 @@ export interface HTMLTextNodeProps extends BaseNodeProps {
 }
 export declare class HTMLTextNode extends Node {
     readonly content: string;
+    static get type(): NodeType;
     static from(data: SerializedHTMLTextNode): HTMLTextNode;
     constructor(props: HTMLTextNodeProps);
     accept(visitor: Visitor): void;
@@ -257,6 +273,7 @@ export declare class HTMLCommentNode extends Node {
     readonly comment_start: Token | null;
     readonly children: Node[];
     readonly comment_end: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedHTMLCommentNode): HTMLCommentNode;
     constructor(props: HTMLCommentNodeProps);
     accept(visitor: Visitor): void;
@@ -281,6 +298,7 @@ export declare class HTMLDoctypeNode extends Node {
     readonly tag_opening: Token | null;
     readonly children: Node[];
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedHTMLDoctypeNode): HTMLDoctypeNode;
     constructor(props: HTMLDoctypeNodeProps);
     accept(visitor: Visitor): void;
@@ -305,6 +323,7 @@ export declare class XMLDeclarationNode extends Node {
     readonly tag_opening: Token | null;
     readonly children: Node[];
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedXMLDeclarationNode): XMLDeclarationNode;
     constructor(props: XMLDeclarationNodeProps);
     accept(visitor: Visitor): void;
@@ -329,6 +348,7 @@ export declare class CDATANode extends Node {
     readonly tag_opening: Token | null;
     readonly children: Node[];
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedCDATANode): CDATANode;
     constructor(props: CDATANodeProps);
     accept(visitor: Visitor): void;
@@ -347,6 +367,7 @@ export interface WhitespaceNodeProps extends BaseNodeProps {
 }
 export declare class WhitespaceNode extends Node {
     readonly value: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedWhitespaceNode): WhitespaceNode;
     constructor(props: WhitespaceNodeProps);
     accept(visitor: Visitor): void;
@@ -377,6 +398,7 @@ export declare class ERBContentNode extends Node {
     readonly tag_closing: Token | null;
     readonly parsed: boolean;
     readonly valid: boolean;
+    static get type(): NodeType;
     static from(data: SerializedERBContentNode): ERBContentNode;
     constructor(props: ERBContentNodeProps);
     accept(visitor: Visitor): void;
@@ -401,6 +423,7 @@ export declare class ERBEndNode extends Node {
     readonly tag_opening: Token | null;
     readonly content: Token | null;
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedERBEndNode): ERBEndNode;
     constructor(props: ERBEndNodeProps);
     accept(visitor: Visitor): void;
@@ -428,6 +451,7 @@ export declare class ERBElseNode extends Node {
     readonly content: Token | null;
     readonly tag_closing: Token | null;
     readonly statements: Node[];
+    static get type(): NodeType;
     static from(data: SerializedERBElseNode): ERBElseNode;
     constructor(props: ERBElseNodeProps);
     accept(visitor: Visitor): void;
@@ -461,6 +485,7 @@ export declare class ERBIfNode extends Node {
     readonly statements: Node[];
     readonly subsequent: Node | null;
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBIfNode): ERBIfNode;
     constructor(props: ERBIfNodeProps);
     accept(visitor: Visitor): void;
@@ -491,6 +516,7 @@ export declare class ERBBlockNode extends Node {
     readonly tag_closing: Token | null;
     readonly body: Node[];
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBBlockNode): ERBBlockNode;
     constructor(props: ERBBlockNodeProps);
     accept(visitor: Visitor): void;
@@ -518,6 +544,7 @@ export declare class ERBWhenNode extends Node {
     readonly content: Token | null;
     readonly tag_closing: Token | null;
     readonly statements: Node[];
+    static get type(): NodeType;
     static from(data: SerializedERBWhenNode): ERBWhenNode;
     constructor(props: ERBWhenNodeProps);
     accept(visitor: Visitor): void;
@@ -554,6 +581,7 @@ export declare class ERBCaseNode extends Node {
     readonly conditions: Node[];
     readonly else_clause: ERBElseNode | null;
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBCaseNode): ERBCaseNode;
     constructor(props: ERBCaseNodeProps);
     accept(visitor: Visitor): void;
@@ -590,6 +618,7 @@ export declare class ERBCaseMatchNode extends Node {
     readonly conditions: Node[];
     readonly else_clause: ERBElseNode | null;
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBCaseMatchNode): ERBCaseMatchNode;
     constructor(props: ERBCaseMatchNodeProps);
     accept(visitor: Visitor): void;
@@ -620,6 +649,7 @@ export declare class ERBWhileNode extends Node {
     readonly tag_closing: Token | null;
     readonly statements: Node[];
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBWhileNode): ERBWhileNode;
     constructor(props: ERBWhileNodeProps);
     accept(visitor: Visitor): void;
@@ -650,6 +680,7 @@ export declare class ERBUntilNode extends Node {
     readonly tag_closing: Token | null;
     readonly statements: Node[];
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBUntilNode): ERBUntilNode;
     constructor(props: ERBUntilNodeProps);
     accept(visitor: Visitor): void;
@@ -680,6 +711,7 @@ export declare class ERBForNode extends Node {
     readonly tag_closing: Token | null;
     readonly statements: Node[];
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBForNode): ERBForNode;
     constructor(props: ERBForNodeProps);
     accept(visitor: Visitor): void;
@@ -710,6 +742,7 @@ export declare class ERBRescueNode extends Node {
     readonly tag_closing: Token | null;
     readonly statements: Node[];
     readonly subsequent: ERBRescueNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBRescueNode): ERBRescueNode;
     constructor(props: ERBRescueNodeProps);
     accept(visitor: Visitor): void;
@@ -737,6 +770,7 @@ export declare class ERBEnsureNode extends Node {
     readonly content: Token | null;
     readonly tag_closing: Token | null;
     readonly statements: Node[];
+    static get type(): NodeType;
     static from(data: SerializedERBEnsureNode): ERBEnsureNode;
     constructor(props: ERBEnsureNodeProps);
     accept(visitor: Visitor): void;
@@ -776,6 +810,7 @@ export declare class ERBBeginNode extends Node {
     readonly else_clause: ERBElseNode | null;
     readonly ensure_clause: ERBEnsureNode | null;
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBBeginNode): ERBBeginNode;
     constructor(props: ERBBeginNodeProps);
     accept(visitor: Visitor): void;
@@ -809,6 +844,7 @@ export declare class ERBUnlessNode extends Node {
     readonly statements: Node[];
     readonly else_clause: ERBElseNode | null;
     readonly end_node: ERBEndNode | null;
+    static get type(): NodeType;
     static from(data: SerializedERBUnlessNode): ERBUnlessNode;
     constructor(props: ERBUnlessNodeProps);
     accept(visitor: Visitor): void;
@@ -833,6 +869,7 @@ export declare class ERBYieldNode extends Node {
     readonly tag_opening: Token | null;
     readonly content: Token | null;
     readonly tag_closing: Token | null;
+    static get type(): NodeType;
     static from(data: SerializedERBYieldNode): ERBYieldNode;
     constructor(props: ERBYieldNodeProps);
     accept(visitor: Visitor): void;
@@ -860,6 +897,7 @@ export declare class ERBInNode extends Node {
     readonly content: Token | null;
     readonly tag_closing: Token | null;
     readonly statements: Node[];
+    static get type(): NodeType;
     static from(data: SerializedERBInNode): ERBInNode;
     constructor(props: ERBInNodeProps);
     accept(visitor: Visitor): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
   "type": "module",
   "license": "MIT",

package/src/ast-utils.ts

@@ -1,5 +1,7 @@
 import {
+  Node,
   LiteralNode,
+  ERBContentNode,
   ERBIfNode,
   ERBUnlessNode,
   ERBBlockNode,
@@ -11,6 +13,7 @@ import {
   HTMLElementNode,
   HTMLOpenTagNode,
   HTMLCloseTagNode,
+  HTMLAttributeNameNode,
   HTMLCommentNode
 } from "./nodes.js"
 
@@ -24,7 +27,8 @@ import {
   filterLiteralNodes
 } from "./node-type-guards.js"
 
-import { Node, ERBContentNode, HTMLAttributeNameNode } from "./nodes.js"
+import type { Location } from "./location.js"
+import type { Position } from "./position.js"
 
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
@@ -189,3 +193,99 @@ export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | HTMLCloseT
 export function isCommentNode(node: Node): boolean {
   return isNode(node, HTMLCommentNode) || (isERBNode(node) && !isERBControlFlowNode(node))
 }
+
+/**
+ * Compares two positions to determine if the first comes before the second
+ * Returns true if pos1 comes before pos2 in source order
+ * @param inclusive - If true, returns true when positions are equal
+ */
+function isPositionBefore(position1: Position, position2: Position, inclusive = false): boolean {
+  if (position1.line < position2.line) return true
+  if (position1.line > position2.line) return false
+
+  return inclusive ? position1.column <= position2.column : position1.column < position2.column
+}
+
+/**
+ * Compares two positions to determine if they are equal
+ * Returns true if pos1 and pos2 are at the same location
+ */
+export function isPositionEqual(position1: Position, position2: Position): boolean {
+  return position1.line === position2.line && position1.column === position2.column
+}
+
+/**
+ * Compares two positions to determine if the first comes after the second
+ * Returns true if pos1 comes after pos2 in source order
+ * @param inclusive - If true, returns true when positions are equal
+ */
+export function isPositionAfter(position1: Position, position2: Position, inclusive = false): boolean {
+  if (position1.line > position2.line) return true
+  if (position1.line < position2.line) return false
+
+  return inclusive ? position1.column >= position2.column : position1.column > position2.column
+}
+
+/**
+ * Gets nodes that appear before the specified location in source order
+ * Uses line and column positions to determine ordering
+ */
+export function getNodesBeforeLocation<T extends Node>(nodes: T[], location: Location): T[] {
+  return nodes.filter(node =>
+    node.location && isPositionBefore(node.location.end, location.start)
+  )
+}
+
+/**
+ * Gets nodes that appear after the specified location in source order
+ * Uses line and column positions to determine ordering
+ */
+export function getNodesAfterLocation<T extends Node>(nodes: T[], location: Location): T[] {
+  return nodes.filter(node =>
+    node.location && isPositionAfter(node.location.start, location.end)
+  )
+}
+
+/**
+ * Splits nodes into before and after the specified location
+ * Returns an object with `before` and `after` arrays
+ */
+export function splitNodesAroundLocation<T extends Node>(nodes: T[], location: Location): { before: T[], after: T[] } {
+  return {
+    before: getNodesBeforeLocation(nodes, location),
+    after: getNodesAfterLocation(nodes, location)
+  }
+}
+
+/**
+ * Splits nodes at a specific position
+ * Returns nodes that end before the position and nodes that start after the position
+ * More precise than splitNodesAroundLocation as it uses a single position point
+ * Uses the same defaults as the individual functions: before=exclusive, after=inclusive
+ */
+export function splitNodesAroundPosition<T extends Node>(nodes: T[], position: Position): { before: T[], after: T[] } {
+  return {
+    before: getNodesBeforePosition(nodes, position), // uses default: inclusive = false
+    after: getNodesAfterPosition(nodes, position)    // uses default: inclusive = true
+  }
+}
+
+/**
+ * Gets nodes that end before the specified position
+ * @param inclusive - If true, includes nodes that end exactly at the position (default: false, matching half-open interval semantics)
+ */
+export function getNodesBeforePosition<T extends Node>(nodes: T[], position: Position, inclusive = false): T[] {
+  return nodes.filter(node =>
+    node.location && isPositionBefore(node.location.end, position, inclusive)
+  )
+}
+
+/**
+ * Gets nodes that start after the specified position  
+ * @param inclusive - If true, includes nodes that start exactly at the position (default: true, matching typical boundary behavior)
+ */
+export function getNodesAfterPosition<T extends Node>(nodes: T[], position: Position, inclusive = true): T[] {
+  return nodes.filter(node =>
+    node.location && isPositionAfter(node.location.start, position, inclusive)
+  )
+}

package/src/errors.ts

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.1/templates/javascript/packages/core/src/errors.ts.erb
 
 import { Location, SerializedLocation } from "./location.js"
 import { Token, SerializedToken } from "./token.js"