@uniformdev/transformer 1.1.40 → 1.1.42

package/dist/cli/index.js

@@ -1611,6 +1611,11 @@ function walkAndRegenerate(value, currentPath) {
   return value;
 }
 
+// src/core/utils.ts
+function splitList(value) {
+  return value.split(/[,;|]/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
 // src/core/services/property-propagator.service.ts
 var PropertyPropagatorService = class {
   constructor(fileSystem, componentService, compositionService, logger) {
@@ -1654,7 +1659,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 propertyNames = splitList(property);
     const resolvedParams = [];
     const resolvedNames = [];
     for (const { sourceType, sourceComponent } of sourceComponents) {
@@ -1892,7 +1897,7 @@ var PropertyPropagatorService = class {
     };
   }
   parsePipeSeparatedValues(value, strict) {
-    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    const entries = splitList(value);
     const normalized = [];
     for (const entry of entries) {
       const exists = normalized.some(
@@ -3850,7 +3855,7 @@ var ComponentAdderService = class {
     return id1.toLowerCase() === id2.toLowerCase();
   }
   parseParentComponentTypes(parentComponentType) {
-    return parentComponentType.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
+    return splitList(parentComponentType);
   }
   matchesAnyParentType(instanceType, parentTypes, strict) {
     return parentTypes.some((pt) => this.compareIds(instanceType, pt, strict));
@@ -4494,7 +4499,7 @@ var SlotPropagatorService = class {
     }
     this.logger.info(`Loading component: ${targetComponentType}`);
     const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
-    const slotNames = slot.split("|").map((s) => s.trim()).filter((s) => s.length > 0);
+    const slotNames = splitList(slot);
     const resolvedSlots = [];
     const resolvedSlotIds = [];
     for (const { sourceType, sourceComponent } of sourceComponents) {
@@ -4669,7 +4674,7 @@ var SlotPropagatorService = class {
     instance.slots[slotName].push(...components);
   }
   parsePipeSeparatedValues(value, strict) {
-    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    const entries = splitList(value);
     const normalized = [];
     for (const entry of entries) {
       const exists = normalized.some(
@@ -4816,8 +4821,8 @@ function createConvertCompositionsToEntriesCommand() {
       logger
     );
     try {
-      const compositionTypes = options.compositionTypes.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
-      const parsePipeSeparated = (value) => value ? [...new Set(value.split("|").map((t) => t.trim()).filter((t) => t.length > 0))] : [];
+      const compositionTypes = splitList(options.compositionTypes);
+      const parsePipeSeparated = (value) => value ? [...new Set(splitList(value))] : [];
       const componentsToReferences = parsePipeSeparated(options.componentsToReferences);
       const componentsToBlocks = parsePipeSeparated(options.componentsToBlocks);
       const slotsToReferences = parsePipeSeparated(options.slotsToReferences);
@@ -5129,7 +5134,7 @@ function createRemoveParameterCommand() {
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const remover = new ParameterRemoverService(fileSystem, componentService, logger);
-    const rawTypes = options.componentType.split("|").map((t) => t.trim()).filter(Boolean);
+    const rawTypes = splitList(options.componentType);
     const hasWildcard = rawTypes.includes("*");
     let componentTypes;
     if (hasWildcard) {
@@ -5440,7 +5445,7 @@ function createRemoveFieldCommand() {
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const remover = new FieldRemoverService(fileSystem, componentService, logger);
-    const rawTypes = options.componentType.split("|").map((t) => t.trim()).filter(Boolean);
+    const rawTypes = splitList(options.componentType);
     const componentTypes = rawTypes.includes("*") ? ["*"] : rawTypes;
     const aggregate = {
       compositionsModified: 0,
@@ -6367,7 +6372,7 @@ function createRemoveOrphanEntriesCommand() {
     };
     const logger = new Logger();
     logger.info(`rootContentTypes: ${options.rootContentTypes}`);
-    const rootContentTypes = options.rootContentTypes.split("|").map((t) => t.trim()).filter(Boolean);
+    const rootContentTypes = splitList(options.rootContentTypes);
     const fileSystem = new FileSystemService();
     const service = new OrphanEntryRemoverService(fileSystem, logger);
     const result = await service.remove({
@@ -6625,7 +6630,8 @@ var UnusedComponentTypeRemoverService = class {
       compositionPatternsDir,
       componentPatternsDir,
       whatIf,
-      strict
+      strict,
+      excludeComponentTypes = []
     } = options;
     const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
     const ctDirExists = await this.fileSystem.fileExists(componentsDirFull);
@@ -6676,7 +6682,10 @@ var UnusedComponentTypeRemoverService = class {
     let retainedComponentTypes = 0;
     for (const { filePath, id } of componentMap.values()) {
       const isUsed = this.isUsed(id, usedTypeIds, strict);
-      if (isUsed) {
+      const isExcluded = excludeComponentTypes.some(
+        (ex) => strict ? ex === id : ex.toLowerCase() === id.toLowerCase()
+      );
+      if (isUsed || isExcluded) {
         retainedComponentTypes++;
       } else {
         const relPath = this.fileSystem.joinPath(
@@ -6775,6 +6784,9 @@ function createRemoveUnusedComponentTypesCommand() {
   const command = new Command18("remove-unused-component-types");
   command.description(
     "Removes component definition files that are not referenced in any composition, pattern, or allowedComponents list."
+  ).option(
+    "--excludeComponentTypes <types>",
+    'Pipe-separated list of component type IDs to keep even if unused (e.g. "Hero|Button")'
   ).action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const options = {
@@ -6786,6 +6798,8 @@ function createRemoveUnusedComponentTypesCommand() {
     logger.info(`compositionsDir: ${options.compositionsDir}`);
     logger.info(`compositionPatternsDir: ${options.compositionPatternsDir}`);
     logger.info(`componentPatternsDir: ${options.componentPatternsDir}`);
+    logger.info(`excludeComponentTypes: ${options.excludeComponentTypes ?? ""}`);
+    const excludeComponentTypes = options.excludeComponentTypes ? splitList(options.excludeComponentTypes) : [];
     const fileSystem = new FileSystemService();
     const service = new UnusedComponentTypeRemoverService(fileSystem, logger);
     const result = await service.remove({
@@ -6795,7 +6809,8 @@ function createRemoveUnusedComponentTypesCommand() {
       compositionPatternsDir: options.compositionPatternsDir,
       componentPatternsDir: options.componentPatternsDir,
       whatIf: options.whatIf ?? false,
-      strict: options.strict ?? false
+      strict: options.strict ?? false,
+      excludeComponentTypes
     });
     logger.success(
       `Removed ${result.removedComponentTypes} unused component type(s). ${result.retainedComponentTypes} component type(s) retained.`
@@ -6814,7 +6829,7 @@ var GenerateMissingProjectMapNodesService = class {
     this.logger = logger;
   }
   async generate(options) {
-    const { rootDir, projectMapNodesDir, compositionsDir, rootContentTypes, whatIf, strict } = options;
+    const { rootDir, projectMapNodesDir, whatIf } = options;
     const nodesDirFull = this.fileSystem.resolvePath(rootDir, projectMapNodesDir);
     const nodesDirExists = await this.fileSystem.fileExists(nodesDirFull);
     if (!nodesDirExists) {
@@ -6843,41 +6858,8 @@ var GenerateMissingProjectMapNodesService = class {
       allNodes.push({ filePath, node });
     }
     const existingPaths = new Set(allNodes.map(({ node }) => node.path));
-    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const compositionIdToType = /* @__PURE__ */ new Map();
-    const compositionsDirExists = await this.fileSystem.fileExists(compositionsDirFull);
-    if (!compositionsDirExists) {
-      this.logger.warn(`Compositions directory not found: ${compositionsDir} \u2014 no source nodes will match`);
-    } else {
-      const compositionFiles = await this.fileSystem.findFiles(
-        compositionsDirFull,
-        "**/*.{json,yaml,yml}"
-      );
-      for (const filePath of compositionFiles) {
-        let comp;
-        try {
-          comp = await this.fileSystem.readFile(filePath);
-        } catch {
-          this.logger.warn(`Could not read composition file: ${filePath} \u2014 skipping`);
-          continue;
-        }
-        if (comp?.composition?._id && comp?.composition?.type) {
-          compositionIdToType.set(comp.composition._id, comp.composition.type);
-        }
-      }
-    }
-    const sourceNodes = allNodes.filter(({ node }) => {
-      if (!node.compositionId) return false;
-      const rootType = compositionIdToType.get(node.compositionId);
-      if (!rootType) {
-        this.logger.warn(
-          `No composition found for compositionId "${node.compositionId}" (node path: ${node.path}) \u2014 skipping`
-        );
-        return false;
-      }
-      return this.matchesContentType(rootType, rootContentTypes, strict);
-    });
-    this.logger.info(`${sourceNodes.length} node(s) match root content types`);
+    const sourceNodes = allNodes.filter(({ node }) => !!node.compositionId);
+    this.logger.info(`${sourceNodes.length} node(s) selected as sources`);
     const ancestorPaths = /* @__PURE__ */ new Set();
     for (const { node } of sourceNodes) {
       for (const ancestor of this.computeAncestorPaths(node.path)) {
@@ -6934,52 +6916,25 @@ var GenerateMissingProjectMapNodesService = class {
     const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
     return `${slug}-node.yaml`;
   }
-  matchesContentType(rootType, rootContentTypes, strict) {
-    for (const ct of rootContentTypes) {
-      if (strict) {
-        if (rootType === ct) return true;
-      } else {
-        if (rootType.toLowerCase() === ct.toLowerCase()) return true;
-      }
-    }
-    return false;
-  }
 };
 
 // src/cli/commands/generate-missing-project-map-nodes.ts
 function createGenerateMissingProjectMapNodesCommand() {
   const command = new Command19("generate-missing-project-map-nodes");
   command.description(
-    "Creates group project map nodes for ancestor path segments that are missing from the project map. Only paths reachable from compositions whose root type matches --rootContentTypes are considered."
-  ).option(
-    "--rootContentTypes <types>",
-    'Pipe-separated list of root component types identifying the leaf-page compositions whose ancestor paths should be filled in (e.g. "BlogPost|NewsArticle")'
-  ).hook("preAction", (thisCommand) => {
-    const opts = thisCommand.opts();
-    const requiredOptions = [{ name: "rootContentTypes", flag: "--rootContentTypes" }];
-    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) => {
+    "Creates group project map nodes for ancestor path segments that are missing from the project map. All project map nodes with a compositionId are used as sources."
+  ).action(async (opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const options = {
-      ...globalOpts,
-      rootContentTypes: opts.rootContentTypes
+      ...globalOpts
     };
     const logger = new Logger();
-    logger.info(`rootContentTypes: ${options.rootContentTypes}`);
-    const rootContentTypes = options.rootContentTypes.split("|").map((t) => t.trim()).filter(Boolean);
     const fileSystem = new FileSystemService();
     const service = new GenerateMissingProjectMapNodesService(fileSystem, logger);
     const result = await service.generate({
       rootDir: options.rootDir,
       projectMapNodesDir: options.projectMapNodesDir,
-      compositionsDir: options.compositionsDir,
-      rootContentTypes,
-      whatIf: options.whatIf ?? false,
-      strict: options.strict ?? false
+      whatIf: options.whatIf ?? false
     });
     logger.success(
       `Created ${result.generatedCount} missing project map node(s). ${result.alreadyCoveredCount} ancestor path(s) already existed.`
@@ -6991,7 +6946,7 @@ function createGenerateMissingProjectMapNodesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.40",
+  version: "1.1.42",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -7073,6 +7028,9 @@ program.requiredOption("--rootDir <path>", "Path to the serialization project ro
   "Project map definitions directory name",
   "projectMapDefinition"
 ).option("--projectMapNodesDir <dir>", "Project map nodes directory name", "projectMapNode").option("--quirksDir <dir>", "Quirks directory name", "quirk");
+program.hook("preAction", (_thisCommand, actionCommand) => {
+  console.error(`[INFO] ${actionCommand.name()} args: ${JSON.stringify(actionCommand.optsWithGlobals())}`);
+});
 program.addCommand(createPropagateRootComponentPropertyCommand());
 program.addCommand(createFindCompositionPatternCandidatesCommand());
 program.addCommand(createUnpackSerializationCommand());