@robinpath/robinpath 0.30.0

package/dist/classes/code-converter/LineIndex.d.ts

@@ -0,0 +1,54 @@
+/**
+ * LineIndex - Fast row/col → offset conversion
+ */
+/**
+ * LineIndex interface for fast row/col → offset conversion
+ */
+export interface LineIndex {
+    offsetAt(row: number, col: number, exclusive?: boolean): number;
+    lineEndOffset(row: number): number;
+    hasNewline(row: number): boolean;
+    getLine(row: number): string;
+    getLines(): string[];
+    lineCount(): number;
+}
+/**
+ * LineIndex implementation - Fast row/col → offset conversion
+ *
+ * Build once per originalScript. Provides O(1) offset conversion
+ * by pre-computing line-start offsets.
+ */
+export declare class LineIndexImpl implements LineIndex {
+    private readonly lineStartOffsets;
+    private readonly lines;
+    private readonly originalScript;
+    constructor(originalScript: string);
+    /**
+     * Convert row/column to character offset
+     * @param row Zero-based row number
+     * @param col Zero-based column number
+     * @param exclusive If true, return offset one past the column (for end positions)
+     * @returns Character offset in the script string
+     */
+    offsetAt(row: number, col: number, exclusive?: boolean): number;
+    /**
+     * Get the offset at the end of a line (after the newline)
+     */
+    lineEndOffset(row: number): number;
+    /**
+     * Check if a line has a newline character
+     */
+    hasNewline(row: number): boolean;
+    /**
+     * Get the text content of a specific line
+     */
+    getLine(row: number): string;
+    /**
+     * Get all lines as an array
+     */
+    getLines(): string[];
+    /**
+     * Get the total number of lines
+     */
+    lineCount(): number;
+}

package/dist/classes/code-converter/Printer.d.ts

