@uniformdev/transformer 1.1.11 → 1.1.13

package/dist/index.d.ts

@@ -132,6 +132,14 @@ interface ConvertCompositionsToEntriesOptions extends GlobalOptions {
     compositionTypes: string;
     flattenComponentIds?: string;
 }
+interface RemoveParameterOptions extends GlobalOptions {
+    componentType: string;
+    parameterId: string;
+}
+interface RemoveFieldOptions extends GlobalOptions {
+    componentType: string;
+    parameterId: string;
+}
 
 declare class TransformError extends Error {
     constructor(message: string);
@@ -417,13 +425,20 @@ interface ContentTypeField {
     localizable?: boolean;
     typeConfig?: Record<string, unknown>;
 }
+interface DataResourceDefinition {
+    type: string;
+    variables?: Record<string, string>;
+}
 interface EntryDefinition {
     entry: {
         _id: string;
         _name: string;
         type: string;
         fields: Record<string, ParameterValue>;
+        _dataResources?: Record<string, DataResourceDefinition>;
+        [key: string]: unknown;
     };
+    [key: string]: unknown;
 }
 interface FlattenedInstance {
     instance: ComponentInstance;
@@ -451,6 +466,7 @@ declare class CompositionConverterService {
     generateEntryFromFlattenedInstance(inst: FlattenedInstance): EntryDefinition;
     findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private walkSlots;
+    private transformContentReferences;
     private compareTypes;
     private truncate;
 }
@@ -466,4 +482,65 @@ declare class CompositionConverterService {
  */
 declare function computeGuidHash(guidOrSeed: string): string;
 
-export { type AddComponentOptions, type AddComponentPatternOptions, ComponentAdderService, ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, CompositionConverterService, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, type ConvertCompositionsToEntriesOptions, 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, computeGuidHash };
+interface RemoveParameterInternalOptions {
+    rootDir: string;
+    componentsDir: string;
+    compositionsDir: string;
+    compositionPatternsDir: string;
+    componentPatternsDir: string;
+    componentType: string;
+    parameterId: string;
+    whatIf: boolean;
+    strict: boolean;
+}
+interface RemoveParameterResult {
+    componentDefinitionUpdated: boolean;
+    compositionsModified: number;
+    compositionPatternsModified: number;
+    componentPatternsModified: number;
+    instancesUpdated: number;
+}
+declare class ParameterRemoverService {
+    private fileSystem;
+    private componentService;
+    private logger;
+    constructor(fileSystem: FileSystemService, componentService: ComponentService, logger: Logger);
+    private compareIds;
+    remove(options: RemoveParameterInternalOptions): Promise<RemoveParameterResult>;
+    private removeParameterInDirectory;
+    private removeParameterFromTree;
+    private removeParameterFromOverrides;
+    private removeOverridesForMatchingInstances;
+    private removeKeyFromMap;
+}
+
+interface RemoveFieldInternalOptions {
+    rootDir: string;
+    compositionsDir: string;
+    compositionPatternsDir: string;
+    componentPatternsDir: string;
+    componentType: string;
+    parameterId: string;
+    whatIf: boolean;
+    strict: boolean;
+}
+interface RemoveFieldResult {
+    compositionsModified: number;
+    compositionPatternsModified: number;
+    componentPatternsModified: number;
+    instancesUpdated: number;
+}
+declare class FieldRemoverService {
+    private fileSystem;
+    private logger;
+    constructor(fileSystem: FileSystemService, logger: Logger);
+    private compareIds;
+    remove(options: RemoveFieldInternalOptions): Promise<RemoveFieldResult>;
+    private removeFieldInDirectory;
+    private removeFieldFromTree;
+    private removeFieldFromOverrides;
+    private removeOverridesForMatchingInstances;
+    private removeKeyFromMap;
+}
+
+export { type AddComponentOptions, type AddComponentPatternOptions, ComponentAdderService, ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, CompositionConverterService, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, type ConvertCompositionsToEntriesOptions, DuplicateIdError, FieldRemoverService, FileNotFoundError, FileSystemService, type GlobalOptions, InvalidYamlError, Logger, type PackSerializationOptions, type Parameter, ParameterRemoverService, type ParameterValue, type PropagateRootComponentPropertyOptions, type PropagateRootComponentSlotOptions, PropertyNotFoundError, PropertyPropagatorService, type RemoveFieldOptions, type RemoveParameterOptions, type RenameComponentOptions, type RenameSlotOptions, SlotAlreadyExistsError, type SlotDefinition, SlotNotFoundError, SlotRenamerService, TransformError, type UnpackSerializationOptions, computeGuidHash };

package/dist/index.js

@@ -1767,6 +1767,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,
@@ -1889,13 +1892,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) {
@@ -1949,6 +1968,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) {
@@ -2011,6 +2054,434 @@ function formatAsBracedUuid(uuid) {
   return `{${clean}}`;
 }
 
+// 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/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/logger.ts
 import chalk from "chalk";
 var Logger = class {
@@ -2043,10 +2514,12 @@ export {
   CompositionConverterService,
   CompositionService,
   DuplicateIdError,
+  FieldRemoverService,
   FileNotFoundError,
   FileSystemService,
   InvalidYamlError,
   Logger,
+  ParameterRemoverService,
   PropertyNotFoundError,
   PropertyPropagatorService,
   SlotAlreadyExistsError,