@karibulab/wsdl2tsx 0.17.0 → 0.17.2

package/dist/cli.js

@@ -23769,7 +23769,8 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
     let elementNamespace;
     let elementTypeValue = null;
     if (typeof element === "object" && element !== null) {
-      elementNamespace = element.$namespace;
+      const originalElementNamespace = element.$namespace;
+      elementNamespace = originalElementNamespace;
       if ("type" in element && typeof element.type === "string") {
         const referencedType = element.type;
         debugContext("extractAllTagsForXmlBody", `Resolviendo tipo referenciado: "${referencedType}" para tag "${tagLocalName}"`);
@@ -23793,18 +23794,17 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
           if (typeof referencedTypeObject === "object" && referencedTypeObject !== null) {
             const refNamespace = referencedTypeObject[NAMESPACE_KEY];
             if (refNamespace) {
-              elementNamespace = refNamespace;
               const refNamespacePrefix = extractNamespacePrefix(refNamespace);
               if (!foundNamespaces.has(refNamespacePrefix)) {
                 foundNamespaces.set(refNamespacePrefix, refNamespace);
-                debugContext("extractAllTagsForXmlBody", `Registrando namespace adicional: "${refNamespacePrefix}" -> "${refNamespace}"`);
+                debugContext("extractAllTagsForXmlBody", `Registrando namespace del tipo referenciado: "${refNamespacePrefix}" -> "${refNamespace}"`);
               }
             }
             if ("type" in referencedTypeObject && typeof referencedTypeObject.type === "object") {
               elementTypeValue = referencedTypeObject.type;
             }
           }
-          debugContext("extractAllTagsForXmlBody", `\u2713 Tipo referenciado resuelto para "${tagLocalName}"`);
+          debugContext("extractAllTagsForXmlBody", `\u2713 Tipo referenciado resuelto para "${tagLocalName}" (elemento en namespace: "${elementNamespace || currentNamespace}", tipo en namespace: "${referencedTypeObject[NAMESPACE_KEY] || "N/A"}")`);
         } else {
           debugContext("extractAllTagsForXmlBody", `\u2717 Tipo referenciado no encontrado: "${referencedType}"`);
         }
@@ -23818,12 +23818,14 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
       foundNamespaces.set(namespacePrefix, namespace);
       debugContext("extractAllTagsForXmlBody", `Registrando namespace del elemento: "${namespacePrefix}" -> "${namespace}"`);
     }
-    debugContext("extractAllTagsForXmlBody", `Agregando tag "${tagLocalName}" al namespace "${namespacePrefix}" (namespace: "${namespace}")`);
+    debugContext("extractAllTagsForXmlBody", `Agregando tag "${tagLocalName}" al namespace "${namespacePrefix}" (namespace del elemento: "${namespace}")`);
     result.push(tagLocalName);
     if (!tagsByNamespace.has(namespace)) {
       tagsByNamespace.set(namespace, []);
     }
-    tagsByNamespace.get(namespace).push(tagLocalName);
+    if (!tagsByNamespace.get(namespace).includes(tagLocalName)) {
+      tagsByNamespace.get(namespace).push(tagLocalName);
+    }
     if (elementTypeValue && typeof elementTypeValue === "object" && elementTypeValue !== null) {
       const nestedTypeObject = elementTypeValue;
       const nestedNamespace = nestedTypeObject[NAMESPACE_KEY] || namespace;
@@ -23850,7 +23852,13 @@ function extractAllTagsForXmlBody(typeObject, namespacesTypeMapping, baseNamespa
         if (!tagsByNamespace.has(nsUri)) {
           tagsByNamespace.set(nsUri, []);
         }
-        tagsByNamespace.get(nsUri).push(...tags);
+        const existingTags = new Set(tagsByNamespace.get(nsUri));
+        for (const tag of tags) {
+          if (!existingTags.has(tag)) {
+            tagsByNamespace.get(nsUri).push(tag);
+            existingTags.add(tag);
+          }
+        }
       }
     }
   }
