@uniformdev/transformer 1.1.41 → 1.1.42

package/dist/cli/index.js

@@ -6829,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) {
@@ -6858,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)) {
@@ -6949,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 = splitList(options.rootContentTypes);
     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.`
@@ -7006,7 +6946,7 @@ function createGenerateMissingProjectMapNodesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.41",
+  version: "1.1.42",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {