cedar-embeddable-editor 0.9.1 → 0.9.2

package/src/app/modules/shared/factory/template-representation.factory.ts

@@ -1,323 +0,0 @@
-import {JsonSchema} from '../models/json-schema.model';
-import {CedarModel} from '../models/cedar-model.model';
-import {JavascriptTypes} from '../models/javascript-types.model';
-import {CedarComponent} from '../models/component/cedar-component.model';
-import {MultiElementComponent} from '../models/element/multi-element-component.model';
-import {CedarTemplate} from '../models/template/cedar-template.model';
-import {NullTemplate} from '../models/template/null-template.model';
-import {EmptyTemplate} from '../models/template/empty-template.model';
-import {TemplateComponent} from '../models/template/template-component.model';
-import {MultiFieldComponent} from '../models/field/multi-field-component.model';
-import {SingleFieldComponent} from '../models/field/single-field-component.model';
-import {SingleElementComponent} from '../models/element/single-element-component.model';
-import {MultiComponent} from '../models/component/multi-component.model';
-import {ElementComponent} from '../models/component/element-component.model';
-import {FieldComponent} from '../models/component/field-component.model';
-import {ChoiceOption} from '../models/info/choice-option.model';
-import {CedarInputTemplate} from '../models/cedar-input-template.model';
-import {StaticFieldComponent} from '../models/static/static-field-component.model';
-import {ComponentTypeHandler} from '../handler/component-type.handler';
-import {InputType} from '../models/input-type.model';
-import {TemplateObjectUtil} from '../util/template-object-util';
-
-export class TemplateRepresentationFactory {
-
-  static create(inputTemplate: CedarInputTemplate, collapseStaticComponents: boolean): TemplateComponent {
-    if (inputTemplate === null) {
-      return new NullTemplate();
-    } else {
-      const template = new CedarTemplate();
-      TemplateRepresentationFactory.wrap(inputTemplate, inputTemplate, template, [], collapseStaticComponents);
-      TemplateRepresentationFactory.extractTemplateLabels(inputTemplate, template);
-      TemplateRepresentationFactory.extractPageBreakPages(template);
-      return template;
-    }
-  }
-
-  static extractPageBreakPages(template: CedarTemplate): void {
-    const pages = [];
-    let page = [];
-    let numPBInRow = 0;
-
-    template.children.forEach((child, index) => {
-      // encountered page-break component
-      if (child instanceof StaticFieldComponent && (child as StaticFieldComponent).basicInfo.inputType === InputType.pageBreak) {
-        if (page.length) {
-          pages.push(page);
-        }
-        // if page-break is the last component, always add an empty page
-        if (index === template.children.length - 1) {
-          pages.push([new EmptyTemplate()]);
-        } else {
-          numPBInRow++;
-        }
-        page = [];
-      } else {
-        page.push(child);
-
-        if (index === template.children.length - 1) {
-          pages.push(page);
-        }
-
-        // add empty pages corresponding to: (number of page breaks in a row - 1)
-        for (let i = 0; i < numPBInRow - 1; i++) {
-          pages.push([new EmptyTemplate()]);
-        }
-        numPBInRow = 0;
-      }
-    });
-    template.pageBreakChildren = pages;
-  }
-
-  private static isFragmentMulti(templateFragment: object): boolean {
-    const fragmentType = templateFragment[CedarModel.type];
-
-    if (fragmentType === JavascriptTypes.object) {
-      return false;
-    } else if (fragmentType === JavascriptTypes.array) {
-      return true;
-    } else {
-      throw new Error(
-        'Invalid node value of ' + CedarModel.type + '. Value found:"' + fragmentType + '". ' +
-        'Expected "' + JavascriptTypes.object + '" or "' + JavascriptTypes.array + '"!'
-      );
-    }
-  }
-
-  private static wrap(templateJsonObj: object, parentJsonObj: object, component: CedarComponent, parentPath: string[], collapseStaticComponents: boolean): void {
-    // const propertyNames: string[] = TemplateRepresentationFactory.getFilteredSchemaPropertyNames(templateJsonObj);
-    // console.log(propertyNames);
-    const propertyNames: string[] = TemplateRepresentationFactory.getOrderedPropertyNames(templateJsonObj);
-    for (const name of propertyNames) {
-      const templateFragment = templateJsonObj[JsonSchema.properties][name];
-
-      const isMulti: boolean = TemplateRepresentationFactory.isFragmentMulti(templateFragment);
-
-      const parentDataNode: object = TemplateRepresentationFactory.getDataNode(parentJsonObj);
-      const dataNode: object = TemplateRepresentationFactory.getDataNode(templateFragment);
-      const fragmentAtType = dataNode[JsonSchema.atType];
-      let r: CedarComponent = null;
-
-      const myPath: string[] = parentPath.slice();
-      myPath.push(name);
-
-      if (fragmentAtType === CedarModel.templateFieldType) {
-        if (isMulti) {
-          r = new MultiFieldComponent();
-        } else {
-          r = new SingleFieldComponent();
-        }
-
-        TemplateRepresentationFactory.extractValueConstraints(dataNode, r as FieldComponent);
-        TemplateRepresentationFactory.extractLabels(dataNode, parentDataNode, name, r as FieldComponent);
-      } else if (fragmentAtType === CedarModel.templateElementType) {
-        if (isMulti) {
-          r = new MultiElementComponent();
-        } else {
-          r = new SingleElementComponent();
-        }
-        TemplateRepresentationFactory.extractLabels(dataNode, parentDataNode, name, r as FieldComponent);
-        TemplateRepresentationFactory.wrap(dataNode, templateJsonObj, r, myPath, collapseStaticComponents);
-      } else if (fragmentAtType === CedarModel.templateStaticFieldType) {
-        r = new StaticFieldComponent();
-        TemplateRepresentationFactory.extractStaticData(dataNode, parentDataNode, name, r as StaticFieldComponent);
-      }
-
-      if (r !== null) {
-        const wrapperElement: ElementComponent = component as ElementComponent;
-        wrapperElement.children.push(r);
-        r.name = name;
-        r.path = myPath;
-      }
-
-      if (isMulti) {
-        const mr = r as MultiComponent;
-        TemplateRepresentationFactory.extractMultiInfo(templateFragment, mr);
-      }
-    }
-
-    if (collapseStaticComponents) {
-      this.collapseStaticFieldsIntoNextFieldOrElement(component);
-    }
-  }
-
-  // private static getFilteredSchemaPropertyNames(jsonObj: object): string[] {
-  //   const names: string[] = [];
-  //   if (jsonObj.hasOwnProperty(JsonSchema.properties)) {
-  //     const prMap = jsonObj[JsonSchema.properties];
-  //     if (prMap instanceof Object) {
-  //       for (const name of Object.keys(prMap)) {
-  //         if (!JsonSchema.builtInProperties.has(name)) {
-  //           names.push(name);
-  //         }
-  //       }
-  //     }
-  //   }
-  //   return names;
-  // }
-
-  private static getOrderedPropertyNames(jsonObj: object): string[] {
-    const order: string[] = [];
-    if (jsonObj.hasOwnProperty(CedarModel.ui)) {
-      const uiMap = jsonObj[CedarModel.ui];
-      if (uiMap.hasOwnProperty(CedarModel.order)) {
-        return uiMap[CedarModel.order];
-      }
-    }
-    return order;
-  }
-
-  private static getDataNode(templateFragment: object): object {
-    if (templateFragment == null) {
-      return null;
-    }
-    const isMulti: boolean = TemplateRepresentationFactory.isFragmentMulti(templateFragment);
-    if (isMulti) {
-      return templateFragment[CedarModel.items];
-    } else {
-      return templateFragment;
-    }
-  }
-
-  private static extractValueConstraints(dataNode: object, fc: FieldComponent): void {
-    fc.basicInfo.inputType = dataNode[CedarModel.ui][CedarModel.inputType];
-
-    if (dataNode[CedarModel.ui][CedarModel.inputType] === InputType.temporal) {
-      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.timezoneEnabled)) {
-        fc.basicInfo.timezoneEnabled = dataNode[CedarModel.ui][CedarModel.timezoneEnabled];
-      }
-      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.inputTimeFormat)) {
-        fc.basicInfo.inputTimeFormat = dataNode[CedarModel.ui][CedarModel.inputTimeFormat];
-      }
-      if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.temporalGranularity)) {
-        fc.basicInfo.temporalGranularity = dataNode[CedarModel.ui][CedarModel.temporalGranularity];
-      }
-    }
-
-    if (dataNode[CedarModel.ui].hasOwnProperty(CedarModel.temporalGranularity)) {
-      fc.basicInfo.temporalGranularity = dataNode[CedarModel.ui][CedarModel.temporalGranularity];
-    }
-
-    if (TemplateObjectUtil.hasValueConstraints(dataNode)) {
-      const vc: object = dataNode[CedarModel.valueConstraints];
-      fc.valueInfo.requiredValue = vc[CedarModel.requiredValue];
-      fc.valueInfo.defaultValue = vc[CedarModel.defaultValue];
-      fc.valueInfo.minLength = vc[CedarModel.minLength];
-      fc.valueInfo.maxLength = vc[CedarModel.maxLength];
-
-      if (vc.hasOwnProperty(CedarModel.temporalType)) {
-        fc.valueInfo.temporalType = vc[CedarModel.temporalType];
-      }
-
-      fc.numberInfo.numberType = vc[CedarModel.numberType];
-      fc.numberInfo.unitOfMeasure = vc[CedarModel.unitOfMeasure];
-      fc.numberInfo.minValue = vc[CedarModel.minValue];
-      fc.numberInfo.maxValue = vc[CedarModel.maxValue];
-      fc.numberInfo.decimalPlace = vc[CedarModel.decimalPlace];
-      fc.choiceInfo.multipleChoice = vc[CedarModel.multipleChoice];
-
-      if (vc[CedarModel.literals] !== undefined) {
-        for (const pair of vc[CedarModel.literals]) {
-          const option = new ChoiceOption();
-          option.label = pair[CedarModel.label];
-          option.selectedByDefault = pair[CedarModel.selectedByDefault];
-          fc.choiceInfo.choices.push(option);
-        }
-      }
-
-      if (TemplateObjectUtil.hasControlledInfo(dataNode)) {
-        fc.basicInfo.inputType = InputType.controlled;
-        fc.controlledInfo.ontologies = vc[CedarModel.ontologies];
-        fc.controlledInfo.valueSets = vc[CedarModel.valueSets];
-        fc.controlledInfo.classes = vc[CedarModel.classes];
-        fc.controlledInfo.branches = vc[CedarModel.branches];
-      }
-    }
-  }
-
-  private static extractLabels(dataNode: object, parentDataNode: object, name: string, fc: FieldComponent): void {
-    fc.labelInfo.preferredLabel = dataNode[CedarModel.skosPrefLabel];
-    fc.labelInfo.description = dataNode[JsonSchema.schemaDescription];
-    fc.labelInfo.label = dataNode[JsonSchema.schemaName];
-    if (parentDataNode != null) {
-      if (fc.labelInfo.description == null || fc.labelInfo.description === 'Help Text') {
-        if (parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions] !== undefined) {
-          fc.labelInfo.description = parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions][name];
-        }
-      }
-      if (fc.labelInfo.label == null || fc.labelInfo.label === name) {
-        if (parentDataNode[CedarModel.ui][CedarModel.propertyLabels] !== undefined) {
-          fc.labelInfo.label = parentDataNode[CedarModel.ui][CedarModel.propertyLabels][name];
-        }
-      }
-    }
-  }
-
-  private static extractMultiInfo(templateFragment: object, mr: MultiComponent): void {
-    mr.multiInfo.minItems = templateFragment[CedarModel.minItems];
-    mr.multiInfo.maxItems = templateFragment[CedarModel.maxItems];
-  }
-
-  private static extractTemplateLabels(templateJsonObj: object, template: CedarTemplate): void {
-    template.labelInfo.label = templateJsonObj[JsonSchema.schemaName];
-    template.labelInfo.description = templateJsonObj[JsonSchema.schemaDescription];
-  }
-
-  private static extractStaticData(dataNode: object, parentDataNode: object, name: string, sfc: StaticFieldComponent): void {
-    sfc.basicInfo.inputType = dataNode[CedarModel.ui][CedarModel.inputType];
-    sfc.labelInfo.preferredLabel = dataNode[CedarModel.skosPrefLabel];
-    sfc.contentInfo.content = dataNode[CedarModel.ui][CedarModel.content];
-    sfc.labelInfo.description = dataNode[JsonSchema.schemaDescription];
-    sfc.labelInfo.label = dataNode[JsonSchema.schemaName];
-    if (parentDataNode != null) {
-      if (sfc.labelInfo.description == null || sfc.labelInfo.description === 'Help Text') {
-        if (parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions] !== undefined) {
-          sfc.labelInfo.description = parentDataNode[CedarModel.ui][CedarModel.propertyDescriptions][name];
-        }
-      }
-      if (sfc.labelInfo.label == null || sfc.labelInfo.label === name) {
-        if (parentDataNode[CedarModel.ui][CedarModel.propertyLabels] !== undefined) {
-          sfc.labelInfo.label = parentDataNode[CedarModel.ui][CedarModel.propertyLabels][name];
-        }
-      }
-    }
-  }
-
-  // Group RTF/image/video fields into consecutive pairs. Any pair gets combined
-  // and displayed inline wherever it's located.
-  // If the RTF/image/video field is odd (not paired with another RTF/image/video),
-  // wrap this field into the next dynamic field/element
-  private static collapseStaticFieldsIntoNextFieldOrElement(component: CedarComponent): void {
-    // re-iterate, inject static components (images) into the next dynamic components
-    // but only if they aren't paired with other like fields
-    if (ComponentTypeHandler.isContainerComponent(component)) {
-      const elementComponent = component as ElementComponent;
-      let prevChild: CedarComponent = null;
-      const newChildren: CedarComponent[] = [];
-      let isStaticPair = false;
-
-      for (let i = 0; i < elementComponent.children.length; i++) {
-        const currentChild: CedarComponent = elementComponent.children[i];
-
-        if (ComponentTypeHandler.isFieldOrElement(currentChild) &&
-            ComponentTypeHandler.isStaticContentComponent(prevChild) && !isStaticPair) {
-          currentChild.linkedStaticFieldComponent = prevChild as StaticFieldComponent;
-          newChildren.pop();
-          newChildren.push(currentChild);
-        } else {
-          newChildren.push(currentChild);
-        }
-
-        if (!isStaticPair && ComponentTypeHandler.isStaticContentComponent(currentChild) &&
-          ComponentTypeHandler.isStaticContentComponent(prevChild)) {
-          isStaticPair = true;
-        } else if (isStaticPair) {
-          isStaticPair = false;
-        }
-        prevChild = currentChild;
-      }
-      elementComponent.children = newChildren;
-    }
-  }
-
-}

