@uniformdev/transformer 1.0.0

package/dist/index.js

@@ -0,0 +1,1116 @@
+// src/core/errors.ts
+var TransformError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TransformError";
+  }
+};
+var ComponentNotFoundError = class extends TransformError {
+  constructor(componentType, path2) {
+    const pathInfo = path2 ? ` (searched: ${path2})` : "";
+    super(`Component not found: ${componentType}${pathInfo}`);
+    this.name = "ComponentNotFoundError";
+  }
+};
+var PropertyNotFoundError = class extends TransformError {
+  constructor(propertyName, componentType) {
+    super(`Property "${propertyName}" not found on component "${componentType}"`);
+    this.name = "PropertyNotFoundError";
+  }
+};
+var InvalidYamlError = class extends TransformError {
+  constructor(filePath, details) {
+    const detailsInfo = details ? `: ${details}` : "";
+    super(`Invalid YAML file: ${filePath}${detailsInfo}`);
+    this.name = "InvalidYamlError";
+  }
+};
+var FileNotFoundError = class extends TransformError {
+  constructor(filePath) {
+    super(`File not found: ${filePath}`);
+    this.name = "FileNotFoundError";
+  }
+};
+var DuplicateIdError = class extends TransformError {
+  constructor(id, arrayProperty, filePath) {
+    super(`Duplicate id "${id}" in array "${arrayProperty}" of file: ${filePath}`);
+    this.name = "DuplicateIdError";
+  }
+};
+var ComponentAlreadyExistsError = class extends TransformError {
+  constructor(componentType, path2) {
+    const pathInfo = path2 ? ` (searched: ${path2})` : "";
+    super(`Component type "${componentType}" already exists${pathInfo}`);
+    this.name = "ComponentAlreadyExistsError";
+  }
+};
+var SlotNotFoundError = class extends TransformError {
+  constructor(slotId, componentType) {
+    super(`Slot "${slotId}" does not exist on component "${componentType}"`);
+    this.name = "SlotNotFoundError";
+  }
+};
+var SlotAlreadyExistsError = class extends TransformError {
+  constructor(slotId, componentType) {
+    super(`Slot "${slotId}" already exists on component "${componentType}"`);
+    this.name = "SlotAlreadyExistsError";
+  }
+};
+
+// src/core/services/file-system.service.ts
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import * as YAML from "yaml";
+var FileSystemService = class {
+  isJsonFile(filePath) {
+    return filePath.toLowerCase().endsWith(".json");
+  }
+  async readFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new FileNotFoundError(filePath);
+    }
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      if (this.isJsonFile(filePath)) {
+        return JSON.parse(content);
+      }
+      return YAML.parse(content);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new InvalidYamlError(filePath, message);
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    let content;
+    if (this.isJsonFile(filePath)) {
+      content = JSON.stringify(data, null, 2);
+    } else {
+      content = YAML.stringify(data, {
+        lineWidth: 0,
+        defaultKeyType: "PLAIN",
+        defaultStringType: "QUOTE_DOUBLE"
+      });
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
+  async readYamlFile(filePath) {
+    return this.readFile(filePath);
+  }
+  async writeYamlFile(filePath, data) {
+    return this.writeFile(filePath, data);
+  }
+  async findFiles(directory, pattern) {
+    const fullPattern = path.join(directory, pattern).replace(/\\/g, "/");
+    return glob(fullPattern);
+  }
+  async fileExists(filePath) {
+    return fs.existsSync(filePath);
+  }
+  resolvePath(...segments) {
+    return path.resolve(...segments);
+  }
+  joinPath(...segments) {
+    return path.join(...segments);
+  }
+  getBasename(filePath, ext) {
+    return path.basename(filePath, ext);
+  }
+  async renameFile(oldPath, newPath) {
+    fs.renameSync(oldPath, newPath);
+  }
+  deleteFile(filePath) {
+    fs.unlinkSync(filePath);
+  }
+  getExtension(filePath) {
+    return path.extname(filePath);
+  }
+  getDirname(filePath) {
+    return path.dirname(filePath);
+  }
+};
+
+// src/core/services/component.service.ts
+var ComponentService = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async loadComponent(componentsDir, componentType, options = {}) {
+    const { strict = false } = options;
+    const jsonPath = this.fileSystem.joinPath(componentsDir, `${componentType}.json`);
+    const yamlPath = this.fileSystem.joinPath(componentsDir, `${componentType}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(componentsDir, `${componentType}.yml`);
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      const component = await this.fileSystem.readFile(jsonPath);
+      return { component, filePath: jsonPath };
+    }
+    if (await this.fileSystem.fileExists(yamlPath)) {
+      const component = await this.fileSystem.readFile(yamlPath);
+      return { component, filePath: yamlPath };
+    }
+    if (await this.fileSystem.fileExists(ymlPath)) {
+      const component = await this.fileSystem.readFile(ymlPath);
+      return { component, filePath: ymlPath };
+    }
+    if (!strict) {
+      const files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
+      for (const filePath of files) {
+        const basename2 = this.fileSystem.getBasename(filePath);
+        const nameWithoutExt = basename2.replace(/\.(json|yaml|yml)$/i, "");
+        if (nameWithoutExt.toLowerCase() === componentType.toLowerCase()) {
+          const component = await this.fileSystem.readFile(filePath);
+          return { component, filePath };
+        }
+      }
+    }
+    throw new ComponentNotFoundError(componentType, componentsDir);
+  }
+  async saveComponent(filePath, component) {
+    await this.fileSystem.writeFile(filePath, component);
+  }
+  findParameter(component, parameterName, options = {}) {
+    const { strict = false } = options;
+    return component.parameters?.find((p) => this.compareIds(p.id, parameterName, strict));
+  }
+  isGroupParameter(parameter) {
+    return parameter.type === "group";
+  }
+  resolveGroupParameters(component, groupParameter, options = {}) {
+    if (!this.isGroupParameter(groupParameter)) {
+      return [groupParameter];
+    }
+    const childrenIds = groupParameter.typeConfig?.childrenParams ?? [];
+    const resolved = [];
+    for (const childId of childrenIds) {
+      const childParam = this.findParameter(component, childId, options);
+      if (childParam) {
+        resolved.push(childParam);
+      }
+    }
+    return resolved;
+  }
+  resolveProperties(component, propertyNames, options = {}) {
+    const parameters = [];
+    const notFound = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const name of propertyNames) {
+      const param = this.findParameter(component, name, options);
+      if (!param) {
+        notFound.push(name);
+        continue;
+      }
+      if (this.isGroupParameter(param)) {
+        const groupParams = this.resolveGroupParameters(component, param, options);
+        for (const gp of groupParams) {
+          if (!seenIds.has(gp.id)) {
+            seenIds.add(gp.id);
+            parameters.push(gp);
+          }
+        }
+      } else {
+        if (!seenIds.has(param.id)) {
+          seenIds.add(param.id);
+          parameters.push(param);
+        }
+      }
+    }
+    return { parameters, notFound };
+  }
+  addParameterToComponent(component, parameter, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      component.parameters = [];
+    }
+    const existingIndex = component.parameters.findIndex(
+      (p) => this.compareIds(p.id, parameter.id, strict)
+    );
+    if (existingIndex >= 0) {
+      component.parameters[existingIndex] = { ...parameter };
+    } else {
+      component.parameters.push({ ...parameter });
+    }
+    return component;
+  }
+  ensureGroupExists(component, groupId, groupName, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      component.parameters = [];
+    }
+    const existing = component.parameters.find((p) => this.compareIds(p.id, groupId, strict));
+    if (existing) {
+      return component;
+    }
+    const groupParam = {
+      id: groupId,
+      name: groupName ?? groupId,
+      type: "group",
+      typeConfig: {
+        childrenParams: []
+      }
+    };
+    component.parameters.push(groupParam);
+    return component;
+  }
+  addParameterToGroup(component, groupId, parameterId, options = {}) {
+    const { strict = false } = options;
+    const group = component.parameters?.find((p) => this.compareIds(p.id, groupId, strict));
+    if (!group || !this.isGroupParameter(group)) {
+      throw new PropertyNotFoundError(groupId, component.id);
+    }
+    if (!group.typeConfig) {
+      group.typeConfig = { childrenParams: [] };
+    }
+    if (!group.typeConfig.childrenParams) {
+      group.typeConfig.childrenParams = [];
+    }
+    const alreadyExists = group.typeConfig.childrenParams.some(
+      (id) => this.compareIds(id, parameterId, strict)
+    );
+    if (!alreadyExists) {
+      group.typeConfig.childrenParams.push(parameterId);
+    }
+    return component;
+  }
+  removeParameter(component, parameterId, options = {}) {
+    const { strict = false } = options;
+    if (!component.parameters) {
+      return component;
+    }
+    component.parameters = component.parameters.filter(
+      (p) => !this.compareIds(p.id, parameterId, strict)
+    );
+    for (const param of component.parameters) {
+      if (this.isGroupParameter(param) && param.typeConfig?.childrenParams) {
+        param.typeConfig.childrenParams = param.typeConfig.childrenParams.filter(
+          (id) => !this.compareIds(id, parameterId, strict)
+        );
+      }
+    }
+    return component;
+  }
+  removeEmptyGroups(component) {
+    if (!component.parameters) {
+      return component;
+    }
+    component.parameters = component.parameters.filter((p) => {
+      if (!this.isGroupParameter(p)) {
+        return true;
+      }
+      const children = p.typeConfig?.childrenParams ?? [];
+      return children.length > 0;
+    });
+    return component;
+  }
+};
+
+// src/core/services/composition.service.ts
+var CompositionService = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  compareTypes(type1, type2, strict) {
+    if (strict) {
+      return type1 === type2;
+    }
+    return type1.toLowerCase() === type2.toLowerCase();
+  }
+  async loadComposition(filePath) {
+    return this.fileSystem.readFile(filePath);
+  }
+  async saveComposition(filePath, composition) {
+    await this.fileSystem.writeFile(filePath, composition);
+  }
+  async findCompositionsByType(compositionsDir, compositionType, options = {}) {
+    const { strict = false } = options;
+    const files = await this.fileSystem.findFiles(compositionsDir, "**/*.{json,yaml,yml}");
+    const results = [];
+    for (const filePath of files) {
+      try {
+        const composition = await this.loadComposition(filePath);
+        if (composition.composition?.type && this.compareTypes(composition.composition.type, compositionType, strict)) {
+          results.push({ composition, filePath });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  findComponentInstances(composition, componentType, options = {}) {
+    const { strict = false } = options;
+    const results = [];
+    this.searchSlots(composition.composition.slots ?? {}, componentType, [], results, strict);
+    return results;
+  }
+  searchSlots(slots, componentType, currentPath, results, strict) {
+    for (const [slotName, instances] of Object.entries(slots)) {
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        const instancePath = [...currentPath, slotName, String(i)];
+        if (this.compareTypes(instance.type, componentType, strict)) {
+          const instanceId = instance._id ?? `${componentType}-${results.length}`;
+          results.push({
+            instance,
+            instanceId,
+            path: instancePath
+          });
+        }
+        if (instance.slots) {
+          this.searchSlots(instance.slots, componentType, instancePath, results, strict);
+        }
+      }
+    }
+  }
+  getRootOverrides(composition) {
+    const rootId = composition.composition._id;
+    const overrides = composition.composition._overrides?.[rootId]?.parameters;
+    if (overrides && Object.keys(overrides).length > 0) {
+      return overrides;
+    }
+    return composition.composition.parameters ?? {};
+  }
+  getInstanceOverrides(composition, instanceId) {
+    return composition.composition._overrides?.[instanceId]?.parameters ?? {};
+  }
+  setInstanceOverride(composition, instanceId, parameterId, value) {
+    if (!composition.composition._overrides) {
+      composition.composition._overrides = {};
+    }
+    if (!composition.composition._overrides[instanceId]) {
+      composition.composition._overrides[instanceId] = {};
+    }
+    if (!composition.composition._overrides[instanceId].parameters) {
+      composition.composition._overrides[instanceId].parameters = {};
+    }
+    composition.composition._overrides[instanceId].parameters[parameterId] = value;
+    return composition;
+  }
+  setInstanceOverrides(composition, instanceId, parameters) {
+    for (const [paramId, value] of Object.entries(parameters)) {
+      this.setInstanceOverride(composition, instanceId, paramId, value);
+    }
+    return composition;
+  }
+  /**
+   * Sets parameters directly on a component instance (preferred approach).
+   * This modifies the instance object in-place.
+   */
+  setInstanceParameters(instance, parameters) {
+    if (!instance.parameters) {
+      instance.parameters = {};
+    }
+    for (const [paramId, value] of Object.entries(parameters)) {
+      instance.parameters[paramId] = value;
+    }
+  }
+  /**
+   * Deletes parameters from root overrides.
+   * Returns true if any parameters were deleted.
+   */
+  deleteRootOverrides(composition, parameterIds, options = {}) {
+    const { strict = false } = options;
+    const rootId = composition.composition._id;
+    let deleted = false;
+    const overrides = composition.composition._overrides?.[rootId]?.parameters;
+    if (overrides) {
+      for (const paramId of parameterIds) {
+        for (const key of Object.keys(overrides)) {
+          if (strict ? key === paramId : key.toLowerCase() === paramId.toLowerCase()) {
+            delete overrides[key];
+            deleted = true;
+          }
+        }
+      }
+    }
+    const rootParams = composition.composition.parameters;
+    if (rootParams) {
+      for (const paramId of parameterIds) {
+        for (const key of Object.keys(rootParams)) {
+          if (strict ? key === paramId : key.toLowerCase() === paramId.toLowerCase()) {
+            delete rootParams[key];
+            deleted = true;
+          }
+        }
+      }
+    }
+    return deleted;
+  }
+};
+
+// src/core/services/property-propagator.service.ts
+var PropertyPropagatorService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async propagate(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionType,
+      property,
+      targetComponentType,
+      targetGroup,
+      whatIf,
+      strict,
+      deleteSourceParameter
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    this.logger.info(`Loading component: ${compositionType}`);
+    const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, compositionType, findOptions);
+    this.logger.info(`Loading component: ${targetComponentType}`);
+    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    const propertyNames = property.split("|").map((p) => p.trim());
+    const { parameters: resolvedParams, notFound } = this.componentService.resolveProperties(
+      sourceComponent,
+      propertyNames,
+      findOptions
+    );
+    if (notFound.length > 0) {
+      throw new PropertyNotFoundError(notFound.join(", "), compositionType);
+    }
+    const resolvedNames = resolvedParams.map((p) => p.id);
+    const groupSources = propertyNames.filter((name) => {
+      const param = this.componentService.findParameter(sourceComponent, name, findOptions);
+      return param && this.componentService.isGroupParameter(param);
+    });
+    if (groupSources.length > 0) {
+      this.logger.info(
+        `Resolved properties: ${resolvedNames.join(", ")} (from ${groupSources.join(", ")})`
+      );
+    } else {
+      this.logger.info(`Resolved properties: ${resolvedNames.join(", ")}`);
+    }
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    const existingGroup = this.componentService.findParameter(
+      modifiedComponent,
+      targetGroup,
+      findOptions
+    );
+    if (!existingGroup) {
+      this.logger.action(whatIf, "CREATE", `Group "${targetGroup}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.ensureGroupExists(
+        modifiedComponent,
+        targetGroup,
+        void 0,
+        findOptions
+      );
+      componentModified = true;
+    }
+    for (const param of resolvedParams) {
+      const existingParam = this.componentService.findParameter(
+        modifiedComponent,
+        param.id,
+        findOptions
+      );
+      if (!existingParam) {
+        this.logger.action(
+          whatIf,
+          "COPY",
+          `Parameter "${param.id}" \u2192 ${targetComponentType}.${targetGroup}`
+        );
+        modifiedComponent = this.componentService.addParameterToComponent(
+          modifiedComponent,
+          param,
+          findOptions
+        );
+        modifiedComponent = this.componentService.addParameterToGroup(
+          modifiedComponent,
+          targetGroup,
+          param.id,
+          findOptions
+        );
+        componentModified = true;
+      } else {
+        this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
+        const group = this.componentService.findParameter(
+          modifiedComponent,
+          targetGroup,
+          findOptions
+        );
+        if (group && this.componentService.isGroupParameter(group)) {
+          const isInGroup = group.typeConfig?.childrenParams?.some(
+            (id) => strict ? id === param.id : id.toLowerCase() === param.id.toLowerCase()
+          );
+          if (!isInGroup) {
+            modifiedComponent = this.componentService.addParameterToGroup(
+              modifiedComponent,
+              targetGroup,
+              param.id,
+              findOptions
+            );
+            componentModified = true;
+          }
+        }
+      }
+    }
+    if (componentModified && !whatIf) {
+      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
+    }
+    const compositions = await this.compositionService.findCompositionsByType(
+      fullCompositionsDir,
+      compositionType,
+      findOptions
+    );
+    let modifiedCompositions = 0;
+    let propagatedInstances = 0;
+    for (const { composition, filePath } of compositions) {
+      const rootOverrides = this.compositionService.getRootOverrides(composition);
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
+      );
+      if (instances.length === 0) {
+        continue;
+      }
+      const valuesToPropagate = {};
+      for (const param of resolvedParams) {
+        if (rootOverrides[param.id]) {
+          valuesToPropagate[param.id] = rootOverrides[param.id];
+        }
+      }
+      if (Object.keys(valuesToPropagate).length === 0) {
+        continue;
+      }
+      let compositionModified = false;
+      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+      const instanceUpdates = [];
+      for (const { instance, instanceId } of instances) {
+        const instanceName = instance._id ?? instanceId;
+        this.compositionService.setInstanceParameters(instance, valuesToPropagate);
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+        );
+      }
+      if (compositionModified) {
+        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
+        for (const update of instanceUpdates) {
+          this.logger.detail(`\u2192 ${update}`);
+        }
+        if (!whatIf) {
+          await this.compositionService.saveComposition(filePath, composition);
+        }
+        modifiedCompositions++;
+      }
+    }
+    let sourceComponentModified = false;
+    if (deleteSourceParameter) {
+      let modifiedSource = { ...sourceComponent };
+      for (const param of resolvedParams) {
+        this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${compositionType}`);
+        modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+        sourceComponentModified = true;
+      }
+      const beforeGroupCount = modifiedSource.parameters?.filter(
+        (p) => this.componentService.isGroupParameter(p)
+      ).length ?? 0;
+      modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
+      const afterGroupCount = modifiedSource.parameters?.filter(
+        (p) => this.componentService.isGroupParameter(p)
+      ).length ?? 0;
+      if (afterGroupCount < beforeGroupCount) {
+        const removedCount = beforeGroupCount - afterGroupCount;
+        this.logger.action(
+          whatIf,
+          "DELETE",
+          `${removedCount} empty group(s) from ${compositionType}`
+        );
+      }
+      if (sourceComponentModified && !whatIf) {
+        await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+      }
+      for (const { composition, filePath } of compositions) {
+        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+        const deleted = this.compositionService.deleteRootOverrides(
+          composition,
+          resolvedNames,
+          findOptions
+        );
+        if (deleted) {
+          this.logger.action(whatIf, "DELETE", `Root overrides from composition/${relativePath}`);
+          this.logger.detail(`\u2192 Removed: ${resolvedNames.join(", ")}`);
+          if (!whatIf) {
+            await this.compositionService.saveComposition(filePath, composition);
+          }
+        }
+      }
+    }
+    return {
+      modifiedComponents: (componentModified ? 1 : 0) + (sourceComponentModified ? 1 : 0),
+      modifiedCompositions,
+      propagatedInstances
+    };
+  }
+};
+
+// src/core/services/slot-renamer.service.ts
+var SlotRenamerService = 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 rename(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      newSlotName,
+      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);
+    if (this.compareIds(slotId, newSlotId, strict)) {
+      throw new TransformError("New slot ID is the same as the current slot ID");
+    }
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    if (!component.slots || component.slots.length === 0) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const slotIndex = component.slots.findIndex(
+      (s) => this.compareIds(s.id, slotId, strict)
+    );
+    if (slotIndex === -1) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const existingNewSlot = component.slots.find(
+      (s) => this.compareIds(s.id, newSlotId, strict)
+    );
+    if (existingNewSlot) {
+      throw new SlotAlreadyExistsError(newSlotId, componentType);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Slot "${slotId}" \u2192 "${newSlotId}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.slots[slotIndex].id = newSlotId;
+    if (newSlotName !== void 0) {
+      component.slots[slotIndex].name = newSlotName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const compositionsResult = await this.renameSlotInDirectory(
+      fullCompositionsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.renameSlotInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.renameSlotInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      slotId,
+      newSlotId,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
+    this.logger.info("");
+    this.logger.info(
+      `Summary: 1 component definition, ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`
+    );
+    return {
+      componentDefinitionUpdated: true,
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesRenamed: totalInstances
+    };
+  }
+  async renameSlotInDirectory(directory, componentType, oldSlotId, newSlotId, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    let filesModified = 0;
+    let instancesRenamed = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) {
+        continue;
+      }
+      const count = this.renameSlotInTree(
+        composition.composition,
+        componentType,
+        oldSlotId,
+        newSlotId,
+        strict
+      );
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${count} instance(s) of ${componentType})`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesRenamed += count;
+      }
+    }
+    return { filesModified, instancesRenamed };
+  }
+  renameSlotInTree(node, componentType, oldSlotId, newSlotId, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, componentType, strict) && node.slots) {
+      const result = this.renameSlotKey(node.slots, oldSlotId, newSlotId, strict);
+      if (result.renamed) {
+        node.slots = result.slots;
+        count++;
+      }
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.renameSlotInTree(instance, componentType, oldSlotId, newSlotId, strict);
+        }
+      }
+    }
+    return count;
+  }
+  renameSlotKey(slots, oldSlotId, newSlotId, strict) {
+    const matchingKey = Object.keys(slots).find(
+      (key) => this.compareIds(key, oldSlotId, strict)
+    );
+    if (!matchingKey) {
+      return { renamed: false, slots };
+    }
+    const newSlots = {};
+    for (const key of Object.keys(slots)) {
+      if (key === matchingKey) {
+        newSlots[newSlotId] = slots[key];
+      } else {
+        newSlots[key] = slots[key];
+      }
+    }
+    return { renamed: true, slots: newSlots };
+  }
+};
+
+// src/core/services/component-renamer.service.ts
+var ComponentRenamerService = 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 rename(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      componentType,
+      newComponentType,
+      newComponentName,
+      whatIf,
+      strict
+    } = options;
+    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);
+    const findOptions = { strict };
+    if (this.compareIds(componentType, newComponentType, strict)) {
+      throw new TransformError("New component type is the same as the current component type");
+    }
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    let targetExists = false;
+    try {
+      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
+      targetExists = true;
+    } catch (error) {
+      if (!(error instanceof ComponentNotFoundError)) {
+        throw error;
+      }
+    }
+    if (targetExists) {
+      throw new ComponentAlreadyExistsError(newComponentType, fullComponentsDir);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Component ID "${componentType}" \u2192 "${newComponentType}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.id = newComponentType;
+    if (newComponentName !== void 0) {
+      component.name = newComponentName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const ext = this.fileSystem.getExtension(componentFilePath);
+    const dir = this.fileSystem.getDirname(componentFilePath);
+    const newFilePath = this.fileSystem.joinPath(dir, `${newComponentType}${ext}`);
+    let fileRenamed = false;
+    if (componentFilePath !== newFilePath) {
+      this.logger.action(
+        whatIf,
+        "RENAME",
+        `component/${this.fileSystem.getBasename(componentFilePath)} \u2192 component/${this.fileSystem.getBasename(newFilePath)}`
+      );
+      if (!whatIf) {
+        await this.fileSystem.renameFile(componentFilePath, newFilePath);
+      }
+      fileRenamed = true;
+    }
+    const allowedComponentsUpdated = await this.updateAllowedComponents(
+      fullComponentsDir,
+      componentType,
+      newComponentType,
+      componentFilePath,
+      whatIf,
+      strict
+    );
+    const compositionsResult = await this.renameTypeInDirectory(
+      fullCompositionsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.renameTypeInDirectory(
+      fullCompositionPatternsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.renameTypeInDirectory(
+      fullComponentPatternsDir,
+      componentType,
+      newComponentType,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    const totalCompositionFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
+    this.logger.info("");
+    this.logger.info(
+      `Summary: 1 component renamed, ${allowedComponentsUpdated} component(s) with allowedComponents updated, ${totalCompositionFiles} composition file(s) (${totalInstances} instance(s)) updated.`
+    );
+    return {
+      componentRenamed: true,
+      fileRenamed,
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesRenamed: totalInstances
+    };
+  }
+  async updateAllowedComponents(componentsDir, oldType, newType, sourceFilePath, whatIf, strict) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
+    } catch {
+      return 0;
+    }
+    let updatedCount = 0;
+    for (const filePath of files) {
+      if (filePath === sourceFilePath) continue;
+      let comp;
+      try {
+        comp = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!comp.slots || comp.slots.length === 0) continue;
+      let fileModified = false;
+      for (const slot of comp.slots) {
+        if (!slot.allowedComponents) continue;
+        for (let i = 0; i < slot.allowedComponents.length; i++) {
+          if (this.compareIds(slot.allowedComponents[i], oldType, strict)) {
+            slot.allowedComponents[i] = newType;
+            fileModified = true;
+          }
+        }
+      }
+      if (fileModified) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `allowedComponents in component/${this.fileSystem.getBasename(filePath)}: ${oldType} \u2192 ${newType}`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, comp);
+        }
+        updatedCount++;
+      }
+    }
+    return updatedCount;
+  }
+  async renameTypeInDirectory(directory, oldType, newType, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    let filesModified = 0;
+    let instancesRenamed = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) continue;
+      const count = this.renameTypeInTree(composition.composition, oldType, newType, strict);
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${count} instance(s))`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
+        }
+        filesModified++;
+        instancesRenamed += count;
+      }
+    }
+    return { filesModified, instancesRenamed };
+  }
+  renameTypeInTree(node, oldType, newType, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, oldType, strict)) {
+      node.type = newType;
+      count++;
+    }
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.renameTypeInTree(instance, oldType, newType, strict);
+        }
+      }
+    }
+    return count;
+  }
+};
+
+// src/cli/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  info(message) {
+    console.log(`${chalk.blue("[INFO]")} ${message}`);
+  }
+  success(message) {
+    console.log(`${chalk.green("[DONE]")} ${message}`);
+  }
+  error(message) {
+    console.log(`${chalk.red("[ERROR]")} ${message}`);
+  }
+  warn(message) {
+    console.log(`${chalk.yellow("[WARN]")} ${message}`);
+  }
+  action(whatIf, actionType, message) {
+    const prefix = whatIf ? chalk.yellow("[WOULD]") : chalk.green(`[${actionType}]`);
+    console.log(`${prefix} ${message}`);
+  }
+  detail(message) {
+    console.log(`  ${chalk.gray(message)}`);
+  }
+};
+export {
+  ComponentAlreadyExistsError,
+  ComponentNotFoundError,
+  ComponentRenamerService,
+  ComponentService,
+  CompositionService,
+  DuplicateIdError,
+  FileNotFoundError,
+  FileSystemService,
+  InvalidYamlError,
+  Logger,
+  PropertyNotFoundError,
+  PropertyPropagatorService,
+  SlotAlreadyExistsError,
+  SlotNotFoundError,
+  SlotRenamerService,
+  TransformError
+};
+//# sourceMappingURL=index.js.map