rawsql-ts 0.5.0-beta → 0.7.0-beta

package/dist/esm/types/models/ValueComponent.d.ts

@@ -13,19 +13,34 @@ export declare class ValueList extends SqlComponent {
     constructor(values: ValueComponent[]);
 }
 export declare class ColumnReference extends SqlComponent {
+    /**
+     * For backward compatibility: returns the namespaces as IdentifierString[] | null (readonly)
+     */
+    get namespaces(): IdentifierString[] | null;
+    /**
+     * For backward compatibility: returns the column name as IdentifierString (readonly)
+     */
+    get column(): IdentifierString;
     static kind: symbol;
-    namespaces: IdentifierString[] | null;
-    column: IdentifierString;
-    constructor(namespaces: string | string[] | null, column: string);
+    qualifiedName: QualifiedName;
+    constructor(namespaces: string | string[] | IdentifierString[] | null, column: string | IdentifierString);
     toString(): string;
     getNamespace(): string;
 }
 export declare class FunctionCall extends SqlComponent {
     static kind: symbol;
-    name: RawString;
+    qualifiedName: QualifiedName;
     argument: ValueComponent | null;
     over: OverExpression | null;
-    constructor(name: string, argument: ValueComponent | null, over: OverExpression | null);
+    constructor(namespaces: string[] | IdentifierString[] | null, name: string | RawString | IdentifierString, argument: ValueComponent | null, over: OverExpression | null);
+    /**
+     * For backward compatibility: returns the namespaces as IdentifierString[] | null (readonly)
+     */
+    get namespaces(): IdentifierString[] | null;
+    /**
+     * For backward compatibility: returns the function name as RawString | IdentifierString (readonly)
+     */
+    get name(): RawString | IdentifierString;
 }
 export type OverExpression = WindowFrameExpression | IdentifierString;
 export declare enum WindowFrameType {
@@ -148,17 +163,39 @@ export declare class BetweenExpression extends SqlComponent {
 export declare class StringSpecifierExpression extends SqlComponent {
     static kind: symbol;
     specifier: RawString;
-    value: ValueComponent;
+    value: LiteralValue;
     constructor(specifier: string, value: string);
 }
 export declare class TypeValue extends SqlComponent {
     static kind: symbol;
-    type: RawString;
+    qualifiedName: QualifiedName;
     argument: ValueComponent | null;
-    constructor(type: string, argument?: ValueComponent | null);
+    constructor(namespaces: string[] | IdentifierString[] | null, name: string | RawString | IdentifierString, argument?: ValueComponent | null);
+    /**
+     * For backward compatibility: returns the namespaces as IdentifierString[] | null (readonly)
+     */
+    get namespaces(): IdentifierString[] | null;
+    /**
+     * For backward compatibility: returns the type name as RawString | IdentifierString (readonly)
+     */
+    get name(): RawString | IdentifierString;
+    getTypeName(): string;
 }
 export declare class TupleExpression extends SqlComponent {
     static kind: symbol;
     values: ValueComponent[];
     constructor(values: ValueComponent[]);
 }
+/**
+ * Represents a qualified name with optional namespaces (e.g. schema.table, db.schema.function)
+ */
+export declare class QualifiedName extends SqlComponent {
+    static kind: symbol;
+    /** List of namespaces (e.g. schema, database) */
+    namespaces: IdentifierString[] | null;
+    /** The actual name (e.g. table, function, type, column) */
+    name: RawString | IdentifierString;
+    constructor(namespaces: string[] | IdentifierString[] | null, name: string | RawString | IdentifierString);
+    /** Returns the full qualified name as a string (dot-separated) */
+    toString(): string;
+}

package/dist/esm/types/parsers/FetchClauseParser.d.ts

@@ -0,0 +1,24 @@
+import { FetchClause, FetchExpression } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class FetchClauseParser {
+    /**
+     * Parses a FETCH clause from a lexeme array starting at the given index.
+     * Supports syntax like: FETCH [FIRST|NEXT] <count> ROWS ONLY
+     * @param lexemes The array of lexemes
+     * @param index The starting index
+     * @returns { value: FetchSpecification, newIndex: number }
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: FetchClause;
+        newIndex: number;
+    };
+}
+export declare class FetchExpressionParser {
+    /**
+     * Parses a FETCH expression (not the whole clause, just the fetch part)
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: FetchExpression;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/FullNameParser.d.ts

@@ -0,0 +1,27 @@
+import { Lexeme } from "../models/Lexeme";
+import { IdentifierString } from "../models/ValueComponent";
+/**
+ * Utility class for parsing fully qualified names (e.g. db.schema.table or db.schema.table.column_name)
+ * This can be used for both table and column references.
+ */
+export declare class FullNameParser {
+    /**
+     * Parses a fully qualified name from lexemes, returning namespaces, table, and new index.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        namespaces: string[] | null;
+        name: IdentifierString;
+        newIndex: number;
+        lastTokenType: number;
+    };
+    /**
+     * Parses a fully qualified name from a string (e.g. 'db.schema.table')
+     * Returns { namespaces, name }
+     */
+    static parse(str: string): {
+        namespaces: string[] | null;
+        name: IdentifierString;
+    };
+    private static parseEscapedOrDotSeparatedIdentifiers;
+    private static extractNamespacesAndName;
+}

package/dist/esm/types/parsers/IdentifierDecorator.d.ts

@@ -0,0 +1,9 @@
+export declare class IdentifierDecorator {
+    start: string;
+    end: string;
+    constructor(identifierEscape?: {
+        start?: string;
+        end?: string;
+    });
+    decorate(text: string): string;
+}

package/dist/esm/types/parsers/InsertQueryParser.d.ts

@@ -13,5 +13,4 @@ export declare class InsertQueryParser {
         value: InsertQuery;
         newIndex: number;
     };
-    private static parseFullQualifiedName;
 }

package/dist/esm/types/parsers/JoinClauseParser.d.ts

@@ -9,6 +9,4 @@ export declare class JoinClauseParser {
     private static parseLateral;
     private static isJoinCommand;
     private static parseJoinClause;
-    private static tryParseJoinOn;
-    private static tryParseJoinUsing;
 }

package/dist/esm/types/parsers/JoinOnClauseParser.d.ts

@@ -0,0 +1,8 @@
+import { JoinOnClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class JoinOnClauseParser {
+    static tryParse(lexemes: Lexeme[], index: number): {
+        value: JoinOnClause;
+        newIndex: number;
+    } | null;
+}

package/dist/esm/types/parsers/JoinUsingClauseParser.d.ts

@@ -0,0 +1,8 @@
+import { JoinUsingClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class JoinUsingClauseParser {
+    static tryParse(lexemes: Lexeme[], index: number): {
+        value: JoinUsingClause;
+        newIndex: number;
+    } | null;
+}

package/dist/esm/types/parsers/OffsetClauseParser.d.ts

@@ -0,0 +1,9 @@
+import { OffsetClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+export declare class OffsetClauseParser {
+    static parse(query: string): OffsetClause;
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: OffsetClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/ParameterDecorator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This decorator formats parameter tokens according to DBMS-specific rules.
+ * It supports prefix/suffix, and parameter style (named, indexed, anonymous).
+ */
+export declare class ParameterDecorator {
+    prefix: string;
+    suffix: string;
+    style: 'named' | 'indexed' | 'anonymous';
+    constructor(options?: {
+        prefix?: string;
+        suffix?: string;
+        style?: 'named' | 'indexed' | 'anonymous';
+    });
+    /**
+     * Decorate a parameter token with DBMS-specific format.
+     * @param token The parameter token
+     * @param index The parameter index (for indexed/anonymous)
+     */
+    decorate(text: string, index: number): string;
+}

package/dist/esm/types/parsers/ReturningClauseParser.d.ts

@@ -0,0 +1,12 @@
+import { Lexeme } from "../models/Lexeme";
+import { ReturningClause } from "../models/Clause";
+export declare class ReturningClauseParser {
+    /**
+     * Parse RETURNING clause from lexemes, starting at the given index.
+     * Returns a ReturningClause instance and the new index after parsing.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ReturningClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SelectClauseParser.d.ts

@@ -1,4 +1,4 @@
-import { SelectClause } from "../models/Clause";
+import { SelectClause, SelectItem } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class SelectClauseParser {
     static parse(query: string): SelectClause;
@@ -6,5 +6,22 @@ export declare class SelectClauseParser {
         value: SelectClause;
         newIndex: number;
     };
-    private static parseItem;
+}
+export declare class SelectItemParser {
+    /**
+     * Parses a single select item from a SQL string.
+     * @param query The SQL string representing a select item (e.g. 'id as user_id').
+     * @returns The parsed SelectItem instance.
+     */
+    static parse(query: string): SelectItem;
+    /**
+     * Parses a single select item from lexemes.
+     * @param lexemes The array of lexemes.
+     * @param index The starting index.
+     * @returns An object containing the SelectItem and the new index.
+     */
+    static parseItem(lexemes: Lexeme[], index: number): {
+        value: SelectItem;
+        newIndex: number;
+    };
 }

package/dist/esm/types/parsers/SetClauseParser.d.ts

@@ -0,0 +1,11 @@
+import { Lexeme } from "../models/Lexeme";
+import { SetClause } from "../models/Clause";
+/**
+ * Parse SET clause from lexemes (including 'SET' keyword check).
+ */
+export declare class SetClauseParser {
+    static parseFromLexeme(lexemes: Lexeme[], idx: number): {
+        setClause: SetClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SourceExpressionParser.d.ts

@@ -1,6 +1,14 @@
 import { SourceExpression } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class SourceExpressionParser {
+    /**
+     * Parse SQL string to SourceExpression (e.g. "table", "table as t", "schema.table t")
+     */
+    static parse(query: string): SourceExpression;
+    static parseTableSourceFromLexemes(lexemes: Lexeme[], index: number): {
+        value: SourceExpression;
+        newIndex: number;
+    };
     static parseFromLexeme(lexemes: Lexeme[], index: number): {
         value: SourceExpression;
         newIndex: number;

package/dist/esm/types/parsers/SourceParser.d.ts

@@ -2,6 +2,20 @@ import { SourceComponent } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class SourceParser {
     static parse(query: string): SourceComponent;
+    /**
+     * Parses only a TableSource from the given lexemes, regardless of the presence of parentheses after the identifier.
+     * This method is specifically used for cases like INSERT queries (e.g., "insert into table_name (col1, col2)")
+     * where a parenthesis immediately following the table name could otherwise be misinterpreted as a function call.
+     * By using this method, the parser forcibly treats the source as a TableSource.
+     *
+     * @param lexemes The array of lexemes to parse.
+     * @param index The starting index in the lexeme array.
+     * @returns An object containing the parsed TableSource and the new index.
+     */
+    static parseTableSourceFromLexemes(lexemes: Lexeme[], index: number): {
+        value: SourceComponent;
+        newIndex: number;
+    };
     static parseFromLexeme(lexemes: Lexeme[], index: number): {
         value: SourceComponent;
         newIndex: number;

package/dist/esm/types/parsers/SqlPrintTokenParser.d.ts

@@ -0,0 +1,144 @@
+import { FromClause, JoinClause, JoinOnClause, JoinUsingClause, FunctionSource, SourceAliasExpression, WhereClause, GroupByClause, HavingClause, SubQuerySource, WindowFrameClause, LimitClause, ForClause, OffsetClause, WindowsClause as WindowClause, CommonTable, WithClause, FetchClause, FetchExpression, UpdateClause, SetClause, ReturningClause, SetClauseItem } from "../models/Clause";
+import { SimpleSelectQuery, ValuesQuery } from "../models/SelectQuery";
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+import { SqlPrintToken } from "../models/SqlPrintToken";
+import { InlineQuery } from "../models/ValueComponent";
+import { IdentifierDecorator } from "./IdentifierDecorator";
+import { ParameterDecorator } from "./ParameterDecorator";
+import { CreateTableQuery } from "../models/CreateTableQuery";
+export declare enum ParameterStyle {
+    Anonymous = "anonymous",
+    Indexed = "indexed",
+    Named = "named"
+}
+export interface FormatterConfig {
+    identifierEscape?: {
+        start: string;
+        end: string;
+    };
+    parameterSymbol?: string | {
+        start: string;
+        end: string;
+    };
+    /**
+     * Parameter style: anonymous (?), indexed ($1), or named (:name)
+     */
+    parameterStyle?: ParameterStyle;
+}
+export declare const PRESETS: Record<string, FormatterConfig>;
+export declare class SqlPrintTokenParser implements SqlComponentVisitor<SqlPrintToken> {
+    private static readonly SPACE_TOKEN;
+    private static readonly COMMA_TOKEN;
+    private static readonly ARGUMENT_SPLIT_COMMA_TOKEN;
+    private static readonly PAREN_OPEN_TOKEN;
+    private static readonly PAREN_CLOSE_TOKEN;
+    private static readonly DOT_TOKEN;
+    private handlers;
+    parameterDecorator: ParameterDecorator;
+    identifierDecorator: IdentifierDecorator;
+    index: number;
+    constructor(options?: {
+        preset?: FormatterConfig;
+        identifierEscape?: {
+            start: string;
+            end: string;
+        };
+        parameterSymbol?: string | {
+            start: string;
+            end: string;
+        };
+        parameterStyle?: 'anonymous' | 'indexed' | 'named';
+    });
+    /**
+     * Pretty-prints a BinarySelectQuery (e.g., UNION, INTERSECT, EXCEPT).
+     * This will recursively print left and right queries, separated by the operator.
+     * @param arg BinarySelectQuery
+     */
+    private visitBinarySelectQuery;
+    /**
+     * Returns an array of tokens representing a comma followed by a space.
+     * This is a common pattern in SQL pretty-printing.
+     */
+    private static commaSpaceTokens;
+    private static argumentCommaSpaceTokens;
+    private visitQualifiedName;
+    private visitPartitionByClause;
+    private visitOrderByClause;
+    /**
+     * Print an OrderByItem (expression [asc|desc] [nulls first|last])
+     */
+    private visitOrderByItem;
+    parse(arg: SqlComponent): {
+        token: SqlPrintToken;
+        params: any[] | Record<string, any>[] | Record<string, any>;
+    };
+    visit(arg: SqlComponent): SqlPrintToken;
+    private visitValueList;
+    private visitColumnReference;
+    private visitFunctionCall;
+    private visitUnaryExpression;
+    private visitBinaryExpression;
+    private visitLiteralValue;
+    private visitParameterExpression;
+    private visitSwitchCaseArgument;
+    private createElseToken;
+    private visitCaseKeyValuePair;
+    private visitRawString;
+    private visitIdentifierString;
+    private visitParenExpression;
+    private visitCastExpression;
+    private visitCaseExpression;
+    private visitArrayExpression;
+    private visitBetweenExpression;
+    private visitStringSpecifierExpression;
+    private visitTypeValue;
+    private visitTupleExpression;
+    private visitWindowFrameExpression;
+    private visitWindowFrameSpec;
+    /**
+     * Prints a window frame boundary value, such as "5 preceding" or "3 following".
+     * @param arg WindowFrameBoundaryValue
+     */
+    private visitWindowFrameBoundaryValue;
+    /**
+     * Prints a static window frame bound, such as "unbounded preceding", "current row", or "unbounded following".
+     * @param arg WindowFrameBoundStatic
+     */
+    private visitWindowFrameBoundStatic;
+    private visitSelectItem;
+    private visitSelectClause;
+    private visitDistinct;
+    private visitDistinctOn;
+    private visitTableSource;
+    private visitSourceExpression;
+    visitFromClause(arg: FromClause): SqlPrintToken;
+    visitJoinClause(arg: JoinClause): SqlPrintToken;
+    visitJoinOnClause(arg: JoinOnClause): SqlPrintToken;
+    visitJoinUsingClause(arg: JoinUsingClause): SqlPrintToken;
+    visitFunctionSource(arg: FunctionSource): SqlPrintToken;
+    visitSourceAliasExpression(arg: SourceAliasExpression): SqlPrintToken;
+    visitWhereClause(arg: WhereClause): SqlPrintToken;
+    visitGroupByClause(arg: GroupByClause): SqlPrintToken;
+    visitHavingClause(arg: HavingClause): SqlPrintToken;
+    visitWindowClause(arg: WindowClause): SqlPrintToken;
+    visitWindowFrameClause(arg: WindowFrameClause): SqlPrintToken;
+    visitLimitClause(arg: LimitClause): SqlPrintToken;
+    visitOffsetClause(arg: OffsetClause): SqlPrintToken;
+    visitFetchClause(arg: FetchClause): SqlPrintToken;
+    visitFetchExpression(arg: FetchExpression): SqlPrintToken;
+    visitForClause(arg: ForClause): SqlPrintToken;
+    visitWithClause(arg: WithClause): SqlPrintToken;
+    visitCommonTable(arg: CommonTable): SqlPrintToken;
+    visitSimpleQuery(arg: SimpleSelectQuery): SqlPrintToken;
+    visitSubQuerySource(arg: SubQuerySource): SqlPrintToken;
+    visitValuesQuery(arg: ValuesQuery): SqlPrintToken;
+    visitInlineQuery(arg: InlineQuery): SqlPrintToken;
+    private visitInsertQuery;
+    private visitInsertClause;
+    private visitUpdateQuery;
+    visitUpdateClause(arg: UpdateClause): SqlPrintToken;
+    visitSetClause(arg: SetClause): SqlPrintToken;
+    visitSetClauseItem(arg: SetClauseItem): SqlPrintToken;
+    visitReturningClause(arg: ReturningClause): SqlPrintToken;
+    visitCreateTableQuery(arg: CreateTableQuery): SqlPrintToken;
+}

package/dist/esm/types/parsers/UpdateClauseParser.d.ts

@@ -0,0 +1,15 @@
+import { UpdateClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+/**
+ * Parses the target of an UPDATE statement (table or source expression with optional alias).
+ */
+export declare class UpdateClauseParser {
+    /**
+     * Parse from lexeme array (returns UpdateClause and new index)
+     * This method parses a table or a table with alias using SourceExpressionParser.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: UpdateClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/UpdateQueryParser.d.ts

@@ -0,0 +1,16 @@
+import { UpdateQuery } from "../models/UpdateQuery";
+import { Lexeme } from "../models/Lexeme";
+export declare class UpdateQueryParser {
+    /**
+     * Parse SQL string to UpdateQuery AST.
+     * @param query SQL string
+     */
+    static parse(query: string): UpdateQuery;
+    /**
+     * Parse from lexeme array (for internal use and tests)
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: UpdateQuery;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/WindowClauseParser.d.ts

@@ -1,9 +1,9 @@
-import { WindowFrameClause } from "../models/Clause";
+import { WindowsClause } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class WindowClauseParser {
-    static parse(query: string): WindowFrameClause;
+    static parse(query: string): WindowsClause;
     static parseFromLexeme(lexemes: Lexeme[], index: number): {
-        value: WindowFrameClause;
+        value: WindowsClause;
         newIndex: number;
     };
 }

package/dist/esm/types/transformers/Formatter.d.ts

@@ -1,108 +1,17 @@
-import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
-export declare enum ParameterStyle {
-    Anonymous = "anonymous",// ?
-    Indexed = "indexed",// $1, $2, ...
-    Named = "named"
-}
-interface FormatterConfig {
-    identifierEscape?: {
-        start: string;
-        end: string;
-    };
-    parameterSymbol?: string | {
-        start: string;
-        end: string;
-    };
-    /**
-     * Parameter style: anonymous (?), indexed ($1), or named (:name)
-     */
-    parameterStyle?: ParameterStyle;
-}
+import { SqlFormatter } from './SqlFormatter';
+import { SqlComponent, SqlComponentVisitor } from '../models/SqlComponent';
+import { FormatterConfig } from '../parsers/SqlPrintTokenParser';
+/**
+ * @deprecated The Formatter class is deprecated. Use SqlFormatter instead.
+ */
 export declare class Formatter implements SqlComponentVisitor<string> {
-    /**
-     * Preset configs for common DB dialects.
-     */
-    static readonly PRESETS: Record<string, FormatterConfig>;
-    private handlers;
-    private config;
-    private parameterIndex;
+    private sqlFormatter;
     constructor();
-    /**
-     * Formats the given SQL AST node into a SQL string.
-     * This is the recommended public API for users.
-     * @param arg The root SQL AST node to format.
-     * @param config (Optional) Formatter configuration.
-     * @returns The formatted SQL string.
-     */
     format(arg: SqlComponent, config?: FormatterConfig | null): string;
     formatWithParameters(arg: SqlComponent, config?: FormatterConfig | null): {
         sql: string;
         params: any[] | Record<string, any>[] | Record<string, any>;
     };
-    /**
-     * Visitor entry point for SQL AST nodes.
-     * Note: This method is public only for interface compatibility.
-     *       Users should call the format() method instead of visit() directly.
-     *       (If you call visit() directly, you are basically breaking the abstraction, so don't do it!)
-     * @param arg The SQL AST node to visit.
-     * @returns The formatted SQL string for the node.
-     */
     visit(arg: SqlComponent): string;
-    private visitBinarySelectQuery;
-    private visitWindowFrameBoundaryValue;
-    private visitWindowFrameBoundStatic;
-    private visitWindowFrameExpression;
-    private visitWindowFrameSpec;
-    private visitJoinUsingClause;
-    private visitJoinOnClause;
-    private visitTypeValue;
-    private visitStringSpecifierExpression;
-    private visitWithClause;
-    private visitCommonTable;
-    private visitDistinctOn;
-    private visitDistinct;
-    private visitHavingClause;
-    private visitGroupByClause;
-    private visitFromClause;
-    private visitJoinClause;
-    private visitSourceAliasExpression;
-    private visitSourceExpression;
-    private visitSubQuerySource;
-    private visitFunctionSource;
-    private visitTableSource;
-    private visitValueList;
-    private visitSwitchCaseArgument;
-    private visitColumnReference;
-    private visitFunctionCall;
-    private visitUnaryExpression;
-    private visitBinaryExpression;
-    private visitLiteralExpression;
-    private visitParameterExpression;
-    private visitSelectItemExpression;
-    private visitSelectClause;
-    private visitSelectQuery;
-    private visitArrayExpression;
-    private visitCaseExpression;
-    private visitCastExpression;
-    private visitBracketExpression;
-    private visitBetweenExpression;
-    private visitPartitionByClause;
-    private visitOrderByClause;
-    private visitOrderByItem;
-    private visitWindowFrameClause;
-    private visitLimitClause;
-    private visitFetchSpecification;
-    private visitForClause;
-    private visitWhereClause;
-    private visitInlineQuery;
-    private visitRawString;
-    private visitIdentifierString;
-    private visitValuesQuery;
-    private visitTupleExpression;
-    /**
-     * Formats a CreateTableQuery into SQL string.
-     */
-    private visitCreateTableQuery;
-    private visitInsertQuery;
 }
-export {};
+export { SqlFormatter };

package/dist/esm/types/transformers/LinePrinter.d.ts

@@ -0,0 +1,41 @@
+export type NewlineOption = ' ' | '\n' | '\r\n';
+export type IndentCharOption = '' | ' ' | '\t';
+/**
+ * SqlPrintHelper provides utility methods for SQL pretty printing.
+ */
+export declare class LinePrinter {
+    indentChar: IndentCharOption;
+    indentSize: number;
+    newline: NewlineOption;
+    lines: PrintLine[];
+    /**
+     * @param indentChar Character used for indentation (default: ' ') // Updated comment to reflect options
+     * @param indentSize Number of indentChar per level (default: 0)
+     * @param newline Newline string (default: '\r\n') // Changed type and default value
+     */
+    constructor(indentChar?: IndentCharOption, indentSize?: number, newline?: NewlineOption);
+    print(): string;
+    /**
+     * Returns the indent string for a given level.
+     * @param level Indentation level
+     */
+    private indent;
+    /**
+     * Appends a newline token to the given tokens array if newline is set, or adds an empty line if tokens is empty.
+     * @param tokens Array of token objects with 'level' and 'text' property
+     * @param level Indentation level
+     */
+    appendNewline(level: number): void;
+    /**
+     * Appends text to the last element of tokens array.
+     * @param tokens Array of token objects with 'text' property
+     * @param text Text to append
+     */
+    appendText(text: string): void;
+    getCurrentLine(): PrintLine;
+}
+export declare class PrintLine {
+    level: number;
+    text: string;
+    constructor(level: number, text: string);
+}