@@ -23987,6 +23995,7 @@ function extractAllNamespaceMappings(baseTypeName, baseTypeObject, schemaObject,
       tagsMapping[finalPrefix] = [];
     }
   }
+  const allTagsAdded = /* @__PURE__ */ new Set();
   for (const [nsUri, tags] of xmlBodyResult.tagsByNamespace) {
     let finalPrefix;
     for (const [p, u] of Object.entries(prefixesMapping)) {
@@ -24003,26 +24012,32 @@ function extractAllNamespaceMappings(baseTypeName, baseTypeObject, schemaObject,
       tagsMapping[finalPrefix] = [];
     }
     const existingTags = new Set(tagsMapping[finalPrefix] || []);
+    const tagsToAdd = [];
     for (const tag of tags) {
-      if (!existingTags.has(tag)) {
-        tagsMapping[finalPrefix].push(tag);
-        existingTags.add(tag);
+      if (!existingTags.has(tag) && !allTagsAdded.has(tag)) {
+        tagsToAdd.push(tag);
+        allTagsAdded.add(tag);
       }
     }
-    debugContext("extractAllNamespaceMappings", `Agregando ${tags.length} tag(s) al namespace "${finalPrefix}" (${nsUri})`);
+    if (tagsToAdd.length > 0) {
+      tagsMapping[finalPrefix].push(...tagsToAdd);
+      debugContext("extractAllNamespaceMappings", `Agregando ${tagsToAdd.length} tag(s) al namespace "${finalPrefix}" (${nsUri}): ${tagsToAdd.join(", ")}`);
+    }
   }
-  if (xmlBodyResult.tags.length > 0) {
+  const baseNamespaceTags = xmlBodyResult.tagsByNamespace.get(baseNamespace);
+  if (baseNamespaceTags && baseNamespaceTags.length > 0) {
     if (tagsMapping[baseNamespacePrefix] === void 0) {
       tagsMapping[baseNamespacePrefix] = [];
       prefixesMapping[baseNamespacePrefix] = baseNamespace;
     }
     const existingTags = new Set(tagsMapping[baseNamespacePrefix] || []);
-    for (const tag of xmlBodyResult.tags) {
+    for (const tag of baseNamespaceTags) {
       if (!existingTags.has(tag)) {
         tagsMapping[baseNamespacePrefix].push(tag);
         existingTags.add(tag);
       }
     }
+    debugContext("extractAllNamespaceMappings", `Agregando ${baseNamespaceTags.length} tag(s) al namespace base "${baseNamespacePrefix}"`);
   }
   return {
     tagsMapping,
@@ -24086,8 +24101,67 @@ function shouldHavePrefix(elementObject) {
   return false;
 }
 
+// src/codegen/xml-generator/type-resolution.ts
+function resolveReferencedType(typeValue, schemaObject, allComplexTypes) {
+  let referencedElement = schemaObject?.[typeValue];
+  if (!referencedElement && allComplexTypes) {
+    referencedElement = allComplexTypes[typeValue];
+  }
+  if (!referencedElement && schemaObject) {
+    const typeLocalName = typeValue.split(":").pop() || typeValue;
+    const matchingKey = Object.keys(schemaObject).find((key) => {
+      if (key === "$namespace" || key === "$qualified") return false;
+      const keyLocalName = key.split(":").pop() || key;
+      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
+    });
+    if (matchingKey) {
+      referencedElement = schemaObject[matchingKey];
+    }
+  }
+  if (!referencedElement && allComplexTypes) {
+    const typeLocalName = typeValue.split(":").pop() || typeValue;
+    const matchingKey = Object.keys(allComplexTypes).find((key) => {
+      const keyLocalName = key.split(":").pop() || key;
+      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
+    });
+    if (matchingKey) {
+      referencedElement = allComplexTypes[matchingKey];
+    }
+  }
+  return referencedElement;
+}
+function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
+  let nestedReferencedElement = schemaObject?.[nestedTypeValue];
+  if (!nestedReferencedElement && allComplexTypes) {
+    nestedReferencedElement = allComplexTypes[nestedTypeValue];
+  }
+  if (!nestedReferencedElement) {
+    const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
+    if (schemaObject) {
+      const nestedMatchingKey = Object.keys(schemaObject).find((key) => {
+        if (key === "$namespace" || key === "$qualified") return false;
+        const keyLocalName = key.split(":").pop() || key;
+        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
+      });
+      if (nestedMatchingKey) {
+        nestedReferencedElement = schemaObject[nestedMatchingKey];
+      }
+    }
+    if (!nestedReferencedElement && allComplexTypes) {
+      const nestedMatchingKey = Object.keys(allComplexTypes).find((key) => {
+        const keyLocalName = key.split(":").pop() || key;
+        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
+      });
+      if (nestedMatchingKey) {
+        nestedReferencedElement = allComplexTypes[nestedMatchingKey];
+      }
+    }
+  }
+  return nestedReferencedElement;
+}
+
 // src/codegen/xml-generator/xml-property.ts
-function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping) {
+function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key, elementObject, parentKey = null, propertyPath = "", parentIsQualified = true, prefixesMapping, schemaObject, allComplexTypes) {
   const namespacePrefix = getNamespacePrefix(
     namespacesTypeMapping,
     baseNamespacePrefix,
@@ -24103,6 +24177,91 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
   const closeTag = isQualified ? `</${namespacePrefix}.${tagLocalName}>` : `</${tagLocalName}>`;
   const isArray2 = typeof elementObject === "object" && elementObject !== null && "maxOccurs" in elementObject && elementObject.maxOccurs !== void 0 && elementObject.maxOccurs !== "1" && elementObject.maxOccurs !== DEFAULT_OCCURS;
   const currentPropertyPath = propertyPath ? propertyPath.endsWith(`.${tagCamelCase}`) || propertyPath === tagCamelCase ? propertyPath : `${propertyPath}.${tagCamelCase}` : tagCamelCase;
+  if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "string" && (schemaObject || allComplexTypes)) {
+    const referencedType = elementObject.type;
+    const referencedElement = resolveReferencedType(referencedType, schemaObject, allComplexTypes);
+    if (referencedElement && typeof referencedElement === "object") {
+      let finalReferencedElement = referencedElement;
+      if ("type" in referencedElement && typeof referencedElement.type === "string") {
+        const nestedReferencedElement = resolveNestedType(referencedElement.type, schemaObject, allComplexTypes);
+        if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
+          finalReferencedElement = nestedReferencedElement;
+        }
+      }
+      if ("type" in finalReferencedElement && typeof finalReferencedElement.type === "object" && finalReferencedElement.type !== null) {
+        const keys = getFilteredKeys(finalReferencedElement.type);
+        if (keys.length > 0) {
+          let parentPropertyPath = "";
+          if (propertyPath === tagCamelCase) {
+            parentPropertyPath = "";
+          } else if (propertyPath.endsWith(`.${tagCamelCase}`)) {
+            parentPropertyPath = propertyPath.slice(0, -(tagCamelCase.length + 1));
+          } else {
+            parentPropertyPath = propertyPath;
+          }
+          const nestedProperties = keys.map((elementKey) => {
+            const nestedElement = finalReferencedElement.type[elementKey];
+            if (typeof nestedElement === "object" && nestedElement !== null) {
+              const nestedKeyLocalName = extractLocalName(elementKey);
+              const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+              const nestedPropertyPath = parentPropertyPath ? `${parentPropertyPath}.${nestedKeyCamelCase}` : nestedKeyCamelCase;
+              return generateXmlPropertyCode(
+                namespacesTypeMapping,
+                baseNamespacePrefix,
+                elementKey,
+                nestedElement,
+                key,
+                nestedPropertyPath,
+                isQualified,
+                prefixesMapping,
+                schemaObject,
+                allComplexTypes
+              );
+            }
+            return "";
+          }).filter(Boolean).join("\n");
+          return `${openTag}
+    ${nestedProperties}
+    ${closeTag}`;
+        }
+      }
+      const referencedKeys = getFilteredKeys(finalReferencedElement);
+      if (referencedKeys.length > 0) {
+        let parentPropertyPath = "";
+        if (propertyPath === tagCamelCase) {
+          parentPropertyPath = "";
+        } else if (propertyPath.endsWith(`.${tagCamelCase}`)) {
+          parentPropertyPath = propertyPath.slice(0, -(tagCamelCase.length + 1));
+        } else {
+          parentPropertyPath = propertyPath;
+        }
+        const nestedProperties = referencedKeys.map((elementKey) => {
+          const nestedElement = finalReferencedElement[elementKey];
+          if (typeof nestedElement === "object" && nestedElement !== null) {
+            const nestedKeyLocalName = extractLocalName(elementKey);
+            const nestedKeyCamelCase = toCamelCase2(nestedKeyLocalName);
+            const nestedPropertyPath = parentPropertyPath ? `${parentPropertyPath}.${nestedKeyCamelCase}` : nestedKeyCamelCase;
+            return generateXmlPropertyCode(
+              namespacesTypeMapping,
+              baseNamespacePrefix,
+              elementKey,
+              nestedElement,
+              key,
+              nestedPropertyPath,
+              isQualified,
+              prefixesMapping,
+              schemaObject,
+              allComplexTypes
+            );
+          }
+          return "";
+        }).filter(Boolean).join("\n");
+        return `${openTag}
+    ${nestedProperties}
+    ${closeTag}`;
+      }
+    }
+  }
   if (typeof elementObject === "object" && elementObject !== null && typeof elementObject.type === "object") {
     const keys = getFilteredKeys(elementObject.type);
     if (isArray2) {
@@ -24119,7 +24278,10 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
               key,
               "item",
               // Usar 'item' directamente en lugar de la ruta completa con índice
-              isQualified
+              isQualified,
+              prefixesMapping,
+              schemaObject,
+              allComplexTypes
             );
           } else {
             const nestedTagLocalName = extractLocalName(elementKey);
@@ -24161,7 +24323,9 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
             currentPropertyPath,
             // Mantener el propertyPath completo (incluye propsInterfaceName si existe)
             isQualified,
-            prefixesMapping
+            prefixesMapping,
+            schemaObject,
+            allComplexTypes
           );
         }
         return "";
@@ -24174,65 +24338,6 @@ function generateXmlPropertyCode(namespacesTypeMapping, baseNamespacePrefix, key
   return `${openTag}{props.${currentPropertyPath}}${closeTag}`;
 }
 
-// src/codegen/xml-generator/type-resolution.ts
-function resolveReferencedType(typeValue, schemaObject, allComplexTypes) {
-  let referencedElement = schemaObject?.[typeValue];
-  if (!referencedElement && allComplexTypes) {
-    referencedElement = allComplexTypes[typeValue];
-  }
-  if (!referencedElement && schemaObject) {
-    const typeLocalName = typeValue.split(":").pop() || typeValue;
-    const matchingKey = Object.keys(schemaObject).find((key) => {
-      if (key === "$namespace" || key === "$qualified") return false;
-      const keyLocalName = key.split(":").pop() || key;
-      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
-    });
-    if (matchingKey) {
-      referencedElement = schemaObject[matchingKey];
-    }
-  }
-  if (!referencedElement && allComplexTypes) {
-    const typeLocalName = typeValue.split(":").pop() || typeValue;
-    const matchingKey = Object.keys(allComplexTypes).find((key) => {
-      const keyLocalName = key.split(":").pop() || key;
-      return keyLocalName === typeLocalName || key === typeValue || key.endsWith(`:${typeLocalName}`) || typeValue.endsWith(keyLocalName);
-    });
-    if (matchingKey) {
-      referencedElement = allComplexTypes[matchingKey];
-    }
-  }
-  return referencedElement;
-}
-function resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes) {
-  let nestedReferencedElement = schemaObject?.[nestedTypeValue];
-  if (!nestedReferencedElement && allComplexTypes) {
-    nestedReferencedElement = allComplexTypes[nestedTypeValue];
-  }
-  if (!nestedReferencedElement) {
-    const nestedTypeLocalName = nestedTypeValue.split(":").pop() || nestedTypeValue;
-    if (schemaObject) {
-      const nestedMatchingKey = Object.keys(schemaObject).find((key) => {
-        if (key === "$namespace" || key === "$qualified") return false;
-        const keyLocalName = key.split(":").pop() || key;
-        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
-      });
-      if (nestedMatchingKey) {
-        nestedReferencedElement = schemaObject[nestedMatchingKey];
-      }
-    }
-    if (!nestedReferencedElement && allComplexTypes) {
-      const nestedMatchingKey = Object.keys(allComplexTypes).find((key) => {
-        const keyLocalName = key.split(":").pop() || key;
-        return keyLocalName === nestedTypeLocalName || key === nestedTypeValue || key.endsWith(`:${nestedTypeLocalName}`) || nestedTypeValue.endsWith(keyLocalName);
-      });
-      if (nestedMatchingKey) {
-        nestedReferencedElement = allComplexTypes[nestedMatchingKey];
-      }
-    }
-  }
-  return nestedReferencedElement;
-}
-
 // src/codegen/xml-generator/xml-body.ts
 function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, baseTypeObject, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping) {
   const keys = getFilteredKeys(baseTypeObject);
@@ -24242,19 +24347,6 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
     const element = baseTypeObject[singleKey];
     if (typeof element === "object" && element !== null && "type" in element) {
       const typeValue = element.type;
-      if (typeof typeValue === "string" && (schemaObject || allComplexTypes)) {
-        const referencedElement = resolveReferencedType(typeValue, schemaObject, allComplexTypes);
-        if (referencedElement && typeof referencedElement === "object") {
-          if ("type" in referencedElement && typeof referencedElement.type === "string") {
-            const nestedTypeValue = referencedElement.type;
-            const nestedReferencedElement = resolveNestedType(nestedTypeValue, schemaObject, allComplexTypes);
-            if (nestedReferencedElement && typeof nestedReferencedElement === "object") {
-              return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, nestedReferencedElement, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
-            }
-          }
-          return generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTypeName, referencedElement, propsInterfaceName, schemaObject, allComplexTypes, prefixesMapping);
-        }
-      }
       if (typeof typeValue === "object" && typeValue !== null) {
         const typeKeys = getFilteredKeys(typeValue);
         if (typeKeys.length > 0) {
@@ -24278,7 +24370,9 @@ function generateXmlBodyCode(baseNamespacePrefix, namespacesTypeMapping, baseTyp
         propertyPath,
         true,
         // El padre (root element) siempre es qualified
-        prefixesMapping
+        prefixesMapping,
+        schemaObject,
+        allComplexTypes
       );
     }
     return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibulab/wsdl2tsx",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "description": "Generador de código TSX desde archivos WSDL",
   "main": "dist/index.js",
   "bin": "./dist/cli.js",
@@ -13,7 +13,7 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@karibulab/wsdl2tsx-runtime": "0.17.0",
+    "@karibulab/wsdl2tsx-runtime": "0.17.2",
     "axios": "^1.7.9",
     "fast-xml-parser": "5.3.3",
     "handlebars": "4.7.8"