python2ts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+import { Tree, SyntaxNode } from '@lezer/common';
+export { py } from 'pythonlib';
+
+interface ParseResult {
+    tree: Tree;
+    source: string;
+}
+interface NodeVisitor<T> {
+    visitNode(node: SyntaxNode, source: string): T;
+}
+declare const NodeTypes: {
+    readonly Script: "Script";
+    readonly ExpressionStatement: "ExpressionStatement";
+    readonly AssignStatement: "AssignStatement";
+    readonly AugmentedAssignStatement: "AugmentedAssignStatement";
+    readonly PrintStatement: "PrintStatement";
+    readonly PassStatement: "PassStatement";
+    readonly BreakStatement: "BreakStatement";
+    readonly ContinueStatement: "ContinueStatement";
+    readonly ReturnStatement: "ReturnStatement";
+    readonly IfStatement: "IfStatement";
+    readonly WhileStatement: "WhileStatement";
+    readonly ForStatement: "ForStatement";
+    readonly FunctionDefinition: "FunctionDefinition";
+    readonly ClassDefinition: "ClassDefinition";
+    readonly TryStatement: "TryStatement";
+    readonly RaiseStatement: "RaiseStatement";
+    readonly ImportStatement: "ImportStatement";
+    readonly FromImportStatement: "FromImportStatement";
+    readonly BinaryExpression: "BinaryExpression";
+    readonly UnaryExpression: "UnaryExpression";
+    readonly CompareOp: "CompareOp";
+    readonly ParenthesizedExpression: "ParenthesizedExpression";
+    readonly ConditionalExpression: "ConditionalExpression";
+    readonly CallExpression: "CallExpression";
+    readonly MemberExpression: "MemberExpression";
+    readonly SubscriptExpression: "SubscriptExpression";
+    readonly Slice: "Slice";
+    readonly Number: "Number";
+    readonly String: "String";
+    readonly FormatString: "FormatString";
+    readonly True: "True";
+    readonly False: "False";
+    readonly None: "None";
+    readonly VariableName: "VariableName";
+    readonly ArrayExpression: "ArrayExpression";
+    readonly DictionaryExpression: "DictionaryExpression";
+    readonly SetExpression: "SetExpression";
+    readonly TupleExpression: "TupleExpression";
+    readonly ListComprehension: "ListComprehension";
+    readonly DictionaryComprehension: "DictionaryComprehension";
+    readonly SetComprehension: "SetComprehension";
+    readonly GeneratorExpression: "GeneratorExpression";
+    readonly ArithOp: "ArithOp";
+    readonly CompareOp_: "CompareOp";
+    readonly AssignOp: "AssignOp";
+    readonly ArgList: "ArgList";
+    readonly ParamList: "ParamList";
+    readonly LambdaExpression: "LambdaExpression";
+    readonly Comment: "Comment";
+    readonly Keyword: "Keyword";
+    readonly Body: "Body";
+};
+type NodeType = (typeof NodeTypes)[keyof typeof NodeTypes];
+
+declare function parse(source: string): ParseResult;
+declare function getNodeText(node: SyntaxNode, source: string): string;
+declare function getChildren(node: SyntaxNode): SyntaxNode[];
+declare function getChildByType(node: SyntaxNode, type: string): SyntaxNode | null;
+declare function getChildrenByType(node: SyntaxNode, type: string): SyntaxNode[];
+declare function walkTree(tree: Tree, callback: (node: SyntaxNode) => void): void;
+declare function debugTree(tree: Tree, source: string): string;
+
+interface TransformContext {
+    source: string;
+    indentLevel: number;
+    usesRuntime: Set<string>;
+    /** Stack of scopes - each scope is a set of variable names declared in that scope */
+    scopeStack: Set<string>[];
+    /** Set of class names defined in this module (for adding 'new' on instantiation) */
+    definedClasses: Set<string>;
+    /** Whether currently processing an abstract class (ABC) */
+    isAbstractClass?: boolean;
+}
+interface TransformResult {
+    code: string;
+    usesRuntime: Set<string>;
+}
+declare function transform(input: string | ParseResult): TransformResult;
+
+interface GeneratorOptions {
+    includeRuntime?: boolean;
+    runtimeImportPath?: string;
+}
+interface GeneratedCode {
+    code: string;
+    runtimeImport: string | null;
+    usedRuntimeFunctions: string[];
+}
+/**
+ * Generate TypeScript code from Python (sync, unformatted)
+ * For formatted output, use generateAsync()
+ */
+declare function generate(input: string | ParseResult, options?: GeneratorOptions): GeneratedCode;
+/**
+ * Transpile Python to TypeScript (sync, unformatted)
+ * For formatted output, use transpileAsync()
+ */
+declare function transpile(python: string, options?: GeneratorOptions): string;
+/**
+ * Format TypeScript code using Prettier
+ */
+declare function formatCode(code: string): Promise<string>;
+/**
+ * Generate TypeScript code from Python (async, formatted with Prettier)
+ */
+declare function generateAsync(input: string | ParseResult, options?: GeneratorOptions): Promise<GeneratedCode>;
+/**
+ * Transpile Python to TypeScript (async, formatted with Prettier)
+ */
+declare function transpileAsync(python: string, options?: GeneratorOptions): Promise<string>;
+
+export { type GeneratedCode, type GeneratorOptions, type NodeType, type NodeVisitor, type ParseResult, type TransformContext, type TransformResult, debugTree, formatCode, generate, generateAsync, getChildByType, getChildren, getChildrenByType, getNodeText, parse, transform, transpile, transpileAsync, walkTree };

package/dist/index.js

@@ -0,0 +1,36 @@
+import {
+  debugTree,
+  formatCode,
+  generate,
+  generateAsync,
+  getChildByType,
+  getChildren,
+  getChildrenByType,
+  getNodeText,
+  parse,
+  transform,
+  transpile,
+  transpileAsync,
+  walkTree
+} from "./chunk-DTI6R2GT.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/index.ts
+import { py } from "pythonlib";
+export {
+  debugTree,
+  formatCode,
+  generate,
+  generateAsync,
+  getChildByType,
+  getChildren,
+  getChildrenByType,
+  getNodeText,
+  parse,
+  py,
+  transform,
+  transpile,
+  transpileAsync,
+  walkTree
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  parse,\n  debugTree,\n  getNodeText,\n  getChildren,\n  getChildByType,\n  getChildrenByType,\n  walkTree\n} from \"./parser/index.js\"\nexport type { ParseResult, NodeVisitor, NodeType } from \"./parser/index.js\"\n\nexport { transform, type TransformResult, type TransformContext } from \"./transformer/index.js\"\n\nexport {\n  generate,\n  generateAsync,\n  transpile,\n  transpileAsync,\n  formatCode,\n  type GeneratorOptions,\n  type GeneratedCode\n} from \"./generator/index.js\"\n\n// Re-export pythonlib runtime for convenience\nexport { py } from \"pythonlib\"\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,SAAS,UAAU;","names":[]}