@uniformdev/transformer 1.1.38 → 1.1.39

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -6370,10 +6370,134 @@ function createRemoveOrphanEntriesCommand() {
   return command;
 }
 
+// src/cli/commands/remove-unused-content-types.ts
+import { Command as Command17 } from "commander";
+
+// src/core/services/unused-content-type-remover.service.ts
+var UnusedContentTypeRemoverService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async remove(options) {
+    const { rootDir, contentTypesDir, entriesDir, whatIf, strict } = options;
+    const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    const ctDirExists = await this.fileSystem.fileExists(contentTypesDirFull);
+    if (!ctDirExists) {
+      this.logger.warn(`Content types directory not found: ${contentTypesDir} \u2014 nothing to do`);
+      return { totalContentTypes: 0, removedContentTypes: 0, retainedContentTypes: 0 };
+    }
+    const ctFiles = await this.fileSystem.findFiles(contentTypesDirFull, "**/*.{json,yaml,yml}");
+    if (ctFiles.length === 0) {
+      this.logger.warn("No content type files found \u2014 nothing to do");
+      return { totalContentTypes: 0, removedContentTypes: 0, retainedContentTypes: 0 };
+    }
+    this.logger.info(`Loaded ${ctFiles.length} content type file(s)`);
+    const contentTypeMap = /* @__PURE__ */ new Map();
+    for (const filePath of ctFiles) {
+      let ct;
+      try {
+        ct = await this.fileSystem.readFile(filePath);
+      } catch {
+        this.logger.warn(`Could not read content type file: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      if (!ct?.id) {
+        this.logger.warn(`Content type file missing id: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      contentTypeMap.set(filePath, { filePath, id: ct.id });
+    }
+    const usedTypeIds = /* @__PURE__ */ new Set();
+    const entriesDirExists = await this.fileSystem.fileExists(entriesDirFull);
+    if (!entriesDirExists) {
+      this.logger.warn(`Entries directory not found: ${entriesDir} \u2014 treating all content types as unused`);
+    } else {
+      const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "**/*.{json,yaml,yml}");
+      this.logger.info(`Loaded ${entryFiles.length} entry file(s)`);
+      for (const filePath of entryFiles) {
+        let entryData;
+        try {
+          entryData = await this.fileSystem.readFile(filePath);
+        } catch {
+          this.logger.warn(`Could not read entry file: ${filePath} \u2014 skipping`);
+          continue;
+        }
+        if (!entryData?.entry?.type) {
+          continue;
+        }
+        usedTypeIds.add(entryData.entry.type);
+      }
+    }
+    let removedContentTypes = 0;
+    let retainedContentTypes = 0;
+    for (const { filePath, id } of contentTypeMap.values()) {
+      const isUsed = this.isUsed(id, usedTypeIds, strict);
+      if (isUsed) {
+        retainedContentTypes++;
+      } else {
+        const relPath = this.fileSystem.joinPath(
+          contentTypesDir,
+          this.fileSystem.getBasename(filePath)
+        );
+        this.logger.action(whatIf, "DELETE", relPath);
+        if (!whatIf) {
+          this.fileSystem.deleteFile(filePath);
+        }
+        removedContentTypes++;
+      }
+    }
+    return {
+      totalContentTypes: contentTypeMap.size,
+      removedContentTypes,
+      retainedContentTypes
+    };
+  }
+  isUsed(contentTypeId, usedTypeIds, strict) {
+    if (strict) {
+      return usedTypeIds.has(contentTypeId);
+    }
+    const lower = contentTypeId.toLowerCase();
+    for (const used of usedTypeIds) {
+      if (used.toLowerCase() === lower) return true;
+    }
+    return false;
+  }
+};
+
+// src/cli/commands/remove-unused-content-types.ts
+function createRemoveUnusedContentTypesCommand() {
+  const command = new Command17("remove-unused-content-types");
+  command.description("Removes content type definition files that have zero entries referencing them.").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts
+    };
+    const logger = new Logger();
+    logger.info(`rootDir: ${options.rootDir}`);
+    logger.info(`contentTypesDir: ${options.contentTypesDir}`);
+    logger.info(`entriesDir: ${options.entriesDir}`);
+    const fileSystem = new FileSystemService();
+    const service = new UnusedContentTypeRemoverService(fileSystem, logger);
+    const result = await service.remove({
+      rootDir: options.rootDir,
+      contentTypesDir: options.contentTypesDir,
+      entriesDir: options.entriesDir,
+      whatIf: options.whatIf ?? false,
+      strict: options.strict ?? false
+    });
+    logger.success(
+      `Removed ${result.removedContentTypes} unused content type(s). ${result.retainedContentTypes} content type(s) retained.`
+    );
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.38",
+  version: "1.1.39",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -6442,7 +6566,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command17();
+var program = new Command18();
 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);
@@ -6471,5 +6595,6 @@ program.addCommand(createAddComponentParameterCommand());
 program.addCommand(createAddContentTypeFieldCommand());
 program.addCommand(createFlattenBlockFieldCommand());
 program.addCommand(createRemoveOrphanEntriesCommand());
+program.addCommand(createRemoveUnusedContentTypesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map