@mtna/web-form-angular 1.0.4 → 1.0.5

package/esm2015/lib/utilities/design-conditionals-util.js

@@ -0,0 +1,124 @@
+import { instanceOfBooleanItemTemplate, instanceOfCheckboxItemTemplate, instanceOfDropdownItemTemplate, instanceOfMultipleChoiceItemTemplate, instanceOfTemplateItemGroupImpl, instanceOfTemplateSectionImpl, } from '@mtna/web-form-ts';
+import { isPresent } from '@mtna/core-ts';
+export function getConditionalProcessingResources(optionId, enable, items) {
+    const conditionalItems = flattenConditionalItems(items);
+    let optionSelector = undefined;
+    let optionItemId = '';
+    for (const conditionalItem of conditionalItems) {
+        if (!isPresent(optionSelector)) {
+            let options = [];
+            if (instanceOfCheckboxItemTemplate(conditionalItem) ||
+                instanceOfDropdownItemTemplate(conditionalItem) ||
+                instanceOfMultipleChoiceItemTemplate(conditionalItem)) {
+                options = conditionalItem.options;
+            }
+            else if (instanceOfBooleanItemTemplate(conditionalItem)) {
+                options.push(conditionalItem.option);
+            }
+            for (const option of options) {
+                if (option.option.id === optionId) {
+                    optionSelector = option;
+                    optionItemId = conditionalItem.instanceId;
+                    break;
+                }
+            }
+        }
+    }
+    return isPresent(optionSelector) ? { conditionalItems, enable, optionItemId, optionSelector } : undefined;
+}
+/**
+ * Flattens a list of template items into a single flat array of conditionalItems.
+ *
+ * @param items
+ */
+export function flattenConditionalItems(items) {
+    let conditionalItems = [];
+    for (const templateItem of items) {
+        if (instanceOfTemplateItemGroupImpl(templateItem)) {
+            conditionalItems.push(templateItem);
+            conditionalItems = [...conditionalItems, ...flattenConditionalItems(templateItem.items)];
+        }
+        else if (instanceOfTemplateSectionImpl(templateItem)) {
+            conditionalItems.push(templateItem);
+            conditionalItems = [...conditionalItems, ...flattenConditionalItems(templateItem.items)];
+        }
+        else {
+            // we know the remaining template items are conditionals
+            const conditionalItem = templateItem;
+            conditionalItems.push(conditionalItem);
+        }
+    }
+    return conditionalItems;
+}
+export function processConditionals(optionId, enable, items) {
+    const conditionalProcessingResources = getConditionalProcessingResources(optionId, enable, items);
+    if (!conditionalProcessingResources) {
+        return;
+    }
+    /*
+     * One of two things may have happened.
+     *  - An item was added to the list of enabled / disabled items.
+     *  - An item was removed from the list of enabled / disabled items.
+     *
+     * In the first scenario we must look up the conditional items in the enabled / disabled list and adjust their
+     * conditions. In the second scenario we must look through all the conditionals, find those that reference the option
+     * item being updated and check if they still exist in the list of enabled / disabled items.
+     *
+     * To perform this in a single pass, we will iterate over all the conditional items and pick out any that are
+     * referenced by the current list of enabled / disabled items, and also any that currently have a condition set on
+     * them where the item ids include the edited option items id. Then we will go about handling the two previously
+     * described scenarios.
+     */
+    const optionSelector = conditionalProcessingResources.optionSelector;
+    const updatedItemIds = new Set(enable
+        ? isPresent(optionSelector.enabledItems)
+            ? optionSelector.enabledItems
+            : []
+        : isPresent(optionSelector.disabledItems)
+            ? optionSelector.disabledItems
+            : []);
+    for (const conditionalItem of conditionalProcessingResources.conditionalItems) {
+        if (updatedItemIds.has(conditionalItem.instanceId)) {
+            updateConditional(conditionalItem, conditionalProcessingResources.optionItemId, enable);
+        }
+        else if (hasCondition(conditionalItem, conditionalProcessingResources.optionItemId)) {
+            removeFromCondition(conditionalItem, conditionalProcessingResources.optionItemId);
+        }
+    }
+}
+export function hasCondition(conditionalItem, optionItemId) {
+    return (isPresent(conditionalItem.condition) &&
+        isPresent(conditionalItem.condition.itemIds) &&
+        conditionalItem.condition.itemIds.includes(optionItemId));
+}
+export function updateConditional(conditional, itemId, enable) {
+    if (!isPresent(conditional.condition)) {
+        conditional.condition = { allRequired: false, itemIds: [], value: '' };
+    }
+    // if the condition is enabled by this item, set disabled to be true.
+    const condition = conditional.condition;
+    conditional.disabled = enable;
+    if (!condition.itemIds.includes(itemId)) {
+        condition.itemIds.push(itemId);
+    }
+    conditional.hasCondition = true;
+}
+export function removeFromCondition(conditional, itemId) {
+    if (!isPresent(conditional.condition)) {
+        return;
+    }
+    const itemIds = isPresent(conditional.condition.itemIds) ? conditional.condition.itemIds : [];
+    const index = itemIds.indexOf(itemId);
+    if (index !== -1) {
+        itemIds.splice(index, 1);
+    }
+    if (itemIds.length > 0) {
+        conditional.condition.itemIds = itemIds;
+    }
+    else {
+        conditional.condition = undefined;
+        conditional.hasCondition = false;
+        conditional.disabled = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"design-conditionals-util.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/utilities/design-conditionals-util.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,6BAA6B,EAC7B,8BAA8B,EAC9B,8BAA8B,EAC9B,oCAAoC,EACpC,+BAA+B,EAC/B,6BAA6B,GAE9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,MAAM,UAAU,iCAAiC,CAC/C,QAAgB,EAChB,MAAe,EACf,KAAqB;IAErB,MAAM,gBAAgB,GAAsB,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC3E,IAAI,cAAc,GAAwC,SAAS,CAAC;IACpE,IAAI,YAAY,GAAW,EAAE,CAAC;IAC9B,KAAK,MAAM,eAAe,IAAI,gBAAgB,EAAE;QAC9C,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE;YAC9B,IAAI,OAAO,GAA8B,EAAE,CAAC;YAC5C,IACE,8BAA8B,CAAC,eAAe,CAAC;gBAC/C,8BAA8B,CAAC,eAAe,CAAC;gBAC/C,oCAAoC,CAAC,eAAe,CAAC,EACrD;gBACA,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC;aACnC;iBAAM,IAAI,6BAA6B,CAAC,eAAe,CAAC,EAAE;gBACzD,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;aACtC;YACD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;gBAC5B,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;oBACjC,cAAc,GAAG,MAAM,CAAC;oBACxB,YAAY,GAAG,eAAe,CAAC,UAAU,CAAC;oBAC1C,MAAM;iBACP;aACF;SACF;KACF;IAED,OAAO,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5G,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAqB;IAC3D,IAAI,gBAAgB,GAAsB,EAAE,CAAC;IAC7C,KAAK,MAAM,YAAY,IAAI,KAAK,EAAE;QAChC,IAAI,+BAA+B,CAAC,YAAY,CAAC,EAAE;YACjD,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpC,gBAAgB,GAAG,CAAC,GAAG,gBAAgB,EAAE,GAAG,uBAAuB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;SAC1F;aAAM,IAAI,6BAA6B,CAAC,YAAY,CAAC,EAAE;YACtD,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpC,gBAAgB,GAAG,CAAC,GAAG,gBAAgB,EAAE,GAAG,uBAAuB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;SAC1F;aAAM;YACL,wDAAwD;YACxD,MAAM,eAAe,GAAG,YAA0C,CAAC;YACnE,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SACxC;KACF;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,QAAgB,EAAE,MAAe,EAAE,KAAqB;IAC1F,MAAM,8BAA8B,GAAG,iCAAiC,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAClG,IAAI,CAAC,8BAA8B,EAAE;QACnC,OAAO;KACR;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,cAAc,GAA4B,8BAA8B,CAAC,cAAc,CAAC;IAC9F,MAAM,cAAc,GAAG,IAAI,GAAG,CAC5B,MAAM;QACJ,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC;YACtC,CAAC,CAAC,cAAc,CAAC,YAAY;YAC7B,CAAC,CAAC,EAAE;QACN,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;YACzC,CAAC,CAAC,cAAc,CAAC,aAAa;YAC9B,CAAC,CAAC,EAAE,CACP,CAAC;IACF,KAAK,MAAM,eAAe,IAAI,8BAA8B,CAAC,gBAAgB,EAAE;QAC7E,IAAI,cAAc,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE;YAClD,iBAAiB,CAAC,eAAe,EAAE,8BAA8B,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;SACzF;aAAM,IAAI,YAAY,CAAC,eAAe,EAAE,8BAA8B,CAAC,YAAY,CAAC,EAAE;YACrF,mBAAmB,CAAC,eAAe,EAAE,8BAA8B,CAAC,YAAY,CAAC,CAAC;SACnF;KACF;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,eAAgC,EAAE,YAAoB;IACjF,OAAO,CACL,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC;QACpC,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC;QAC5C,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CACzD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,WAA4B,EAAE,MAAc,EAAE,MAAe;IAC7F,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE;QACrC,WAAW,CAAC,SAAS,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;KACxE;IACD,qEAAqE;IACrE,MAAM,SAAS,GAAc,WAAW,CAAC,SAAS,CAAC;IACnD,WAAW,CAAC,QAAQ,GAAG,MAAM,CAAC;IAC9B,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;QACvC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;KAChC;IACD,WAAW,CAAC,YAAY,GAAG,IAAI,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,WAA4B,EAAE,MAAc;IAC9E,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE;QACrC,OAAO;KACR;IACD,MAAM,OAAO,GAAG,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9F,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;QAChB,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;KAC1B;IACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;QACtB,WAAW,CAAC,SAAS,CAAC,OAAO,GAAG,OAAO,CAAC;KACzC;SAAM;QACL,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC;QAClC,WAAW,CAAC,YAAY,GAAG,KAAK,CAAC;QACjC,WAAW,CAAC,QAAQ,GAAG,KAAK,CAAC;KAC9B;AACH,CAAC","sourcesContent":["import {\n  Condition,\n  ConditionalItem,\n  FormOptionSelector,\n  instanceOfBooleanItemTemplate,\n  instanceOfCheckboxItemTemplate,\n  instanceOfDropdownItemTemplate,\n  instanceOfMultipleChoiceItemTemplate,\n  instanceOfTemplateItemGroupImpl,\n  instanceOfTemplateSectionImpl,\n  TemplateItem,\n} from '@mtna/web-form-ts';\nimport { isPresent } from '@mtna/core-ts';\nimport { ConditionalProcessingResources } from '../models';\n\nexport function getConditionalProcessingResources(\n  optionId: string,\n  enable: boolean,\n  items: TemplateItem[]\n): ConditionalProcessingResources | undefined {\n  const conditionalItems: ConditionalItem[] = flattenConditionalItems(items);\n  let optionSelector: FormOptionSelector<any> | undefined = undefined;\n  let optionItemId: string = '';\n  for (const conditionalItem of conditionalItems) {\n    if (!isPresent(optionSelector)) {\n      let options: FormOptionSelector<any>[] = [];\n      if (\n        instanceOfCheckboxItemTemplate(conditionalItem) ||\n        instanceOfDropdownItemTemplate(conditionalItem) ||\n        instanceOfMultipleChoiceItemTemplate(conditionalItem)\n      ) {\n        options = conditionalItem.options;\n      } else if (instanceOfBooleanItemTemplate(conditionalItem)) {\n        options.push(conditionalItem.option);\n      }\n      for (const option of options) {\n        if (option.option.id === optionId) {\n          optionSelector = option;\n          optionItemId = conditionalItem.instanceId;\n          break;\n        }\n      }\n    }\n  }\n\n  return isPresent(optionSelector) ? { conditionalItems, enable, optionItemId, optionSelector } : undefined;\n}\n\n/**\n * Flattens a list of template items into a single flat array of conditionalItems.\n *\n * @param items\n */\nexport function flattenConditionalItems(items: TemplateItem[]): ConditionalItem[] {\n  let conditionalItems: ConditionalItem[] = [];\n  for (const templateItem of items) {\n    if (instanceOfTemplateItemGroupImpl(templateItem)) {\n      conditionalItems.push(templateItem);\n      conditionalItems = [...conditionalItems, ...flattenConditionalItems(templateItem.items)];\n    } else if (instanceOfTemplateSectionImpl(templateItem)) {\n      conditionalItems.push(templateItem);\n      conditionalItems = [...conditionalItems, ...flattenConditionalItems(templateItem.items)];\n    } else {\n      // we know the remaining template items are conditionals\n      const conditionalItem = templateItem as unknown as ConditionalItem;\n      conditionalItems.push(conditionalItem);\n    }\n  }\n  return conditionalItems;\n}\n\nexport function processConditionals(optionId: string, enable: boolean, items: TemplateItem[]) {\n  const conditionalProcessingResources = getConditionalProcessingResources(optionId, enable, items);\n  if (!conditionalProcessingResources) {\n    return;\n  }\n\n  /*\n   * One of two things may have happened.\n   *  - An item was added to the list of enabled / disabled items.\n   *  - An item was removed from the list of enabled / disabled items.\n   *\n   * In the first scenario we must look up the conditional items in the enabled / disabled list and adjust their\n   * conditions. In the second scenario we must look through all the conditionals, find those that reference the option\n   * item being updated and check if they still exist in the list of enabled / disabled items.\n   *\n   * To perform this in a single pass, we will iterate over all the conditional items and pick out any that are\n   * referenced by the current list of enabled / disabled items, and also any that currently have a condition set on\n   * them where the item ids include the edited option items id. Then we will go about handling the two previously\n   * described scenarios.\n   */\n  const optionSelector: FormOptionSelector<any> = conditionalProcessingResources.optionSelector;\n  const updatedItemIds = new Set(\n    enable\n      ? isPresent(optionSelector.enabledItems)\n        ? optionSelector.enabledItems\n        : []\n      : isPresent(optionSelector.disabledItems)\n      ? optionSelector.disabledItems\n      : []\n  );\n  for (const conditionalItem of conditionalProcessingResources.conditionalItems) {\n    if (updatedItemIds.has(conditionalItem.instanceId)) {\n      updateConditional(conditionalItem, conditionalProcessingResources.optionItemId, enable);\n    } else if (hasCondition(conditionalItem, conditionalProcessingResources.optionItemId)) {\n      removeFromCondition(conditionalItem, conditionalProcessingResources.optionItemId);\n    }\n  }\n}\n\nexport function hasCondition(conditionalItem: ConditionalItem, optionItemId: string) {\n  return (\n    isPresent(conditionalItem.condition) &&\n    isPresent(conditionalItem.condition.itemIds) &&\n    conditionalItem.condition.itemIds.includes(optionItemId)\n  );\n}\n\nexport function updateConditional(conditional: ConditionalItem, itemId: string, enable: boolean) {\n  if (!isPresent(conditional.condition)) {\n    conditional.condition = { allRequired: false, itemIds: [], value: '' };\n  }\n  // if the condition is enabled by this item, set disabled to be true.\n  const condition: Condition = conditional.condition;\n  conditional.disabled = enable;\n  if (!condition.itemIds.includes(itemId)) {\n    condition.itemIds.push(itemId);\n  }\n  conditional.hasCondition = true;\n}\n\nexport function removeFromCondition(conditional: ConditionalItem, itemId: string) {\n  if (!isPresent(conditional.condition)) {\n    return;\n  }\n  const itemIds = isPresent(conditional.condition.itemIds) ? conditional.condition.itemIds : [];\n  const index = itemIds.indexOf(itemId);\n  if (index !== -1) {\n    itemIds.splice(index, 1);\n  }\n  if (itemIds.length > 0) {\n    conditional.condition.itemIds = itemIds;\n  } else {\n    conditional.condition = undefined;\n    conditional.hasCondition = false;\n    conditional.disabled = false;\n  }\n}\n"]}

package/esm2015/lib/utilities/form-option-design-util.js

@@ -0,0 +1,88 @@
+import { instanceOfModelDesignProperty } from '@mtna/designer-ts';
+import { OptionSelectorMapper } from '../models/design/design-mapper/option-selector-mapper';
+import { isPresent, isType } from '@mtna/core-ts';
+import { optionGroupItemSectionDisplayNameMap } from '../models/design/option-group-item-section-display-name-map.model';
+import { optionItemSectionDisplayNameMap } from '../models/design/option-item-section-display-name-map.model';
+import { i18n_optionProperties } from '../models/i18n-constants.model';
+import { prop_item_option, prop_item_options, prop_option_template } from '../models/design/template-design-constants.model';
+export function getNewFormOptionSelector(designBase) {
+    return {
+        acknowledgement: {},
+        containerDescription: '',
+        codeValue: '',
+        disabledItems: [],
+        enabledItems: [],
+        multiSelect: false,
+        option: {
+            name: designBase.display,
+            help: '',
+            description: '',
+            id: designBase.id,
+            value: undefined,
+        },
+        selected: false,
+        selectionCount: 0,
+        unavailable: false,
+    };
+}
+export function optionSelectorToDesign(formOptionSelector, languageId, optionTemplateMap, references, parent, context) {
+    const design = new OptionSelectorMapper({
+        model: formOptionSelector,
+        languageId,
+        context,
+        customParams: { optionTemplateMap, references },
+    }).getDesign();
+    return Object.assign(Object.assign({}, design), { parent });
+}
+export function designToOptionSelector(design, context) {
+    const formOptionSelector = new OptionSelectorMapper({
+        design,
+        context,
+    }).getModel();
+    return formOptionSelector;
+}
+export function getOptionSelectorPotentialDesigns(design, property) {
+    const potentialDesigns = new OptionSelectorMapper({ design }).getPotentialDesigns(property);
+    return potentialDesigns;
+}
+export function instanceOfFormOptionSelector(something) {
+    return (isType(something, 'containerDescription', 'codeValue', 'option') &&
+        isPresent(something.containerDescription) &&
+        isPresent(something.codeValue) &&
+        isPresent(something.option));
+}
+function getDesignsBySectionAndProperty(design, sectionDisplay, propertyKey) {
+    const section = design.sections.find((s) => s.display === sectionDisplay);
+    if (!section)
+        return [];
+    const property = section.properties.find((p) => instanceOfModelDesignProperty(p) && p.property === propertyKey);
+    if (property && instanceOfModelDesignProperty(property)) {
+        return property.values;
+    }
+    return [];
+}
+function getOptionDesigns(design, mapperType) {
+    const sectionDisplay = mapperType === 'optionGroupItem' ? optionGroupItemSectionDisplayNameMap[design.type] : optionItemSectionDisplayNameMap[design.type];
+    const propertyKey = mapperType === 'optionGroupItem' ? prop_item_options : prop_item_option;
+    return getDesignsBySectionAndProperty(design, sectionDisplay, propertyKey);
+}
+function getOptionTemplateDesign(optionDesign) {
+    const designs = getDesignsBySectionAndProperty(optionDesign, i18n_optionProperties, prop_option_template);
+    return isPresent(designs[0]) ? designs[0] : undefined;
+}
+export function getOptionsAndTemplateMap(design, mapperType, toTemplateItemFn, context) {
+    const options = [];
+    const optionTemplateMap = {};
+    const optionDesigns = getOptionDesigns(design, mapperType);
+    for (const optionDesign of optionDesigns) {
+        const optionSelector = designToOptionSelector(optionDesign, context);
+        options.push(optionSelector);
+        const optionTemplateDesign = getOptionTemplateDesign(optionDesign);
+        if (isPresent(optionTemplateDesign)) {
+            const optionTemplate = toTemplateItemFn(optionTemplateDesign, context);
+            optionTemplateMap[optionSelector.option.id] = optionTemplate;
+        }
+    }
+    return { options, optionTemplateMap };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-option-design-util.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/utilities/form-option-design-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormOptionSelector, Option, Section, TemplateItem } from '@mtna/web-form-ts';\nimport { MtnaLanguageId } from '@mtna/core-i18n-angular';\nimport { Context, Design, DesignBase, DesignProperty, instanceOfModelDesignProperty, ReferenceDesignValue } from '@mtna/designer-ts';\nimport { OptionSelectorMapper } from '../models/design/design-mapper/option-selector-mapper';\nimport { isPresent, isType } from '@mtna/core-ts';\nimport { optionGroupItemSectionDisplayNameMap } from '../models/design/option-group-item-section-display-name-map.model';\nimport { optionItemSectionDisplayNameMap } from '../models/design/option-item-section-display-name-map.model';\nimport { i18n_optionProperties } from '../models/i18n-constants.model';\nimport { prop_item_option, prop_item_options, prop_option_template } from '../models/design/template-design-constants.model';\n\nexport function getNewFormOptionSelector(designBase: DesignBase): FormOptionSelector<Option<unknown>> {\n  return {\n    acknowledgement: {} as Section,\n    containerDescription: '',\n    codeValue: '',\n    disabledItems: [],\n    enabledItems: [],\n    multiSelect: false,\n    option: {\n      name: designBase.display,\n      help: '',\n      description: '',\n      id: designBase.id,\n      value: undefined,\n    } as Option<unknown>,\n    selected: false,\n    selectionCount: 0,\n    unavailable: false,\n  };\n}\n\nexport function optionSelectorToDesign<O extends Option<unknown>>(\n  formOptionSelector: FormOptionSelector<O>,\n  languageId: MtnaLanguageId,\n  optionTemplateMap: Record<string, TemplateItem>,\n  references: Record<string, ReferenceDesignValue>,\n  parent?: DesignBase,\n  context?: Context\n): Design {\n  const design: Design = new OptionSelectorMapper({\n    model: formOptionSelector,\n    languageId,\n    context,\n    customParams: { optionTemplateMap, references },\n  }).getDesign();\n  return { ...design, parent };\n}\n\nexport function designToOptionSelector<O extends Option<unknown>>(design: Design, context?: Context): FormOptionSelector<O> {\n  const formOptionSelector = new OptionSelectorMapper({\n    design,\n    context,\n  }).getModel();\n  return formOptionSelector as FormOptionSelector<O>;\n}\n\nexport function getOptionSelectorPotentialDesigns(design: Design, property: DesignProperty): DesignBase[] {\n  const potentialDesigns = new OptionSelectorMapper({ design }).getPotentialDesigns(property);\n  return potentialDesigns;\n}\n\nexport function instanceOfFormOptionSelector(something: unknown): something is FormOptionSelector<Option<unknown>> {\n  return (\n    isType<FormOptionSelector<Option<unknown>>>(something, 'containerDescription', 'codeValue', 'option') &&\n    isPresent(something.containerDescription) &&\n    isPresent(something.codeValue) &&\n    isPresent(something.option)\n  );\n}\n\nfunction getDesignsBySectionAndProperty(design: Design, sectionDisplay: string, propertyKey: string): Design[] {\n  const section = design.sections.find((s) => s.display === sectionDisplay);\n  if (!section) return [];\n\n  const property = section.properties.find((p) => instanceOfModelDesignProperty(p) && p.property === propertyKey);\n\n  if (property && instanceOfModelDesignProperty(property)) {\n    return property.values;\n  }\n\n  return [];\n}\n\nfunction getOptionDesigns(design: Design, mapperType: 'optionGroupItem' | 'optionItem'): Design[] {\n  const sectionDisplay =\n    mapperType === 'optionGroupItem' ? optionGroupItemSectionDisplayNameMap[design.type] : optionItemSectionDisplayNameMap[design.type];\n  const propertyKey = mapperType === 'optionGroupItem' ? prop_item_options : prop_item_option;\n\n  return getDesignsBySectionAndProperty(design, sectionDisplay, propertyKey);\n}\n\nfunction getOptionTemplateDesign(optionDesign: Design): Design | undefined {\n  const designs = getDesignsBySectionAndProperty(optionDesign, i18n_optionProperties, prop_option_template);\n  return isPresent(designs[0]) ? designs[0] : undefined;\n}\n\nexport function getOptionsAndTemplateMap<O extends Option<unknown>>(\n  design: Design,\n  mapperType: 'optionGroupItem' | 'optionItem',\n  toTemplateItemFn: (design: Design, context?: Context) => TemplateItem,\n  context?: Context\n): {\n  options: FormOptionSelector<O>[];\n  optionTemplateMap: Record<string, TemplateItem>;\n} {\n  const options: FormOptionSelector<O>[] = [];\n  const optionTemplateMap: Record<string, TemplateItem> = {};\n\n  const optionDesigns: Design[] = getOptionDesigns(design, mapperType);\n\n  for (const optionDesign of optionDesigns) {\n    const optionSelector: FormOptionSelector<O> = designToOptionSelector<O>(optionDesign, context);\n    options.push(optionSelector);\n\n    const optionTemplateDesign: Design | undefined = getOptionTemplateDesign(optionDesign);\n\n    if (isPresent(optionTemplateDesign)) {\n      const optionTemplate = toTemplateItemFn(optionTemplateDesign, context);\n      optionTemplateMap[optionSelector.option.id] = optionTemplate;\n    }\n  }\n\n  return { options, optionTemplateMap };\n}\n"]}

package/esm2015/lib/utilities/generate-form-steps.js

@@ -50,4 +50,4 @@ export function generateFormStepsFromOutline(outline) {
         return newArray;
     }, []);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-form-steps.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/utilities/generate-form-steps.ts"],"names":[],"mappings":"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","sourcesContent":["import { toLetters } from '@mtna/core-ts';\nimport { FormItem, isDataCubeItem, isSection, OutlineStep } from '@mtna/web-form-ts';\n\nimport { FormStep, FormStepGroup, isFormStepGroup } from '../models';\n\n/**\n * Builds up an array of FormSteps or FormStepGroups based on what is found in the provided form items. For most typical\n * forms this will mean that a step is generated for every section that is found in the form. It is assumed that all\n * inputs are held within sections and therefore the sections are the steps that should be monitored for completeness.\n * However, in some circumstances, like very short forms, it may be the case that there are no sections and that all\n * the items are set directly on the form itself. In these circumstances the allSteps parameter can be set to true and\n * a step will be produced for each form item found.\n *\n * @param items the items of the form\n * @param allSteps flag indicating that a form step should be produced for every form item\n */\nexport function generateFormSteps(items: Array<FormItem>, allSteps = false): Array<FormStep | FormStepGroup> {\n  // Build up an array of steps based on the form items\n  return items.reduce((newArray: Array<FormStep | FormStepGroup>, item: FormItem) => {\n    // The number of non-group steps, used to number the top level steps\n    const count = newArray.filter((step) => !isFormStepGroup(step)).length;\n    if (allSteps) {\n      newArray.push(new FormStep(count + 1, item.name || 'No Title', item.instanceId, !item.required));\n    } else if (isSection(item)) {\n      // If the item is a Section, add a step\n      newArray.push(new FormStep(count + 1, item.title.value || 'No Title', item.instanceId, !item.required));\n    } else if (isDataCubeItem(item)) {\n      // If the item is a DataCubeItem, add a step and add a group step for the sub-sections\n      newArray.push(new FormStep(count + 1, item.title.value || '', item.instanceId, !item.required));\n\n      const subSectionSteps = item.items\n        .filter(isSection)\n        .map((item, index) => new FormStep(`${count + 1}${toLetters(index + 1)}`, item.title.value || '', item.instanceId, !item.required));\n      newArray.push(new FormStepGroup(subSectionSteps, item.instanceId, false, item.name, count + 1));\n    }\n\n    return newArray;\n  }, []);\n}\n\nexport function generateFormStepsFromOutline(outline: OutlineStep[]): Array<FormStep | FormStepGroup> {\n  return outline.reduce((newArray: Array<FormStep | FormStepGroup>, step: OutlineStep) => {\n    // The number of non-group steps, used to number the top level steps\n    const count = newArray.filter((step) => !isFormStepGroup(step)).length;\n    if (step.childSteps && step.childSteps.length > 0) {\n      newArray.push(new FormStep(count + 1, step.label, step.instanceId || step.templateId, step.optional));\n      const subSectionSteps = step.childSteps.map(\n        (item, index) => new FormStep(`${count + 1}${toLetters(index + 1)}`, item.label, item.instanceId || item.templateId, item.optional)\n      );\n      newArray.push(new FormStepGroup(subSectionSteps, step.instanceId || step.templateId, false, step.label, count + 1));\n    } else {\n      newArray.push(new FormStep(count + 1, step.label, step.instanceId || step.templateId, step.optional));\n    }\n    return newArray;\n  }, []);\n}\n\n// model from andrew\nexport interface FormStepData extends OutlineStep {\n  num: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-form-steps.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/utilities/generate-form-steps.ts"],"names":[],"mappings":"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","sourcesContent":["import { toLetters } from '@mtna/core-ts';\nimport { FormItem, isDataCubeItem, isSection, OutlineStep, TemplateItem } from '@mtna/web-form-ts';\n\nimport { FormStep, FormStepGroup, isFormStepGroup } from '../models';\n\n/**\n * Builds up an array of FormSteps or FormStepGroups based on what is found in the provided form items. For most typical\n * forms this will mean that a step is generated for every section that is found in the form. It is assumed that all\n * inputs are held within sections and therefore the sections are the steps that should be monitored for completeness.\n * However, in some circumstances, like very short forms, it may be the case that there are no sections and that all\n * the items are set directly on the form itself. In these circumstances the allSteps parameter can be set to true and\n * a step will be produced for each form item found.\n *\n * @param items the items of the form\n * @param allSteps flag indicating that a form step should be produced for every form item\n */\nexport function generateFormSteps(items: Array<FormItem | TemplateItem>, allSteps = false): Array<FormStep | FormStepGroup> {\n  // Build up an array of steps based on the form items\n  return items.reduce((newArray: Array<FormStep | FormStepGroup>, item: FormItem | TemplateItem) => {\n    // The number of non-group steps, used to number the top level steps\n    const count = newArray.filter((step) => !isFormStepGroup(step)).length;\n    if (allSteps) {\n      newArray.push(new FormStep(count + 1, item.name || 'No Title', item.instanceId, !item.required));\n    } else if (isSection(item)) {\n      // If the item is a Section, add a step\n      newArray.push(new FormStep(count + 1, item.title.value || 'No Title', item.instanceId, !item.required));\n    } else if (isDataCubeItem(item)) {\n      // If the item is a DataCubeItem, add a step and add a group step for the sub-sections\n      newArray.push(new FormStep(count + 1, item.title.value || '', item.instanceId, !item.required));\n\n      const subSectionSteps = item.items\n        .filter(isSection)\n        .map((item, index) => new FormStep(`${count + 1}${toLetters(index + 1)}`, item.title.value || '', item.instanceId, !item.required));\n      newArray.push(new FormStepGroup(subSectionSteps, item.instanceId, false, item.name, count + 1));\n    }\n\n    return newArray;\n  }, []);\n}\n\nexport function generateFormStepsFromOutline(outline: OutlineStep[]): Array<FormStep | FormStepGroup> {\n  return outline.reduce((newArray: Array<FormStep | FormStepGroup>, step: OutlineStep) => {\n    // The number of non-group steps, used to number the top level steps\n    const count = newArray.filter((step) => !isFormStepGroup(step)).length;\n    if (step.childSteps && step.childSteps.length > 0) {\n      newArray.push(new FormStep(count + 1, step.label, step.instanceId || step.templateId, step.optional));\n      const subSectionSteps = step.childSteps.map(\n        (item, index) => new FormStep(`${count + 1}${toLetters(index + 1)}`, item.label, item.instanceId || item.templateId, item.optional)\n      );\n      newArray.push(new FormStepGroup(subSectionSteps, step.instanceId || step.templateId, false, step.label, count + 1));\n    } else {\n      newArray.push(new FormStep(count + 1, step.label, step.instanceId || step.templateId, step.optional));\n    }\n    return newArray;\n  }, []);\n}\n\n// model from andrew\nexport interface FormStepData extends OutlineStep {\n  num: string;\n}\n"]}

package/esm2015/lib/utilities/index.js

@@ -1,6 +1,9 @@
+import * as MtnaTemplateDesign from './template-design-util';
+import * as MtnaTemplateCoreDesign from './template-design-core-util';
 import * as MtnaWfSerializer from './serializer-util';
-export { MtnaWfSerializer };
+export { MtnaTemplateDesign, MtnaTemplateCoreDesign, MtnaWfSerializer };
 export * from './animations';
+export * from './design-conditionals-util';
 export * from './find-form-control';
 export * from './find-form-item';
 export * from './flatten-steps';
@@ -9,5 +12,6 @@ export * from './generate-form-steps';
 export * from './get-item-class-suffix';
 export * from './is-form-control';
 export * from './is-form-group';
+export * from './merge-template-util';
 export * from './update-step-status';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvdXRpbGl0aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxnQkFBZ0IsTUFBTSxtQkFBbUIsQ0FBQztBQUV0RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIE10bmFXZlNlcmlhbGl6ZXIgZnJvbSAnLi9zZXJpYWxpemVyLXV0aWwnO1xuXG5leHBvcnQgeyBNdG5hV2ZTZXJpYWxpemVyIH07XG5leHBvcnQgKiBmcm9tICcuL2FuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9maW5kLWZvcm0tY29udHJvbCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbmQtZm9ybS1pdGVtJztcbmV4cG9ydCAqIGZyb20gJy4vZmxhdHRlbi1zdGVwcyc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tc3RlcC51dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vZ2VuZXJhdGUtZm9ybS1zdGVwcyc7XG5leHBvcnQgKiBmcm9tICcuL2dldC1pdGVtLWNsYXNzLXN1ZmZpeCc7XG5leHBvcnQgKiBmcm9tICcuL2lzLWZvcm0tY29udHJvbCc7XG5leHBvcnQgKiBmcm9tICcuL2lzLWZvcm0tZ3JvdXAnO1xuZXhwb3J0ICogZnJvbSAnLi91cGRhdGUtc3RlcC1zdGF0dXMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvdXRpbGl0aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxrQkFBa0IsTUFBTSx3QkFBd0IsQ0FBQztBQUM3RCxPQUFPLEtBQUssc0JBQXNCLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxLQUFLLGdCQUFnQixNQUFNLG1CQUFtQixDQUFDO0FBRXRELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxzQkFBc0IsRUFBRSxnQkFBZ0IsRUFBRSxDQUFDO0FBQ3hFLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIE10bmFUZW1wbGF0ZURlc2lnbiBmcm9tICcuL3RlbXBsYXRlLWRlc2lnbi11dGlsJztcbmltcG9ydCAqIGFzIE10bmFUZW1wbGF0ZUNvcmVEZXNpZ24gZnJvbSAnLi90ZW1wbGF0ZS1kZXNpZ24tY29yZS11dGlsJztcbmltcG9ydCAqIGFzIE10bmFXZlNlcmlhbGl6ZXIgZnJvbSAnLi9zZXJpYWxpemVyLXV0aWwnO1xuXG5leHBvcnQgeyBNdG5hVGVtcGxhdGVEZXNpZ24sIE10bmFUZW1wbGF0ZUNvcmVEZXNpZ24sIE10bmFXZlNlcmlhbGl6ZXIgfTtcbmV4cG9ydCAqIGZyb20gJy4vYW5pbWF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2Rlc2lnbi1jb25kaXRpb25hbHMtdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbmQtZm9ybS1jb250cm9sJztcbmV4cG9ydCAqIGZyb20gJy4vZmluZC1mb3JtLWl0ZW0nO1xuZXhwb3J0ICogZnJvbSAnLi9mbGF0dGVuLXN0ZXBzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1zdGVwLnV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9nZW5lcmF0ZS1mb3JtLXN0ZXBzJztcbmV4cG9ydCAqIGZyb20gJy4vZ2V0LWl0ZW0tY2xhc3Mtc3VmZml4JztcbmV4cG9ydCAqIGZyb20gJy4vaXMtZm9ybS1jb250cm9sJztcbmV4cG9ydCAqIGZyb20gJy4vaXMtZm9ybS1ncm91cCc7XG5leHBvcnQgKiBmcm9tICcuL21lcmdlLXRlbXBsYXRlLXV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi91cGRhdGUtc3RlcC1zdGF0dXMnO1xuIl19

package/esm2015/lib/utilities/merge-template-util.js

@@ -0,0 +1,116 @@
+import { instanceOfBooleanItemTemplate, instanceOfCheckboxItemTemplate, instanceOfDropdownItemTemplate, instanceOfMultipleChoiceItemTemplate, instanceOfTemplateItemGroupImpl, instanceOfTemplateSectionImpl, } from '@mtna/web-form-ts';
+export function mergeFormOptionSelector(source, target) {
+    const mergedFormOptionSelector = Object.assign(Object.assign(Object.assign({}, target), source), { disabledItems: source.disabledItems, enabledItems: source.enabledItems, option: Object.assign(Object.assign({}, target.option), source.option) });
+    return mergedFormOptionSelector;
+}
+export function mergeOptionTemplateMap(source, target) {
+    const mergedOptionTemplateMap = Object.assign({}, target);
+    for (const key of Object.keys(source)) {
+        if (mergedOptionTemplateMap[key]) {
+            mergedOptionTemplateMap[key] = mergeTemplateItem(source[key], mergedOptionTemplateMap[key]);
+        }
+        else {
+            mergedOptionTemplateMap[key] = source[key];
+        }
+    }
+    return mergedOptionTemplateMap;
+}
+export function mergeBooleanItemTemplate(source, target) {
+    // const conditional: Conditional = mergeConditional(source.conditional, target.conditional);
+    const option = mergeFormOptionSelector(source.option, target.option);
+    const optionTemplateMap = mergeOptionTemplateMap(source.optionTemplateMap, target.optionTemplateMap);
+    const mergedBooleanItemTemplate = Object.assign(Object.assign(Object.assign({}, target), source), { codeOption: target.codeOption || source.codeOption, option,
+        optionTemplateMap });
+    return mergedBooleanItemTemplate;
+}
+export function mergeFormOptionSelectors(source, target) {
+    const options = [];
+    for (const option of source) {
+        const targetOption = target.find((t) => t.option.id === option.option.id);
+        if (targetOption) {
+            options.push(mergeFormOptionSelector(option, targetOption));
+        }
+        else {
+            options.push(option);
+        }
+    }
+    return options;
+}
+export function mergeExtendedTemplateOptionGroupItem(source, target) {
+    const options = mergeFormOptionSelectors(source.options, target.options);
+    const optionTemplateMap = mergeOptionTemplateMap(source.optionTemplateMap, target.optionTemplateMap);
+    const mergedExtendedTemplateOptionGroupItem = Object.assign(Object.assign(Object.assign({}, target), source), { codeValueTemplateInline: target.codeValueTemplateInline || source.codeValueTemplateInline, codeValueTemplateMap: target.codeValueTemplateMap || source.codeValueTemplateMap, options,
+        optionTemplateMap });
+    return mergedExtendedTemplateOptionGroupItem;
+}
+export function mergeTemplateItemGroup(source, target) {
+    const layout = source.layout || target.layout;
+    const items = [];
+    for (const sourceItem of source.items) {
+        const targetItem = target.items.find((i) => i.instanceId === sourceItem.instanceId);
+        if (targetItem) {
+            items.push(mergeTemplateItem(sourceItem, targetItem));
+        }
+        else {
+            items.push(sourceItem);
+        }
+    }
+    const mergedTemplateItemGroup = Object.assign(Object.assign(Object.assign({}, target), source), { layout, items });
+    return mergedTemplateItemGroup;
+}
+export function mergeTemplateItemBase(source, target) {
+    const mergedTemplateItemBase = Object.assign(Object.assign({}, target), source);
+    return mergedTemplateItemBase;
+}
+export function mergeTemplateSection(source, target) {
+    const title = mergeTemplateItemBase(source.title, target.title);
+    const items = [];
+    for (const sourceItem of source.items) {
+        const targetItem = target.items.find((i) => i.instanceId === sourceItem.instanceId);
+        if (targetItem) {
+            items.push(mergeTemplateItem(sourceItem, targetItem));
+        }
+        else {
+            items.push(sourceItem);
+        }
+    }
+    const mergedTemplateSection = Object.assign(Object.assign(Object.assign({}, target), source), { title, items });
+    return mergedTemplateSection;
+}
+export function mergeTemplateItem(source, target) {
+    let mergedTemplateItem;
+    if (instanceOfBooleanItemTemplate(source) && instanceOfBooleanItemTemplate(target)) {
+        mergedTemplateItem = mergeBooleanItemTemplate(source, target);
+    }
+    else if ((instanceOfCheckboxItemTemplate(source) && instanceOfCheckboxItemTemplate(target)) ||
+        (instanceOfDropdownItemTemplate(source) && instanceOfDropdownItemTemplate(target)) ||
+        (instanceOfMultipleChoiceItemTemplate(source) && instanceOfMultipleChoiceItemTemplate(target))) {
+        mergedTemplateItem = mergeExtendedTemplateOptionGroupItem(source, target);
+    }
+    else if (instanceOfTemplateItemGroupImpl(source) && instanceOfTemplateItemGroupImpl(target)) {
+        mergedTemplateItem = mergeTemplateItemGroup(source, target);
+    }
+    else if (instanceOfTemplateSectionImpl(source) && instanceOfTemplateSectionImpl(target)) {
+        mergedTemplateItem = mergeTemplateSection(source, target);
+    }
+    else {
+        mergedTemplateItem = Object.assign(Object.assign({}, target), source);
+    }
+    return mergedTemplateItem;
+}
+export function mergeTemplate(source, target) {
+    var _a;
+    const mergedItems = [];
+    for (const item of source.items) {
+        const targetItem = (_a = target.items) === null || _a === void 0 ? void 0 : _a.find((i) => i.instanceId === item.instanceId);
+        if (targetItem) {
+            mergedItems.push(mergeTemplateItem(item, targetItem));
+        }
+        else {
+            mergedItems.push(item);
+        }
+    }
+    const mergedTemplate = Object.assign(Object.assign(Object.assign({}, target), source), { items: mergedItems });
+    return mergedTemplate;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merge-template-util.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/utilities/merge-template-util.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BooleanItemTemplate,\n  BooleanOption,\n  CheckboxItemTemplate,\n  DropdownItemTemplate,\n  FormOptionSelector,\n  instanceOfBooleanItemTemplate,\n  instanceOfCheckboxItemTemplate,\n  instanceOfDropdownItemTemplate,\n  instanceOfMultipleChoiceItemTemplate,\n  instanceOfTemplateItemGroupImpl,\n  instanceOfTemplateSectionImpl,\n  Layout,\n  MultipleChoiceItemTemplate,\n  Option,\n  StringOption,\n  Template,\n  TemplateItem,\n  TemplateItemGroupImpl,\n  TemplateSectionImpl,\n  TitleItemTemplate,\n} from '@mtna/web-form-ts';\n\nexport function mergeFormOptionSelector<O extends Option<unknown>>(\n  source: FormOptionSelector<O>,\n  target: FormOptionSelector<O>\n): FormOptionSelector<O> {\n  const mergedFormOptionSelector: FormOptionSelector<O> = {\n    ...target,\n    ...source,\n    disabledItems: source.disabledItems,\n    enabledItems: source.enabledItems,\n    option: {\n      ...target.option,\n      ...source.option,\n    },\n  };\n  return mergedFormOptionSelector;\n}\n\nexport function mergeOptionTemplateMap(\n  source: Record<string, TemplateItem>,\n  target: Record<string, TemplateItem>\n): Record<string, TemplateItem> {\n  const mergedOptionTemplateMap: Record<string, TemplateItem> = { ...target };\n  for (const key of Object.keys(source)) {\n    if (mergedOptionTemplateMap[key]) {\n      mergedOptionTemplateMap[key] = mergeTemplateItem(source[key], mergedOptionTemplateMap[key]);\n    } else {\n      mergedOptionTemplateMap[key] = source[key];\n    }\n  }\n  return mergedOptionTemplateMap;\n}\n\nexport function mergeBooleanItemTemplate(source: BooleanItemTemplate, target: BooleanItemTemplate) {\n  // const conditional: Conditional = mergeConditional(source.conditional, target.conditional);\n  const option: FormOptionSelector<BooleanOption> = mergeFormOptionSelector<BooleanOption>(source.option, target.option);\n  const optionTemplateMap: Record<string, TemplateItem> = mergeOptionTemplateMap(source.optionTemplateMap, target.optionTemplateMap);\n  const mergedBooleanItemTemplate: BooleanItemTemplate = {\n    ...target,\n    ...source,\n    codeOption: target.codeOption || source.codeOption,\n    option,\n    optionTemplateMap,\n  };\n  return mergedBooleanItemTemplate;\n}\n\nexport function mergeFormOptionSelectors(\n  source: FormOptionSelector<StringOption>[],\n  target: FormOptionSelector<StringOption>[]\n): FormOptionSelector<StringOption>[] {\n  const options: FormOptionSelector<StringOption>[] = [];\n  for (const option of source) {\n    const targetOption = target.find((t) => t.option.id === option.option.id);\n    if (targetOption) {\n      options.push(mergeFormOptionSelector<StringOption>(option, targetOption));\n    } else {\n      options.push(option);\n    }\n  }\n  return options;\n}\n\nexport function mergeExtendedTemplateOptionGroupItem(\n  source: CheckboxItemTemplate | DropdownItemTemplate | MultipleChoiceItemTemplate,\n  target: CheckboxItemTemplate | DropdownItemTemplate | MultipleChoiceItemTemplate\n): CheckboxItemTemplate | DropdownItemTemplate | MultipleChoiceItemTemplate {\n  const options: FormOptionSelector<StringOption>[] = mergeFormOptionSelectors(source.options, target.options);\n  const optionTemplateMap: Record<string, TemplateItem> = mergeOptionTemplateMap(source.optionTemplateMap, target.optionTemplateMap);\n  const mergedExtendedTemplateOptionGroupItem: CheckboxItemTemplate | DropdownItemTemplate | MultipleChoiceItemTemplate = {\n    ...target,\n    ...source,\n    codeValueTemplateInline: target.codeValueTemplateInline || source.codeValueTemplateInline,\n    codeValueTemplateMap: target.codeValueTemplateMap || source.codeValueTemplateMap,\n    options,\n    optionTemplateMap,\n  };\n  return mergedExtendedTemplateOptionGroupItem;\n}\n\nexport function mergeTemplateItemGroup(source: TemplateItemGroupImpl, target: TemplateItemGroupImpl): TemplateItemGroupImpl {\n  const layout: Layout = source.layout || target.layout;\n  const items: TemplateItem[] = [];\n  for (const sourceItem of source.items) {\n    const targetItem = target.items.find((i) => i.instanceId === sourceItem.instanceId);\n    if (targetItem) {\n      items.push(mergeTemplateItem(sourceItem, targetItem));\n    } else {\n      items.push(sourceItem);\n    }\n  }\n  const mergedTemplateItemGroup: TemplateItemGroupImpl = { ...target, ...source, layout, items };\n  return mergedTemplateItemGroup;\n}\n\nexport function mergeTemplateItemBase(source: TemplateItem, target: TemplateItem): TemplateItem {\n  const mergedTemplateItemBase: TemplateItem = { ...target, ...source };\n  return mergedTemplateItemBase;\n}\n\nexport function mergeTemplateSection(source: TemplateSectionImpl, target: TemplateSectionImpl): TemplateSectionImpl {\n  const title = mergeTemplateItemBase(source.title, target.title) as TitleItemTemplate;\n  const items: TemplateItem[] = [];\n  for (const sourceItem of source.items) {\n    const targetItem = target.items.find((i) => i.instanceId === sourceItem.instanceId);\n    if (targetItem) {\n      items.push(mergeTemplateItem(sourceItem, targetItem));\n    } else {\n      items.push(sourceItem);\n    }\n  }\n  const mergedTemplateSection: TemplateSectionImpl = { ...target, ...source, title, items };\n  return mergedTemplateSection;\n}\n\nexport function mergeTemplateItem(source: TemplateItem, target: TemplateItem): TemplateItem {\n  let mergedTemplateItem: TemplateItem | undefined;\n  if (instanceOfBooleanItemTemplate(source) && instanceOfBooleanItemTemplate(target)) {\n    mergedTemplateItem = mergeBooleanItemTemplate(source, target);\n  } else if (\n    (instanceOfCheckboxItemTemplate(source) && instanceOfCheckboxItemTemplate(target)) ||\n    (instanceOfDropdownItemTemplate(source) && instanceOfDropdownItemTemplate(target)) ||\n    (instanceOfMultipleChoiceItemTemplate(source) && instanceOfMultipleChoiceItemTemplate(target))\n  ) {\n    mergedTemplateItem = mergeExtendedTemplateOptionGroupItem(source, target);\n  } else if (instanceOfTemplateItemGroupImpl(source) && instanceOfTemplateItemGroupImpl(target)) {\n    mergedTemplateItem = mergeTemplateItemGroup(source, target);\n  } else if (instanceOfTemplateSectionImpl(source) && instanceOfTemplateSectionImpl(target)) {\n    mergedTemplateItem = mergeTemplateSection(source, target);\n  } else {\n    mergedTemplateItem = { ...target, ...source };\n  }\n  return mergedTemplateItem;\n}\n\nexport function mergeTemplate(source: Template, target: Template): Template {\n  const mergedItems: TemplateItem[] = [];\n  for (const item of source.items) {\n    const targetItem = target.items?.find((i) => i.instanceId === item.instanceId);\n    if (targetItem) {\n      mergedItems.push(mergeTemplateItem(item, targetItem));\n    } else {\n      mergedItems.push(item);\n    }\n  }\n  const mergedTemplate: Template = { ...target, ...source, items: mergedItems };\n  return mergedTemplate;\n}\n"]}