@@ -0,0 +1,117 @@
+import { PrintContext, CommentWithPosition } from './types';
+import { Value } from '../../utils/types';
+import { Statement } from '../../types/Ast.type';
+import { Writer } from './Writer';
+/**
+ * Printer class - AST → string conversion
+ *
+ * Pure function(s), no access to originalScript.
+ * Uses a Writer to avoid heavy string concatenations.
+ */
+export declare class Printer {
+    private static printersRegistry;
+    /**
+     * Print a statement node to code
+     */
+    static printNode(node: Statement, ctx: PrintContext): string;
+    /**
+     * Print a comment
+     */
+    static printComment(comment: CommentWithPosition, indentLevel?: number): string;
+    /**
+     * Get value type
+     */
+    static getValueType(value: Value): 'string' | 'number' | 'boolean' | 'null' | 'object' | 'array';
+    /**
+     * Convert value type
+     */
+    static convertValueType(value: Value, targetType: 'string' | 'number' | 'boolean' | 'null' | 'object' | 'array'): Value | null;
+    /**
+     * Print argument/expression code
+     */
+    static printArg(arg: any, _ctx: PrintContext): string | null;
+    /**
+     * Print a variable reference
+     */
+    static printVarRef(name: string, path?: any[]): string;
+    /**
+     * Print an into target
+     */
+    static printIntoTarget(targetName: string, targetPath?: any[]): string;
+    /**
+     * Print assignment node
+     */
+    static printAssignment(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print cell block node
+     */
+    static printCellBlock(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print chunk marker node
+     */
+    static printChunkMarker(node: any, writer: Writer, _ctx: PrintContext): void;
+    /**
+     * Print command node
+     */
+    static printCommand(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print a comment node
+     */
+    static printCommentNode(node: any, writer: Writer, _ctx: PrintContext): void;
+    /**
+     * Get leading comments from a statement node.
+     */
+    private static getLeadingComments;
+    /**
+     * Get inline comment from a statement node.
+     */
+    static getInlineComment(stmt: any): CommentWithPosition | null;
+    /**
+     * Format an inline comment as a string to append to a line.
+     */
+    static formatInlineComment(comment: CommentWithPosition | null): string;
+    /**
+     * Emit decorators for a node if they exist.
+     */
+    private static emitDecorators;
+    /**
+     * Emit leading comments for a statement, preserving blank lines between them.
+     */
+    static emitLeadingComments(stmt: any, writer: Writer, _ctx: PrintContext, indentLevel: number): boolean;
+    /**
+     * Check if there's a blank line gap between the last comment and a statement.
+     */
+    static emitBlankLineAfterComments(stmt: any, writer: Writer): void;
+    /**
+     * Check if there's a blank line gap between two statements.
+     */
+    static emitBlankLineBetweenStatements(prevStmt: any, currentStmt: any, writer: Writer): void;
+    /**
+     * Print define (function definition) node
+     */
+    static printDefine(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print do block node
+     */
+    static printDo(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print for loop node
+     */
+    static printForLoop(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print ifBlock node
+     */
+    static printIfBlock(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print on block node
+     */
+    static printOnBlock(node: any, writer: Writer, ctx: PrintContext): void;
+    /**
+     * Print prompt block node
+     */
+    static printPromptBlock(node: any, writer: Writer, _ctx: PrintContext): void;
+    /**
+     * Print together block node
+     */
+    static printTogether(node: any, writer: Writer, ctx: PrintContext): void;
+}

package/dist/classes/code-converter/Writer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Writer - Efficient string building for code generation
+ *
+ * Avoids repeated string concatenation by using an array-based approach.
+ */
+export declare class Writer {
+    private parts;
+    private currentIndent;
+    private indentString;
+    /**
+     * Push a string to the output
+     */
+    push(text: string): void;
+    /**
+     * Push a newline
+     */
+    newline(): void;
+    /**
+     * Set the indentation level
+     */
+    indent(level: number): void;
+    /**
+     * Push text with current indentation
+     */
+    pushIndented(text: string): void;
+    /**
+     * Push a line with current indentation
+     */
+    pushLine(text: string): void;
+    /**
+     * Push a blank line
+     */
+    pushBlankLine(): void;
+    /**
+     * Get the final string
+     */
+    toString(): string;
+    /**
+     * Clear all content
+     */
+    clear(): void;
+}

package/dist/classes/code-converter/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Code Converter Module - Exports
+ */
+export { ASTToCodeConverter, PatchPlanner, PatchApplier, CommentLayoutNormalizer } from './ASTToCodeConverter';
+export { Writer } from './Writer';
+export { LineIndexImpl } from './LineIndex';
+export { Printer } from './Printer';
+export type { Patch, CommentLayout, PrintContext, LineIndex, CommentWithPosition } from './types';

package/dist/classes/code-converter/types.d.ts

@@ -0,0 +1,29 @@
+import { CommentWithPosition } from '../../types/Ast.type';
+import { LineIndex } from './LineIndex';
+/**
+ * Represents a patch operation to apply to source code
+ */
+export interface Patch {
+    startOffset: number;
+    endOffset: number;
+    replacement: string;
+}
+/**
+ * Comment layout information for a statement
+ */
+export interface CommentLayout {
+    leadingComments: CommentWithPosition[];
+    inlineComment: CommentWithPosition | null;
+    leadingGapLines: number;
+    trailingBlankLinesAfterStandaloneComment: number;
+}
+/**
+ * Context for printing AST nodes
+ */
+export interface PrintContext {
+    indentLevel: number;
+    lineIndex: LineIndex;
+    originalScript?: string;
+    allowExtractOriginalCode?: boolean;
+}
+export type { CommentWithPosition, LineIndex };

package/dist/classes/exceptions.d.ts

@@ -0,0 +1,26 @@
+import { Value } from '../utils';
+/**
+ * Special exception used to signal early return from functions or global scope
+ */
+export declare class ReturnException extends Error {
+    value: Value;
+    constructor(value: Value);
+}
+/**
+ * Special exception used to signal break from loops
+ */
+export declare class BreakException extends Error {
+    constructor();
+}
+/**
+ * Special exception used to signal continue to next iteration of loops
+ */
+export declare class ContinueException extends Error {
+    constructor();
+}
+/**
+ * Special exception used to signal end of script execution
+ */
+export declare class EndException extends Error {
+    constructor();
+}

package/dist/classes/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Barrel export for all RobinPath classes
+ */
+export { Lexer, TokenKind, KEYWORDS } from './Lexer';
+export type { Token, SourcePosition } from './Lexer';
+export { TokenStream } from './TokenStream';
+export { Parser } from './Parser';
+export { ExpressionEvaluator } from './ExpressionEvaluator';
+export { Executor } from './Executor';
+export { ExecutionStateTracker } from './ExecutionStateTracker';
+export type { ExecutionLog, ExecutionStepInfo, LogCallback } from './ExecutionStateTracker';
+export { ReturnException, BreakException, EndException } from './exceptions';
+export { RobinPathThread } from './RobinPathThread';
+export { ASTSerializer } from './ASTSerializer';
+export { ASTToCodeConverter, Printer, LineIndexImpl } from './code-converter';
+export type { PrintContext, LineIndex } from './code-converter';