@wavemaker-ai/react-codegen 1.0.0-rc.647712 → 12.0.0-rc.335

package/dist/transpiler/index.mjs

@@ -39375,14 +39375,17 @@ var removeLeadingCssBlockComments = (rule) => {
   }
   return { prefix, rest: rule.slice(idx) };
 };
+var CUSTOM_TAG_SELECTOR_PATTERN = /(^|[\s>+~,(])([a-zA-Z][a-zA-Z0-9]*-[a-zA-Z0-9-]*)/g;
+var convertCustomTagSelectorsToClasses = (sel) => sel.replace(CUSTOM_TAG_SELECTOR_PATTERN, (_match, boundary, tag) => `${boundary}.${tag}`);
 var scopeSingleSelector = (selector, scopeClass) => {
-  const sel = selector.trim();
-  if (!sel) {
-    return sel;
+  const trimmed = selector.trim();
+  if (!trimmed) {
+    return trimmed;
   }
-  if (sel.startsWith(":")) {
-    return sel;
+  if (trimmed.startsWith(":")) {
+    return trimmed;
   }
+  const sel = convertCustomTagSelectorsToClasses(trimmed);
   const wmAppIndex = sel.search(/\.wm-app\b/);
   if (wmAppIndex !== -1) {
     if (sel.includes(`.${scopeClass}`)) {
@@ -39771,6 +39774,54 @@ function resolveFormatContext(expression, context) {
   return expression.replace(/,\s*\{formatContext:''\}/g, "").replace(FORMAT_CONTEXT_REGEX, "");
 }
 
+// src/services/schema-to-ts.ts
+function toPascalCase(name) {
+  const words = String(name || "").split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (!words.length) return "Model";
+  let result = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  if (/^[0-9]/.test(result)) result = "_" + result;
+  return result;
+}
+function buildServiceClassName(serviceId, tag) {
+  const servicePascal = toPascalCase(serviceId || "");
+  const serviceCore = servicePascal.endsWith("Service") ? servicePascal.slice(0, -"Service".length) : servicePascal;
+  const core = tag === servicePascal || tag === serviceCore ? serviceCore : tag;
+  return `${core}Service`;
+}
+
+// src/services/doc-normalizer.ts
+function toCamelCaseIdentifier(name) {
+  if (typeof name !== "string" || !/[^a-zA-Z0-9]/.test(name)) return name;
+  const words = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (!words.length) return name;
+  let result = words.map((w, i) => i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  if (/^[0-9]/.test(result)) result = "_" + result;
+  return result;
+}
+function deriveMethodName(rawOperationId, prefixCandidates) {
+  if (!rawOperationId) return "";
+  for (const prefix of prefixCandidates) {
+    if (!prefix) continue;
+    const doubled = `${prefix}_${prefix}_`;
+    if (rawOperationId.startsWith(doubled)) {
+      return toCamelCaseIdentifier(rawOperationId.slice(prefix.length + 1));
+    }
+  }
+  let operationId = rawOperationId;
+  let strippedSomething = true;
+  while (strippedSomething) {
+    strippedSomething = false;
+    for (const prefix of prefixCandidates) {
+      if (prefix && operationId.startsWith(`${prefix}_`)) {
+        operationId = operationId.slice(prefix.length + 1);
+        strippedSomething = true;
+        break;
+      }
+    }
+  }
+  return toCamelCaseIdentifier(operationId);
+}
+
 // src/variables/variable.transformer.ts
 var import_lodash2 = __toESM(require_lodash());
 function bindingValueIsStatic(value) {
@@ -39803,6 +39854,28 @@ function isStaticParamsVariable(variable2) {
   }
   return filterExpressionsAreStatic(variable2.filterExpressions);
 }
+function simpleSingularize(plural) {
+  const lower = plural.toLowerCase();
+  if (lower.endsWith("ies")) return plural.substring(0, plural.length - 3) + "y";
+  if (lower.endsWith("es")) return plural.substring(0, plural.length - 2);
+  if (lower.endsWith("s")) return plural.substring(0, plural.length - 1);
+  return plural;
+}
+function simplePluralize(singular) {
+  if (!singular) return singular;
+  const last = singular[singular.length - 1].toLowerCase();
+  const prev = singular.length > 1 ? singular[singular.length - 2].toLowerCase() : null;
+  const vowels = "aeiouy";
+  if (last === "x" || last === "s") {
+    return singular + "es";
+  } else if (last === "y") {
+    return prev !== null && vowels.includes(prev) ? singular + "s" : singular.slice(0, -1) + "ies";
+  } else if (last === "h") {
+    return prev !== null && (prev === "c" || prev === "s") ? singular + "es" : singular + "s";
+  } else {
+    return singular + "s";
+  }
+}
 function parseStaticJsonValue(value) {
   const trimmedValue = value.trim();
   if (!trimmedValue.startsWith("{") && !trimmedValue.startsWith("[")) {
@@ -40212,9 +40285,166 @@ function transformModelVariable(variable2, scope) {
   tv.isList = !!variable2.isList;
   return tv;
 }
-function transformServiceVariable(variable2, scope) {
+var capitalizeFirstLetter = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var getServiceInstanceName = (className) => className.charAt(0).toLowerCase() + className.slice(1);
+function getServiceLocalName(serviceId, className) {
+  const instanceName = getServiceInstanceName(className);
+  if (!serviceId) {
+    return instanceName;
+  }
+  const prefix = toPascalCase(serviceId);
+  const core = prefix.endsWith("Service") ? prefix.slice(0, -"Service".length) : prefix;
+  if (className.startsWith(core)) {
+    return instanceName;
+  }
+  return getServiceInstanceName(`${core}${className}`);
+}
+function getServiceClassName(prefix) {
+  if (!prefix || typeof prefix !== "string") return "Service";
+  const base = prefix.replace(/[\s/\\\-_]+/g, "").trim();
+  if (!base) return "Service";
+  let basePascal = capitalizeFirstLetter(base);
+  if (basePascal.endsWith("Controller")) {
+    basePascal = basePascal.slice(0, -"Controller".length);
+  }
+  if (!basePascal) return "Service";
+  return basePascal.endsWith("Service") ? basePascal : basePascal + "Service";
+}
+function toCamelCaseIdentifier2(name) {
+  if (typeof name !== "string" || !/[^a-zA-Z0-9]/.test(name)) return name;
+  const words = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (!words.length) return name;
+  let result = words.map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  if (/^[0-9]/.test(result)) result = "_" + result;
+  return result;
+}
+function resolveServiceTag(serviceId, controller, serviceType) {
+  const isLumpedOpenApiService = serviceType === "OpenAPIService" && (!controller || controller.toLowerCase() === "default");
+  const base = isLumpedOpenApiService ? serviceId.endsWith("Service") ? serviceId.slice(0, -"Service".length) : serviceId : controller || serviceId;
+  return base ? toPascalCase(base) : base;
+}
+function formatServiceDetails(variable2) {
+  if (variable2.operationId) {
+    const serviceName = variable2.service;
+    let prefix;
+    let invokeFnName;
+    if (serviceName) {
+      prefix = serviceName;
+      const controllerRaw = variable2.controller ? `${variable2.controller}Controller` : void 0;
+      const prefixCandidates = [serviceName, variable2.controller, controllerRaw].filter(
+        Boolean
+      );
+      invokeFnName = deriveMethodName(variable2.operationId, prefixCandidates);
+    } else {
+      const sepIdx = variable2.operationId.indexOf("_");
+      prefix = sepIdx >= 0 ? variable2.operationId.substring(0, sepIdx) : variable2.operationId;
+      invokeFnName = sepIdx >= 0 ? variable2.operationId.substring(sepIdx + 1) : variable2.operationId;
+    }
+    invokeFnName = toCamelCaseIdentifier2(invokeFnName);
+    const formattedServiceName = variable2.service ? buildServiceClassName(
+      variable2.service,
+      resolveServiceTag(variable2.service, variable2.controller, variable2.serviceType)
+    ) : getServiceClassName(prefix);
+    return {
+      formattedServiceName,
+      invokeFnName
+    };
+  }
+  if (variable2.type && variable2.operation) {
+    const entity = variable2.type;
+    const singular = simpleSingularize(entity);
+    const plural = simplePluralize(singular);
+    const operationMap = {
+      read: `filter${plural}`,
+      insert: `create${singular}`,
+      update: `edit${singular}`,
+      delete: `delete${singular}`
+    };
+    const invokeFnName = operationMap[variable2.operation];
+    if (!invokeFnName) return null;
+    const formattedServiceName = variable2.liveSource ? buildServiceClassName(variable2.liveSource, capitalizeFirstLetter(entity)) : capitalizeFirstLetter(entity + "Service");
+    return {
+      formattedServiceName,
+      invokeFnName
+    };
+  }
+  return null;
+}
+function isServiceAvailable(className, validServiceClassNames) {
+  return !validServiceClassNames || !className || validServiceClassNames.has(className);
+}
+function callArgExpression(arg, isLiveVariable, isBodyTypeQueryOrProcedure = false) {
+  if (isBodyTypeQueryOrProcedure && arg.source.kind === "body") {
+    return "params";
+  }
+  if (arg.source.kind === "pageable") {
+    const props = arg.source.paramNames.map((wireName) => {
+      const prop = wireName === "sort" ? "sort" : wireName === "size" ? "pageSize" : "pageNumber";
+      return `${prop}: params?.[${JSON.stringify(wireName)}]`;
+    }).join(", ");
+    return `{ ${props} }`;
+  }
+  return `params?.[${JSON.stringify(liveVariableParamKey(arg, isLiveVariable))}]`;
+}
+function applyServiceCallShape(tv, lookupKey, methodArgsByOperation, servicePathByOperation, isLiveVariable = false, isBodyTypeQueryOrProcedure = false) {
+  var _a;
+  const importPath = servicePathByOperation == null ? void 0 : servicePathByOperation.get(lookupKey);
+  if (importPath) {
+    tv.serviceImportPath = importPath;
+    const resolvedClassName = importPath.split("/").pop();
+    if (resolvedClassName && resolvedClassName !== tv.serviceFileClass) {
+      tv.serviceFile = resolvedClassName;
+      tv.serviceFileClass = resolvedClassName;
+      tv.serviceExportName = getServiceInstanceName(resolvedClassName);
+      tv.serviceInstanceName = getServiceLocalName((_a = tv.service) != null ? _a : tv.liveSource, resolvedClassName);
+    }
+  }
+  const args = methodArgsByOperation == null ? void 0 : methodArgsByOperation.get(lookupKey);
+  if (!args) {
+    return;
+  }
+  tv.hasResolvedCallArgs = true;
+  tv.callArgs = args.map((arg) => callArgExpression(arg, isLiveVariable, isBodyTypeQueryOrProcedure));
+}
+function liveVariableParamKey(arg, isLiveVariable) {
+  const swaggerName = arg.source.paramName;
+  if (!isLiveVariable) {
+    return swaggerName;
+  }
+  switch (arg.source.kind) {
+    case "query":
+      return swaggerName === "q" ? "data" : swaggerName;
+    case "body":
+    case "formData":
+      return "data";
+    case "path":
+      return "id";
+    default:
+      return swaggerName;
+  }
+}
+function transformServiceVariable(variable2, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+  var _a;
+  const serviceDetails = formatServiceDetails(variable2);
+  let skipInvokeHttp = false;
+  if (!isServiceAvailable(serviceDetails == null ? void 0 : serviceDetails.formattedServiceName, validServiceClassNames)) {
+    console.warn(
+      `ServiceVariable "${variable2.name}" references service "${variable2.service}" (${serviceDetails == null ? void 0 : serviceDetails.formattedServiceName}), which was not generated. Emitting the variable without an invokeHttp \u2014 the runtime falls back to its own transport.`
+    );
+    skipInvokeHttp = true;
+  }
+  const operationKey = `${variable2.service}::${variable2.operationId}`;
+  if (servicePathByOperation && !servicePathByOperation.has(operationKey)) {
+    console.warn(
+      `ServiceVariable "${variable2.name}" references operation "${variable2.operationId}" on service "${variable2.service}", which has no such operation. Emitting the variable without an invokeHttp \u2014 the runtime falls back to its own transport.`
+    );
+    skipInvokeHttp = true;
+  }
   const tv = transformVariable(variable2, scope);
   tv.classname = "ServiceVariable";
+  tv.hasInvokeHttp = !skipInvokeHttp;
   tv.operationId = variable2.operationId;
   tv.isList = !!variable2.isList;
   tv.inFlightBehavior = variable2.inFlightBehavior;
@@ -40228,6 +40458,21 @@ function transformServiceVariable(variable2, scope) {
   tv.autoUpdate = variable2.autoUpdate;
   tv.orderBy = variable2.orderBy;
   tv.isStaticParams = isStaticParamsVariable(variable2);
+  tv.serviceFile = serviceDetails == null ? void 0 : serviceDetails.formattedServiceName;
+  tv.serviceFileClass = serviceDetails == null ? void 0 : serviceDetails.formattedServiceName;
+  tv.serviceExportName = serviceDetails && getServiceInstanceName(serviceDetails.formattedServiceName);
+  tv.serviceInstanceName = serviceDetails && getServiceLocalName(variable2.service, serviceDetails.formattedServiceName);
+  const lookupKey = `${variable2.service}::${variable2.operationId}`;
+  tv.invokeFnName = (_a = methodNameByOperation == null ? void 0 : methodNameByOperation.get(lookupKey)) != null ? _a : serviceDetails == null ? void 0 : serviceDetails.invokeFnName;
+  const isBodyTypeQueryOrProcedure = ["QueryExecution", "ProcedureExecution"].includes(variable2.controller) && ["put", "post"].includes(variable2.operationType);
+  applyServiceCallShape(
+    tv,
+    lookupKey,
+    methodArgsByOperation,
+    servicePathByOperation,
+    false,
+    isBodyTypeQueryOrProcedure
+  );
   return tv;
 }
 function transformNavigationAction(variable2, scope) {
@@ -40257,9 +40502,11 @@ function transformNotificationAction(variable2, scope, imports102) {
   tv.classname = "NotificationAction";
   tv.group = "action";
   tv.operation = variable2.operation;
-  const partialContent = Array.isArray(variable2.dataBinding) ? variable2.dataBinding.filter((binding) => {
-    return binding.target === "page";
-  })[0] : null;
+  const bindings = Array.isArray(variable2.dataBinding) ? variable2.dataBinding : [];
+  const getBinding = (target) => bindings.find((b) => b.target === target);
+  const contentBinding = getBinding("content");
+  const rendersPartial = contentBinding ? contentBinding.value === "page" : variable2.operation !== "toast";
+  const partialContent = rendersPartial ? getBinding("page") : null;
   if (variable2.onOk || variable2.onClick) {
     tv.onOk = appendIfNotEmpty(bind_ex_transformer_default(variable2.onOk || variable2.onClick, scope, "event"));
   }
@@ -40315,9 +40562,61 @@ function transformLogoutVariable(variable2, scope) {
   tv.redirectTo = variable2.redirectTo;
   return tv;
 }
-function transformLiveVariable(variable2, scope) {
+function findOperationKeyByMethodName(serviceName, methodName, methodNameByOperation) {
+  if (!serviceName || !methodName || !methodNameByOperation) {
+    return void 0;
+  }
+  const prefix = `${serviceName}::`;
+  for (const [key, name] of methodNameByOperation) {
+    if (name === methodName && key.startsWith(prefix)) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function findLiveOperationKeyByVerb(liveSource, entity, verbTokens, methodNameByOperation) {
+  if (!liveSource || !entity || !methodNameByOperation) {
+    return void 0;
+  }
+  const tagPrefix = `${liveSource}::${entity}Controller_`;
+  let best;
+  for (const key of methodNameByOperation.keys()) {
+    if (!key.startsWith(tagPrefix)) continue;
+    const verbAndName = key.slice(tagPrefix.length);
+    if (!verbTokens.some((verb) => verbAndName.startsWith(verb))) continue;
+    if (!best || key.length < best.length) {
+      best = key;
+    }
+  }
+  return best;
+}
+var LIVE_OPERATION_VERBS = {
+  readTableData: ["find"],
+  searchTableDataWithQuery: ["filter"],
+  searchTableData: ["search"],
+  insertTableData: ["create"],
+  updateTableData: ["edit"],
+  deleteTableData: ["delete"]
+};
+var LIVE_DEFAULT_ACTION_BY_OPERATION = {
+  read: "searchTableDataWithQuery",
+  insert: "insertTableData",
+  update: "updateTableData",
+  delete: "deleteTableData"
+};
+function transformLiveVariable(variable2, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+  var _a, _b;
+  const serviceDetails = formatServiceDetails(variable2);
+  let skipInvokeHttp = false;
+  if (serviceDetails && !isServiceAvailable(serviceDetails.formattedServiceName, validServiceClassNames)) {
+    console.warn(
+      `LiveVariable "${variable2.name}" targets entity "${variable2.type}" (${serviceDetails.formattedServiceName}), which was not generated. Emitting the variable without an invokeHttp \u2014 the runtime falls back to its own transport.`
+    );
+    skipInvokeHttp = true;
+  }
   const tv = transformVariable(variable2, scope);
   tv.classname = "LiveVariable";
+  tv.hasInvokeHttp = !skipInvokeHttp;
   tv.isList = !!variable2.isList;
   tv.inFlightBehavior = variable2.inFlightBehavior;
   tv.maxResults = variable2.maxResults;
@@ -40334,9 +40633,117 @@ function transformLiveVariable(variable2, scope) {
   tv.filterExpressions = variable2.filterExpressions;
   tv._id = variable2._id;
   tv.isStaticParams = isStaticParamsVariable(variable2);
+  if (serviceDetails) {
+    tv.serviceFile = serviceDetails.formattedServiceName;
+    tv.serviceFileClass = serviceDetails.formattedServiceName;
+    tv.serviceExportName = getServiceInstanceName(serviceDetails.formattedServiceName);
+    tv.serviceInstanceName = getServiceLocalName(
+      variable2.liveSource,
+      serviceDetails.formattedServiceName
+    );
+    tv.invokeFnName = serviceDetails.invokeFnName;
+    let lookupKey = findOperationKeyByMethodName(
+      variable2.liveSource,
+      serviceDetails.invokeFnName,
+      methodNameByOperation
+    );
+    if (!lookupKey) {
+      lookupKey = findLiveOperationKeyByVerb(
+        variable2.liveSource,
+        variable2.type,
+        (_a = LIVE_OPERATION_VERBS[LIVE_DEFAULT_ACTION_BY_OPERATION[variable2.operation]]) != null ? _a : [],
+        methodNameByOperation
+      );
+    }
+    if (lookupKey) {
+      tv.invokeFnName = (_b = methodNameByOperation == null ? void 0 : methodNameByOperation.get(lookupKey)) != null ? _b : tv.invokeFnName;
+      applyServiceCallShape(
+        tv,
+        lookupKey,
+        methodArgsByOperation,
+        servicePathByOperation,
+        true
+        // LiveVariable — its params object is keyed by the runtime's own DB-operation names
+      );
+    }
+    tv.liveTargets = buildLiveTargets(
+      variable2,
+      methodArgsByOperation,
+      methodNameByOperation,
+      servicePathByOperation
+    );
+  }
   return tv;
 }
-function transformCrudVariable(variable2, scope) {
+function buildLiveTargets(variable2, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+  var _a, _b, _c;
+  const entity = variable2.type;
+  if (!entity) {
+    return void 0;
+  }
+  const singular = simpleSingularize(entity);
+  const plural = simplePluralize(singular);
+  const byAction = [
+    // readTableData's template is `GET /<entity>?page=&size=&:sort` — the collection GET, which
+    // the generator names find<Plural>. filter<Plural> is the POST /filter twin and belongs only
+    // to the query-bearing actions.
+    ["readTableData", `find${plural}`],
+    ["searchTableDataWithQuery", `filter${plural}`],
+    ["searchTableData", `search${plural}ByQueryFilters`],
+    ["insertTableData", `create${singular}`],
+    ["updateTableData", `edit${singular}`],
+    ["deleteTableData", `delete${singular}`]
+  ];
+  const targets = [];
+  for (const [action, guessedMethodName] of byAction) {
+    let lookupKey = findOperationKeyByMethodName(
+      variable2.liveSource,
+      guessedMethodName,
+      methodNameByOperation
+    );
+    if (!lookupKey) {
+      lookupKey = findLiveOperationKeyByVerb(
+        variable2.liveSource,
+        entity,
+        (_a = LIVE_OPERATION_VERBS[action]) != null ? _a : [],
+        methodNameByOperation
+      );
+    }
+    if (!lookupKey || servicePathByOperation && !servicePathByOperation.has(lookupKey)) {
+      continue;
+    }
+    const methodName = (_b = methodNameByOperation == null ? void 0 : methodNameByOperation.get(lookupKey)) != null ? _b : guessedMethodName;
+    const shape = {};
+    applyServiceCallShape(shape, lookupKey, methodArgsByOperation, servicePathByOperation, true);
+    targets.push({
+      action,
+      invokeFnName: methodName,
+      callArgs: (_c = shape.callArgs) != null ? _c : [],
+      hasResolvedCallArgs: !!shape.hasResolvedCallArgs
+    });
+  }
+  return targets.length ? targets : void 0;
+}
+function buildCrudTargets(variable2, crudOperationsById) {
+  const group = crudOperationsById == null ? void 0 : crudOperationsById.get(variable2.crudOperationId);
+  if (!group) {
+    return void 0;
+  }
+  const targets = Object.entries(group).map(([operationType, target]) => {
+    const className = target.importPath.split("/").pop();
+    return {
+      operationType,
+      importPath: target.importPath,
+      serviceExportName: getServiceInstanceName(className),
+      serviceInstanceName: getServiceLocalName(variable2.service, className),
+      invokeFnName: target.methodName,
+      // A CrudVariable is never a LiveVariable, so params are keyed by the swagger names.
+      callArgs: target.args.map((arg) => callArgExpression(arg, false))
+    };
+  });
+  return targets.length ? targets : void 0;
+}
+function transformCrudVariable(variable2, scope, crudOperationsById) {
   const tv = transformVariable(variable2, scope);
   tv._id = variable2._id;
   tv.name = variable2.name;
@@ -40361,15 +40768,23 @@ function transformCrudVariable(variable2, scope) {
   tv.dataBinding = variable2._transformedDataBinding || variable2.dataBinding;
   tv.classname = "CrudVariable";
   tv.group = "variable";
+  tv.crudTargets = buildCrudTargets(variable2, crudOperationsById);
   tv.isStaticParams = isStaticParamsVariable(variable2);
   return tv;
 }
-var variable_transformer_default = (variable2, scope, appUrl, imports102) => {
+var variable_transformer_default = (variable2, scope, appUrl, imports102, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation, crudOperationsById) => {
   switch (variable2.category) {
     case "wm.Variable":
       return transformModelVariable(variable2, scope);
     case "wm.ServiceVariable":
-      return transformServiceVariable(variable2, scope);
+      return transformServiceVariable(
+        variable2,
+        scope,
+        validServiceClassNames,
+        methodArgsByOperation,
+        methodNameByOperation,
+        servicePathByOperation
+      );
     case "wm.NavigationAction":
       return transformNavigationAction(variable2, scope);
     case "wm.TimerAction":
@@ -40383,9 +40798,16 @@ var variable_transformer_default = (variable2, scope, appUrl, imports102) => {
     case "wm.LogoutAction":
       return transformLogoutVariable(variable2, scope);
     case "wm.LiveVariable":
-      return transformLiveVariable(variable2, scope);
+      return transformLiveVariable(
+        variable2,
+        scope,
+        validServiceClassNames,
+        methodArgsByOperation,
+        methodNameByOperation,
+        servicePathByOperation
+      );
     case "wm.CrudVariable":
-      return transformCrudVariable(variable2, scope);
+      return transformCrudVariable(variable2, scope, crudOperationsById);
   }
   return null;
 };
@@ -45355,9 +45777,14 @@ var dialog_transformer_default = {
   pre: (element, context) => {
     element.getAttribute("name");
     const hasExplicitBody = element.childNodes.some(
-      (e) => isHTMLElement(e) && ["wm-dialogcontent", "wm-dialogbody"].includes(e.tagName.toLowerCase())
+      (e) => isHTMLElement(e) && ["wm-dialogcontent", "wm-dialogbody"].includes(e.tagName.toLowerCase()) && e.childNodes.some(isHTMLElement)
     );
     if (!hasExplicitBody) {
+      const markerIndex = element.childNodes.findIndex(
+        (e) => isHTMLElement(e) && ["wm-dialogcontent", "wm-dialogbody"].includes(e.tagName.toLowerCase())
+      );
+      const marker = markerIndex >= 0 ? element.childNodes[markerIndex] : null;
+      const remainingChildren = markerIndex >= 0 ? element.childNodes.filter((_, i) => i !== markerIndex) : element.childNodes;
       const content = new HTMLElement(
         "wm-dialogbody",
         {},
@@ -45366,10 +45793,13 @@ var dialog_transformer_default = {
         [0, 41]
       );
       content.nodeType = NodeType.ELEMENT_NODE;
-      const actionsIndex = element.childNodes.findIndex(
+      if (marker) {
+        content.setAttributes(marker.attributes);
+      }
+      const actionsIndex = remainingChildren.findIndex(
         (e) => isHTMLElement(e) && e.tagName.toLowerCase() === "wm-dialogactions"
       );
-      content.childNodes = element.childNodes;
+      content.childNodes = remainingChildren;
       element.childNodes = [content];
       if (actionsIndex >= 0) {
         const actions = content.childNodes.splice(actionsIndex, 1);
@@ -45486,6 +45916,8 @@ var tabs_transformer_default = {
           `fragment.Widgets.${widgetName}.currentItem`,
           "currentItem"
         );
+        transformRepeatChildAttr(repeatTemplate, "fragment.item", "$item");
+        transformRepeatChildAttr(repeatTemplate, "fragment.index", "$index");
         transformRepeatChildData(
           repeatTemplate,
           dataSet.substring(5) + "[0]",
@@ -45595,6 +46027,8 @@ var prefab_container_transformer_default = {
 __toESM(require_lodash());
 var DefaultProfile = {
   generateWeb: false,
+  generateWmxComponents: true,
+  groupPagesByLayout: true,
   copyResources: true,
   lazyloadPages: true,
   lazyloadPartials: true,