package/src/app/modules/shared/handler/component-type.handler.ts

@@ -1,51 +0,0 @@
-import {CedarComponent} from '../models/component/cedar-component.model';
-import {SingleFieldComponent} from '../models/field/single-field-component.model';
-import {MultiFieldComponent} from '../models/field/multi-field-component.model';
-import {StaticFieldComponent} from '../models/static/static-field-component.model';
-import {InputType} from '../models/input-type.model';
-import {CedarTemplate} from '../models/template/cedar-template.model';
-import {SingleElementComponent} from '../models/element/single-element-component.model';
-import {MultiElementComponent} from '../models/element/multi-element-component.model';
-
-export class ComponentTypeHandler {
-
-  public static isImage(component: CedarComponent): boolean {
-    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.image;
-  }
-
-  static isYoutube(component: CedarComponent): boolean {
-    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.youtube;
-  }
-
-  public static isRichText(component: CedarComponent): boolean {
-    return component instanceof StaticFieldComponent && component.basicInfo.inputType === InputType.richText;
-  }
-
-  public static isStaticContentComponent(component: CedarComponent): boolean {
-    return this.isImage(component) || this.isYoutube(component) || this.isRichText(component);
-  }
-
-  public static isField(component: CedarComponent): boolean {
-    return component instanceof SingleFieldComponent || component instanceof MultiFieldComponent;
-  }
-
-  public static isElement(component: CedarComponent): boolean {
-    return component instanceof SingleElementComponent || component instanceof MultiElementComponent;
-  }
-
-  static isContainerComponent(component: CedarComponent): boolean {
-    return component instanceof CedarTemplate || component instanceof SingleElementComponent || component instanceof MultiElementComponent;
-  }
-
-  static isTemplate(component: CedarComponent): boolean {
-    return component instanceof CedarTemplate;
-  }
-
-  static isFieldOrElement(component: CedarComponent): boolean {
-    return this.isField(component) || this.isElement(component);
-  }
-
-  static isMulti(component: CedarComponent): boolean {
-    return component instanceof MultiFieldComponent || component instanceof MultiElementComponent;
-  }
-}

