@uniformdev/transformer 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -109,6 +109,25 @@ interface RenameSlotOptions extends GlobalOptions {
     newSlotId: string;
     newSlotName?: string;
 }
+interface AddComponentOptions extends GlobalOptions {
+    parentComponentType: string;
+    slot: string;
+    newComponentType: string;
+    parameters?: string;
+}
+interface AddComponentPatternOptions extends GlobalOptions {
+    parentComponentType: string;
+    slot: string;
+    componentPatternId: string;
+    parameters?: string;
+}
+interface PropagateRootComponentSlotOptions extends GlobalOptions {
+    compositionType: string;
+    slot: string;
+    targetComponentType: string;
+    targetSlot: string;
+    deleteSourceSlot?: boolean;
+}
 
 declare class TransformError extends Error {
     constructor(message: string);
@@ -179,6 +198,10 @@ declare class ComponentService {
     addParameterToGroup(component: ComponentDefinition, groupId: string, parameterId: string, options?: FindOptions$1): ComponentDefinition;
     removeParameter(component: ComponentDefinition, parameterId: string, options?: FindOptions$1): ComponentDefinition;
     removeEmptyGroups(component: ComponentDefinition): ComponentDefinition;
+    findSlot(component: ComponentDefinition, slotId: string, options?: FindOptions$1): SlotDefinition | undefined;
+    addSlot(component: ComponentDefinition, slot: SlotDefinition): ComponentDefinition;
+    updateSlotAllowedComponents(component: ComponentDefinition, slotId: string, allowedComponents: string[], options?: FindOptions$1): ComponentDefinition;
+    removeSlot(component: ComponentDefinition, slotId: string, options?: FindOptions$1): ComponentDefinition;
 }
 
 interface FindOptions {
@@ -317,4 +340,44 @@ declare class ComponentRenamerService {
     private renameTypeInTree;
 }
 
-export { ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, DuplicateIdError, FileNotFoundError, FileSystemService, type GlobalOptions, InvalidYamlError, Logger, type PackSerializationOptions, type Parameter, type ParameterValue, type PropagateRootComponentPropertyOptions, PropertyNotFoundError, PropertyPropagatorService, type RenameComponentOptions, type RenameSlotOptions, SlotAlreadyExistsError, type SlotDefinition, SlotNotFoundError, SlotRenamerService, TransformError, type UnpackSerializationOptions };
+interface AddComponentInternalOptions {
+    rootDir: string;
+    componentsDir: string;
+    compositionsDir: string;
+    compositionPatternsDir: string;
+    componentPatternsDir: string;
+    parentComponentType: string;
+    slot: string;
+    newComponentType?: string;
+    componentPatternId?: string;
+    parameters?: string;
+    whatIf: boolean;
+    strict: boolean;
+}
+interface AddComponentResult {
+    allowedComponentsUpdated: boolean;
+    compositionsModified: number;
+    compositionPatternsModified: number;
+    componentPatternsModified: number;
+    instancesAdded: number;
+}
+declare class ComponentAdderService {
+    private fileSystem;
+    private componentService;
+    private logger;
+    constructor(fileSystem: FileSystemService, componentService: ComponentService, logger: Logger);
+    private compareIds;
+    private parseParameters;
+    private generateId;
+    private cloneComponentInstance;
+    private regenerateInstanceIds;
+    private createComponentInstance;
+    private addComponentToSlot;
+    addComponent(options: AddComponentInternalOptions): Promise<AddComponentResult>;
+    addComponentPattern(options: AddComponentInternalOptions): Promise<AddComponentResult>;
+    private loadComponentPattern;
+    private addComponentToDirectory;
+    private addComponentToNestedSlots;
+}
+
+export { type AddComponentOptions, type AddComponentPatternOptions, ComponentAdderService, ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, DuplicateIdError, FileNotFoundError, FileSystemService, type GlobalOptions, InvalidYamlError, Logger, type PackSerializationOptions, type Parameter, type ParameterValue, type PropagateRootComponentPropertyOptions, type PropagateRootComponentSlotOptions, PropertyNotFoundError, PropertyPropagatorService, type RenameComponentOptions, type RenameSlotOptions, SlotAlreadyExistsError, type SlotDefinition, SlotNotFoundError, SlotRenamerService, TransformError, type UnpackSerializationOptions };

package/dist/index.js

@@ -314,6 +314,34 @@ var ComponentService = class {
     });
     return component;
   }
