python2ts 1.0.0 → 1.1.0

package/dist/{chunk-VYG6GDWU.js → chunk-65ZOMVMA.js}

@@ -228,7 +228,9 @@ function createContext(source) {
     usesRuntime: /* @__PURE__ */ new Set(),
     scopeStack: [/* @__PURE__ */ new Set()],
     // Start with one global scope
-    definedClasses: /* @__PURE__ */ new Set()
+    definedClasses: /* @__PURE__ */ new Set(),
+    insideFunctionBody: 0,
+    hoistedImports: []
   };
 }
 function pushScope(ctx) {
@@ -512,23 +514,29 @@ function parseDocstring(content) {
       currentThrowsDesc = [];
     }
   };
-  for (const line of lines) {
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex] ?? "";
     const trimmed = line.trim();
-    if (/^(Args|Arguments|Parameters):$/i.test(trimmed)) {
+    if (/^-+$/.test(trimmed)) {
+      continue;
+    }
+    const nextLine = lines[lineIndex + 1]?.trim() ?? "";
+    const isNumpySection = /^-+$/.test(nextLine);
+    if (/^(Args|Arguments|Parameters):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       currentSection = "params";
       continue;
     }
-    if (/^(Returns?|Yields?):$/i.test(trimmed)) {
+    if (/^(Returns?|Yields?):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       flushParam();
       currentSection = "returns";
       continue;
     }
-    if (/^(Raises?|Throws?|Exceptions?):$/i.test(trimmed)) {
+    if (/^(Raises?|Throws?|Exceptions?):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       flushParam();
       currentSection = "throws";
       continue;
     }
-    if (/^[A-Z][a-z]+:$/.test(trimmed)) {
+    if (/^[A-Z][a-z]+:?$/.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       continue;
     }
     switch (currentSection) {
@@ -540,14 +548,23 @@ function parseDocstring(content) {
         if (googleMatch) {
           flushParam();
           currentParamName = googleMatch[1] ?? "";
-          const desc = googleMatch[2] ?? "";
-          if (desc) currentParamDesc.push(desc);
+          const afterColon = googleMatch[2] ?? "";
+          const looksLikeType = /^[a-z_][a-z0-9_]*(?:\s+(?:of|or)\s+[a-z_][a-z0-9_]*)*$/i.test(
+            afterColon
+          );
+          if (afterColon && !looksLikeType) {
+            currentParamDesc.push(afterColon);
+          }
         } else if (currentParamName && trimmed) {
           currentParamDesc.push(trimmed);
         }
         break;
       }
       case "returns": {
+        const looksLikeType = /^[a-z_][a-z0-9_]*$/i.test(trimmed);
+        if (looksLikeType && returnsLines.length === 0) {
+          continue;
+        }
         const stripped = trimmed.replace(/^(?:\([^)]*\)|[^:]+):\s*/, "");
         if (stripped || trimmed) {
           returnsLines.push(stripped || trimmed);
@@ -561,6 +578,9 @@ function parseDocstring(content) {
           currentThrowsType = throwsMatch[1] ?? "Error";
           const desc = throwsMatch[2] ?? "";
           if (desc) currentThrowsDesc.push(desc);
+        } else if (/^[A-Z][a-zA-Z]*(?:Error|Exception|Warning)?$/.test(trimmed)) {
+          flushThrows();
+          currentThrowsType = trimmed;
         } else if (trimmed) {
           currentThrowsDesc.push(trimmed);
         }
@@ -626,7 +646,8 @@ function transform(input) {
   const code = transformNode(parseResult.tree.topNode, ctx);
   return {
     code,
-    usesRuntime: ctx.usesRuntime
+    usesRuntime: ctx.usesRuntime,
+    hoistedImports: ctx.hoistedImports
   };
 }
 function transformNode(node, ctx) {
@@ -755,7 +776,9 @@ function transformAssignStatement(node, ctx) {
   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");
-  const targets = children.slice(0, assignOpIndex).filter((c) => c.name !== "," && c.name !== "TypeDef");
+  const beforeAssign = children.slice(0, assignOpIndex);
+  const hasTrailingComma = beforeAssign.some((c) => c.name === ",");
+  const targets = beforeAssign.filter((c) => c.name !== "," && c.name !== "TypeDef");
   const values = children.slice(assignOpIndex + 1).filter((c) => c.name !== ",");
   if (targets.length === 0 || values.length === 0) {
     return getNodeText(node, ctx.source);
@@ -777,7 +800,7 @@ function transformAssignStatement(node, ctx) {
       return `type ${aliasName} = ${aliasType}`;
     }
   }
-  if (targets.length === 1) {
+  if (targets.length === 1 && !hasTrailingComma) {
     const target = targets[0];
     if (!target) return getNodeText(node, ctx.source);
     if (target.name === "MemberExpression" && isSliceExpression(target)) {
@@ -913,9 +936,29 @@ function transformBinaryExpression(node, ctx) {
   if (children.length < 3) return getNodeText(node, ctx.source);
   const left = children[0];
   const op = children[1];
-  const right = children[2];
-  if (!left || !op || !right) return getNodeText(node, ctx.source);
+  if (!left || !op) return getNodeText(node, ctx.source);
   const opText = getNodeText(op, ctx.source);
+  if ((opText === "is" || opText === "not") && children.length >= 4) {
+    const secondOp = children[2];
+    const secondOpText = secondOp ? getNodeText(secondOp, ctx.source) : "";
+    if (opText === "is" && secondOpText === "not") {
+      const right2 = children[3];
+      if (!right2) return getNodeText(node, ctx.source);
+      const leftCode2 = transformNode(left, ctx);
+      const rightCode2 = transformNode(right2, ctx);
+      return `(${leftCode2} !== ${rightCode2})`;
+    }
+    if (opText === "not" && secondOpText === "in") {
+      const right2 = children[3];
+      if (!right2) return getNodeText(node, ctx.source);
+      const leftCode2 = transformNode(left, ctx);
+      const rightCode2 = transformNode(right2, ctx);
+      ctx.usesRuntime.add("contains");
+      return `!contains(${leftCode2}, ${rightCode2})`;
+    }
+  }
+  const right = children[2];
+  if (!right) return getNodeText(node, ctx.source);
   if (isComparisonOperator(opText) && isChainedComparison(left)) {
     const leftComparison = transformNode(left, ctx);
     const middleValue = extractRightOperand(left, ctx);
@@ -1246,6 +1289,15 @@ function transformCallExpression(node, ctx) {
     case "bin":
       ctx.usesRuntime.add("bin");
       return `bin(${args})`;
+    case "getattr":
+      ctx.usesRuntime.add("getattr");
+      return `getattr(${args})`;
+    case "hasattr":
+      ctx.usesRuntime.add("hasattr");
+      return `hasattr(${args})`;
+    case "setattr":
+      ctx.usesRuntime.add("setattr");
+      return `setattr(${args})`;
     // itertools functions
     case "chain":
       ctx.usesRuntime.add("itertools/chain");
@@ -1658,7 +1710,7 @@ function transformArgList(node, ctx) {
     if (item.name === "**" || item.name === "ArithOp" && getNodeText(item, ctx.source) === "**") {
       const nextItem = items[i + 1];
       if (nextItem) {
-        args.push(`...Object.entries(${transformNode(nextItem, ctx)})`);
+        kwArgs.push({ name: "__spread__", value: transformNode(nextItem, ctx) });
         i += 2;
         continue;
       }
@@ -1680,8 +1732,24 @@ function transformArgList(node, ctx) {
     i++;
   }
   if (kwArgs.length > 0) {
-    const kwArgsStr = kwArgs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
-    args.push(`{ ${kwArgsStr} }`);
+    const spreadKwargs = kwArgs.filter((kw) => kw.name === "__spread__");
+    const regularKwargs = kwArgs.filter((kw) => kw.name !== "__spread__");
+    if (regularKwargs.length > 0 && spreadKwargs.length > 0) {
+      const regularStr = regularKwargs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
+      const spreadStr = spreadKwargs.map((kw) => `...${kw.value}`).join(", ");
+      args.push(`{ ${spreadStr}, ${regularStr} }`);
+    } else if (spreadKwargs.length > 0) {
+      const firstSpread = spreadKwargs[0];
+      if (spreadKwargs.length === 1 && firstSpread) {
+        args.push(firstSpread.value);
+      } else {
+        const spreadStr = spreadKwargs.map((kw) => `...${kw.value}`).join(", ");
+        args.push(`{ ${spreadStr} }`);
+      }
+    } else {
+      const kwArgsStr = regularKwargs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
+      args.push(`{ ${kwArgsStr} }`);
+    }
   }
   return args.join(", ");
 }
@@ -1791,10 +1859,31 @@ function transformArrayExpression(node, ctx) {
 }
 function transformDictionaryExpression(node, ctx) {
   const children = getChildren(node);
-  const pairs = [];
   const items = children.filter(
     (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== ":"
   );
+  const keyNodes = [];
+  for (let i = 0; i < items.length; i += 2) {
+    const key = items[i];
+    if (key) keyNodes.push(key);
+  }
+  const allKeysValidForObjectLiteral = keyNodes.every(
+    (key) => key.name === "String" || key.name === "Number" || key.name === "VariableName"
+  );
+  if (!allKeysValidForObjectLiteral) {
+    const mapPairs = [];
+    for (let i = 0; i < items.length; i += 2) {
+      const key = items[i];
+      const value = items[i + 1];
+      if (key && value) {
+        const keyCode = transformNode(key, ctx);
+        const valueCode = transformNode(value, ctx);
+        mapPairs.push(`[${keyCode}, ${valueCode}]`);
+      }
+    }
+    return `new Map([${mapPairs.join(", ")}])`;
+  }
+  const pairs = [];
   for (let i = 0; i < items.length; i += 2) {
     const key = items[i];
     const value = items[i + 1];
@@ -2480,11 +2569,17 @@ function isExceptionType(name) {
 function transformImportStatement(node, ctx) {
   const children = getChildren(node);
   const hasFrom = children.some((c) => c.name === "from");
+  let importCode;
   if (hasFrom) {
-    return transformFromImport(children, ctx);
+    importCode = transformFromImport(children, ctx);
   } else {
-    return transformSimpleImport(children, ctx);
+    importCode = transformSimpleImport(children, ctx);
   }
+  if (ctx.insideFunctionBody > 0 && importCode) {
+    ctx.hoistedImports.push(importCode);
+    return "";
+  }
+  return importCode;
 }
 function transformSimpleImport(children, ctx) {
   const names = [];
@@ -2736,9 +2831,64 @@ ${innerIndent}}`;
   }
   return result;
 }
-function transformBody(node, ctx, skipFirst = false) {
+function extractParamNames(node, source) {
+  const children = getChildren(node);
+  const names = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "(" || child.name === ")" || child.name === "," || child.name === "/" || child.name === ":") {
+      i++;
+      continue;
+    }
+    if (child.name === "*" || getNodeText(child, source) === "*") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "VariableName") {
+        names.push(getNodeText(nextChild, source));
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (child.name === "**" || getNodeText(child, source) === "**") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "VariableName") {
+        names.push(getNodeText(nextChild, source));
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName") {
+      names.push(getNodeText(child, source));
+      i++;
+      continue;
+    }
+    if (child.name === "AssignParam" || child.name === "DefaultParam") {
+      const paramChildren = getChildren(child);
+      const name = paramChildren.find((c) => c.name === "VariableName");
+      if (name) {
+        names.push(getNodeText(name, source));
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return names;
+}
+function transformBody(node, ctx, skipFirst = false, predeclaredVars = []) {
   ctx.indentLevel++;
   pushScope(ctx);
+  for (const v of predeclaredVars) {
+    declareVariable(ctx, v);
+  }
   const children = getChildren(node);
   const indent = "  ".repeat(ctx.indentLevel);
   let filteredChildren = children.filter((child) => child.name !== ":");
@@ -2790,7 +2940,10 @@ function transformFunctionDefinition(node, ctx) {
   const indent = "  ".repeat(ctx.indentLevel);
   const { jsdoc, skipFirstStatement } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null, skipFirstStatement: false };
   const params = paramList ? transformParamList(paramList, ctx) : "";
-  const bodyCode = body ? transformBody(body, ctx, skipFirstStatement) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source) : [];
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformBody(body, ctx, skipFirstStatement, paramNames) : "";
+  ctx.insideFunctionBody--;
   const isGenerator = body ? containsYield(body) : false;
   let returnType = "";
   if (returnTypeDef) {
@@ -2964,7 +3117,10 @@ function transformClassMethod(node, ctx, decorator) {
   }
   const { jsdoc, skipFirstStatement } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null, skipFirstStatement: false };
   const params = paramList ? transformMethodParamList(paramList, ctx) : "";
-  const bodyCode = body ? transformClassMethodBody(body, ctx, skipFirstStatement) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source).filter((n) => n !== "self" && n !== "cls") : [];
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformClassMethodBody(body, ctx, skipFirstStatement, paramNames) : "";
+  ctx.insideFunctionBody--;
   const isGenerator = body ? containsYield(body) : false;
   const generatorStar = isGenerator ? "*" : "";
   if (methodName === "__init__") {
@@ -3125,8 +3281,12 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
   }
   return params.join(", ");
 }
-function transformClassMethodBody(node, ctx, skipFirst = false) {
+function transformClassMethodBody(node, ctx, skipFirst = false, predeclaredVars = []) {
   ctx.indentLevel++;
+  pushScope(ctx);
+  for (const v of predeclaredVars) {
+    declareVariable(ctx, v);
+  }
   const children = getChildren(node);
   const indent = "  ".repeat(ctx.indentLevel);
   let filteredChildren = children.filter((child) => child.name !== ":");
@@ -3152,6 +3312,7 @@ function transformClassMethodBody(node, ctx, skipFirst = false) {
     }
     return indent + transformed;
   }).filter((s) => s.trim() !== "");
+  popScope(ctx);
   ctx.indentLevel--;
   return statements.join("\n");
 }
@@ -3259,12 +3420,15 @@ function transformDecoratedStatement(node, ctx) {
     }
   }
   const params = paramList ? transformParamList(paramList, ctx) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source) : [];
   if (decorators.length === 1 && decorators[0]?.name === "overload") {
     const returnType = extractMethodReturnType(funcDef, ctx);
     const returnTypeStr = returnType ? `: ${returnType === "null" ? "void" : returnType}` : "";
     return `function ${funcName}(${params})${returnTypeStr}`;
   }
-  const bodyCode = body ? transformBody(body, ctx) : "";
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformBody(body, ctx, false, paramNames) : "";
+  ctx.insideFunctionBody--;
   let funcExpr = `function ${funcName}(${params}) {
 ${bodyCode}
 }`;
@@ -3821,16 +3985,50 @@ ${classDecl}` : classDecl;
 function transformParamList(node, ctx) {
   const children = getChildren(node);
   const params = [];
+  const kwOnlyParams = [];
   let restParam = null;
   let kwargsParam = null;
+  let inKeywordOnly = false;
   let i = 0;
+  const parseParam = (startIndex) => {
+    const child = children[startIndex];
+    if (!child || child.name !== "VariableName") return null;
+    const nameCode = getNodeText(child, ctx.source);
+    let tsType = null;
+    let defaultValue = null;
+    let offset = 1;
+    const nextChild = children[startIndex + 1];
+    if (nextChild && nextChild.name === "TypeDef") {
+      tsType = extractTypeAnnotation(nextChild, ctx);
+      offset = 2;
+    }
+    const afterType = children[startIndex + offset];
+    if (afterType && afterType.name === "AssignOp") {
+      const defaultValChild = children[startIndex + offset + 1];
+      if (defaultValChild) {
+        defaultValue = transformNode(defaultValChild, ctx);
+        offset += 2;
+      }
+    }
+    return {
+      param: { name: nameCode, type: tsType, defaultValue },
+      consumed: offset
+    };
+  };
+  const formatParam = (p) => {
+    const typeAnnotation = p.type ? `: ${p.type}` : "";
+    if (p.defaultValue !== null) {
+      return `${p.name}${typeAnnotation} = ${p.defaultValue}`;
+    }
+    return `${p.name}${typeAnnotation}`;
+  };
   while (i < children.length) {
     const child = children[i];
     if (!child) {
       i++;
       continue;
     }
-    if (child.name === "(" || child.name === ")" || child.name === ",") {
+    if (child.name === "(" || child.name === ")" || child.name === "," || child.name === "/") {
       i++;
       continue;
     }
@@ -3847,16 +4045,17 @@ function transformParamList(node, ctx) {
           restParam = `...${name}`;
           i += 2;
         }
+        inKeywordOnly = true;
         continue;
       }
+      inKeywordOnly = true;
       i++;
       continue;
     }
     if (child.name === "**" || getNodeText(child, ctx.source) === "**") {
       const nextChild = children[i + 1];
       if (nextChild && nextChild.name === "VariableName") {
-        const name = getNodeText(nextChild, ctx.source);
-        kwargsParam = name;
+        kwargsParam = getNodeText(nextChild, ctx.source);
         i += 2;
         continue;
       }
@@ -3864,30 +4063,16 @@ function transformParamList(node, ctx) {
       continue;
     }
     if (child.name === "VariableName") {
-      const nameCode = getNodeText(child, ctx.source);
-      let typeAnnotation = "";
-      let offset = 1;
-      const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "TypeDef") {
-        const tsType = extractTypeAnnotation(nextChild, ctx);
-        if (tsType) {
-          typeAnnotation = `: ${tsType}`;
-        }
-        offset = 2;
-      }
-      const afterType = children[i + offset];
-      if (afterType && afterType.name === "AssignOp") {
-        const defaultValChild = children[i + offset + 1];
-        if (defaultValChild) {
-          const defaultCode = transformNode(defaultValChild, ctx);
-          params.push(`${nameCode}${typeAnnotation} = ${defaultCode}`);
-          i += offset + 2;
-          continue;
+      const result = parseParam(i);
+      if (result) {
+        if (inKeywordOnly) {
+          kwOnlyParams.push(result.param);
+        } else {
+          params.push(formatParam(result.param));
         }
+        i += result.consumed;
+        continue;
       }
-      params.push(`${nameCode}${typeAnnotation}`);
-      i += offset;
-      continue;
     }
     if (child.name === "AssignParam" || child.name === "DefaultParam") {
       const paramChildren = getChildren(child);
@@ -3897,12 +4082,15 @@ function transformParamList(node, ctx) {
       if (name) {
         const nameCode = getNodeText(name, ctx.source);
         const tsType = extractTypeAnnotation(typeDef, ctx);
-        const typeAnnotation = tsType ? `: ${tsType}` : "";
+        let defaultValue = null;
         if (defaultVal && name !== defaultVal && defaultVal.name !== "TypeDef") {
-          const defaultCode = transformNode(defaultVal, ctx);
-          params.push(`${nameCode}${typeAnnotation} = ${defaultCode}`);
+          defaultValue = transformNode(defaultVal, ctx);
+        }
+        const param = { name: nameCode, type: tsType, defaultValue };
+        if (inKeywordOnly) {
+          kwOnlyParams.push(param);
         } else {
-          params.push(`${nameCode}${typeAnnotation}`);
+          params.push(formatParam(param));
         }
       }
       i++;
@@ -3910,7 +4098,25 @@ function transformParamList(node, ctx) {
     }
     i++;
   }
-  if (kwargsParam && !restParam) {
+  if (kwOnlyParams.length > 0) {
+    const destructuredNames = [];
+    const typeProps = [];
+    const defaults = [];
+    for (const p of kwOnlyParams) {
+      destructuredNames.push(p.name);
+      const propType = p.type ?? "unknown";
+      typeProps.push(`${p.name}?: ${propType}`);
+      if (p.defaultValue !== null) {
+        defaults.push(`${p.name} = ${p.defaultValue}`);
+      } else {
+        defaults.push(p.name);
+      }
+    }
+    const destructure = `{ ${defaults.join(", ")} }`;
+    const typeAnnotation = `{ ${typeProps.join("; ")} }`;
+    params.push(`${destructure}: ${typeAnnotation} = {}`);
+  }
+  if (kwargsParam) {
     const kwargsType = ": Record<string, unknown>";
     params.push(`${kwargsParam}${kwargsType} = {}`);
   }
@@ -4051,15 +4257,29 @@ function transformDictComprehension(node, ctx) {
       continue;
     }
     if (item.name === "for" || item.name === "Keyword" && getNodeText(item, ctx.source) === "for") {
-      const varNode = clauseItems[i + 1];
-      const iterableNode = clauseItems[i + 3];
-      if (varNode && iterableNode) {
+      const variables = [];
+      let j = i + 1;
+      while (j < clauseItems.length) {
+        const currentItem = clauseItems[j];
+        if (currentItem?.name === "in" || currentItem && getNodeText(currentItem, ctx.source) === "in") {
+          break;
+        }
+        const varItem = clauseItems[j];
+        if (varItem && varItem.name !== ",") {
+          variables.push(transformNode(varItem, ctx));
+        }
+        j++;
+      }
+      const iterableNode = clauseItems[j + 1];
+      const firstVariable = variables[0];
+      if (variables.length > 0 && iterableNode && firstVariable) {
+        const variable = variables.length === 1 ? firstVariable : `[${variables.join(", ")}]`;
         clauses.push({
           type: "for",
-          variable: transformNode(varNode, ctx),
+          variable,
           iterable: transformNode(iterableNode, ctx)
         });
-        i += 4;
+        i = j + 2;
       } else {
         i++;
       }
@@ -4371,6 +4591,10 @@ function generate(input, options = {}) {
     runtimeImport = buildRuntimeImports(usedRuntimeFunctions, basePath);
   }
   let code = result.code;
+  if (result.hoistedImports.length > 0) {
+    const hoistedCode = result.hoistedImports.join("\n");
+    code = hoistedCode + "\n\n" + code;
+  }
   if (runtimeImport) {
     code = runtimeImport + "\n\n" + code;
   }
@@ -4479,4 +4703,4 @@ export {
 /* v8 ignore next -- bare yield statement @preserve */
 /* v8 ignore next 2 -- fallback for future/unknown runtime functions @preserve */
 /* v8 ignore start -- async wrappers tested via CLI @preserve */
-//# sourceMappingURL=chunk-VYG6GDWU.js.map
+//# sourceMappingURL=chunk-65ZOMVMA.js.map