package/src/app/modules/shared/handler/data-object-builder.handler.ts

@@ -1,159 +0,0 @@
-import {TemplateComponent} from '../models/template/template-component.model';
-import {CedarComponent} from '../models/component/cedar-component.model';
-import {SingleElementComponent} from '../models/element/single-element-component.model';
-import {MultiElementComponent} from '../models/element/multi-element-component.model';
-import {CedarTemplate} from '../models/template/cedar-template.model';
-import {ElementComponent} from '../models/component/element-component.model';
-import {SingleFieldComponent} from '../models/field/single-field-component.model';
-import {MultiFieldComponent} from '../models/field/multi-field-component.model';
-import {FieldComponent} from '../models/component/field-component.model';
-import {JsonSchema} from '../models/json-schema.model';
-import * as _ from 'lodash-es';
-import {InstanceExtractData} from '../models/instance-extract-data.model';
-import {InstanceFullData} from '../models/instance-full-data.model';
-import {DataObjectUtil} from '../util/data-object-util';
-import {MultiInstanceObjectHandler} from './multi-instance-object.handler';
-import {CedarInputTemplate} from '../models/cedar-input-template.model';
-import {DataObjectBuildingMode} from '../models/enum/data-object-building-mode.model';
-
-export class DataObjectBuilderHandler {
-
-  private dataObject: object;
-  private dataObjectFull: object;
-  private templateJsonObj: object;
-  private templateRepresentation: TemplateComponent;
-  private multiInstanceObjectService: MultiInstanceObjectHandler;
-
-  static getSubTemplate(template: CedarInputTemplate, path: string[]): CedarInputTemplate {
-    if (path.length === 0) {
-      return template;
-    }
-    const firstPath = path[0];
-    const remainingPath = path.slice(1);
-    const subTemplate = DataObjectUtil.getSafeSubTemplate(template, firstPath);
-    return this.getSubTemplate(subTemplate, remainingPath);
-  }
-
-  public static buildRecursively(component: CedarComponent, dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
-    let ret = null;
-    if (templateJsonObj != null) {
-      DataObjectBuilderHandler.addContext(component, dataObject, templateJsonObj, buildingMode);
-    }
-    if (component instanceof SingleElementComponent || component instanceof MultiElementComponent || component instanceof CedarTemplate) {
-      const iterableComponent: ElementComponent = component as ElementComponent;
-      const targetName = iterableComponent.name;
-      if (component instanceof MultiElementComponent) {
-        const multiElement: MultiElementComponent = component as MultiElementComponent;
-        dataObject[targetName] = DataObjectUtil.getEmptyList();
-        if (multiElement.multiInfo.minItems > 0) {
-          const dummyTargetObject: object = DataObjectUtil.getEmptyObject();
-          const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
-          for (const childComponent of iterableComponent.children) {
-            DataObjectBuilderHandler.buildRecursively(childComponent, dummyTargetObject, subTemplate, buildingMode);
-          }
-          for (let idx = 0; idx < multiElement.multiInfo.minItems; idx++) {
-            const clone = _.cloneDeep(dummyTargetObject as any);
-            dataObject[targetName].push(clone);
-          }
-        }
-      } else {
-        dataObject[targetName] = DataObjectUtil.getEmptyObject();
-        const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
-        for (const childComponent of iterableComponent.children) {
-          DataObjectBuilderHandler.buildRecursively(childComponent, dataObject[targetName], subTemplate, buildingMode);
-        }
-      }
-      ret = dataObject[targetName];
-    }
-    if (component instanceof SingleFieldComponent || component instanceof MultiFieldComponent) {
-      const nonIterableComponent = component as FieldComponent;
-      const targetName = nonIterableComponent.name;
-      if (component instanceof MultiFieldComponent) {
-        const multiField: MultiFieldComponent = component as MultiFieldComponent;
-        dataObject[targetName] = DataObjectUtil.getEmptyList();
-        if (multiField.multiInfo.minItems > 0) {
-          const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
-          for (let idx = 0; idx < multiField.multiInfo.minItems; idx++) {
-            dataObject[targetName].push(DataObjectUtil.getEmptyValueWrapper(subTemplate, buildingMode));
-          }
-        }
-      } else {
-        const subTemplate = DataObjectUtil.getSafeSubTemplate(templateJsonObj, targetName);
-        dataObject[targetName] = DataObjectUtil.getEmptyValueWrapper(subTemplate, buildingMode);
-      }
-      ret = dataObject[targetName];
-    }
-    return ret;
-  }
-
-  public static setCurrentCountToMinRecursively(component: CedarComponent, path: string[]): void {
-    if (path.length === 0) {
-      return;
-    }
-    const firstPath = path[0];
-    const remainingPath = path.slice(1);
-    if (component instanceof SingleElementComponent) {
-      const singleElement: SingleElementComponent = component as SingleElementComponent;
-      for (const childComponent of singleElement.children) {
-        DataObjectBuilderHandler.setCurrentCountToMinRecursively(childComponent, remainingPath);
-      }
-    } else if (component instanceof MultiElementComponent) {
-      const multiElement: MultiElementComponent = component as MultiElementComponent;
-      const min = multiElement.multiInfo.getSafeMinItems();
-      if (min === 0) {
-        multiElement.multiInfo.minItems = 1;
-      }
-      for (const childComponent of multiElement.children) {
-        DataObjectBuilderHandler.setCurrentCountToMinRecursively(childComponent, remainingPath);
-      }
-    } else if (component instanceof MultiFieldComponent) {
-      const multiField: MultiFieldComponent = component as MultiFieldComponent;
-      const min = multiField.multiInfo.getSafeMinItems();
-      if (min === 0) {
-        multiField.multiInfo.minItems = 1;
-      }
-    }
-  }
-
-  private static addContext(component: CedarComponent, dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
-    if (buildingMode === DataObjectBuildingMode.INCLUDE_CONTEXT) {
-      const props = templateJsonObj[JsonSchema.properties];
-      const propsContext = props[JsonSchema.atContext];
-      const propsContextProps = propsContext[JsonSchema.properties];
-      const p: object = {};
-      for (const key of Object.keys(propsContextProps)) {
-        p[key] = DataObjectUtil.convertTemplateContextNode(propsContextProps[key]);
-      }
-      dataObject[JsonSchema.atContext] = p;
-    }
-  }
-
-  injectMultiInstanceService(multiInstanceObjectService: MultiInstanceObjectHandler): void {
-    this.multiInstanceObjectService = multiInstanceObjectService;
-  }
-
-  buildNewExtractDataObject(templateRepresentation: TemplateComponent, templateJsonObj: CedarInputTemplate): InstanceExtractData {
-    this.templateJsonObj = templateJsonObj;
-    this.templateRepresentation = templateRepresentation;
-    this.dataObject = new InstanceExtractData();
-    this.buildNewByIterating(this.dataObject, templateJsonObj, DataObjectBuildingMode.EXCLUDE_CONTEXT);
-    return this.dataObject;
-  }
-
-  buildNewFullDataObject(templateRepresentation: TemplateComponent, templateJsonObj: CedarInputTemplate): InstanceFullData {
-    this.templateJsonObj = templateJsonObj;
-    this.templateRepresentation = templateRepresentation;
-    this.dataObjectFull = new InstanceFullData();
-    this.buildNewByIterating(this.dataObjectFull, templateJsonObj, DataObjectBuildingMode.INCLUDE_CONTEXT);
-    return this.dataObjectFull;
-  }
-
-  private buildNewByIterating(dataObject: InstanceExtractData, templateJsonObj: CedarInputTemplate, buildingMode: DataObjectBuildingMode): void {
-    if (this.templateRepresentation != null && this.templateRepresentation.children != null) {
-      for (const childComponent of this.templateRepresentation.children) {
-        DataObjectBuilderHandler.buildRecursively(childComponent, dataObject, templateJsonObj, buildingMode);
-      }
-    }
-  }
-
-}