@herb-tools/core 0.8.10 → 0.9.1

package/dist/types/errors.d.ts

@@ -1,7 +1,8 @@
 import { Location, SerializedLocation } from "./location.js";
+import { Position, SerializedPosition } from "./position.js";
 import { Token, SerializedToken } from "./token.js";
 import { Diagnostic, MonacoDiagnostic } from "./diagnostic.js";
-export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "QUOTES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSINGERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR" | "ERB_CASE_WITH_CONDITIONS_ERROR";
+export type HerbErrorType = "UNEXPECTED_ERROR" | "UNEXPECTED_TOKEN_ERROR" | "MISSING_OPENING_TAG_ERROR" | "MISSING_CLOSING_TAG_ERROR" | "TAG_NAMES_MISMATCH_ERROR" | "VOID_ELEMENT_CLOSING_TAG_ERROR" | "UNCLOSED_ELEMENT_ERROR" | "RUBY_PARSE_ERROR" | "ERB_CONTROL_FLOW_SCOPE_ERROR" | "MISSING_ERB_END_TAG_ERROR" | "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR" | "ERB_CASE_WITH_CONDITIONS_ERROR" | "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR" | "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR" | "INVALID_COMMENT_CLOSING_TAG_ERROR" | "OMITTED_CLOSING_TAG_ERROR" | "UNCLOSED_OPEN_TAG_ERROR" | "UNCLOSED_CLOSE_TAG_ERROR" | "UNCLOSED_QUOTE_ERROR" | "MISSING_ATTRIBUTE_VALUE_ERROR" | "UNCLOSED_ERB_TAG_ERROR" | "STRAY_ERB_CLOSING_TAG_ERROR" | "NESTED_ERB_TAG_ERROR" | "RENDER_AMBIGUOUS_LOCALS_ERROR" | "RENDER_MISSING_LOCALS_ERROR" | "RENDER_NO_ARGUMENTS_ERROR" | "RENDER_CONFLICTING_PARTIAL_ERROR" | "RENDER_INVALID_AS_OPTION_ERROR" | "RENDER_OBJECT_AND_COLLECTION_ERROR" | "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR";
 export type SerializedErrorType = string;
 export interface SerializedHerbError {
     type: string;
@@ -133,29 +134,6 @@ export declare class TagNamesMismatchError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
-export interface SerializedQuotesMismatchError {
-    type: "QUOTES_MISMATCH_ERROR";
-    message: string;
-    location: SerializedLocation;
-    opening_quote: SerializedToken | null;
-    closing_quote: SerializedToken | null;
-}
-export interface QuotesMismatchErrorProps {
-    type: string;
-    message: string;
-    location: Location;
-    opening_quote: Token | null;
-    closing_quote: Token | null;
-}
-export declare class QuotesMismatchError extends HerbError {
-    readonly opening_quote: Token | null;
-    readonly closing_quote: Token | null;
-    static from(data: SerializedQuotesMismatchError): QuotesMismatchError;
-    constructor(props: QuotesMismatchErrorProps);
-    toJSON(): SerializedQuotesMismatchError;
-    toMonacoDiagnostic(): MonacoDiagnostic;
-    treeInspect(): string;
-}
 export interface SerializedVoidElementClosingTagError {
     type: "VOID_ELEMENT_CLOSING_TAG_ERROR";
     message: string;
@@ -249,7 +227,7 @@ export declare class ERBControlFlowScopeError extends HerbError {
     treeInspect(): string;
 }
 export interface SerializedMissingERBEndTagError {
-    type: "MISSINGERB_END_TAG_ERROR";
+    type: "MISSING_ERB_END_TAG_ERROR";
     message: string;
     location: SerializedLocation;
     keyword: string;
@@ -302,4 +280,391 @@ export declare class ERBCaseWithConditionsError extends HerbError {
     toMonacoDiagnostic(): MonacoDiagnostic;
     treeInspect(): string;
 }
+export interface SerializedConditionalElementMultipleTagsError {
+    type: "CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    line: any;
+    column: any;
+}
+export interface ConditionalElementMultipleTagsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    line: any;
+    column: any;
+}
+export declare class ConditionalElementMultipleTagsError extends HerbError {
+    readonly line: any;
+    readonly column: any;
+    static from(data: SerializedConditionalElementMultipleTagsError): ConditionalElementMultipleTagsError;
+    constructor(props: ConditionalElementMultipleTagsErrorProps);
+    toJSON(): SerializedConditionalElementMultipleTagsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedConditionalElementConditionMismatchError {
+    type: "CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: string;
+    open_condition: string;
+    open_line: any;
+    open_column: any;
+    close_condition: string;
+    close_line: any;
+    close_column: any;
+}
+export interface ConditionalElementConditionMismatchErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: string;
+    open_condition: string;
+    open_line: any;
+    open_column: any;
+    close_condition: string;
+    close_line: any;
+    close_column: any;
+}
+export declare class ConditionalElementConditionMismatchError extends HerbError {
+    readonly tag_name: string;
+    readonly open_condition: string;
+    readonly open_line: any;
+    readonly open_column: any;
+    readonly close_condition: string;
+    readonly close_line: any;
+    readonly close_column: any;
+    static from(data: SerializedConditionalElementConditionMismatchError): ConditionalElementConditionMismatchError;
+    constructor(props: ConditionalElementConditionMismatchErrorProps);
+    toJSON(): SerializedConditionalElementConditionMismatchError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedInvalidCommentClosingTagError {
+    type: "INVALID_COMMENT_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    closing_tag: SerializedToken | null;
+}
+export interface InvalidCommentClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    closing_tag: Token | null;
+}
+export declare class InvalidCommentClosingTagError extends HerbError {
+    readonly closing_tag: Token | null;
+    static from(data: SerializedInvalidCommentClosingTagError): InvalidCommentClosingTagError;
+    constructor(props: InvalidCommentClosingTagErrorProps);
+    toJSON(): SerializedInvalidCommentClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedOmittedClosingTagError {
+    type: "OMITTED_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+    insertion_point: SerializedPosition;
+}
+export interface OmittedClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+    insertion_point: Position;
+}
+export declare class OmittedClosingTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    readonly insertion_point: Position;
+    static from(data: SerializedOmittedClosingTagError): OmittedClosingTagError;
+    constructor(props: OmittedClosingTagErrorProps);
+    toJSON(): SerializedOmittedClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedOpenTagError {
+    type: "UNCLOSED_OPEN_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: SerializedToken | null;
+}
+export interface UnclosedOpenTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: Token | null;
+}
+export declare class UnclosedOpenTagError extends HerbError {
+    readonly tag_name: Token | null;
+    static from(data: SerializedUnclosedOpenTagError): UnclosedOpenTagError;
+    constructor(props: UnclosedOpenTagErrorProps);
+    toJSON(): SerializedUnclosedOpenTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedCloseTagError {
+    type: "UNCLOSED_CLOSE_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    tag_name: SerializedToken | null;
+}
+export interface UnclosedCloseTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    tag_name: Token | null;
+}
+export declare class UnclosedCloseTagError extends HerbError {
+    readonly tag_name: Token | null;
+    static from(data: SerializedUnclosedCloseTagError): UnclosedCloseTagError;
+    constructor(props: UnclosedCloseTagErrorProps);
+    toJSON(): SerializedUnclosedCloseTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedQuoteError {
+    type: "UNCLOSED_QUOTE_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_quote: SerializedToken | null;
+}
+export interface UnclosedQuoteErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_quote: Token | null;
+}
+export declare class UnclosedQuoteError extends HerbError {
+    readonly opening_quote: Token | null;
+    static from(data: SerializedUnclosedQuoteError): UnclosedQuoteError;
+    constructor(props: UnclosedQuoteErrorProps);
+    toJSON(): SerializedUnclosedQuoteError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedMissingAttributeValueError {
+    type: "MISSING_ATTRIBUTE_VALUE_ERROR";
+    message: string;
+    location: SerializedLocation;
+    attribute_name: string;
+}
+export interface MissingAttributeValueErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    attribute_name: string;
+}
+export declare class MissingAttributeValueError extends HerbError {
+    readonly attribute_name: string;
+    static from(data: SerializedMissingAttributeValueError): MissingAttributeValueError;
+    constructor(props: MissingAttributeValueErrorProps);
+    toJSON(): SerializedMissingAttributeValueError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedUnclosedERBTagError {
+    type: "UNCLOSED_ERB_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+}
+export interface UnclosedERBTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+}
+export declare class UnclosedERBTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    static from(data: SerializedUnclosedERBTagError): UnclosedERBTagError;
+    constructor(props: UnclosedERBTagErrorProps);
+    toJSON(): SerializedUnclosedERBTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedStrayERBClosingTagError {
+    type: "STRAY_ERB_CLOSING_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface StrayERBClosingTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class StrayERBClosingTagError extends HerbError {
+    static from(data: SerializedStrayERBClosingTagError): StrayERBClosingTagError;
+    constructor(props: StrayERBClosingTagErrorProps);
+    toJSON(): SerializedStrayERBClosingTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedNestedERBTagError {
+    type: "NESTED_ERB_TAG_ERROR";
+    message: string;
+    location: SerializedLocation;
+    opening_tag: SerializedToken | null;
+    nested_tag_line: any;
+    nested_tag_column: any;
+}
+export interface NestedERBTagErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    opening_tag: Token | null;
+    nested_tag_line: any;
+    nested_tag_column: any;
+}
+export declare class NestedERBTagError extends HerbError {
+    readonly opening_tag: Token | null;
+    readonly nested_tag_line: any;
+    readonly nested_tag_column: any;
+    static from(data: SerializedNestedERBTagError): NestedERBTagError;
+    constructor(props: NestedERBTagErrorProps);
+    toJSON(): SerializedNestedERBTagError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderAmbiguousLocalsError {
+    type: "RENDER_AMBIGUOUS_LOCALS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    partial: string;
+}
+export interface RenderAmbiguousLocalsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    partial: string;
+}
+export declare class RenderAmbiguousLocalsError extends HerbError {
+    readonly partial: string;
+    static from(data: SerializedRenderAmbiguousLocalsError): RenderAmbiguousLocalsError;
+    constructor(props: RenderAmbiguousLocalsErrorProps);
+    toJSON(): SerializedRenderAmbiguousLocalsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderMissingLocalsError {
+    type: "RENDER_MISSING_LOCALS_ERROR";
+    message: string;
+    location: SerializedLocation;
+    partial: string;
+    keywords: string;
+}
+export interface RenderMissingLocalsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    partial: string;
+    keywords: string;
+}
+export declare class RenderMissingLocalsError extends HerbError {
+    readonly partial: string;
+    readonly keywords: string;
+    static from(data: SerializedRenderMissingLocalsError): RenderMissingLocalsError;
+    constructor(props: RenderMissingLocalsErrorProps);
+    toJSON(): SerializedRenderMissingLocalsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderNoArgumentsError {
+    type: "RENDER_NO_ARGUMENTS_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface RenderNoArgumentsErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class RenderNoArgumentsError extends HerbError {
+    static from(data: SerializedRenderNoArgumentsError): RenderNoArgumentsError;
+    constructor(props: RenderNoArgumentsErrorProps);
+    toJSON(): SerializedRenderNoArgumentsError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderConflictingPartialError {
+    type: "RENDER_CONFLICTING_PARTIAL_ERROR";
+    message: string;
+    location: SerializedLocation;
+    positional_partial: string;
+    keyword_partial: string;
+}
+export interface RenderConflictingPartialErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    positional_partial: string;
+    keyword_partial: string;
+}
+export declare class RenderConflictingPartialError extends HerbError {
+    readonly positional_partial: string;
+    readonly keyword_partial: string;
+    static from(data: SerializedRenderConflictingPartialError): RenderConflictingPartialError;
+    constructor(props: RenderConflictingPartialErrorProps);
+    toJSON(): SerializedRenderConflictingPartialError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderInvalidAsOptionError {
+    type: "RENDER_INVALID_AS_OPTION_ERROR";
+    message: string;
+    location: SerializedLocation;
+    as_value: string;
+}
+export interface RenderInvalidAsOptionErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    as_value: string;
+}
+export declare class RenderInvalidAsOptionError extends HerbError {
+    readonly as_value: string;
+    static from(data: SerializedRenderInvalidAsOptionError): RenderInvalidAsOptionError;
+    constructor(props: RenderInvalidAsOptionErrorProps);
+    toJSON(): SerializedRenderInvalidAsOptionError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderObjectAndCollectionError {
+    type: "RENDER_OBJECT_AND_COLLECTION_ERROR";
+    message: string;
+    location: SerializedLocation;
+}
+export interface RenderObjectAndCollectionErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+}
+export declare class RenderObjectAndCollectionError extends HerbError {
+    static from(data: SerializedRenderObjectAndCollectionError): RenderObjectAndCollectionError;
+    constructor(props: RenderObjectAndCollectionErrorProps);
+    toJSON(): SerializedRenderObjectAndCollectionError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
+export interface SerializedRenderLayoutWithoutBlockError {
+    type: "RENDER_LAYOUT_WITHOUT_BLOCK_ERROR";
+    message: string;
+    location: SerializedLocation;
+    layout: string;
+}
+export interface RenderLayoutWithoutBlockErrorProps {
+    type: string;
+    message: string;
+    location: Location;
+    layout: string;
+}
+export declare class RenderLayoutWithoutBlockError extends HerbError {
+    readonly layout: string;
+    static from(data: SerializedRenderLayoutWithoutBlockError): RenderLayoutWithoutBlockError;
+    constructor(props: RenderLayoutWithoutBlockErrorProps);
+    toJSON(): SerializedRenderLayoutWithoutBlockError;
+    toMonacoDiagnostic(): MonacoDiagnostic;
+    treeInspect(): string;
+}
 export declare function fromSerializedError(error: SerializedHerbError): HerbError;

package/dist/types/extract-ruby-options.d.ts

@@ -0,0 +1,6 @@
+export interface ExtractRubyOptions {
+    semicolons?: boolean;
+    comments?: boolean;
+    preserve_positions?: boolean;
+}
+export declare const DEFAULT_EXTRACT_RUBY_OPTIONS: ExtractRubyOptions;

package/dist/types/herb-backend.d.ts

@@ -1,7 +1,9 @@
 import { LexResult } from "./lex-result.js";
 import { ParseResult } from "./parse-result.js";
 import type { LibHerbBackend, BackendPromise } from "./backend.js";
-import type { ParserOptions } from "./parser-options.js";
+import type { ParseOptions } from "./parser-options.js";
+import type { ExtractRubyOptions } from "./extract-ruby-options.js";
+import type { PrismParseResult } from "./prism/index.js";
 /**
  * The main Herb parser interface, providing methods to lex and parse input.
  */
@@ -31,9 +33,8 @@ export declare abstract class HerbBackend {
      * Lexes a file.
      * @param path - The file path to lex.
      * @returns A `LexResult` instance.
-     * @throws Error if the backend is not loaded.
      */
-    lexFile(path: string): LexResult;
+    abstract lexFile(path: string): LexResult;
     /**
      * Parses the given source string into a `ParseResult`.
      * @param source - The source code to parse.
@@ -41,21 +42,28 @@ export declare abstract class HerbBackend {
      * @returns A `ParseResult` instance.
      * @throws Error if the backend is not loaded.
      */
-    parse(source: string, options?: ParserOptions): ParseResult;
+    parse(source: string, options?: ParseOptions): ParseResult;
     /**
      * Parses a file.
      * @param path - The file path to parse.
      * @returns A `ParseResult` instance.
-     * @throws Error if the backend is not loaded.
      */
-    parseFile(path: string): ParseResult;
+    abstract parseFile(path: string): ParseResult;
     /**
      * Extracts embedded Ruby code from the given source.
      * @param source - The source code to extract Ruby from.
+     * @param options - Optional extraction options.
      * @returns The extracted Ruby code as a string.
      * @throws Error if the backend is not loaded.
      */
-    extractRuby(source: string): string;
+    extractRuby(source: string, options?: ExtractRubyOptions): string;
+    /**
+     * Parses a Ruby source string using Prism via the libherb backend.
+     * @param source - The Ruby source code to parse.
+     * @returns A Prism ParseResult containing the AST.
+     * @throws Error if the backend is not loaded.
+     */
+    parseRuby(source: string): PrismParseResult;
     /**
      * Extracts HTML from the given source.
      * @param source - The source code to extract HTML from.

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./backend.js";
 export * from "./diagnostic.js";
 export * from "./didyoumean.js";
 export * from "./errors.js";
+export * from "./extract-ruby-options.js";
 export * from "./herb-backend.js";
 export * from "./levenshtein.js";
 export * from "./lex-result.js";
@@ -19,3 +20,4 @@ export * from "./token.js";
 export * from "./util.js";
 export * from "./visitor.js";
 export * from "./warning.js";
+export * from "./prism";