@uniformdev/transformer 1.1.49 → 1.1.51

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -4044,6 +4044,7 @@ var ComponentAdderService = class {
       parentComponentType,
       slot,
       componentPatternId,
+      compositionIds,
       whatIf,
       strict
     } = options;
@@ -4137,7 +4138,8 @@ var ComponentAdderService = class {
       newInstance,
       whatIf,
       strict,
-      "composition"
+      "composition",
+      compositionIds
     );
     const compositionPatternsResult = await this.addComponentToDirectory(
       fullCompositionPatternsDir,
@@ -4146,7 +4148,8 @@ var ComponentAdderService = class {
       newInstance,
       whatIf,
       strict,
-      "compositionPattern"
+      "compositionPattern",
+      compositionIds
     );
     const componentPatternsResult = await this.addComponentToDirectory(
       fullComponentPatternsDir,
@@ -4210,7 +4213,7 @@ var ComponentAdderService = class {
     }
     return raw;
   }
-  async addComponentToDirectory(directory, parentTypes, slot, newInstance, whatIf, strict, dirType) {
+  async addComponentToDirectory(directory, parentTypes, slot, newInstance, whatIf, strict, dirType, compositionIds) {
     const exists = await this.fileSystem.fileExists(directory);
     if (!exists) {
       this.logger.detail(`${dirType} directory does not exist, skipping`);
@@ -4242,6 +4245,12 @@ var ComponentAdderService = class {
           continue;
         }
         const rootInstance = composition.composition;
+        if (compositionIds && compositionIds.length > 0) {
+          const compositionId = rootInstance._id;
+          if (!compositionId || !compositionIds.some((id) => this.compareIds(compositionId, id, strict))) {
+            continue;
+          }
+        }
         const rootPath = `${rootInstance._id ?? ""}${rootInstance.type}`;
         let modified = false;
         if (this.matchesAnyParentType(rootInstance.type, parentTypes, strict)) {
@@ -4400,7 +4409,7 @@ function createAddComponentCommand() {
 import { Command as Command8 } from "commander";
 function createAddComponentPatternCommand() {
   const command = new Command8("add-component-pattern");
-  command.description("Adds a component pattern instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component pattern will be added").option("--componentPatternId <id>", "The component pattern ID to add").hook("preAction", (thisCommand) => {
+  command.description("Adds a component pattern instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component pattern will be added").option("--componentPatternId <id>", "The component pattern ID to add").option("--compositionIds <ids>", "Comma, semicolon, or pipe-separated list of composition IDs to limit the operation to").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "parentComponentType", flag: "--parentComponentType" },
@@ -4418,12 +4427,20 @@ function createAddComponentPatternCommand() {
       ...globalOpts,
       parentComponentType: opts.parentComponentType,
       slot: opts.slot,
-      componentPatternId: opts.componentPatternId
+      componentPatternId: opts.componentPatternId,
+      compositionIds: opts.compositionIds
     };
     const logger = new Logger();
+    logger.info(`parentComponentType: ${options.parentComponentType}`);
+    logger.info(`slot: ${options.slot}`);
+    logger.info(`componentPatternId: ${options.componentPatternId}`);
+    if (options.compositionIds) {
+      logger.info(`compositionIds: ${options.compositionIds}`);
+    }
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const adder = new ComponentAdderService(fileSystem, componentService, logger);
+    const parsedCompositionIds = options.compositionIds ? splitList(options.compositionIds) : void 0;
     try {
       const result = await adder.addComponentPattern({
         rootDir: options.rootDir,
@@ -4434,6 +4451,7 @@ function createAddComponentPatternCommand() {
         parentComponentType: options.parentComponentType,
         slot: options.slot,
         componentPatternId: options.componentPatternId,
+        compositionIds: parsedCompositionIds,
         whatIf: options.whatIf ?? false,
         strict: options.strict ?? false
       });
@@ -7473,10 +7491,220 @@ function createPropagateRootSlotCommand() {
   return command;
 }
 
+// src/cli/commands/clear-slot.ts
+import { Command as Command22 } from "commander";
+
+// src/core/services/slot-clearer.service.ts
+var SlotClearerService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  matchesParentType(type, parentTypes, strict) {
+    if (!parentTypes) return true;
+    return parentTypes.some((pt) => this.compareIds(type, pt, strict));
+  }
+  matchesCompositionId(id, compositionIds, strict) {
+    if (!compositionIds) return true;
+    return compositionIds.some((cid) => this.compareIds(id, cid, strict));
+  }
+  async clearSlot(options) {
+    const {
+      rootDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      slot,
+      parentComponentTypes,
+      compositionIds,
+      whatIf,
+      strict
+    } = options;
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    this.logger.info(
+      `Clearing slot "${slot}"` + (parentComponentTypes ? ` on component type(s): ${parentComponentTypes.join(", ")}` : "") + (compositionIds ? ` in composition(s): ${compositionIds.join(", ")}` : "")
+    );
+    const compositionsResult = await this.clearSlotInDirectory(
+      fullCompositionsDir,
+      slot,
+      parentComponentTypes,
+      compositionIds,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.clearSlotInDirectory(
+      fullCompositionPatternsDir,
+      slot,
+      parentComponentTypes,
+      null,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.clearSlotInDirectory(
+      fullComponentPatternsDir,
+      slot,
+      parentComponentTypes,
+      null,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesUpdated + compositionPatternsResult.instancesUpdated + componentPatternsResult.instancesUpdated;
+    this.logger.info("");
+    this.logger.info(`Summary: ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`);
+    return {
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesUpdated: totalInstances
+    };
+  }
+  async clearSlotInDirectory(directory, slot, parentComponentTypes, compositionIds, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesUpdated: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesUpdated: 0 };
+    }
+    let filesModified = 0;
+    let instancesUpdated = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) {
+        continue;
+      }
+      if (compositionIds && !this.matchesCompositionId(composition.composition._id, compositionIds, strict)) {
+        continue;
+      }
+      const count = this.clearSlotInTree(
+        composition.composition,
+        slot,
+        parentComponentTypes,
+        strict
+      );
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "CLEAR",
+          `slot "${slot}" in ${label}/${relativePath} (${count} instance(s))`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesUpdated += count;
+      }
+    }
+    return { filesModified, instancesUpdated };
+  }
+  clearSlotInTree(node, slot, parentComponentTypes, strict) {
+    let count = 0;
+    if (this.matchesParentType(node.type, parentComponentTypes, strict) && node.slots) {
+      const matchingSlotKey = Object.keys(node.slots).find(
+        (k) => this.compareIds(k, slot, strict)
+      );
+      if (matchingSlotKey) {
+        const slotContent = node.slots[matchingSlotKey];
+        if (Array.isArray(slotContent) && slotContent.length > 0) {
+          node.slots[matchingSlotKey] = [];
+          count++;
+        }
+      }
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.clearSlotInTree(instance, slot, parentComponentTypes, strict);
+        }
+      }
+    }
+    return count;
+  }
+};
+
+// src/cli/commands/clear-slot.ts
+function createClearSlotCommand() {
+  const command = new Command22("clear-slot");
+  command.description(
+    "Removes all components from a given slot in compositions, composition patterns, and component patterns."
+  ).option("--slot <name>", "The slot name to clear").option(
+    "--parentComponentType <types>",
+    "Comma/semicolon/pipe-separated list of parent component types to filter by"
+  ).option(
+    "--compositionIds <ids>",
+    "Comma/semicolon/pipe-separated list of composition IDs to restrict processing to"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [{ name: "slot", flag: "--slot" }];
+    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,
+      slot: opts.slot,
+      parentComponentType: opts.parentComponentType,
+      compositionIds: opts.compositionIds
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const clearer = new SlotClearerService(fileSystem, logger);
+    const parentComponentTypes = options.parentComponentType ? splitList(options.parentComponentType) : null;
+    const compositionIds = options.compositionIds ? splitList(options.compositionIds) : null;
+    try {
+      const result = await clearer.clearSlot({
+        rootDir: options.rootDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        slot: options.slot,
+        parentComponentTypes,
+        compositionIds,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Cleared slot: ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
+      );
+    } catch (error) {
+      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.49",
+  version: "1.1.51",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -7545,7 +7773,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command22();
+var program = new Command23();
 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);
@@ -7582,5 +7810,6 @@ program.addCommand(createRemoveUnusedComponentTypesCommand());
 program.addCommand(createGenerateMissingProjectMapNodesCommand());
 program.addCommand(createSplitContentTypeCommand());
 program.addCommand(createPropagateRootSlotCommand());
+program.addCommand(createClearSlotCommand());
 program.parse();
 //# sourceMappingURL=index.js.map