@uniformdev/transformer 1.1.11 → 1.1.13

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command11 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -3696,6 +3696,9 @@ var CompositionConverterService = class {
           value: instances.map((inst) => inst.determinisiticId)
         };
       }
+      if (flattenComponentIds.length > 0) {
+        this.transformContentReferences(entry);
+      }
       const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${compositionId}.json`);
       this.logger.action(
         whatIf,
@@ -3818,13 +3821,29 @@ var CompositionConverterService = class {
   // --- Entry Generation ---
   generateEntryFromComposition(composition) {
     const comp = composition.composition;
+    const compositionSpecificKeys = /* @__PURE__ */ new Set(["_id", "_name", "type", "parameters", "slots", "_overrides"]);
+    const extraRootProps = {};
+    for (const [key, value] of Object.entries(comp)) {
+      if (!compositionSpecificKeys.has(key) && value != null) {
+        extraRootProps[key] = value;
+      }
+    }
+    const wrapperKeys = /* @__PURE__ */ new Set(["composition"]);
+    const extraWrapperProps = {};
+    for (const [key, value] of Object.entries(composition)) {
+      if (!wrapperKeys.has(key) && value != null) {
+        extraWrapperProps[key] = value;
+      }
+    }
     return {
       entry: {
         _id: comp._id,
         _name: comp._name ?? comp._id,
         type: comp.type,
-        fields: { ...comp.parameters ?? {} }
-      }
+        fields: { ...comp.parameters ?? {} },
+        ...extraRootProps
+      },
+      ...extraWrapperProps
     };
   }
   generateEntryFromFlattenedInstance(inst) {
@@ -3878,6 +3897,30 @@ var CompositionConverterService = class {
       }
     }
   }
+  // --- Content Reference Transformation ---
+  transformContentReferences(entry) {
+    const dataResources = {};
+    for (const [fieldName, field] of Object.entries(entry.entry.fields)) {
+      if (field.type === "contentReference" && Array.isArray(field.value)) {
+        const entryIds = field.value;
+        const resourceKey = `ref-${entry.entry._id}-${fieldName}`;
+        field.value = `\${#jptr:/${resourceKey}/entries}`;
+        dataResources[resourceKey] = {
+          type: "uniformContentInternalReference",
+          variables: {
+            locale: "${locale}",
+            entryIds: entryIds.join(",")
+          }
+        };
+      }
+    }
+    if (Object.keys(dataResources).length > 0) {
+      entry.entry._dataResources = {
+        ...entry.entry._dataResources ?? {},
+        ...dataResources
+      };
+    }
+  }
   // --- Utilities ---
   compareTypes(type1, type2, strict) {
     if (strict) {
@@ -4007,10 +4050,548 @@ function createConvertCompositionsToEntriesCommand() {
   return command;
 }
 
+// src/cli/commands/remove-parameter.ts
+import { Command as Command11 } from "commander";
+
+// src/core/services/parameter-remover.service.ts
+var ParameterRemoverService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async remove(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      parameterId,
+      whatIf,
+      strict
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    const param = this.componentService.findParameter(component, parameterId, findOptions);
+    if (!param) {
+      throw new PropertyNotFoundError(parameterId, componentType);
+    }
+    this.logger.action(
+      whatIf,
+      "REMOVE",
+      `Parameter "${parameterId}" from component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    let modifiedComponent = this.componentService.removeParameter(component, parameterId, findOptions);
+    const beforeGroupCount = modifiedComponent.parameters?.filter(
+      (p) => this.componentService.isGroupParameter(p)
+    ).length ?? 0;
+    modifiedComponent = this.componentService.removeEmptyGroups(modifiedComponent);
+    const afterGroupCount = modifiedComponent.parameters?.filter(
+      (p) => this.componentService.isGroupParameter(p)
+    ).length ?? 0;
+    if (afterGroupCount < beforeGroupCount) {
+      const removedCount = beforeGroupCount - afterGroupCount;
+      this.logger.action(
+        whatIf,
+        "REMOVE",
+        `${removedCount} empty group(s) from component/${this.fileSystem.getBasename(componentFilePath)}`
+      );
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, modifiedComponent);
+    }
+    const compositionsResult = await this.removeParameterInDirectory(
+      fullCompositionsDir,
+      componentType,
+      parameterId,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.removeParameterInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      parameterId,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.removeParameterInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      parameterId,
+      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: 1 component definition updated, ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`
+    );
+    return {
+      componentDefinitionUpdated: true,
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesUpdated: totalInstances
+    };
+  }
+  async removeParameterInDirectory(directory, componentType, parameterId, 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;
+      }
+      const count = this.removeParameterFromTree(
+        composition.composition,
+        componentType,
+        parameterId,
+        strict
+      );
+      const overridesCount = this.removeParameterFromOverrides(
+        composition,
+        componentType,
+        parameterId,
+        strict
+      );
+      const totalCount = count + overridesCount;
+      if (totalCount > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${totalCount} instance(s) of ${componentType})`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesUpdated += totalCount;
+      }
+    }
+    return { filesModified, instancesUpdated };
+  }
+  removeParameterFromTree(node, componentType, parameterId, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, componentType, strict) && node.parameters) {
+      const removed = this.removeKeyFromMap(node.parameters, parameterId, strict);
+      if (removed) {
+        count++;
+      }
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.removeParameterFromTree(instance, componentType, parameterId, strict);
+        }
+      }
+    }
+    return count;
+  }
+  removeParameterFromOverrides(composition, componentType, parameterId, strict) {
+    if (!composition.composition._overrides) {
+      return 0;
+    }
+    let count = 0;
+    if (this.compareIds(composition.composition.type, componentType, strict)) {
+      const rootId = composition.composition._id;
+      const rootOverrides = composition.composition._overrides[rootId];
+      if (rootOverrides?.parameters) {
+        const removed = this.removeKeyFromMap(rootOverrides.parameters, parameterId, strict);
+        if (removed) {
+          count++;
+        }
+      }
+    }
+    const counter = { count: 0 };
+    this.removeOverridesForMatchingInstances(
+      composition.composition,
+      composition.composition._overrides,
+      componentType,
+      parameterId,
+      strict,
+      counter
+    );
+    count += counter.count;
+    return count;
+  }
+  removeOverridesForMatchingInstances(node, overrides, componentType, parameterId, strict, counter) {
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          if (this.compareIds(instance.type, componentType, strict) && instance._id) {
+            const instanceOverrides = overrides[instance._id];
+            if (instanceOverrides?.parameters) {
+              const removed = this.removeKeyFromMap(instanceOverrides.parameters, parameterId, strict);
+              if (removed) {
+                counter.count++;
+              }
+            }
+          }
+          this.removeOverridesForMatchingInstances(
+            instance,
+            overrides,
+            componentType,
+            parameterId,
+            strict,
+            counter
+          );
+        }
+      }
+    }
+  }
+  removeKeyFromMap(map, key, strict) {
+    const matchingKey = Object.keys(map).find(
+      (k) => this.compareIds(k, key, strict)
+    );
+    if (!matchingKey) {
+      return false;
+    }
+    delete map[matchingKey];
+    return true;
+  }
+};
+
+// src/cli/commands/remove-parameter.ts
+function createRemoveParameterCommand() {
+  const command = new Command11("remove-parameter");
+  command.description(
+    "Removes a parameter definition from a component and deletes all corresponding parameter values from compositions, composition patterns, and component patterns."
+  ).option("--componentType <type>", "The component type that owns the parameter to remove").option("--parameterId <id>", "The parameter ID to remove").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "componentType", flag: "--componentType" },
+      { name: "parameterId", flag: "--parameterId" }
+    ];
+    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,
+      componentType: opts.componentType,
+      parameterId: opts.parameterId
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const remover = new ParameterRemoverService(fileSystem, componentService, logger);
+    try {
+      const result = await remover.remove({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        componentType: options.componentType,
+        parameterId: options.parameterId,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Removed parameter: ${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;
+}
+
+// src/cli/commands/remove-field.ts
+import { Command as Command12 } from "commander";
+
+// src/core/services/field-remover.service.ts
+var FieldRemoverService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async remove(options) {
+    const {
+      rootDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      parameterId,
+      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(`Removing field "${parameterId}" from instances of ${componentType}`);
+    const compositionsResult = await this.removeFieldInDirectory(
+      fullCompositionsDir,
+      componentType,
+      parameterId,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.removeFieldInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      parameterId,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.removeFieldInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      parameterId,
+      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 removeFieldInDirectory(directory, componentType, parameterId, 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;
+      }
+      const treeCount = this.removeFieldFromTree(
+        composition.composition,
+        componentType,
+        parameterId,
+        strict
+      );
+      const overridesCount = this.removeFieldFromOverrides(
+        composition,
+        componentType,
+        parameterId,
+        strict
+      );
+      const totalCount = treeCount + overridesCount;
+      if (totalCount > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${totalCount} instance(s) of ${componentType})`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesUpdated += totalCount;
+      }
+    }
+    return { filesModified, instancesUpdated };
+  }
+  removeFieldFromTree(node, componentType, parameterId, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, componentType, strict) && node.parameters) {
+      const removed = this.removeKeyFromMap(node.parameters, parameterId, strict);
+      if (removed) {
+        count++;
+      }
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.removeFieldFromTree(instance, componentType, parameterId, strict);
+        }
+      }
+    }
+    return count;
+  }
+  removeFieldFromOverrides(composition, componentType, parameterId, strict) {
+    if (!composition.composition._overrides) {
+      return 0;
+    }
+    let count = 0;
+    if (this.compareIds(composition.composition.type, componentType, strict)) {
+      const rootId = composition.composition._id;
+      const rootOverrides = composition.composition._overrides[rootId];
+      if (rootOverrides?.parameters) {
+        const removed = this.removeKeyFromMap(rootOverrides.parameters, parameterId, strict);
+        if (removed) {
+          count++;
+        }
+      }
+    }
+    count += this.removeOverridesForMatchingInstances(
+      composition.composition,
+      composition.composition._overrides,
+      componentType,
+      parameterId,
+      strict
+    );
+    return count;
+  }
+  removeOverridesForMatchingInstances(node, overrides, componentType, parameterId, strict) {
+    let count = 0;
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          if (this.compareIds(instance.type, componentType, strict) && instance._id) {
+            const instanceOverrides = overrides[instance._id];
+            if (instanceOverrides?.parameters) {
+              const removed = this.removeKeyFromMap(instanceOverrides.parameters, parameterId, strict);
+              if (removed) {
+                count++;
+              }
+            }
+          }
+          count += this.removeOverridesForMatchingInstances(
+            instance,
+            overrides,
+            componentType,
+            parameterId,
+            strict
+          );
+        }
+      }
+    }
+    return count;
+  }
+  removeKeyFromMap(map, key, strict) {
+    const matchingKey = Object.keys(map).find(
+      (k) => this.compareIds(k, key, strict)
+    );
+    if (!matchingKey) {
+      return false;
+    }
+    delete map[matchingKey];
+    return true;
+  }
+};
+
+// src/cli/commands/remove-field.ts
+function createRemoveFieldCommand() {
+  const command = new Command12("remove-field");
+  command.description(
+    "Removes parameter values from component instances in compositions, composition patterns, and component patterns without modifying the component definition."
+  ).option("--componentType <type>", "The component type whose instances should have the parameter value removed").option("--parameterId <id>", "The parameter value key to remove from matching instances").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "componentType", flag: "--componentType" },
+      { name: "parameterId", flag: "--parameterId" }
+    ];
+    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,
+      componentType: opts.componentType,
+      parameterId: opts.parameterId
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const remover = new FieldRemoverService(fileSystem, logger);
+    try {
+      const result = await remover.remove({
+        rootDir: options.rootDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        componentType: options.componentType,
+        parameterId: options.parameterId,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Removed field: ${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.11",
+  version: "1.1.13",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -4079,7 +4660,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command11();
+var program = new Command13();
 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);
@@ -4102,5 +4683,7 @@ program.addCommand(createAddComponentCommand());
 program.addCommand(createAddComponentPatternCommand());
 program.addCommand(createPropagateRootComponentSlotCommand());
 program.addCommand(createConvertCompositionsToEntriesCommand());
+program.addCommand(createRemoveParameterCommand());
+program.addCommand(createRemoveFieldCommand());
 program.parse();
 //# sourceMappingURL=index.js.map