+  // Slot methods
+  findSlot(component, slotId, options = {}) {
+    const { strict = false } = options;
+    return component.slots?.find((s) => this.compareIds(s.id, slotId, strict));
+  }
+  addSlot(component, slot) {
+    if (!component.slots) {
+      component.slots = [];
+    }
+    component.slots.push({ ...slot });
+    return component;
+  }
+  updateSlotAllowedComponents(component, slotId, allowedComponents, options = {}) {
+    const { strict = false } = options;
+    const slot = component.slots?.find((s) => this.compareIds(s.id, slotId, strict));
+    if (slot) {
+      slot.allowedComponents = allowedComponents;
+    }
+    return component;
+  }
+  removeSlot(component, slotId, options = {}) {
+    const { strict = false } = options;
+    if (!component.slots) {
+      return component;
+    }
+    component.slots = component.slots.filter((s) => !this.compareIds(s.id, slotId, strict));
+    return component;
+  }
 };
 
 // src/core/services/composition.service.ts
@@ -1072,6 +1100,439 @@ var ComponentRenamerService = class {
   }
 };
 
+// src/core/services/component-adder.service.ts
+import { randomUUID } from "crypto";
+var ComponentAdderService = 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();
+  }
+  parseParameters(parameterString) {
+    const result = {};
+    if (!parameterString) return result;
+    const pairs = parameterString.split("|");
+    for (const pair of pairs) {
+      const [key, ...valueParts] = pair.split(":");
+      if (key && valueParts.length > 0) {
+        result[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+    return result;
+  }
+  generateId(baseName) {
+    return `${baseName}-${randomUUID().slice(0, 8)}`;
+  }
+  cloneComponentInstance(instance) {
+    const clone = JSON.parse(JSON.stringify(instance));
+    if (clone._id) {
+      clone._id = this.generateId(clone.type);
+    }
+    if (clone.slots) {
+      for (const slotInstances of Object.values(clone.slots)) {
+        if (Array.isArray(slotInstances)) {
+          for (const nestedInstance of slotInstances) {
+            this.regenerateInstanceIds(nestedInstance);
+          }
+        }
+      }
+    }
+    return clone;
+  }
+  regenerateInstanceIds(instance) {
+    if (instance._id) {
+      instance._id = this.generateId(instance.type);
+    }
+    if (instance.slots) {
+      for (const slotInstances of Object.values(instance.slots)) {
+        if (Array.isArray(slotInstances)) {
+          for (const nestedInstance of slotInstances) {
+            this.regenerateInstanceIds(nestedInstance);
+          }
+        }
+      }
+    }
+  }
+  createComponentInstance(componentType, parameters) {
+    const instance = {
+      type: componentType,
+      _id: this.generateId(componentType)
+    };
+    if (Object.keys(parameters).length > 0) {
+      instance.parameters = {};
+      for (const [key, value] of Object.entries(parameters)) {
+        instance.parameters[key] = {
+          type: "text",
+          value
+        };
+      }
+    }
+    return instance;
+  }
+  addComponentToSlot(slots, slotId, instance) {
+    if (!slots[slotId]) {
+      slots[slotId] = [];
+    }
+    slots[slotId].push(instance);
+  }
+  async addComponent(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      newComponentType,
+      parameters: paramString,
+      whatIf,
+      strict
+    } = options;
+    if (!newComponentType) {
+      throw new TransformError("newComponentType is required for add-component");
+    }
+    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 };
+    this.logger.info(`Loading parent component: ${parentComponentType}`);
+    const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
+    const slotDef = parentComponent.slots?.find(
+      (s) => this.compareIds(s.id, slot, strict)
+    );
+    if (!slotDef) {
+      throw new SlotNotFoundError(slot, parentComponentType);
+    }
+    this.logger.info(`Validating new component: ${newComponentType}`);
+    try {
+      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
+    } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        throw new TransformError(
+          `Component type "${newComponentType}" not found in ${fullComponentsDir}`
+        );
+      }
+      throw error;
+    }
+    let allowedComponentsUpdated = false;
+    const slotIndex = parentComponent.slots?.findIndex(
+      (s) => this.compareIds(s.id, slotDef.id, strict)
+    );
+    if (slotIndex !== void 0 && slotIndex >= 0) {
+      const actualSlot = parentComponent.slots[slotIndex];
+      if (!actualSlot.allowedComponents) {
+        actualSlot.allowedComponents = [];
+      }
+      const isAlreadyAllowed = actualSlot.allowedComponents.some(
+        (c) => this.compareIds(c, newComponentType, strict)
+      );
+      if (!isAlreadyAllowed) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+        );
+        actualSlot.allowedComponents.push(newComponentType);
+        if (!whatIf) {
+          await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
+        }
+        allowedComponentsUpdated = true;
+      }
+    }
+    const parsedParams = this.parseParameters(paramString);
+    const newInstance = this.createComponentInstance(newComponentType, parsedParams);
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+    );
+    return {
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+    };
+  }
+  async addComponentPattern(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      componentPatternId,
+      whatIf,
+      strict
+    } = options;
+    if (!componentPatternId) {
+      throw new TransformError("componentPatternId is required for add-component-pattern");
+    }
+    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 };
+    this.logger.info(`Loading parent component: ${parentComponentType}`);
+    const { component: parentComponent } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
+    const slotDef = parentComponent.slots?.find(
+      (s) => this.compareIds(s.id, slot, strict)
+    );
+    if (!slotDef) {
+      throw new SlotNotFoundError(slot, parentComponentType);
+    }
+    this.logger.info(`Loading component pattern: ${componentPatternId}`);
+    const pattern = await this.loadComponentPattern(
+      fullComponentPatternsDir,
+      componentPatternId,
+      strict
+    );
+    const patternDefinition = pattern.definition;
+    if (!patternDefinition || !patternDefinition.type) {
+      throw new TransformError(
+        `Component pattern "${componentPatternId}" has no valid definition or missing type`
+      );
+    }
+    let allowedComponentsUpdated = false;
+    const componentTypeInPattern = patternDefinition.type;
+    const slotIndex = parentComponent.slots?.findIndex(
+      (s) => this.compareIds(s.id, slotDef.id, strict)
+    );
+    if (slotIndex !== void 0 && slotIndex >= 0) {
+      const actualSlot = parentComponent.slots[slotIndex];
+      if (!actualSlot.allowedComponents) {
+        actualSlot.allowedComponents = [];
+      }
+      const isAlreadyAllowed = actualSlot.allowedComponents.some(
+        (c) => this.compareIds(c, componentTypeInPattern, strict)
+      );
+      if (!isAlreadyAllowed) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+        );
+        actualSlot.allowedComponents.push(componentTypeInPattern);
+        if (!whatIf) {
+          await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions).then(
+            ({ filePath }) => this.componentService.saveComponent(filePath, parentComponent)
+          );
+        }
+        allowedComponentsUpdated = true;
+      }
+    }
+    const newInstance = this.cloneComponentInstance(patternDefinition);
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentComponentType,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+    );
+    return {
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+    };
+  }
+  async loadComponentPattern(componentPatternsDir, patternId, strict) {
+    const jsonPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.json`);
+    const yamlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yml`);
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      return this.fileSystem.readFile(jsonPath);
+    }
+    if (await this.fileSystem.fileExists(yamlPath)) {
+      return this.fileSystem.readFile(yamlPath);
+    }
+    if (await this.fileSystem.fileExists(ymlPath)) {
+      return this.fileSystem.readFile(ymlPath);
+    }
+    if (!strict) {
+      const files = await this.fileSystem.findFiles(componentPatternsDir, "*.{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() === patternId.toLowerCase()) {
+          return this.fileSystem.readFile(filePath);
+        }
+      }
+    }
+    throw new TransformError(`Component pattern "${patternId}" not found in ${componentPatternsDir}`);
+  }
+  async addComponentToDirectory(directory, parentComponentType, slot, newInstance, whatIf, strict, dirType) {
+    const exists = await this.fileSystem.fileExists(directory);
+    if (!exists) {
+      this.logger.detail(`${dirType} directory does not exist, skipping`);
+      return 0;
+    }
+    const files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    let filesModified = 0;
+    for (const filePath of files) {
+      try {
+        const content = await this.fileSystem.readFile(filePath);
+        let composition = null;
+        let isComponentPattern = false;
+        if (dirType === "componentPattern" && content && typeof content === "object" && "definition" in content) {
+          isComponentPattern = true;
+          const pattern = content;
+          if (pattern.definition && pattern.definition.slots) {
+            composition = {
+              composition: {
+                _id: "pattern-root",
+                type: pattern.definition.type,
+                slots: pattern.definition.slots
+              }
+            };
+          }
+        } else {
+          composition = content;
+        }
+        if (!composition?.composition) {
+          continue;
+        }
+        const rootInstance = composition.composition;
+        let modified = false;
+        if (this.compareIds(rootInstance.type, parentComponentType, strict)) {
+          if (!rootInstance.slots) {
+            rootInstance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(rootInstance.slots, slot, instanceCopy);
+          modified = true;
+        }
+        if (rootInstance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            rootInstance.slots,
+            parentComponentType,
+            slot,
+            newInstance,
+            strict
+          );
+          if (nestedModified) {
+            modified = true;
+          }
+        }
+        if (modified) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${newInstance.type}" to slot "${slot}" in ${dirType}/${this.fileSystem.getBasename(filePath)}`
+          );
+          if (!whatIf) {
+            if (isComponentPattern && content && typeof content === "object" && "definition" in content) {
+              const pattern = content;
+              if (rootInstance.slots) {
+                pattern.definition.slots = rootInstance.slots;
+              }
+            }
+            await this.fileSystem.writeFile(filePath, content);
+          }
+          filesModified++;
+        }
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("skipping")) {
+          this.logger.detail(`Skipping ${filePath}: ${error.message}`);
+        }
+      }
+    }
+    return filesModified;
+  }
+  addComponentToNestedSlots(slots, parentComponentType, slot, newInstance, strict) {
+    let modified = false;
+    for (const slotInstances of Object.values(slots)) {
+      if (!Array.isArray(slotInstances)) continue;
+      for (const instance of slotInstances) {
+        if (this.compareIds(instance.type, parentComponentType, strict)) {
+          if (!instance.slots) {
+            instance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(instance.slots, slot, instanceCopy);
+          modified = true;
+        }
+        if (instance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            instance.slots,
+            parentComponentType,
+            slot,
+            newInstance,
+            strict
+          );
+          if (nestedModified) {
+            modified = true;
+          }
+        }
+      }
+    }
+    return modified;
+  }
+};
+
 // src/cli/logger.ts
 import chalk from "chalk";
 var Logger = class {
@@ -1096,6 +1557,7 @@ var Logger = class {
   }
 };
 export {
+  ComponentAdderService,
   ComponentAlreadyExistsError,
   ComponentNotFoundError,
   ComponentRenamerService,