python2ts 1.3.3 → 1.4.1

package/dist/{chunk-TBFKEIAB.js → chunk-R57A2BPG.js}

@@ -791,6 +791,8 @@ function transformNode(node, ctx) {
       return transformExpressionStatement(node, ctx);
     case "AssignStatement":
       return transformAssignStatement(node, ctx);
+    case "UpdateStatement":
+      return transformUpdateStatement(node, ctx);
     case "BinaryExpression":
       return transformBinaryExpression(node, ctx);
     case "UnaryExpression":
@@ -807,6 +809,8 @@ function transformNode(node, ctx) {
       return transformString(node, ctx);
     case "FormatString":
       return transformFormatString(node, ctx);
+    case "ContinuedString":
+      return transformContinuedString(node, ctx);
     case "Boolean":
       return transformBoolean(node, ctx);
     case "None":
@@ -927,6 +931,42 @@ function transformExpressionStatement(node, ctx) {
 function transformAssignStatement(node, ctx) {
   const children = getChildren(node);
   if (children.length < 3) return getNodeText(node, ctx.source);
+  const assignOpIndices = children.map((c, i) => c.name === "AssignOp" || c.name === "=" ? i : -1).filter((i) => i !== -1);
+  if (assignOpIndices.length > 1) {
+    const targets2 = [];
+    const lastAssignOpIndex = assignOpIndices[assignOpIndices.length - 1];
+    if (lastAssignOpIndex === void 0) return getNodeText(node, ctx.source);
+    for (let i = 0; i < assignOpIndices.length; i++) {
+      const opIndex = assignOpIndices[i];
+      if (opIndex === void 0) continue;
+      const prevOpIndex = i > 0 ? assignOpIndices[i - 1] : -1;
+      const startIdx = prevOpIndex !== void 0 ? prevOpIndex + 1 : 0;
+      const targetNodes = children.slice(startIdx, opIndex).filter((c) => c.name !== ",");
+      if (targetNodes.length === 1 && targetNodes[0]) {
+        targets2.push(targetNodes[0]);
+      }
+    }
+    const valueNodes = children.slice(lastAssignOpIndex + 1).filter((c) => c.name !== ",");
+    if (valueNodes.length !== 1 || !valueNodes[0]) return getNodeText(node, ctx.source);
+    const valueCode = transformNode(valueNodes[0], ctx);
+    const results = [];
+    let lastVarName = valueCode;
+    for (let i = targets2.length - 1; i >= 0; i--) {
+      const target = targets2[i];
+      if (!target) continue;
+      const targetCode = transformNode(target, ctx);
+      const varName = getNodeText(target, ctx.source);
+      let needsDeclaration = false;
+      if (target.name === "VariableName" && !isVariableDeclared(ctx, varName)) {
+        needsDeclaration = true;
+        declareVariable(ctx, varName);
+      }
+      const keyword = needsDeclaration ? "let " : "";
+      results.push(`${keyword}${targetCode} = ${lastVarName}`);
+      lastVarName = targetCode;
+    }
+    return results.join(";\n");
+  }
   const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
   if (assignOpIndex === -1) return getNodeText(node, ctx.source);
   const typeDef = children.slice(0, assignOpIndex).find((c) => c.name === "TypeDef");
@@ -1025,6 +1065,23 @@ function extractVariableNames(nodes, source) {
   }
   return names;
 }
+function transformUpdateStatement(node, ctx) {
+  const children = getChildren(node);
+  const target = children.find(
+    (c) => c.name === "VariableName" || c.name === "MemberExpression" || c.name === "Subscript"
+  );
+  const op = children.find((c) => c.name === "UpdateOp");
+  const value = children.find(
+    (c) => c !== target && c.name !== "UpdateOp" && c.name !== "(" && c.name !== ")" && c.name !== "," && c.name !== ":"
+  );
+  if (!target || !op || !value) {
+    return getNodeText(node, ctx.source);
+  }
+  const targetCode = transformNode(target, ctx);
+  const opText = getNodeText(op, ctx.source);
+  const valueCode = transformNode(value, ctx);
+  return `${targetCode} ${opText} ${valueCode}`;
+}
 function isSliceExpression(node) {
   const children = getChildren(node);
   return children.some((c) => c.name === ":");
@@ -1317,6 +1374,51 @@ function transformFormatString(node, ctx) {
   result += "`";
   return result;
 }
+function transformContinuedString(node, ctx) {
+  const children = getChildren(node);
+  const hasFormatString = children.some((c) => c.name === "FormatString");
+  if (hasFormatString) {
+    const parts = children.filter((c) => c.name === "String" || c.name === "FormatString").map((c) => {
+      if (c.name === "FormatString") {
+        return transformFormatString(c, ctx);
+      } else {
+        const text = getNodeText(c, ctx.source);
+        let content;
+        if (/^[rR]['"]/.test(text)) {
+          content = text.slice(2, -1);
+        } else if (/^[rR]"""/.test(text) || /^[rR]'''/.test(text)) {
+          content = text.slice(4, -3);
+        } else if (text.startsWith('"""') || text.startsWith("'''")) {
+          content = text.slice(3, -3);
+        } else {
+          content = text.slice(1, -1);
+        }
+        return "`" + content.replace(/`/g, "\\`") + "`";
+      }
+    });
+    return parts.join(" + ");
+  } else {
+    const parts = children.filter((c) => c.name === "String").map((c) => {
+      const text = getNodeText(c, ctx.source);
+      let content;
+      if (/^[rR]['"]/.test(text)) {
+        content = text.slice(2, -1);
+      } else if (/^[rR]"""/.test(text) || /^[rR]'''/.test(text)) {
+        content = text.slice(4, -3);
+      } else if (text.startsWith('"""') || text.startsWith("'''")) {
+        content = text.slice(3, -3);
+      } else {
+        content = text.slice(1, -1);
+      }
+      return content;
+    });
+    const joined = parts.join("");
+    if (joined.includes('"') && !joined.includes("'")) {
+      return "'" + joined + "'";
+    }
+    return '"' + joined + '"';
+  }
+}
 function transformBoolean(node, ctx) {
   const text = getNodeText(node, ctx.source);
   return text === "True" ? "true" : "false";
@@ -3140,7 +3242,12 @@ function transformWithStatement(node, ctx) {
       body = child;
       break;
     }
-    if (child.name !== "as" && child.name !== ":" && child.name !== "VariableName") {
+    if (child.name === "as" || child.name === ":") {
+      i++;
+      continue;
+    }
+    const isContextManagerExpr = child.name !== "VariableName" || children[i + 1]?.name === "as" || children[i + 1]?.name === "Body" || children[i + 1]?.name === ",";
+    if (isContextManagerExpr) {
       const expr = child;
       let varName = null;
       const nextChild = children[i + 1];
@@ -3691,6 +3798,45 @@ function transformClassMethodBody(node, ctx, skipFirst = false, predeclaredVars
 function transformClassAssignment(node, ctx) {
   const children = getChildren(node);
   if (children.length < 3) return getNodeText(node, ctx.source);
+  const assignOpIndices = children.map((c, i) => c.name === "AssignOp" || c.name === "=" ? i : -1).filter((i) => i !== -1);
+  if (assignOpIndices.length > 1) {
+    const chainTargets = [];
+    const lastAssignOpIndex = assignOpIndices[assignOpIndices.length - 1];
+    if (lastAssignOpIndex === void 0) return getNodeText(node, ctx.source);
+    for (let i = 0; i < assignOpIndices.length; i++) {
+      const opIndex = assignOpIndices[i];
+      if (opIndex === void 0) continue;
+      const prevOpIndex = i > 0 ? assignOpIndices[i - 1] : -1;
+      const startIdx = prevOpIndex !== void 0 ? prevOpIndex + 1 : 0;
+      const targetNodes = children.slice(startIdx, opIndex).filter((c) => c.name !== ",");
+      if (targetNodes.length === 1 && targetNodes[0]) {
+        chainTargets.push(targetNodes[0]);
+      }
+    }
+    const valueNodes = children.slice(lastAssignOpIndex + 1).filter((c) => c.name !== ",");
+    if (valueNodes.length !== 1 || !valueNodes[0]) return getNodeText(node, ctx.source);
+    const valueCode = transformNode(valueNodes[0], ctx);
+    const results = [];
+    let lastVarName = valueCode;
+    const indent = "  ".repeat(ctx.indentLevel);
+    for (let i = chainTargets.length - 1; i >= 0; i--) {
+      const target = chainTargets[i];
+      if (!target) continue;
+      const targetCode = transformNode(target, ctx);
+      const varName = getNodeText(target, ctx.source);
+      const isMemberAssignment = target.name === "MemberExpression";
+      let needsDeclaration = false;
+      if (!isMemberAssignment && target.name === "VariableName" && !isVariableDeclared(ctx, varName)) {
+        needsDeclaration = true;
+        declareVariable(ctx, varName);
+      }
+      const keyword = needsDeclaration ? "let " : "";
+      results.push(`${keyword}${targetCode} = ${lastVarName}`);
+      lastVarName = targetCode;
+    }
+    return results.join(`;
+${indent}`);
+  }
   const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
   if (assignOpIndex === -1) return getNodeText(node, ctx.source);
   const targets = children.slice(0, assignOpIndex).filter((c) => c.name !== ",");
@@ -4564,15 +4710,40 @@ function parseComprehensionClauses(children, ctx) {
       continue;
     }
     if (item.name === "for" || item.name === "Keyword" && getNodeText(item, ctx.source) === "for") {
-      const varNode = items[i + 1];
-      const iterableNode = items[i + 3];
-      if (varNode && iterableNode) {
+      let inIndex = -1;
+      for (let j = i + 1; j < items.length; j++) {
+        const candidate = items[j];
+        if (candidate && (candidate.name === "in" || candidate.name === "Keyword" && getNodeText(candidate, ctx.source) === "in")) {
+          inIndex = j;
+          break;
+        }
+      }
+      if (inIndex === -1) {
+        i++;
+        continue;
+      }
+      const varNodes = [];
+      for (let j = i + 1; j < inIndex; j++) {
+        const varCandidate = items[j];
+        if (varCandidate && varCandidate.name !== ",") {
+          varNodes.push(varCandidate);
+        }
+      }
+      const iterableNode = items[inIndex + 1];
+      if (varNodes.length > 0 && iterableNode) {
+        let variable;
+        const firstVarNode = varNodes[0];
+        if (varNodes.length === 1 && firstVarNode) {
+          variable = transformNode(firstVarNode, ctx);
+        } else {
+          variable = "[" + varNodes.map((v) => transformNode(v, ctx)).join(", ") + "]";
+        }
         clauses.push({
           type: "for",
-          variable: transformNode(varNode, ctx),
+          variable,
           iterable: transformNode(iterableNode, ctx)
         });
-        i += 4;
+        i = inIndex + 2;
       } else {
         i++;
       }

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   transpileAsync
-} from "../chunk-TBFKEIAB.js";
+} from "../chunk-R57A2BPG.js";
 
 // src/cli/index.ts
 import { parseArgs } from "util";

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   transpile,
   transpileAsync,
   walkTree
-} from "./chunk-TBFKEIAB.js";
+} from "./chunk-R57A2BPG.js";
 export {
   debugTree,
   formatCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "python2ts",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "AST-based Python to TypeScript transpiler. Convert Python code to clean, idiomatic TypeScript with full type preservation.",
   "homepage": "https://sebastian-software.github.io/python2ts/",
   "repository": {