@valtimo/components 10.1.0 → 10.2.1

package/esm2020/lib/components/menu/menu.service.mjs

@@ -23,14 +23,16 @@ import * as i2 from "@valtimo/document";
 import * as i3 from "@valtimo/security";
 import * as i4 from "ngx-logger";
 import * as i5 from "@angular/router";
+import * as i6 from "keycloak-angular";
 export class MenuService {
-    constructor(configService, documentService, userProviderService, logger, menuIncludeService, router) {
+    constructor(configService, documentService, userProviderService, logger, menuIncludeService, router, keycloakService) {
         this.configService = configService;
         this.documentService = documentService;
         this.userProviderService = userProviderService;
         this.logger = logger;
         this.menuIncludeService = menuIncludeService;
         this.router = router;
+        this.keycloakService = keycloakService;
         this.includeFunctionObservables = {};
         this._menuItems$ = new BehaviorSubject(undefined);
         this.currentRoute$ = this.router.events.pipe(filter(event => event instanceof NavigationEnd), map(event => event?.url));
@@ -38,6 +40,7 @@ export class MenuService {
         const config = configService?.config;
         this.menuConfig = config?.menu;
         this.disableCaseCount = config?.featureToggles?.disableCaseCount;
+        this.enableObjectManagement = config?.featureToggles?.enableObjectManagement;
     }
     init() {
         this.reload();
@@ -83,9 +86,10 @@ export class MenuService {
         return this._menuItems$.asObservable();
     }
     reload() {
-        return this._menuItems$.next(this.loadMenuItems());
+        const roles = this.keycloakService.getUserRoles(true);
+        return this._menuItems$.next(this.loadMenuItems(roles));
     }
-    loadMenuItems() {
+    loadMenuItems(userRoles) {
         let menuItems = [];
         this.menuConfig.menuItems.forEach((menuItem) => {
             if (menuItem.includeFunction !== undefined) {
@@ -93,7 +97,9 @@ export class MenuService {
                     this.menuIncludeService.getIncludeFunction(menuItem.includeFunction);
             }
             menuItem.show = true;
-            menuItems.push(menuItem);
+            if (userRoles.find(userRole => menuItem.roles.includes(userRole))) {
+                menuItems.push(menuItem);
+            }
         });
         menuItems = this.sortMenuItems(menuItems);
         this.appendDossierSubMenuItems(menuItems).subscribe(value => (menuItems = this.applyMenuRoleSecurity(value)));
@@ -174,12 +180,12 @@ export class MenuService {
         return !menuItem.roles || menuItem.roles.some(role => roles.includes(role));
     }
 }
-MenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuService, deps: [{ token: i1.ConfigService }, { token: i2.DocumentService }, { token: i3.UserProviderService }, { token: i4.NGXLogger }, { token: i1.MenuIncludeService }, { token: i5.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+MenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuService, deps: [{ token: i1.ConfigService }, { token: i2.DocumentService }, { token: i3.UserProviderService }, { token: i4.NGXLogger }, { token: i1.MenuIncludeService }, { token: i5.Router }, { token: i6.KeycloakService }], target: i0.ɵɵFactoryTarget.Injectable });
 MenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MenuService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.DocumentService }, { type: i3.UserProviderService }, { type: i4.NGXLogger }, { type: i1.MenuIncludeService }, { type: i5.Router }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.service.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/components/src/lib/components/menu/menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {ConfigService, MenuConfig, MenuIncludeService, MenuItem} from '@valtimo/config';\nimport {NGXLogger} from 'ngx-logger';\nimport {UserProviderService} from '@valtimo/security';\nimport {NavigationEnd, Router} from '@angular/router';\nimport {BehaviorSubject, combineLatest, Observable, Subject, timer} from 'rxjs';\nimport {DocumentDefinitions, DocumentService} from '@valtimo/document';\nimport {filter, map, take} from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MenuService {\n  public includeFunctionObservables: {[key: string]: Observable<boolean>} = {};\n\n  private _menuItems$ = new BehaviorSubject<MenuItem[]>(undefined);\n  private menuConfig: MenuConfig;\n\n  private readonly disableCaseCount!: boolean;\n\n  constructor(\n    private readonly configService: ConfigService,\n    private readonly documentService: DocumentService,\n    private readonly userProviderService: UserProviderService,\n    private readonly logger: NGXLogger,\n    private readonly menuIncludeService: MenuIncludeService,\n    private readonly router: Router\n  ) {\n    const config = configService?.config;\n    this.menuConfig = config?.menu;\n    this.disableCaseCount = config?.featureToggles?.disableCaseCount;\n  }\n\n  init(): void {\n    this.reload();\n    this.logger.debug('Menu initialized');\n  }\n\n  private readonly currentRoute$ = this.router.events.pipe(\n    filter(event => event instanceof NavigationEnd),\n    map(event => (event as NavigationEnd)?.url)\n  );\n\n  private readonly dossierItemsAppended$ = new BehaviorSubject<boolean>(false);\n\n  // Find out which menu item sequence number matches the current url the closest\n  public get closestSequence$(): Observable<string> {\n    return combineLatest([this.dossierItemsAppended$, this.currentRoute$, this.menuItems$]).pipe(\n      filter(([dossierItemsAppended]) => dossierItemsAppended),\n      map(([dossierItemsAppended, currentRoute, menuItems]) => {\n        let closestSequence = '0';\n        let highestDifference = 0;\n\n        // recursive function to check how closely each item matches to the current url\n        const checkItemMatch = (stringUrl: string, sequence: string): void => {\n          // length of the current full url\n          const currentRouteUrlLength = currentRoute.length;\n          // length of the current full url with the item's url substracted\n          const currentRouteSubstractLength = currentRoute.replace(stringUrl, '').length;\n          // the amount of characters that could be substracted\n          const difference = currentRouteUrlLength - currentRouteSubstractLength;\n\n          // the larger the amount of characters that could be substracted, the more closely the menu item url matches the current url\n          if (difference > highestDifference) {\n            highestDifference = difference;\n            closestSequence = sequence;\n          }\n        };\n\n        // check how closely each menu item (and child menu item) matches the current url using a recursive function\n        menuItems.forEach(item => {\n          checkItemMatch(item.link?.join('') || '', `${item.sequence}`);\n\n          if (item.children) {\n            item.children.forEach(childItem => {\n              if (Array.isArray(childItem.link)) {\n                checkItemMatch(\n                  Array.isArray(item.link)\n                    ? [...item.link, ...childItem.link].join('')\n                    : childItem.link.join(''),\n                  `${item.sequence}${childItem.sequence}`\n                );\n              }\n            });\n          }\n        });\n\n        // returns the closest sequence number (each menu item has a sequence number)\n\n        return closestSequence;\n      })\n    );\n  }\n\n  public get menuItems$(): Observable<MenuItem[]> {\n    return this._menuItems$.asObservable();\n  }\n\n  public reload(): void {\n    return this._menuItems$.next(this.loadMenuItems());\n  }\n\n  private loadMenuItems(): MenuItem[] {\n    let menuItems: MenuItem[] = [];\n    this.menuConfig.menuItems.forEach((menuItem: MenuItem) => {\n      if (menuItem.includeFunction !== undefined) {\n        this.includeFunctionObservables[menuItem.title] =\n          this.menuIncludeService.getIncludeFunction(menuItem.includeFunction);\n      }\n\n      menuItem.show = true;\n      menuItems.push(menuItem);\n    });\n    menuItems = this.sortMenuItems(menuItems);\n    this.appendDossierSubMenuItems(menuItems).subscribe(\n      value => (menuItems = this.applyMenuRoleSecurity(value))\n    );\n    return menuItems;\n  }\n\n  private sortMenuItems(menuItems: MenuItem[]): MenuItem[] {\n    return menuItems.sort((a, b) => a.sequence - b.sequence);\n  }\n\n  private appendDossierSubMenuItems(menuItems: MenuItem[]): Observable<MenuItem[]> {\n    return new Observable(subscriber => {\n      this.logger.debug('appendDossierSubMenuItems');\n      this.documentService.getAllDefinitions().subscribe(definitions => {\n        combineLatest([\n          ...definitions.content.map(definition =>\n            this.documentService.getCaseSettings(definition?.id?.name)\n          ),\n        ])\n          .pipe(take(1))\n          .subscribe(allCaseSettings => {\n            const openDocumentCountMap =\n              !this.disableCaseCount && this.getOpenDocumentCountMap(definitions);\n\n            const dossierMenuItems: MenuItem[] = definitions.content.map((definition, index) => {\n              const caseSettings = allCaseSettings?.find(\n                setting => setting.name === definition.id.name\n              );\n\n              return {\n                link: ['/dossiers/' + definition.id.name],\n                title: definition.schema.title,\n                iconClass: 'icon mdi mdi-dot-circle',\n                sequence: index,\n                show: true,\n                ...(!this.disableCaseCount &&\n                  caseSettings?.canHaveAssignee && {\n                    count$: openDocumentCountMap.get(definition.id.name),\n                  }),\n              } as MenuItem;\n            });\n            this.logger.debug('found dossierMenuItems', dossierMenuItems);\n            const menuItemIndex = menuItems.findIndex(({title}) => title === 'Dossiers');\n            if (menuItemIndex > 0) {\n              const dossierMenu = menuItems[menuItemIndex];\n              this.logger.debug('updating dossierMenu', dossierMenu);\n              dossierMenu.children = dossierMenuItems;\n              menuItems[menuItemIndex] = dossierMenu;\n            }\n            subscriber.next(menuItems);\n            this.dossierItemsAppended$.next(true);\n            this.logger.debug('appendDossierSubMenuItems finished');\n          });\n      });\n    });\n  }\n\n  private getOpenDocumentCountMap(definitions: DocumentDefinitions): Map<string, Subject<number>> {\n    const countMap = new Map<string, Subject<number>>();\n    definitions.content.forEach(definition =>\n      countMap.set(definition.id.name, new Subject<number>())\n    );\n\n    timer(0, 5000).subscribe(() => {\n      this.documentService.getOpenDocumentCount().subscribe(openDocumentCountList => {\n        openDocumentCountList.forEach(openDocumentCount =>\n          countMap\n            .get(openDocumentCount.documentDefinitionName)\n            .next(openDocumentCount.openDocumentCount)\n        );\n      });\n    });\n    return countMap;\n  }\n\n  private applyMenuRoleSecurity(menuItems: MenuItem[]): MenuItem[] {\n    this.userProviderService.getUserSubject().subscribe(user => {\n      if (user.roles != null) {\n        this.logger.debug('applyMenuRoleSecurity');\n        const userRoles = user.roles;\n        menuItems.forEach((menuItem: MenuItem) => {\n          const access = this.determineRoleAccess(menuItem, userRoles);\n          this.logger.debug('Menu: check role access', menuItem.roles, access);\n          if (menuItem.show !== access) {\n            this.logger.debug('Menu: Change access', menuItem, access);\n            menuItem.show = access;\n          }\n        });\n      }\n    });\n    return menuItems;\n  }\n\n  private determineRoleAccess(menuItem: MenuItem, roles: string[]): boolean {\n    return !menuItem.roles || menuItem.roles.some(role => roles.includes(role));\n  }\n}\n"]}
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.DocumentService }, { type: i3.UserProviderService }, { type: i4.NGXLogger }, { type: i1.MenuIncludeService }, { type: i5.Router }, { type: i6.KeycloakService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.service.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/components/src/lib/components/menu/menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {ConfigService, MenuConfig, MenuIncludeService, MenuItem} from '@valtimo/config';\nimport {NGXLogger} from 'ngx-logger';\nimport {UserProviderService} from '@valtimo/security';\nimport {NavigationEnd, Router} from '@angular/router';\nimport {BehaviorSubject, combineLatest, Observable, Subject, timer} from 'rxjs';\nimport {DocumentDefinitions, DocumentService} from '@valtimo/document';\nimport {filter, map, take} from 'rxjs/operators';\nimport {KeycloakService} from 'keycloak-angular';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MenuService {\n  public includeFunctionObservables: {[key: string]: Observable<boolean>} = {};\n\n  private _menuItems$ = new BehaviorSubject<MenuItem[]>(undefined);\n  private menuConfig: MenuConfig;\n\n  private readonly disableCaseCount!: boolean;\n  private readonly enableObjectManagement!: boolean;\n\n  constructor(\n    private readonly configService: ConfigService,\n    private readonly documentService: DocumentService,\n    private readonly userProviderService: UserProviderService,\n    private readonly logger: NGXLogger,\n    private readonly menuIncludeService: MenuIncludeService,\n    private readonly router: Router,\n    private readonly keycloakService: KeycloakService\n  ) {\n    const config = configService?.config;\n    this.menuConfig = config?.menu;\n    this.disableCaseCount = config?.featureToggles?.disableCaseCount;\n    this.enableObjectManagement = config?.featureToggles?.enableObjectManagement;\n  }\n\n  init(): void {\n    this.reload();\n    this.logger.debug('Menu initialized');\n  }\n\n  private readonly currentRoute$ = this.router.events.pipe(\n    filter(event => event instanceof NavigationEnd),\n    map(event => (event as NavigationEnd)?.url)\n  );\n\n  private readonly dossierItemsAppended$ = new BehaviorSubject<boolean>(false);\n\n  // Find out which menu item sequence number matches the current url the closest\n  public get closestSequence$(): Observable<string> {\n    return combineLatest([this.dossierItemsAppended$, this.currentRoute$, this.menuItems$]).pipe(\n      filter(([dossierItemsAppended]) => dossierItemsAppended),\n      map(([dossierItemsAppended, currentRoute, menuItems]) => {\n        let closestSequence = '0';\n        let highestDifference = 0;\n\n        // recursive function to check how closely each item matches to the current url\n        const checkItemMatch = (stringUrl: string, sequence: string): void => {\n          // length of the current full url\n          const currentRouteUrlLength = currentRoute.length;\n          // length of the current full url with the item's url substracted\n          const currentRouteSubstractLength = currentRoute.replace(stringUrl, '').length;\n          // the amount of characters that could be substracted\n          const difference = currentRouteUrlLength - currentRouteSubstractLength;\n\n          // the larger the amount of characters that could be substracted, the more closely the menu item url matches the current url\n          if (difference > highestDifference) {\n            highestDifference = difference;\n            closestSequence = sequence;\n          }\n        };\n\n        // check how closely each menu item (and child menu item) matches the current url using a recursive function\n        menuItems.forEach(item => {\n          checkItemMatch(item.link?.join('') || '', `${item.sequence}`);\n\n          if (item.children) {\n            item.children.forEach(childItem => {\n              if (Array.isArray(childItem.link)) {\n                checkItemMatch(\n                  Array.isArray(item.link)\n                    ? [...item.link, ...childItem.link].join('')\n                    : childItem.link.join(''),\n                  `${item.sequence}${childItem.sequence}`\n                );\n              }\n            });\n          }\n        });\n\n        // returns the closest sequence number (each menu item has a sequence number)\n\n        return closestSequence;\n      })\n    );\n  }\n\n  public get menuItems$(): Observable<MenuItem[]> {\n    return this._menuItems$.asObservable();\n  }\n\n  public reload(): void {\n    const roles = this.keycloakService.getUserRoles(true);\n    return this._menuItems$.next(this.loadMenuItems(roles));\n  }\n\n  private loadMenuItems(userRoles: Array<string>): MenuItem[] {\n    let menuItems: MenuItem[] = [];\n    this.menuConfig.menuItems.forEach((menuItem: MenuItem) => {\n\n      if (menuItem.includeFunction !== undefined) {\n        this.includeFunctionObservables[menuItem.title] =\n          this.menuIncludeService.getIncludeFunction(menuItem.includeFunction);\n      }\n\n      menuItem.show = true;\n\n      if (userRoles.find(userRole => menuItem.roles.includes(userRole))) {\n        menuItems.push(menuItem);\n      }\n    });\n    menuItems = this.sortMenuItems(menuItems);\n    this.appendDossierSubMenuItems(menuItems).subscribe(\n      value => (menuItems = this.applyMenuRoleSecurity(value))\n    );\n    return menuItems;\n  }\n\n  private sortMenuItems(menuItems: MenuItem[]): MenuItem[] {\n    return menuItems.sort((a, b) => a.sequence - b.sequence);\n  }\n\n  private appendDossierSubMenuItems(menuItems: MenuItem[]): Observable<MenuItem[]> {\n    return new Observable(subscriber => {\n      this.logger.debug('appendDossierSubMenuItems');\n      this.documentService.getAllDefinitions().subscribe(definitions => {\n        combineLatest([\n          ...definitions.content.map(definition =>\n            this.documentService.getCaseSettings(definition?.id?.name)\n          ),\n        ])\n          .pipe(take(1))\n          .subscribe(allCaseSettings => {\n            const openDocumentCountMap =\n              !this.disableCaseCount && this.getOpenDocumentCountMap(definitions);\n\n            const dossierMenuItems: MenuItem[] = definitions.content.map((definition, index) => {\n              const caseSettings = allCaseSettings?.find(\n                setting => setting.name === definition.id.name\n              );\n\n              return {\n                link: ['/dossiers/' + definition.id.name],\n                title: definition.schema.title,\n                iconClass: 'icon mdi mdi-dot-circle',\n                sequence: index,\n                show: true,\n                ...(!this.disableCaseCount &&\n                  caseSettings?.canHaveAssignee && {\n                    count$: openDocumentCountMap.get(definition.id.name),\n                  }),\n              } as MenuItem;\n            });\n            this.logger.debug('found dossierMenuItems', dossierMenuItems);\n            const menuItemIndex = menuItems.findIndex(({title}) => title === 'Dossiers');\n            if (menuItemIndex > 0) {\n              const dossierMenu = menuItems[menuItemIndex];\n              this.logger.debug('updating dossierMenu', dossierMenu);\n              dossierMenu.children = dossierMenuItems;\n              menuItems[menuItemIndex] = dossierMenu;\n            }\n            subscriber.next(menuItems);\n            this.dossierItemsAppended$.next(true);\n            this.logger.debug('appendDossierSubMenuItems finished');\n          });\n      });\n    });\n  }\n\n  private getOpenDocumentCountMap(definitions: DocumentDefinitions): Map<string, Subject<number>> {\n    const countMap = new Map<string, Subject<number>>();\n    definitions.content.forEach(definition =>\n      countMap.set(definition.id.name, new Subject<number>())\n    );\n\n    timer(0, 5000).subscribe(() => {\n      this.documentService.getOpenDocumentCount().subscribe(openDocumentCountList => {\n        openDocumentCountList.forEach(openDocumentCount =>\n          countMap\n            .get(openDocumentCount.documentDefinitionName)\n            .next(openDocumentCount.openDocumentCount)\n        );\n      });\n    });\n    return countMap;\n  }\n\n  private applyMenuRoleSecurity(menuItems: MenuItem[]): MenuItem[] {\n    this.userProviderService.getUserSubject().subscribe(user => {\n      if (user.roles != null) {\n        this.logger.debug('applyMenuRoleSecurity');\n        const userRoles = user.roles;\n        menuItems.forEach((menuItem: MenuItem) => {\n          const access = this.determineRoleAccess(menuItem, userRoles);\n          this.logger.debug('Menu: check role access', menuItem.roles, access);\n          if (menuItem.show !== access) {\n            this.logger.debug('Menu: Change access', menuItem, access);\n            menuItem.show = access;\n          }\n        });\n      }\n    });\n    return menuItems;\n  }\n\n  private determineRoleAccess(menuItem: MenuItem, roles: string[]): boolean {\n    return !menuItem.roles || menuItem.roles.some(role => roles.includes(role));\n  }\n}\n"]}

package/esm2020/lib/components/multi-input/carbon-multi-input.component.mjs

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@valtimo/user-interface";
+import * as i3 from "carbon-components-angular";
+import * as i4 from "@ngx-translate/core";
+export class CarbonMultiInputComponent {
+    constructor() {
+        this.name = '';
+        this.title = '';
+        this.titleTranslationKey = '';
+        this.type = 'value';
+        this.initialAmountOfRows = 1;
+        this.minimumAmountOfRows = 1;
+        this.maxRows = 20;
+        this.addRowText = '';
+        this.addRowTranslationKey = '';
+        this.deleteRowText = '';
+        this.deleteRowTranslationKey = '';
+        this.disabled = false;
+        this.margin = false;
+        this.tooltip = '';
+        this.required = false;
+        this.valueChange = new EventEmitter();
+        this.values$ = new BehaviorSubject([]);
+        this.mappedValues$ = this.values$.pipe(map(values => values
+            .map(value => this.getMappedValue(value))
+            .filter(value => this.type === 'value'
+            ? value
+            : value.value && value.key)));
+        this.addRowEnabled$ = this.values$.pipe(map(values => !!(values.length < this.maxRows)));
+    }
+    ngOnInit() {
+        this.values$.next(this.getInitialRows());
+        this.openValuesSubscription();
+    }
+    ngOnDestroy() {
+        this.valuesSubscription?.unsubscribe();
+    }
+    addRow() {
+        combineLatest([this.values$, this.addRowEnabled$])
+            .pipe(take(1))
+            .subscribe(([values, addRowEnabled]) => {
+            if (addRowEnabled) {
+                this.values$.next([...values, this.getEmptyValue()]);
+            }
+        });
+    }
+    deleteRow(uuid) {
+        this.values$.pipe(take(1)).subscribe(values => {
+            if (values.length > this.minimumAmountOfRows) {
+                this.values$.next(values.filter(value => value.uuid !== uuid));
+            }
+        });
+    }
+    trackByFn(index, value) {
+        return value.uuid;
+    }
+    onValueChange(templateValue, inputValue, change) {
+        this.values$.pipe(take(1)).subscribe(values => {
+            this.values$.next(values.map(stateValue => {
+                if (stateValue.uuid === templateValue.uuid) {
+                    if (change === 'value') {
+                        return { ...stateValue, value: inputValue };
+                    }
+                    else if (change === 'key') {
+                        return { ...stateValue, key: inputValue };
+                    }
+                }
+                return stateValue;
+            }));
+        });
+    }
+    getInitialRows() {
+        const minimumRows = this.minimumAmountOfRows;
+        const initialRows = this.initialAmountOfRows;
+        const amountOfInitalRows = minimumRows > initialRows ? minimumRows : initialRows > 1 ? initialRows : 1;
+        if (!this.defaultValues) {
+            return new Array(amountOfInitalRows).fill(this.getEmptyValue());
+        }
+        else {
+            return this.defaultValues.map(defaultValue => ({ ...defaultValue, uuid: uuidv4() }));
+        }
+    }
+    getEmptyValue() {
+        return {
+            key: '',
+            value: '',
+            uuid: uuidv4(),
+        };
+    }
+    getMappedValue(valueToMap) {
+        if (this.type === 'keyValue') {
+            return { key: valueToMap.key, value: valueToMap.value };
+        }
+        else {
+            return valueToMap.value;
+        }
+    }
+    openValuesSubscription() {
+        this.valuesSubscription = this.mappedValues$.subscribe(values => {
+            this.valueChange.emit(values);
+        });
+    }
+}
+CarbonMultiInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CarbonMultiInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: CarbonMultiInputComponent, selector: "valtimo-carbon-multi-input", inputs: { name: "name", title: "title", titleTranslationKey: "titleTranslationKey", type: "type", initialAmountOfRows: "initialAmountOfRows", minimumAmountOfRows: "minimumAmountOfRows", maxRows: "maxRows", addRowText: "addRowText", addRowTranslationKey: "addRowTranslationKey", deleteRowText: "deleteRowText", deleteRowTranslationKey: "deleteRowTranslationKey", disabled: "disabled", defaultValues: "defaultValues", margin: "margin", tooltip: "tooltip", required: "required" }, outputs: { valueChange: "valueChange" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2020 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"v-multi-input\"\n  [ngClass]=\"{'v-multi-input--margin': margin}\"\n  *ngIf=\"{\n    addRowText:\n      addRowText || addRowTranslationKey\n        ? addRowTranslationKey\n          ? (addRowTranslationKey | translate)\n          : addRowText\n        : ('interface.addRow' | translate),\n    deleteRowText:\n      deleteRowText || deleteRowTranslationKey\n        ? deleteRowTranslationKey\n          ? (deleteRowTranslationKey | translate)\n          : deleteRowText\n        : ('interface.deleteRow' | translate)\n  } as vars\"\n>\n  <v-input-label\n    *ngIf=\"title || titleTranslationKey\"\n    [title]=\"title\"\n    [titleTranslationKey]=\"titleTranslationKey\"\n    [name]=\"name\"\n    [tooltip]=\"tooltip\"\n    [required]=\"required\"\n  >\n  </v-input-label>\n  <div class=\"v-multi-input__rows\">\n    <div\n      class=\"v-multi-input__row\"\n      *ngFor=\"let value of values$ | async as values; trackBy: trackByFn\"\n    >\n      <ng-container *ngIf=\"type === 'value'\">\n        <ng-container *ngTemplateOutlet=\"singleValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <ng-container *ngIf=\"type === 'keyValue'\">\n        <ng-container *ngTemplateOutlet=\"keyValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <button\n        [disabled]=\"values?.length <= this.minimumAmountOfRows || disabled\"\n        ibmButton=\"danger\"\n        size=\"md\"\n        [iconOnly]=\"true\"\n        (click)=\"deleteRow(value.uuid)\"\n        [title]=\"vars.deleteRowText\"\n      >\n        <svg class=\"cds--btn__icon\" ibmIcon=\"trash-can\" size=\"16\"></svg>\n      </button>\n    </div>\n    <div class=\"v-multi-input__add-button\">\n      <button\n        (click)=\"addRow()\"\n        ibmButton=\"primary\"\n        size=\"md\"\n        [disabled]=\"(addRowEnabled$ | async) === false || disabled\"\n      >\n        {{ vars.addRowText }}\n        <svg class=\"cds--btn__icon\" ibmIcon=\"add\" size=\"16\"></svg>\n      </button>\n    </div>\n  </div>\n</div>\n\n<ng-template #singleValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (change)=\"onValueChange(value, $event, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n\n<ng-template #keyValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'key')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.key\"\n    />\n  </div>\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n", styles: [".v-multi-input--margin{margin-block-end:var(--v-input-margin)}.v-multi-input__row{display:flex;flex-direction:row;align-items:center;margin-block-end:var(--v-multi-input-row-spacing-block)}.v-multi-input__input{margin-inline-end:var(--v-multi-input-input-spacing-inline)}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i2.InputLabelComponent, selector: "v-input-label", inputs: ["name", "title", "titleTranslationKey", "tooltip", "required", "largeMargin", "small"] }, { kind: "directive", type: i3.Button, selector: "[ibmButton]", inputs: ["ibmButton", "size", "skeleton", "iconOnly", "isExpressive"] }, { kind: "directive", type: i3.IconDirective, selector: "[ibmIcon]", inputs: ["ibmIcon", "size", "title", "ariaLabel", "ariaLabelledBy", "ariaHidden", "isFocusable"] }, { kind: "directive", type: i3.TextInput, selector: "[ibmText]", inputs: ["theme", "size", "invalid", "warn", "skeleton"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-carbon-multi-input', template: "<!--\n  ~ Copyright 2015-2020 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"v-multi-input\"\n  [ngClass]=\"{'v-multi-input--margin': margin}\"\n  *ngIf=\"{\n    addRowText:\n      addRowText || addRowTranslationKey\n        ? addRowTranslationKey\n          ? (addRowTranslationKey | translate)\n          : addRowText\n        : ('interface.addRow' | translate),\n    deleteRowText:\n      deleteRowText || deleteRowTranslationKey\n        ? deleteRowTranslationKey\n          ? (deleteRowTranslationKey | translate)\n          : deleteRowText\n        : ('interface.deleteRow' | translate)\n  } as vars\"\n>\n  <v-input-label\n    *ngIf=\"title || titleTranslationKey\"\n    [title]=\"title\"\n    [titleTranslationKey]=\"titleTranslationKey\"\n    [name]=\"name\"\n    [tooltip]=\"tooltip\"\n    [required]=\"required\"\n  >\n  </v-input-label>\n  <div class=\"v-multi-input__rows\">\n    <div\n      class=\"v-multi-input__row\"\n      *ngFor=\"let value of values$ | async as values; trackBy: trackByFn\"\n    >\n      <ng-container *ngIf=\"type === 'value'\">\n        <ng-container *ngTemplateOutlet=\"singleValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <ng-container *ngIf=\"type === 'keyValue'\">\n        <ng-container *ngTemplateOutlet=\"keyValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <button\n        [disabled]=\"values?.length <= this.minimumAmountOfRows || disabled\"\n        ibmButton=\"danger\"\n        size=\"md\"\n        [iconOnly]=\"true\"\n        (click)=\"deleteRow(value.uuid)\"\n        [title]=\"vars.deleteRowText\"\n      >\n        <svg class=\"cds--btn__icon\" ibmIcon=\"trash-can\" size=\"16\"></svg>\n      </button>\n    </div>\n    <div class=\"v-multi-input__add-button\">\n      <button\n        (click)=\"addRow()\"\n        ibmButton=\"primary\"\n        size=\"md\"\n        [disabled]=\"(addRowEnabled$ | async) === false || disabled\"\n      >\n        {{ vars.addRowText }}\n        <svg class=\"cds--btn__icon\" ibmIcon=\"add\" size=\"16\"></svg>\n      </button>\n    </div>\n  </div>\n</div>\n\n<ng-template #singleValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (change)=\"onValueChange(value, $event, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n\n<ng-template #keyValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'key')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.key\"\n    />\n  </div>\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n", styles: [".v-multi-input--margin{margin-block-end:var(--v-input-margin)}.v-multi-input__row{display:flex;flex-direction:row;align-items:center;margin-block-end:var(--v-multi-input-row-spacing-block)}.v-multi-input__input{margin-inline-end:var(--v-multi-input-input-spacing-inline)}\n"] }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], titleTranslationKey: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], initialAmountOfRows: [{
+                type: Input
+            }], minimumAmountOfRows: [{
+                type: Input
+            }], maxRows: [{
+                type: Input
+            }], addRowText: [{
+                type: Input
+            }], addRowTranslationKey: [{
+                type: Input
+            }], deleteRowText: [{
+                type: Input
+            }], deleteRowTranslationKey: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], defaultValues: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carbon-multi-input.component.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/components/src/lib/components/multi-input/carbon-multi-input.component.ts","../../../../../../../projects/valtimo/components/src/lib/components/multi-input/carbon-multi-input.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,KAAK,EAAqB,MAAM,EAAC,MAAM,eAAe,CAAC;AAOxF,OAAO,EAAC,eAAe,EAAE,aAAa,EAA2B,MAAM,MAAM,CAAC;AAC9E,OAAO,EAAC,GAAG,EAAE,IAAI,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAC,EAAE,IAAI,MAAM,EAAC,MAAM,MAAM,CAAC;;;;;;AAOlC,MAAM,OAAO,yBAAyB;IALtC;QAMW,SAAI,GAAG,EAAE,CAAC;QACV,UAAK,GAAG,EAAE,CAAC;QACX,wBAAmB,GAAG,EAAE,CAAC;QACzB,SAAI,GAAmB,OAAO,CAAC;QAC/B,wBAAmB,GAAG,CAAC,CAAC;QACxB,wBAAmB,GAAG,CAAC,CAAC;QACxB,YAAO,GAAG,EAAE,CAAC;QACb,eAAU,GAAG,EAAE,CAAC;QAChB,yBAAoB,GAAG,EAAE,CAAC;QAC1B,kBAAa,GAAG,EAAE,CAAC;QACnB,4BAAuB,GAAG,EAAE,CAAC;QAC7B,aAAQ,GAAG,KAAK,CAAC;QAEjB,WAAM,GAAG,KAAK,CAAC;QACf,YAAO,GAAG,EAAE,CAAC;QACb,aAAQ,GAAG,KAAK,CAAC;QAEhB,gBAAW,GAAmC,IAAI,YAAY,EAAE,CAAC;QAElE,YAAO,GAAG,IAAI,eAAe,CAAmB,EAAE,CAAC,CAAC;QACpD,kBAAa,GAAiC,IAAI,CAAC,OAAO,CAAC,IAAI,CACtE,GAAG,CACD,MAAM,CAAC,EAAE,CACP,MAAM;aACH,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;aACxC,MAAM,CAAC,KAAK,CAAC,EAAE,CACd,IAAI,CAAC,IAAI,KAAK,OAAO;YACnB,CAAC,CAAC,KAAK;YACP,CAAC,CAAE,KAA4B,CAAC,KAAK,IAAK,KAA4B,CAAC,GAAG,CACzD,CAC1B,CACF,CAAC;QACO,mBAAc,GAAwB,IAAI,CAAC,OAAO,CAAC,IAAI,CAC9D,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAChD,CAAC;KA0FH;IAtFC,QAAQ;QACN,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAED,WAAW;QACT,IAAI,CAAC,kBAAkB,EAAE,WAAW,EAAE,CAAC;IACzC,CAAC;IAED,MAAM;QACJ,aAAa,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;aAC/C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,SAAS,CAAC,CAAC,CAAC,MAAM,EAAE,aAAa,CAAC,EAAE,EAAE;YACrC,IAAI,aAAa,EAAE;gBACjB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;aACtD;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC5C,IAAI,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,mBAAmB,EAAE;gBAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;aAChE;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAa,EAAE,KAAyB;QAChD,OAAO,KAAK,CAAC,IAAc,CAAC;IAC9B,CAAC;IAED,aAAa,CACX,aAAiC,EACjC,UAAkB,EAClB,MAAuB;QAEvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CACf,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBACtB,IAAI,UAAU,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,EAAE;oBAC1C,IAAI,MAAM,KAAK,OAAO,EAAE;wBACtB,OAAO,EAAC,GAAG,UAAU,EAAE,KAAK,EAAE,UAAU,EAAC,CAAC;qBAC3C;yBAAM,IAAI,MAAM,KAAK,KAAK,EAAE;wBAC3B,OAAO,EAAC,GAAG,UAAU,EAAE,GAAG,EAAE,UAAU,EAAC,CAAC;qBACzC;iBACF;gBACD,OAAO,UAAU,CAAC;YACpB,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,cAAc;QACpB,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAC7C,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAC7C,MAAM,kBAAkB,GACtB,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAE9E,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,OAAO,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;SACjE;aAAM;YACL,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,EAAC,GAAG,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,EAAC,CAAC,CAAC,CAAC;SACpF;IACH,CAAC;IAEO,aAAa;QACnB,OAAO;YACL,GAAG,EAAE,EAAE;YACP,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,MAAM,EAAE;SACf,CAAC;IACJ,CAAC;IAEO,cAAc,CAAC,UAA8B;QACnD,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE;YAC5B,OAAO,EAAC,GAAG,EAAE,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAC,CAAC;SACvD;aAAM;YACL,OAAO,UAAU,CAAC,KAAK,CAAC;SACzB;IACH,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC9D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;;uHA5HU,yBAAyB;2GAAzB,yBAAyB,ykBChCtC,o6GA4GA;4FD5Ea,yBAAyB;kBALrC,SAAS;+BACE,4BAA4B;8BAK7B,IAAI;sBAAZ,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,mBAAmB;sBAA3B,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,mBAAmB;sBAA3B,KAAK;gBACG,mBAAmB;sBAA3B,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,oBAAoB;sBAA5B,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,uBAAuB;sBAA/B,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBAEI,WAAW;sBAApB,MAAM","sourcesContent":["/*\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Component, EventEmitter, Input, OnDestroy, OnInit, Output} from '@angular/core';\nimport {\n  MultiInputKeyValue,\n  MultiInputOutput,\n  MultiInputType,\n  MultiInputValues,\n} from '@valtimo/user-interface';\nimport {BehaviorSubject, combineLatest, Observable, Subscription} from 'rxjs';\nimport {map, take} from 'rxjs/operators';\nimport {v4 as uuidv4} from 'uuid';\n\n@Component({\n  selector: 'valtimo-carbon-multi-input',\n  templateUrl: './carbon-multi-input.component.html',\n  styleUrls: ['./carbon-multi-input.component.scss'],\n})\nexport class CarbonMultiInputComponent implements OnInit, OnDestroy {\n  @Input() name = '';\n  @Input() title = '';\n  @Input() titleTranslationKey = '';\n  @Input() type: MultiInputType = 'value';\n  @Input() initialAmountOfRows = 1;\n  @Input() minimumAmountOfRows = 1;\n  @Input() maxRows = 20;\n  @Input() addRowText = '';\n  @Input() addRowTranslationKey = '';\n  @Input() deleteRowText = '';\n  @Input() deleteRowTranslationKey = '';\n  @Input() disabled = false;\n  @Input() defaultValues!: MultiInputValues;\n  @Input() margin = false;\n  @Input() tooltip = '';\n  @Input() required = false;\n\n  @Output() valueChange: EventEmitter<MultiInputOutput> = new EventEmitter();\n\n  readonly values$ = new BehaviorSubject<MultiInputValues>([]);\n  readonly mappedValues$: Observable<MultiInputOutput> = this.values$.pipe(\n    map(\n      values =>\n        values\n          .map(value => this.getMappedValue(value))\n          .filter(value =>\n            this.type === 'value'\n              ? value\n              : (value as MultiInputKeyValue).value && (value as MultiInputKeyValue).key\n          ) as MultiInputOutput\n    )\n  );\n  readonly addRowEnabled$: Observable<boolean> = this.values$.pipe(\n    map(values => !!(values.length < this.maxRows))\n  );\n\n  private valuesSubscription!: Subscription;\n\n  ngOnInit(): void {\n    this.values$.next(this.getInitialRows());\n    this.openValuesSubscription();\n  }\n\n  ngOnDestroy(): void {\n    this.valuesSubscription?.unsubscribe();\n  }\n\n  addRow(): void {\n    combineLatest([this.values$, this.addRowEnabled$])\n      .pipe(take(1))\n      .subscribe(([values, addRowEnabled]) => {\n        if (addRowEnabled) {\n          this.values$.next([...values, this.getEmptyValue()]);\n        }\n      });\n  }\n\n  deleteRow(uuid: string): void {\n    this.values$.pipe(take(1)).subscribe(values => {\n      if (values.length > this.minimumAmountOfRows) {\n        this.values$.next(values.filter(value => value.uuid !== uuid));\n      }\n    });\n  }\n\n  trackByFn(index: number, value: MultiInputKeyValue): string {\n    return value.uuid as string;\n  }\n\n  onValueChange(\n    templateValue: MultiInputKeyValue,\n    inputValue: string,\n    change: 'key' | 'value'\n  ): void {\n    this.values$.pipe(take(1)).subscribe(values => {\n      this.values$.next(\n        values.map(stateValue => {\n          if (stateValue.uuid === templateValue.uuid) {\n            if (change === 'value') {\n              return {...stateValue, value: inputValue};\n            } else if (change === 'key') {\n              return {...stateValue, key: inputValue};\n            }\n          }\n          return stateValue;\n        })\n      );\n    });\n  }\n\n  private getInitialRows(): MultiInputValues {\n    const minimumRows = this.minimumAmountOfRows;\n    const initialRows = this.initialAmountOfRows;\n    const amountOfInitalRows =\n      minimumRows > initialRows ? minimumRows : initialRows > 1 ? initialRows : 1;\n\n    if (!this.defaultValues) {\n      return new Array(amountOfInitalRows).fill(this.getEmptyValue());\n    } else {\n      return this.defaultValues.map(defaultValue => ({...defaultValue, uuid: uuidv4()}));\n    }\n  }\n\n  private getEmptyValue(): MultiInputKeyValue {\n    return {\n      key: '',\n      value: '',\n      uuid: uuidv4(),\n    };\n  }\n\n  private getMappedValue(valueToMap: MultiInputKeyValue): MultiInputKeyValue | string {\n    if (this.type === 'keyValue') {\n      return {key: valueToMap.key, value: valueToMap.value};\n    } else {\n      return valueToMap.value;\n    }\n  }\n\n  private openValuesSubscription(): void {\n    this.valuesSubscription = this.mappedValues$.subscribe(values => {\n      this.valueChange.emit(values);\n    });\n  }\n}\n","<!--\n  ~ Copyright 2015-2020 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<div\n  class=\"v-multi-input\"\n  [ngClass]=\"{'v-multi-input--margin': margin}\"\n  *ngIf=\"{\n    addRowText:\n      addRowText || addRowTranslationKey\n        ? addRowTranslationKey\n          ? (addRowTranslationKey | translate)\n          : addRowText\n        : ('interface.addRow' | translate),\n    deleteRowText:\n      deleteRowText || deleteRowTranslationKey\n        ? deleteRowTranslationKey\n          ? (deleteRowTranslationKey | translate)\n          : deleteRowText\n        : ('interface.deleteRow' | translate)\n  } as vars\"\n>\n  <v-input-label\n    *ngIf=\"title || titleTranslationKey\"\n    [title]=\"title\"\n    [titleTranslationKey]=\"titleTranslationKey\"\n    [name]=\"name\"\n    [tooltip]=\"tooltip\"\n    [required]=\"required\"\n  >\n  </v-input-label>\n  <div class=\"v-multi-input__rows\">\n    <div\n      class=\"v-multi-input__row\"\n      *ngFor=\"let value of values$ | async as values; trackBy: trackByFn\"\n    >\n      <ng-container *ngIf=\"type === 'value'\">\n        <ng-container *ngTemplateOutlet=\"singleValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <ng-container *ngIf=\"type === 'keyValue'\">\n        <ng-container *ngTemplateOutlet=\"keyValue; context: {value: value}\"></ng-container>\n      </ng-container>\n      <button\n        [disabled]=\"values?.length <= this.minimumAmountOfRows || disabled\"\n        ibmButton=\"danger\"\n        size=\"md\"\n        [iconOnly]=\"true\"\n        (click)=\"deleteRow(value.uuid)\"\n        [title]=\"vars.deleteRowText\"\n      >\n        <svg class=\"cds--btn__icon\" ibmIcon=\"trash-can\" size=\"16\"></svg>\n      </button>\n    </div>\n    <div class=\"v-multi-input__add-button\">\n      <button\n        (click)=\"addRow()\"\n        ibmButton=\"primary\"\n        size=\"md\"\n        [disabled]=\"(addRowEnabled$ | async) === false || disabled\"\n      >\n        {{ vars.addRowText }}\n        <svg class=\"cds--btn__icon\" ibmIcon=\"add\" size=\"16\"></svg>\n      </button>\n    </div>\n  </div>\n</div>\n\n<ng-template #singleValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (change)=\"onValueChange(value, $event, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n\n<ng-template #keyValue let-value=\"value\">\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'key')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.key\"\n    />\n  </div>\n  <div class=\"v-multi-input__input\">\n    <input\n      ibmText\n      (input)=\"onValueChange(value, $event.target.value, 'value')\"\n      [disabled]=\"disabled\"\n      [defaultValue]=\"value.value\"\n    />\n  </div>\n</ng-template>\n"]}

package/esm2020/lib/components/multi-input/carbon-multi-input.module.mjs

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2015-2020 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CarbonMultiInputComponent } from './carbon-multi-input.component';
+import { ButtonModule, InputLabelModule, InputModule } from '@valtimo/user-interface';
+import { TranslateModule } from '@ngx-translate/core';
+import { ButtonModule as CarbonButtonModule, IconModule, InputModule as CarbonInputModule, } from 'carbon-components-angular';
+import * as i0 from "@angular/core";
+export class CarbonMultiInputModule {
+}
+CarbonMultiInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CarbonMultiInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputModule, declarations: [CarbonMultiInputComponent], imports: [CommonModule,
+        InputLabelModule,
+        InputModule,
+        ButtonModule,
+        TranslateModule,
+        CarbonButtonModule,
+        IconModule,
+        CarbonInputModule], exports: [CarbonMultiInputComponent] });
+CarbonMultiInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputModule, imports: [CommonModule,
+        InputLabelModule,
+        InputModule,
+        ButtonModule,
+        TranslateModule,
+        CarbonButtonModule,
+        IconModule,
+        CarbonInputModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CarbonMultiInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CarbonMultiInputComponent],
+                    imports: [
+                        CommonModule,
+                        InputLabelModule,
+                        InputModule,
+                        ButtonModule,
+                        TranslateModule,
+                        CarbonButtonModule,
+                        IconModule,
+                        CarbonInputModule,
+                    ],
+                    exports: [CarbonMultiInputComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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