@uniformdev/transformer 1.1.35 → 1.1.36

package/dist/index.d.ts

@@ -307,7 +307,10 @@ declare class CompositionService {
 }
 
 declare class Logger {
+    private verbose;
+    constructor(verbose?: boolean);
     info(message: string): void;
+    debug(message: string): void;
     success(message: string): void;
     error(message: string): void;
     warn(message: string): void;

package/dist/index.js

@@ -649,6 +649,7 @@ var CompositionConverterService = class {
         );
         const contentType = this.generateContentType(component);
         contentTypeMap.set(rootType, contentType);
+        this.logger.debug(`Generated content type "${rootType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${rootType} \u2014 skipping content type generation`);
@@ -684,6 +685,7 @@ var CompositionConverterService = class {
         if (isRefType) {
           const contentType = this.generateContentType(component);
           targetContentTypeMap.set(targetType, contentType);
+          this.logger.debug(`Generated reference content type "${targetType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (isBlockType) {
           let blockId = targetType;
@@ -713,6 +715,7 @@ var CompositionConverterService = class {
           blockContentType.id = blockId;
           blockContentType.name = needsRename ? `${blockContentType.name} Block` : blockContentType.name;
           targetContentTypeMap.set(blockId, blockContentType);
+          this.logger.debug(`Generated block content type "${blockId}" with ${blockContentType.fields.length} field(s): ${blockContentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (!isBlockType) {
           if (!isRefType) {
@@ -754,6 +757,7 @@ var CompositionConverterService = class {
         }
       } else {
         entry = this.generateEntryFromComposition(composition);
+        this.logger.debug(`Generated entry "${entry.entry._id}" from composition "${compositionName}" (${compositionType}) with fields: ${Object.keys(entry.entry.fields).join(", ") || "(none)"}`);
       }
       const refsByType = /* @__PURE__ */ new Map();
       if (componentsToReferences.length > 0 && comp.slots) {
@@ -771,6 +775,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of reference type "${refType}"`);
           if (instances.length > 0) {
             refsByType.set(refType, instances);
             if (missingTargetTypes.includes(refType)) {
@@ -784,6 +789,7 @@ var CompositionConverterService = class {
         const refIds = [];
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          this.logger.debug(`Reference instance "${inst.determinisiticId}" (${refType}): ${existingId ? `reusing existing entry "${existingId}"` : `assigned new ID "${inst.determinisiticId}"`}`);
           refIds.push(existingId ?? inst.determinisiticId);
         }
         resolvedRefIds.set(refType, refIds);
@@ -813,6 +819,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of block type "${blockType}"`);
           if (instances.length > 0) {
             blocksByType.set(blockType, instances);
             if (missingTargetTypes.includes(blockType)) {
@@ -869,6 +876,7 @@ var CompositionConverterService = class {
               "UPDATE",
               `${entriesDir}/${existingId}.json (${refType}, merged fields from "${this.truncate(compositionName, 50)}")`
             );
+            this.logger.debug(`Merging fields [${Object.keys(inst.instance.parameters ?? {}).join(", ") || "(none)"}] into existing reference entry "${existingId}"`);
             if (!whatIf) {
               const existingEntry = await this.fileSystem.readFile(existingEntryPath2);
               if (existingEntry?.entry) {
@@ -893,6 +901,7 @@ var CompositionConverterService = class {
             "WRITE",
             `${entriesDir}/${inst.determinisiticId}.json (${refType} from "${this.truncate(compositionName, 50)}")`
           );
+          this.logger.debug(`Writing reference entry "${inst.determinisiticId}" (${refType}) with fields: ${Object.keys(flatEntry.entry.fields).join(", ") || "(none)"}`);
           if (!whatIf) {
             await this.fileSystem.writeFile(flatEntryPath, flatEntry);
           }
@@ -919,6 +928,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${refType}" (contentReference) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -941,6 +951,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${resolvedBlockId}" ($block) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -965,6 +976,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${baseFieldCount} fields${extrasInfo})`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -977,6 +989,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -1342,6 +1355,7 @@ var PropertyPropagatorService = class {
       try {
         const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
         sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+        this.logger.debug(`Loaded source component "${sourceType}" from ${sourceFilePath}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${sourceType} (searched: ${fullComponentsDir})`);
@@ -1352,6 +1366,7 @@ var PropertyPropagatorService = class {
     }
     this.logger.info(`Loading component: ${targetComponentType}`);
     const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    this.logger.debug(`Loaded target component "${targetComponentType}" from ${targetFilePath}`);
     const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
     const resolvedParams = [];
     const resolvedNames = [];
@@ -1372,6 +1387,8 @@ var PropertyPropagatorService = class {
         if (!exists) {
           resolvedParams.push(param);
           resolvedNames.push(param.id);
+        } else {
+          this.logger.debug(`Parameter "${param.id}" already collected from another source \u2014 skipping duplicate`);
         }
       }
     }
@@ -1410,7 +1427,10 @@ var PropertyPropagatorService = class {
         targetGroup,
         findOptions
       );
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) created on component ${targetComponentType}`);
       componentModified = true;
+    } else {
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) already exists on ${targetComponentType}`);
     }
     for (const param of resolvedParams) {
       const existingParam = this.componentService.findParameter(
@@ -1435,6 +1455,7 @@ var PropertyPropagatorService = class {
           param.id,
           findOptions
         );
+        this.logger.debug(`Parameter "${param.id}" (type: ${param.type}) added to component ${targetComponentType} in group "${targetGroup}"`);
         componentModified = true;
       } else {
         this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
@@ -1454,7 +1475,10 @@ var PropertyPropagatorService = class {
               param.id,
               findOptions
             );
+            this.logger.debug(`Parameter "${param.id}" added to group "${targetGroup}" on ${targetComponentType} (was missing from group)`);
             componentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" already in group "${targetGroup}" on ${targetComponentType} \u2014 no change`);
           }
         }
       }
@@ -1467,6 +1491,7 @@ var PropertyPropagatorService = class {
       compositionTypes,
       findOptions
     );
+    this.logger.debug(`Found ${compositions.length} composition(s) matching types [${compositionTypes.join(", ")}]`);
     let modifiedCompositions = 0;
     let propagatedInstances = 0;
     for (const { composition, filePath } of compositions) {
@@ -1477,6 +1502,7 @@ var PropertyPropagatorService = class {
         findOptions
       );
       if (instances.length === 0) {
+        this.logger.debug(`Skipping "${filePath}": no instances of ${targetComponentType} found`);
         continue;
       }
       const valuesToPropagate = {};
@@ -1486,6 +1512,7 @@ var PropertyPropagatorService = class {
         }
       }
       if (Object.keys(valuesToPropagate).length === 0) {
+        this.logger.debug(`Skipping "${filePath}": ${instances.length} instance(s) of ${targetComponentType} found but none of [${resolvedNames.join(", ")}] present in root overrides`);
         continue;
       }
       let compositionModified = false;
@@ -1497,9 +1524,11 @@ var PropertyPropagatorService = class {
         this.compositionService.setInstanceParameters(instance, clonedValues);
         compositionModified = true;
         propagatedInstances++;
+        const updatedParamNames = Object.keys(valuesToPropagate).join(", ");
         instanceUpdates.push(
-          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+          `${targetComponentType} "${instanceName}": ${updatedParamNames}`
         );
+        this.logger.debug(`Component ${targetComponentType} "${instanceName}": parameters ${updatedParamNames} updated`);
       }
       if (compositionModified) {
         this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
@@ -1522,7 +1551,10 @@ var PropertyPropagatorService = class {
           if (exists) {
             this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
             modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+            this.logger.debug(`Parameter "${param.id}" removed from component ${sourceType}`);
             sourceComponentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" not found on source component "${sourceType}" \u2014 nothing to delete`);
           }
         }
         const beforeGroupCount = modifiedSource.parameters?.filter(
@@ -1561,6 +1593,8 @@ var PropertyPropagatorService = class {
           if (!whatIf) {
             await this.compositionService.saveComposition(filePath, composition);
           }
+        } else {
+          this.logger.debug(`No root overrides matching [${resolvedNames.join(", ")}] in composition/${relativePath}`);
         }
       }
     }
@@ -2934,9 +2968,16 @@ var FieldRemoverService = class {
 // src/cli/logger.ts
 import chalk from "chalk";
 var Logger = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
   info(message) {
     console.log(`${chalk.blue("[INFO]")} ${message}`);
   }
+  debug(message) {
+    if (!this.verbose) return;
+    console.log(`${chalk.magenta("[DEBUG]")} ${message}`);
+  }
   success(message) {
     console.log(`${chalk.green("[DONE]")} ${message}`);
   }