@uniformdev/transformer 1.1.43 → 1.1.45

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -6908,12 +6908,12 @@ var GenerateMissingProjectMapNodesService = class {
   }
   pathToNodeId(nodePath) {
     if (nodePath === "/") return "pmn-group-root";
-    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
+    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-").replace(/[\\:*?"<>|]/g, "_");
     return `pmn-group-${slug}`;
   }
   pathToFileName(nodePath) {
     if (nodePath === "/") return "root-node.yaml";
-    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
+    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-").replace(/[\\:*?"<>|]/g, "_");
     return `${slug}-node.yaml`;
   }
 };
@@ -7141,10 +7141,295 @@ function createSplitContentTypeCommand() {
   return command;
 }
 
+// src/cli/commands/propagate-root-slot.ts
+import { Command as Command21 } from "commander";
+
+// src/core/services/root-slot-propagator.service.ts
+var RootSlotPropagatorService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async propagate(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionType,
+      slot,
+      targetComponentType,
+      whatIf,
+      strict
+    } = options;
+    const findOptions = { strict };
+    const compositionTypes = this.parseSeparatedValues(compositionType, strict);
+    const slotNames = splitList(slot);
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const sourceComponents = [];
+    for (const sourceType of compositionTypes) {
+      this.logger.info(`Loading component: ${sourceType}`);
+      try {
+        const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
+        for (const slotName of slotNames) {
+          const slotDef = this.componentService.findSlot(sourceComponent, slotName, findOptions);
+          if (!slotDef) {
+            this.logger.warn(`Slot "${slotName}" not found on component "${sourceType}" \u2014 skipping`);
+          }
+        }
+        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})`);
+          continue;
+        }
+        throw error;
+      }
+    }
+    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 compositions = await this.compositionService.findCompositionsByTypes(
+      fullCompositionsDir,
+      compositionTypes,
+      findOptions
+    );
+    this.logger.debug(
+      `Found ${compositions.length} composition(s) matching types [${compositionTypes.join(", ")}]`
+    );
+    const componentTypesInSlot = /* @__PURE__ */ new Set();
+    for (const { composition } of compositions) {
+      const rootSlots = composition.composition.slots ?? {};
+      for (const slotName of slotNames) {
+        const slotContent = rootSlots[slotName] ?? [];
+        for (const instance of slotContent) {
+          if (instance.type) {
+            componentTypesInSlot.add(instance.type);
+          }
+        }
+      }
+    }
+    const collectedTypes = Array.from(componentTypesInSlot).sort();
+    this.logger.info(
+      `Collected component types from slot contents: [${collectedTypes.join(", ")}]`
+    );
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    for (const slotName of slotNames) {
+      const existingSlot = this.componentService.findSlot(modifiedComponent, slotName, findOptions);
+      if (!existingSlot) {
+        this.logger.action(whatIf, "CREATE", `Slot "${slotName}" on ${targetComponentType}`);
+        modifiedComponent = this.componentService.addSlot(modifiedComponent, {
+          id: slotName,
+          name: slotName,
+          allowedComponents: collectedTypes
+        });
+        this.logger.debug(
+          `Slot "${slotName}" created on "${targetComponentType}" with allowedComponents: [${collectedTypes.join(", ")}]`
+        );
+        componentModified = true;
+      } else {
+        const existingAllowed = existingSlot.allowedComponents ?? [];
+        const newTypes = collectedTypes.filter(
+          (t) => !existingAllowed.some(
+            (a) => strict ? a === t : a.toLowerCase() === t.toLowerCase()
+          )
+        );
+        if (newTypes.length > 0) {
+          const merged = [...existingAllowed, ...newTypes].sort();
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Slot "${slotName}" allowedComponents on ${targetComponentType}`
+          );
+          this.logger.detail(`\u2192 Adding: ${newTypes.join(", ")}`);
+          modifiedComponent = this.componentService.updateSlotAllowedComponents(
+            modifiedComponent,
+            slotName,
+            merged,
+            findOptions
+          );
+          componentModified = true;
+        } else {
+          this.logger.info(
+            `Slot "${slotName}" on "${targetComponentType}" already has all required allowedComponents`
+          );
+        }
+      }
+    }
+    if (componentModified && !whatIf) {
+      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
+    }
+    let modifiedCompositions = 0;
+    let propagatedInstances = 0;
+    for (const { composition, filePath } of compositions) {
+      const rootSlots = composition.composition.slots ?? {};
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
+      );
+      if (instances.length === 0) {
+        this.logger.debug(
+          `Skipping "${filePath}": no instances of ${targetComponentType} found`
+        );
+        continue;
+      }
+      const componentsToPropagate = [];
+      for (const slotName of slotNames) {
+        const slotContent = rootSlots[slotName] ?? [];
+        componentsToPropagate.push(...slotContent);
+      }
+      if (componentsToPropagate.length === 0) {
+        this.logger.debug(
+          `Skipping "${filePath}": slot(s) [${slotNames.join(", ")}] are empty`
+        );
+        continue;
+      }
+      let compositionModified = false;
+      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+      const instanceUpdates = [];
+      for (const { instance, instanceId } of instances) {
+        const instanceName = instance._id ?? instanceId;
+        for (const slotName of slotNames) {
+          const slotContent = rootSlots[slotName] ?? [];
+          if (slotContent.length === 0) continue;
+          const clonedComponents = regenerateIds(
+            slotContent,
+            `${instanceName}.${slotName}`
+          );
+          this.addComponentsToInstanceSlot(instance, slotName, clonedComponents);
+        }
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${componentsToPropagate.length} component(s) \u2192 [${slotNames.join(", ")}]`
+        );
+        this.logger.debug(
+          `Component ${targetComponentType} "${instanceName}": slot(s) [${slotNames.join(", ")}] updated`
+        );
+      }
+      if (compositionModified) {
+        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
+        for (const update of instanceUpdates) {
+          this.logger.detail(`\u2192 ${update}`);
+        }
+        if (!whatIf) {
+          await this.compositionService.saveComposition(filePath, composition);
+        }
+        modifiedCompositions++;
+      }
+    }
+    return {
+      modifiedComponents: componentModified ? 1 : 0,
+      modifiedCompositions,
+      propagatedInstances
+    };
+  }
+  addComponentsToInstanceSlot(instance, slotName, components) {
+    if (!instance.slots) {
+      instance.slots = {};
+    }
+    if (!instance.slots[slotName]) {
+      instance.slots[slotName] = [];
+    }
+    instance.slots[slotName].push(...components);
+  }
+  parseSeparatedValues(value, strict) {
+    const entries = splitList(value);
+    const normalized = [];
+    for (const entry of entries) {
+      const exists = normalized.some(
+        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+      );
+      if (!exists) {
+        normalized.push(entry);
+      }
+    }
+    return normalized;
+  }
+};
+
+// src/cli/commands/propagate-root-slot.ts
+function createPropagateRootSlotCommand() {
+  const command = new Command21("propagate-root-slot");
+  command.description(
+    "Propagates a named slot (with all its component instances) from the root of compositions to every instance of a target component type, keeping the same slot name and updating allowedComponents based on actual slot contents."
+  ).option(
+    "--compositionType <type>",
+    "The composition type(s) to process. Supports pipe-separated lists (e.g., RelatedTopicPage|LandingPage)"
+  ).option(
+    "--slot <slot>",
+    "The slot name to propagate. The same slot name is used on both the source root and the target component. Supports pipe-separated lists."
+  ).option(
+    "--targetComponentType <type>",
+    "The component type that will receive the slot contents"
+  ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionType", flag: "--compositionType" },
+      { name: "slot", flag: "--slot" },
+      { name: "targetComponentType", flag: "--targetComponentType" }
+    ];
+    const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
+    if (missing.length > 0) {
+      console.error(`error: missing required options: ${missing.join(", ")}`);
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      compositionType: opts.compositionType,
+      slot: opts.slot,
+      targetComponentType: opts.targetComponentType
+    };
+    const logger = new Logger(opts.verbose ?? false);
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const propagator = new RootSlotPropagatorService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const result = await propagator.propagate({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionType: options.compositionType,
+        slot: options.slot,
+        targetComponentType: options.targetComponentType,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s), propagated to ${result.propagatedInstances} instance(s)`
+      );
+    } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.43",
+  version: "1.1.45",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -7213,7 +7498,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command21();
+var program = new Command22();
 var appVersion = package_default.version;
 console.error(`uniform-transform v${appVersion}`);
 program.name("uniform-transform").description("CLI tool for transforming Uniform.dev serialization files offline").version(appVersion);
@@ -7249,5 +7534,6 @@ program.addCommand(createRemoveUnusedContentTypesCommand());
 program.addCommand(createRemoveUnusedComponentTypesCommand());
 program.addCommand(createGenerateMissingProjectMapNodesCommand());
 program.addCommand(createSplitContentTypeCommand());
+program.addCommand(createPropagateRootSlotCommand());
 program.parse();
 //# sourceMappingURL=index.js.map