@alfresco/adf-content-services 8.1.0-15730481703 → 8.1.0-15782677066

package/esm2022/lib/tag/tags-creator/tags-creator-mode.mjs

@@ -0,0 +1,27 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+/**
+ * Available modes for tags creator.
+ * Create mode allows only for creating completely new tags.
+ * Create and Assign mode allows for both - creation of new tags and selection of existing tags.
+ */
+export var TagsCreatorMode;
+(function (TagsCreatorMode) {
+    TagsCreatorMode[TagsCreatorMode["CREATE"] = 0] = "CREATE";
+    TagsCreatorMode[TagsCreatorMode["CREATE_AND_ASSIGN"] = 1] = "CREATE_AND_ASSIGN";
+})(TagsCreatorMode || (TagsCreatorMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFncy1jcmVhdG9yLW1vZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3RhZy90YWdzLWNyZWF0b3IvdGFncy1jcmVhdG9yLW1vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUg7Ozs7R0FJRztBQUNILE1BQU0sQ0FBTixJQUFZLGVBR1g7QUFIRCxXQUFZLGVBQWU7SUFDdkIseURBQU0sQ0FBQTtJQUNOLCtFQUFpQixDQUFBO0FBQ3JCLENBQUMsRUFIVyxlQUFlLEtBQWYsZUFBZSxRQUcxQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLyoqXG4gKiBBdmFpbGFibGUgbW9kZXMgZm9yIHRhZ3MgY3JlYXRvci5cbiAqIENyZWF0ZSBtb2RlIGFsbG93cyBvbmx5IGZvciBjcmVhdGluZyBjb21wbGV0ZWx5IG5ldyB0YWdzLlxuICogQ3JlYXRlIGFuZCBBc3NpZ24gbW9kZSBhbGxvd3MgZm9yIGJvdGggLSBjcmVhdGlvbiBvZiBuZXcgdGFncyBhbmQgc2VsZWN0aW9uIG9mIGV4aXN0aW5nIHRhZ3MuXG4gKi9cbmV4cG9ydCBlbnVtIFRhZ3NDcmVhdG9yTW9kZSB7XG4gICAgQ1JFQVRFLFxuICAgIENSRUFURV9BTkRfQVNTSUdOXG59XG4iXX0=

package/esm2022/lib/tag/tags-creator/tags-creator.component.mjs

@@ -0,0 +1,371 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { DynamicChipListComponent, NotificationService } from '@alfresco/adf-core';
+import { Component, DestroyRef, ElementRef, EventEmitter, HostBinding, inject, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TranslateModule } from '@ngx-translate/core';
+import { EMPTY, forkJoin, Subject, timer } from 'rxjs';
+import { debounce, distinctUntilChanged, finalize, first, map, takeUntil, tap } from 'rxjs/operators';
+import { AutoFocusDirective } from '../../directives';
+import { TagService } from '../services/tag.service';
+import { TagsCreatorMode } from './tags-creator-mode';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tag.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/forms";
+import * as i7 from "@ngx-translate/core";
+import * as i8 from "@angular/material/list";
+import * as i9 from "@angular/material/progress-spinner";
+const DEFAULT_TAGS_SORTING = {
+    orderBy: 'tag',
+    direction: 'asc'
+};
+/**
+ * Allows to create multiple tags. That component contains input and two lists. Top list is all created tags, bottom list is searched tags based on input's value.
+ */
+export class TagsCreatorComponent {
+    /**
+     * Default top list.
+     *
+     * @param tags tags which should be displayed as default tags for top list.
+     */
+    set tags(tags) {
+        this._tags = [...tags];
+        this.tagsToDisplay = this.tags.map((tag) => ({ id: tag, name: tag }));
+        this._initialExistingTags = null;
+        this._existingTags = null;
+        this.loadTags(this.tagNameControl.value);
+        this.tagNameControl.updateValueAndValidity();
+    }
+    get tags() {
+        return this._tags;
+    }
+    /**
+     * Decides if input for tags creation/searching should be visible. When input is hidden then panel of existing tags is hidden as well.
+     *
+     * @param tagNameControlVisible true if input should be visible, false otherwise.
+     */
+    set tagNameControlVisible(tagNameControlVisible) {
+        this._tagNameControlVisible = tagNameControlVisible;
+        if (tagNameControlVisible) {
+            this._existingTagsPanelVisible = true;
+            setTimeout(() => {
+                this.tagNameInputElement?.nativeElement?.scrollIntoView();
+            });
+        }
+        else {
+            this._existingTagsPanelVisible = false;
+            this.clearTagNameInput();
+        }
+        this.existingTagsPanelVisibilityChange.emit(this.existingTagsPanelVisible);
+    }
+    get tagNameControlVisible() {
+        return this._tagNameControlVisible;
+    }
+    constructor(tagService, notificationService) {
+        this.tagService = tagService;
+        this.notificationService = notificationService;
+        /**
+         * False if tags can be removed from top list, true otherwise.
+         */
+        this.disabledTagsRemoving = false;
+        /**
+         * Emitted when bottom list is showing or hiding.
+         */
+        this.existingTagsPanelVisibilityChange = new EventEmitter();
+        /**
+         * Emitted when tags in top list are changed.
+         */
+        this.tagsChange = new EventEmitter();
+        this.tagsToDisplay = [];
+        this.nameErrorMessagesByErrors = new Map([
+            ['duplicatedExistingTag', 'EXISTING_TAG'],
+            ['duplicatedAddedTag', 'ALREADY_ADDED_TAG'],
+            ['emptyTag', 'EMPTY_TAG'],
+            ['specialCharacters', 'SPECIAL_CHARACTERS']
+        ]);
+        this.existingTagsListLimit = 15;
+        this.exactTagSet$ = new Subject();
+        this._tags = [];
+        this._tagNameControl = new FormControl('', [this.validateIfNotAlreadyAdded.bind(this), this.validateEmptyTag, this.validateSpecialCharacters], this.validateIfNotExistingTag.bind(this));
+        this._tagNameControlVisible = false;
+        this._tagNameErrorMessageKey = '';
+        this._spinnerVisible = false;
+        this._typing = false;
+        this._tagsListScrollbarVisible = false;
+        this.cancelExistingTagsLoading$ = new Subject();
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.tagNameControl.valueChanges
+            .pipe(map((name) => name.trim()), distinctUntilChanged((previous, current) => {
+            const valueNotChanged = previous === current;
+            if (valueNotChanged) {
+                this.exactTagSet$.next();
+            }
+            return valueNotChanged;
+        }), tap((name) => {
+            this._typing = true;
+            if (name) {
+                this._spinnerVisible = true;
+                this._existingTagsPanelVisible = true;
+            }
+            this.existingTagsPanelVisibilityChange.emit(this.existingTagsPanelVisible);
+            this.cancelExistingTagsLoading$.next();
+            this._initialExistingTags = null;
+            this._existingTags = null;
+        }), debounce((name) => (name ? timer(300) : EMPTY)), takeUntilDestroyed(this.destroyRef))
+            .subscribe((name) => this.onTagNameControlValueChange(name));
+        this.tagNameControl.statusChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.setTagNameControlErrorMessageKey());
+        this.setTagNameControlErrorMessageKey();
+    }
+    ngOnDestroy() {
+        this.cancelExistingTagsLoading$.next();
+        this.cancelExistingTagsLoading$.complete();
+    }
+    get hostClass() {
+        return this.existingTagsPanelVisible;
+    }
+    get tagNameControl() {
+        return this._tagNameControl;
+    }
+    /*
+     * Returns `true` if tags empty and non editable state, otherwise `false`
+     */
+    get showEmptyTagMessage() {
+        return this.tags?.length === 0 && !this.tagNameControlVisible;
+    }
+    get existingTags() {
+        return this._existingTags;
+    }
+    get tagNameErrorMessageKey() {
+        return this._tagNameErrorMessageKey;
+    }
+    get spinnerVisible() {
+        return this._spinnerVisible;
+    }
+    get typing() {
+        return this._typing;
+    }
+    get tagsListScrollbarVisible() {
+        return this._tagsListScrollbarVisible;
+    }
+    get existingTagsPanelVisible() {
+        return this._existingTagsPanelVisible;
+    }
+    /**
+     * Add tags to top list using value which is set in input. Adding tag is not allowed when value in input is invalid
+     * or if user is still typing what means that validation for input is not called yet.
+     */
+    addTag() {
+        if (!this._typing && !this.tagNameControl.invalid) {
+            this.tags = [...this.tags, this.tagNameControl.value.trim()];
+            this.clearTagNameInput();
+            this.checkScrollbarVisibility();
+            this.tagsChange.emit(this.tags);
+        }
+    }
+    /**
+     * Remove tag from top list. In case that tag was part of search result then that tag is moved to bottom list
+     * (list of existing tags) after removing so user can reselect it again later.
+     *
+     * @param tag tag's name which should be removed from top list.
+     */
+    removeTag(tag) {
+        this.removeTagFromArray(this.tags, tag);
+        this.tags = [...this.tags];
+        this.tagNameControl.updateValueAndValidity();
+        this.updateExistingTagsListOnRemoveFromTagsToConfirm(tag);
+        this.exactTagSet$.next();
+        this.checkScrollbarVisibility();
+        this.tagsChange.emit(this.tags);
+    }
+    /**
+     * Called when user selects any tag from list of existing tags. It moves tag from existing tags list to top list.
+     *
+     * @param selectedTag changes
+     */
+    addExistingTagToTagsToAssign(selectedTag) {
+        if (!this.isOnlyCreateMode()) {
+            this.tags.push(selectedTag.entry.tag);
+            this.removeTagFromArray(this.existingTags, selectedTag);
+            this.tagNameControl.updateValueAndValidity();
+            this.tags = [...this.tags];
+            this.exactTagSet$.next();
+            this.tagsChange.emit(this.tags);
+        }
+    }
+    /**
+     * Checks if component is in Create mode.
+     *
+     * @returns `true` if `Create` mode, `false` otherwise.
+     */
+    isOnlyCreateMode() {
+        return this.mode === TagsCreatorMode.CREATE;
+    }
+    onTagNameControlValueChange(name) {
+        this.tagNameControl.markAsTouched();
+        this.loadTags(name);
+    }
+    loadTags(name) {
+        if (name && !this.tagNameControl.hasError('specialCharacters')) {
+            forkJoin({
+                exactResult: this.tagService.findTagByName(name),
+                searchedResult: this.tagService.searchTags(name, DEFAULT_TAGS_SORTING, false, 0, this.existingTagsListLimit)
+            })
+                .pipe(takeUntil(this.cancelExistingTagsLoading$), finalize(() => (this._typing = false)))
+                .subscribe({
+                next: ({ exactResult, searchedResult }) => {
+                    if (exactResult) {
+                        this.existingExactTag = exactResult;
+                        this.removeExactTagFromSearchedResult(searchedResult);
+                        searchedResult.list.entries.unshift(exactResult);
+                    }
+                    else {
+                        this.existingExactTag = null;
+                    }
+                    this._initialExistingTags = searchedResult.list.entries;
+                    this.excludeAlreadyAddedTags(this._initialExistingTags);
+                    this.exactTagSet$.next();
+                    this._spinnerVisible = false;
+                },
+                error: () => {
+                    this.notificationService.showError('TAG.TAGS_CREATOR.ERRORS.FETCH_TAGS');
+                    this._spinnerVisible = false;
+                }
+            });
+        }
+        else {
+            this.existingExactTag = null;
+            this._spinnerVisible = false;
+        }
+    }
+    removeExactTagFromSearchedResult(searchedResult) {
+        const exactTagIndex = searchedResult.list.entries.findIndex((row) => this.compareTags(row.entry.tag, this.existingExactTag.entry.tag));
+        if (exactTagIndex > -1) {
+            searchedResult.list.entries.splice(exactTagIndex, 1);
+        }
+    }
+    validateIfNotExistingTag(tagNameControl) {
+        return this.exactTagSet$.pipe(map(() => this.compareTags(tagNameControl.value, this.existingExactTag?.entry?.tag) ? { duplicatedExistingTag: true } : null), first());
+    }
+    validateIfNotAlreadyAdded(tagNameControl) {
+        return this.tags.some((tag) => this.compareTags(tag, tagNameControl.value)) ? { duplicatedAddedTag: true } : null;
+    }
+    compareTags(tagName1, tagName2) {
+        return tagName1?.trim().toUpperCase() === tagName2?.trim().toUpperCase();
+    }
+    validateEmptyTag(tagNameControl) {
+        return tagNameControl.value.length && !tagNameControl.value.trim() ? { emptyTag: true } : null;
+    }
+    validateSpecialCharacters(tagNameControl) {
+        const specialSymbolsRegex = /[{}()^':"\\|<>/?.*]/;
+        return tagNameControl.value.length && specialSymbolsRegex.test(tagNameControl.value) ? { specialCharacters: true } : null;
+    }
+    setTagNameControlErrorMessageKey() {
+        this._tagNameErrorMessageKey = this.tagNameControl.invalid
+            ? `TAG.TAGS_CREATOR.ERRORS.${this.nameErrorMessagesByErrors.get(Object.keys(this.tagNameControl.errors)[0])}`
+            : '';
+    }
+    checkScrollbarVisibility() {
+        setTimeout(() => {
+            this._tagsListScrollbarVisible = this.tagsListElement.nativeElement.scrollHeight > this.tagsListElement.nativeElement.clientHeight;
+        });
+    }
+    removeTagFromArray(tags, tag) {
+        tags.splice(tags.indexOf(tag), 1);
+    }
+    updateExistingTagsListOnRemoveFromTagsToConfirm(tag) {
+        const entryForTagAddedToExistingTags = this._initialExistingTags?.find((tagEntry) => tagEntry.entry.tag === tag);
+        if (entryForTagAddedToExistingTags) {
+            this.existingTags.unshift(entryForTagAddedToExistingTags);
+            if (this.existingExactTag) {
+                if (tag !== this.existingExactTag.entry.tag) {
+                    this.removeTagFromArray(this.existingTags, this.existingExactTag);
+                    this.sortExistingTags();
+                    this.existingTags.unshift(this.existingExactTag);
+                }
+            }
+            else {
+                this.sortExistingTags();
+            }
+            this.exactTagSet$.next();
+        }
+    }
+    sortExistingTags() {
+        this.existingTags.sort((tagEntry1, tagEntry2) => tagEntry1.entry.tag.localeCompare(tagEntry2.entry.tag));
+    }
+    excludeAlreadyAddedTags(tags) {
+        this._existingTags = tags.filter((tag) => !this.tags.includes(tag.entry.tag));
+    }
+    clearTagNameInput() {
+        this.tagNameControl.setValue('');
+        this.tagNameControl.markAsUntouched();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagsCreatorComponent, deps: [{ token: i1.TagService }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TagsCreatorComponent, isStandalone: true, selector: "adf-tags-creator", inputs: { mode: "mode", disabledTagsRemoving: "disabledTagsRemoving", tags: "tags", tagNameControlVisible: "tagNameControlVisible" }, outputs: { existingTagsPanelVisibilityChange: "existingTagsPanelVisibilityChange", tagsChange: "tagsChange" }, host: { properties: { "class.adf-creator-with-existing-tags-panel": "this.hostClass" } }, viewQueries: [{ propertyName: "tagsListElement", first: true, predicate: ["tagsList"], descendants: true }, { propertyName: "tagNameInputElement", first: true, predicate: ["tagNameInput"], descendants: true }], ngImport: i0, template: "<div class=\"adf-tags-creation\">\n    <div *ngIf=\"tagNameControlVisible\" class=\"adf-tag-name-field\">\n        <input\n            #tagNameInput\n            class=\"adf-tag-search-field\"\n            matInput\n            autocomplete=\"off\"\n            [formControl]=\"tagNameControl\"\n            (keyup.enter)=\"addTag()\"\n            adf-auto-focus\n            placeholder=\"{{ 'TAG.TAGS_CREATOR.TAG_SEARCH_PLACEHOLDER' | translate }}\"\n        />\n        <mat-error *ngIf=\"tagNameControl.invalid && tagNameControl.touched\">\n            {{ tagNameErrorMessageKey | translate }}\n        </mat-error>\n    </div>\n    <p class=\"adf-no-tags-message\" *ngIf=\"showEmptyTagMessage\">\n        {{ 'TAG.TAGS_CREATOR.NO_TAGS_CREATED' | translate }}\n    </p>\n    <div class=\"adf-tags-list\" [class.adf-tags-list-fixed]=\"!tagNameControlVisible\" #tagsList>\n        <ng-container *ngIf=\"tags?.length > 0\">\n            <adf-dynamic-chip-list\n                class=\"adf-tags-chips-container\"\n                [chips]=\"tagsToDisplay\"\n                [disableDelete]=\"disabledTagsRemoving\"\n                (removedChip)=\"removeTag($event)\" />\n        </ng-container>\n    </div>\n</div>\n<div class=\"adf-existing-tags-panel\" *ngIf=\"existingTagsPanelVisible\">\n    <span\n        *ngIf=\"!spinnerVisible || existingTags\"\n        class=\"adf-create-tag-label\"\n        (click)=\"addTag()\"\n        role=\"button\"\n        tabindex=\"0\"\n        (keyup.enter)=\"addTag()\"\n        [hidden]=\"!tagNameControl.value || tagNameControl.invalid || typing\"\n    >\n        {{ 'TAG.TAGS_CREATOR.CREATE_TAG' | translate : { tag: tagNameControl.value } }}\n    </span>\n    <p *ngIf=\"!spinnerVisible && existingTags\" class=\"adf-existing-tags-label\">\n        {{ (isOnlyCreateMode() ? 'TAG.TAGS_CREATOR.EXISTING_TAGS' : 'TAG.TAGS_CREATOR.EXISTING_TAGS_SELECTION') | translate }}\n    </p>\n    <div class=\"adf-tags-list\">\n        <mat-list *ngIf=\"!spinnerVisible && existingTags\" [disabled]=\"isOnlyCreateMode()\">\n            <mat-list-item *ngFor=\"let tagRow of existingTags\" class=\"adf-tag\"\n                           (click)=\"addExistingTagToTagsToAssign(tagRow)\">\n                {{ tagRow.entry.tag }}\n            </mat-list-item>\n            <p *ngIf=\"!existingTags?.length\">{{ 'TAG.TAGS_CREATOR.NO_EXISTING_TAGS' | translate }}</p>\n        </mat-list>\n        <mat-spinner\n            *ngIf=\"spinnerVisible\"\n            class=\"adf-tags-creator-spinner\"\n            [diameter]=\"50\"\n            [attr.aria-label]=\"'TAG.TAGS_CREATOR.TAGS_LOADING' | translate\"\n        />\n    </div>\n</div>\n", styles: ["adf-tags-creator{display:block}adf-tags-creator .adf-no-tags-message{margin-top:28.5px;margin-bottom:0;height:30px}adf-tags-creator .adf-tag-name-field,adf-tags-creator .adf-tag-name-field[hidden]{display:flex;flex-direction:column;margin-right:12px}adf-tags-creator .adf-tag-search-field{background:var(--adf-metadata-buttons-background-color);border-radius:12px;padding:5px 6px;border:none;outline:none;font:inherit;color:currentcolor;margin:0;vertical-align:bottom;text-align:inherit;box-sizing:content-box}adf-tags-creator .adf-create-tag-label{color:var(--theme-primary-color);cursor:pointer;margin-top:-1px;padding-left:12px;overflow-wrap:anywhere;display:inline-block;padding-right:12px;overflow:auto}adf-tags-creator .adf-tags-list{margin-top:8px}adf-tags-creator .adf-tags-chip{height:auto}adf-tags-creator .adf-existing-tags-panel{border-top-left-radius:6px;border-top-right-radius:6px;width:100%}adf-tags-creator .adf-existing-tags-panel .adf-existing-tags-label{font-size:10px;color:var(--theme-secondary-text-color);padding-left:12px;margin-bottom:2px}adf-tags-creator .adf-existing-tags-panel .adf-tags-list{padding-left:12px;margin-top:-2px;padding-right:0;display:flex;flex-direction:column}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag{margin:0;padding:4px;font-size:14px;height:auto;width:unset;background-color:inherit;color:inherit}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag:not(.mdc-list-item--disabled):hover{cursor:pointer;background:var(--adf-theme-mat-grey-color-a200)}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag span{padding:0}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tags-creator-spinner{margin:auto;overflow:unset;min-height:62px}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .mdc-list-item--disabled .mdc-list-item__primary-text{opacity:1}adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mdc-evolution-chip__cell--primary,adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mdc-evolution-chip__action--primary,adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mat-mdc-chip-action-label{overflow:hidden;word-break:break-all}adf-tags-creator [hidden]{visibility:hidden;display:none}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i4.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i5.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i6.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: AutoFocusDirective, selector: "[adf-auto-focus]" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatChipsModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "ngmodule", type: MatIconModule }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i8.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i8.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i9.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "component", type: DynamicChipListComponent, selector: "adf-dynamic-chip-list", inputs: ["pagination", "chips", "showDelete", "disableDelete", "limitChipsDisplayed", "roundUpChips"], outputs: ["displayNext", "removedChip"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TagsCreatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tags-creator', standalone: true, imports: [
+                        CommonModule,
+                        MatInputModule,
+                        ReactiveFormsModule,
+                        AutoFocusDirective,
+                        TranslateModule,
+                        MatChipsModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatListModule,
+                        MatProgressSpinnerModule,
+                        DynamicChipListComponent
+                    ], encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-tags-creation\">\n    <div *ngIf=\"tagNameControlVisible\" class=\"adf-tag-name-field\">\n        <input\n            #tagNameInput\n            class=\"adf-tag-search-field\"\n            matInput\n            autocomplete=\"off\"\n            [formControl]=\"tagNameControl\"\n            (keyup.enter)=\"addTag()\"\n            adf-auto-focus\n            placeholder=\"{{ 'TAG.TAGS_CREATOR.TAG_SEARCH_PLACEHOLDER' | translate }}\"\n        />\n        <mat-error *ngIf=\"tagNameControl.invalid && tagNameControl.touched\">\n            {{ tagNameErrorMessageKey | translate }}\n        </mat-error>\n    </div>\n    <p class=\"adf-no-tags-message\" *ngIf=\"showEmptyTagMessage\">\n        {{ 'TAG.TAGS_CREATOR.NO_TAGS_CREATED' | translate }}\n    </p>\n    <div class=\"adf-tags-list\" [class.adf-tags-list-fixed]=\"!tagNameControlVisible\" #tagsList>\n        <ng-container *ngIf=\"tags?.length > 0\">\n            <adf-dynamic-chip-list\n                class=\"adf-tags-chips-container\"\n                [chips]=\"tagsToDisplay\"\n                [disableDelete]=\"disabledTagsRemoving\"\n                (removedChip)=\"removeTag($event)\" />\n        </ng-container>\n    </div>\n</div>\n<div class=\"adf-existing-tags-panel\" *ngIf=\"existingTagsPanelVisible\">\n    <span\n        *ngIf=\"!spinnerVisible || existingTags\"\n        class=\"adf-create-tag-label\"\n        (click)=\"addTag()\"\n        role=\"button\"\n        tabindex=\"0\"\n        (keyup.enter)=\"addTag()\"\n        [hidden]=\"!tagNameControl.value || tagNameControl.invalid || typing\"\n    >\n        {{ 'TAG.TAGS_CREATOR.CREATE_TAG' | translate : { tag: tagNameControl.value } }}\n    </span>\n    <p *ngIf=\"!spinnerVisible && existingTags\" class=\"adf-existing-tags-label\">\n        {{ (isOnlyCreateMode() ? 'TAG.TAGS_CREATOR.EXISTING_TAGS' : 'TAG.TAGS_CREATOR.EXISTING_TAGS_SELECTION') | translate }}\n    </p>\n    <div class=\"adf-tags-list\">\n        <mat-list *ngIf=\"!spinnerVisible && existingTags\" [disabled]=\"isOnlyCreateMode()\">\n            <mat-list-item *ngFor=\"let tagRow of existingTags\" class=\"adf-tag\"\n                           (click)=\"addExistingTagToTagsToAssign(tagRow)\">\n                {{ tagRow.entry.tag }}\n            </mat-list-item>\n            <p *ngIf=\"!existingTags?.length\">{{ 'TAG.TAGS_CREATOR.NO_EXISTING_TAGS' | translate }}</p>\n        </mat-list>\n        <mat-spinner\n            *ngIf=\"spinnerVisible\"\n            class=\"adf-tags-creator-spinner\"\n            [diameter]=\"50\"\n            [attr.aria-label]=\"'TAG.TAGS_CREATOR.TAGS_LOADING' | translate\"\n        />\n    </div>\n</div>\n", styles: ["adf-tags-creator{display:block}adf-tags-creator .adf-no-tags-message{margin-top:28.5px;margin-bottom:0;height:30px}adf-tags-creator .adf-tag-name-field,adf-tags-creator .adf-tag-name-field[hidden]{display:flex;flex-direction:column;margin-right:12px}adf-tags-creator .adf-tag-search-field{background:var(--adf-metadata-buttons-background-color);border-radius:12px;padding:5px 6px;border:none;outline:none;font:inherit;color:currentcolor;margin:0;vertical-align:bottom;text-align:inherit;box-sizing:content-box}adf-tags-creator .adf-create-tag-label{color:var(--theme-primary-color);cursor:pointer;margin-top:-1px;padding-left:12px;overflow-wrap:anywhere;display:inline-block;padding-right:12px;overflow:auto}adf-tags-creator .adf-tags-list{margin-top:8px}adf-tags-creator .adf-tags-chip{height:auto}adf-tags-creator .adf-existing-tags-panel{border-top-left-radius:6px;border-top-right-radius:6px;width:100%}adf-tags-creator .adf-existing-tags-panel .adf-existing-tags-label{font-size:10px;color:var(--theme-secondary-text-color);padding-left:12px;margin-bottom:2px}adf-tags-creator .adf-existing-tags-panel .adf-tags-list{padding-left:12px;margin-top:-2px;padding-right:0;display:flex;flex-direction:column}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag{margin:0;padding:4px;font-size:14px;height:auto;width:unset;background-color:inherit;color:inherit}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag:not(.mdc-list-item--disabled):hover{cursor:pointer;background:var(--adf-theme-mat-grey-color-a200)}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tag span{padding:0}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .adf-tags-creator-spinner{margin:auto;overflow:unset;min-height:62px}adf-tags-creator .adf-existing-tags-panel .adf-tags-list .mdc-list-item--disabled .mdc-list-item__primary-text{opacity:1}adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mdc-evolution-chip__cell--primary,adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mdc-evolution-chip__action--primary,adf-tags-creator .mdc-evolution-chip-set .mat-mdc-standard-chip .mat-mdc-chip-action-label{overflow:hidden;word-break:break-all}adf-tags-creator [hidden]{visibility:hidden;display:none}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TagService }, { type: i2.NotificationService }], propDecorators: { mode: [{
+                type: Input,
+                args: [{ required: true }]
+            }], disabledTagsRemoving: [{
+                type: Input
+            }], tags: [{
+                type: Input
+            }], tagNameControlVisible: [{
+                type: Input
+            }], existingTagsPanelVisibilityChange: [{
+                type: Output
+            }], tagsChange: [{
+                type: Output
+            }], tagsListElement: [{
+                type: ViewChild,
+                args: ['tagsList']
+            }], tagNameInputElement: [{
+                type: ViewChild,
+                args: ['tagNameInput']
+            }], hostClass: [{
+                type: HostBinding,
+                args: ['class.adf-creator-with-existing-tags-panel']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tags-creator.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tag/tags-creator/tags-creator.component.ts","../../../../../../../lib/content-services/src/lib/tag/tags-creator/tags-creator.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 { Chip, DynamicChipListComponent, NotificationService } from '@alfresco/adf-core';\nimport { TagEntry, TagPaging } from '@alfresco/js-api';\nimport {\n    Component,\n    DestroyRef,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormControl, ReactiveFormsModule } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatChipsModule } from '@angular/material/chips';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatListModule } from '@angular/material/list';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { EMPTY, forkJoin, Observable, Subject, timer } from 'rxjs';\nimport { debounce, distinctUntilChanged, finalize, first, map, takeUntil, tap } from 'rxjs/operators';\nimport { AutoFocusDirective } from '../../directives';\nimport { TagService } from '../services/tag.service';\nimport { TagsCreatorMode } from './tags-creator-mode';\n\ninterface TagNameControlErrors {\n    duplicatedExistingTag?: boolean;\n    duplicatedAddedTag?: boolean;\n    emptyTag?: boolean;\n    specialCharacters?: boolean;\n}\n\nconst DEFAULT_TAGS_SORTING = {\n    orderBy: 'tag',\n    direction: 'asc'\n};\n\n/**\n * Allows to create multiple tags. That component contains input and two lists. Top list is all created tags, bottom list is searched tags based on input's value.\n */\n@Component({\n    selector: 'adf-tags-creator',\n    standalone: true,\n    imports: [\n        CommonModule,\n        MatInputModule,\n        ReactiveFormsModule,\n        AutoFocusDirective,\n        TranslateModule,\n        MatChipsModule,\n        MatButtonModule,\n        MatIconModule,\n        MatListModule,\n        MatProgressSpinnerModule,\n        DynamicChipListComponent\n    ],\n    templateUrl: './tags-creator.component.html',\n    styleUrls: ['./tags-creator.component.scss'],\n    encapsulation: ViewEncapsulation.None\n})\nexport class TagsCreatorComponent implements OnInit, OnDestroy {\n    /**\n     * Mode for component.\n     * In Create mode we can't select existing tags, we can only create them.\n     * In Create and Assign mode we can both - create tags and select existing tags.\n     */\n    @Input({ required: true })\n    mode: TagsCreatorMode;\n\n    /**\n     * False if tags can be removed from top list, true otherwise.\n     */\n    @Input()\n    disabledTagsRemoving = false;\n\n    /**\n     * Default top list.\n     *\n     * @param tags tags which should be displayed as default tags for top list.\n     */\n    @Input()\n    set tags(tags: string[]) {\n        this._tags = [...tags];\n        this.tagsToDisplay = this.tags.map((tag) => ({ id: tag, name: tag }));\n        this._initialExistingTags = null;\n        this._existingTags = null;\n        this.loadTags(this.tagNameControl.value);\n        this.tagNameControl.updateValueAndValidity();\n    }\n\n    get tags(): string[] {\n        return this._tags;\n    }\n\n    /**\n     * Decides if input for tags creation/searching should be visible. When input is hidden then panel of existing tags is hidden as well.\n     *\n     * @param tagNameControlVisible true if input should be visible, false otherwise.\n     */\n    @Input()\n    set tagNameControlVisible(tagNameControlVisible: boolean) {\n        this._tagNameControlVisible = tagNameControlVisible;\n        if (tagNameControlVisible) {\n            this._existingTagsPanelVisible = true;\n            setTimeout(() => {\n                this.tagNameInputElement?.nativeElement?.scrollIntoView();\n            });\n        } else {\n            this._existingTagsPanelVisible = false;\n            this.clearTagNameInput();\n        }\n        this.existingTagsPanelVisibilityChange.emit(this.existingTagsPanelVisible);\n    }\n\n    get tagNameControlVisible(): boolean {\n        return this._tagNameControlVisible;\n    }\n\n    /**\n     * Emitted when bottom list is showing or hiding.\n     */\n    @Output()\n    existingTagsPanelVisibilityChange = new EventEmitter<boolean>();\n    /**\n     * Emitted when tags in top list are changed.\n     */\n    @Output()\n    tagsChange = new EventEmitter<string[]>();\n\n    tagsToDisplay: Chip[] = [];\n\n    readonly nameErrorMessagesByErrors = new Map<keyof TagNameControlErrors, string>([\n        ['duplicatedExistingTag', 'EXISTING_TAG'],\n        ['duplicatedAddedTag', 'ALREADY_ADDED_TAG'],\n        ['emptyTag', 'EMPTY_TAG'],\n        ['specialCharacters', 'SPECIAL_CHARACTERS']\n    ]);\n\n    private readonly existingTagsListLimit = 15;\n\n    private exactTagSet$ = new Subject<void>();\n    private _tags: string[] = [];\n    private _tagNameControl = new FormControl<string>(\n        '',\n        [this.validateIfNotAlreadyAdded.bind(this), this.validateEmptyTag, this.validateSpecialCharacters],\n        this.validateIfNotExistingTag.bind(this)\n    );\n    private _tagNameControlVisible = false;\n    private _existingTags: TagEntry[];\n    private _initialExistingTags: TagEntry[];\n    private _tagNameErrorMessageKey = '';\n    private _spinnerVisible = false;\n    private _typing = false;\n    private _tagsListScrollbarVisible = false;\n    private cancelExistingTagsLoading$ = new Subject<void>();\n    private existingExactTag: TagEntry;\n    private _existingTagsPanelVisible: boolean;\n\n    @ViewChild('tagsList')\n    private tagsListElement: ElementRef;\n    @ViewChild('tagNameInput')\n    private tagNameInputElement: ElementRef;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    constructor(private tagService: TagService, private notificationService: NotificationService) {}\n\n    ngOnInit(): void {\n        this.tagNameControl.valueChanges\n            .pipe(\n                map((name: string) => name.trim()),\n                distinctUntilChanged((previous, current) => {\n                    const valueNotChanged = previous === current;\n                    if (valueNotChanged) {\n                        this.exactTagSet$.next();\n                    }\n                    return valueNotChanged;\n                }),\n                tap((name: string) => {\n                    this._typing = true;\n                    if (name) {\n                        this._spinnerVisible = true;\n                        this._existingTagsPanelVisible = true;\n                    }\n                    this.existingTagsPanelVisibilityChange.emit(this.existingTagsPanelVisible);\n                    this.cancelExistingTagsLoading$.next();\n                    this._initialExistingTags = null;\n                    this._existingTags = null;\n                }),\n                debounce((name: string) => (name ? timer(300) : EMPTY)),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((name: string) => this.onTagNameControlValueChange(name));\n\n        this.tagNameControl.statusChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.setTagNameControlErrorMessageKey());\n\n        this.setTagNameControlErrorMessageKey();\n    }\n\n    ngOnDestroy(): void {\n        this.cancelExistingTagsLoading$.next();\n        this.cancelExistingTagsLoading$.complete();\n    }\n\n    @HostBinding('class.adf-creator-with-existing-tags-panel')\n    get hostClass(): boolean {\n        return this.existingTagsPanelVisible;\n    }\n\n    get tagNameControl(): FormControl<string> {\n        return this._tagNameControl;\n    }\n\n    /*\n     * Returns `true` if tags empty and non editable state, otherwise `false`\n     */\n    get showEmptyTagMessage(): boolean {\n        return this.tags?.length === 0 && !this.tagNameControlVisible;\n    }\n\n    get existingTags(): TagEntry[] {\n        return this._existingTags;\n    }\n\n    get tagNameErrorMessageKey(): string {\n        return this._tagNameErrorMessageKey;\n    }\n\n    get spinnerVisible(): boolean {\n        return this._spinnerVisible;\n    }\n\n    get typing(): boolean {\n        return this._typing;\n    }\n\n    get tagsListScrollbarVisible(): boolean {\n        return this._tagsListScrollbarVisible;\n    }\n\n    get existingTagsPanelVisible(): boolean {\n        return this._existingTagsPanelVisible;\n    }\n\n    /**\n     * Add tags to top list using value which is set in input. Adding tag is not allowed when value in input is invalid\n     * or if user is still typing what means that validation for input is not called yet.\n     */\n    addTag(): void {\n        if (!this._typing && !this.tagNameControl.invalid) {\n            this.tags = [...this.tags, this.tagNameControl.value.trim()];\n            this.clearTagNameInput();\n            this.checkScrollbarVisibility();\n            this.tagsChange.emit(this.tags);\n        }\n    }\n\n    /**\n     * Remove tag from top list. In case that tag was part of search result then that tag is moved to bottom list\n     * (list of existing tags) after removing so user can reselect it again later.\n     *\n     * @param tag tag's name which should be removed from top list.\n     */\n    removeTag(tag: string): void {\n        this.removeTagFromArray(this.tags, tag);\n        this.tags = [...this.tags];\n        this.tagNameControl.updateValueAndValidity();\n        this.updateExistingTagsListOnRemoveFromTagsToConfirm(tag);\n        this.exactTagSet$.next();\n        this.checkScrollbarVisibility();\n        this.tagsChange.emit(this.tags);\n    }\n\n    /**\n     * Called when user selects any tag from list of existing tags. It moves tag from existing tags list to top list.\n     *\n     * @param selectedTag changes\n     */\n    addExistingTagToTagsToAssign(selectedTag: TagEntry): void {\n        if (!this.isOnlyCreateMode()) {\n            this.tags.push(selectedTag.entry.tag);\n            this.removeTagFromArray(this.existingTags, selectedTag);\n            this.tagNameControl.updateValueAndValidity();\n            this.tags = [...this.tags];\n            this.exactTagSet$.next();\n            this.tagsChange.emit(this.tags);\n        }\n    }\n\n    /**\n     * Checks if component is in Create mode.\n     *\n     * @returns `true` if `Create` mode, `false` otherwise.\n     */\n    isOnlyCreateMode(): boolean {\n        return this.mode === TagsCreatorMode.CREATE;\n    }\n\n    private onTagNameControlValueChange(name: string): void {\n        this.tagNameControl.markAsTouched();\n        this.loadTags(name);\n    }\n\n    private loadTags(name: string) {\n        if (name && !this.tagNameControl.hasError('specialCharacters')) {\n            forkJoin({\n                exactResult: this.tagService.findTagByName(name),\n                searchedResult: this.tagService.searchTags(name, DEFAULT_TAGS_SORTING, false, 0, this.existingTagsListLimit)\n            })\n                .pipe(\n                    takeUntil(this.cancelExistingTagsLoading$),\n                    finalize(() => (this._typing = false))\n                )\n                .subscribe({\n                    next: ({ exactResult, searchedResult }: { exactResult: TagEntry; searchedResult: TagPaging }) => {\n                        if (exactResult) {\n                            this.existingExactTag = exactResult;\n                            this.removeExactTagFromSearchedResult(searchedResult);\n                            searchedResult.list.entries.unshift(exactResult);\n                        } else {\n                            this.existingExactTag = null;\n                        }\n\n                        this._initialExistingTags = searchedResult.list.entries;\n                        this.excludeAlreadyAddedTags(this._initialExistingTags);\n                        this.exactTagSet$.next();\n                        this._spinnerVisible = false;\n                    },\n                    error: () => {\n                        this.notificationService.showError('TAG.TAGS_CREATOR.ERRORS.FETCH_TAGS');\n                        this._spinnerVisible = false;\n                    }\n                });\n        } else {\n            this.existingExactTag = null;\n            this._spinnerVisible = false;\n        }\n    }\n\n    private removeExactTagFromSearchedResult(searchedResult: TagPaging): void {\n        const exactTagIndex = searchedResult.list.entries.findIndex((row) => this.compareTags(row.entry.tag, this.existingExactTag.entry.tag));\n\n        if (exactTagIndex > -1) {\n            searchedResult.list.entries.splice(exactTagIndex, 1);\n        }\n    }\n\n    private validateIfNotExistingTag(tagNameControl: FormControl<string>): Observable<TagNameControlErrors | null> {\n        return this.exactTagSet$.pipe(\n            map<void, TagNameControlErrors | null>(() =>\n                this.compareTags(tagNameControl.value, this.existingExactTag?.entry?.tag) ? { duplicatedExistingTag: true } : null\n            ),\n            first()\n        );\n    }\n\n    private validateIfNotAlreadyAdded(tagNameControl: FormControl<string>): TagNameControlErrors | null {\n        return this.tags.some((tag) => this.compareTags(tag, tagNameControl.value)) ? { duplicatedAddedTag: true } : null;\n    }\n\n    private compareTags(tagName1?: string, tagName2?: string): boolean {\n        return tagName1?.trim().toUpperCase() === tagName2?.trim().toUpperCase();\n    }\n\n    private validateEmptyTag(tagNameControl: FormControl<string>): TagNameControlErrors | null {\n        return tagNameControl.value.length && !tagNameControl.value.trim() ? { emptyTag: true } : null;\n    }\n\n    private validateSpecialCharacters(tagNameControl: FormControl<string>): TagNameControlErrors | null {\n        const specialSymbolsRegex = /[{}()^':\"\\\\|<>/?.*]/;\n        return tagNameControl.value.length && specialSymbolsRegex.test(tagNameControl.value) ? { specialCharacters: true } : null;\n    }\n\n    private setTagNameControlErrorMessageKey(): void {\n        this._tagNameErrorMessageKey = this.tagNameControl.invalid\n            ? `TAG.TAGS_CREATOR.ERRORS.${this.nameErrorMessagesByErrors.get(\n                  Object.keys(this.tagNameControl.errors)[0] as keyof TagNameControlErrors\n              )}`\n            : '';\n    }\n\n    private checkScrollbarVisibility(): void {\n        setTimeout(() => {\n            this._tagsListScrollbarVisible = this.tagsListElement.nativeElement.scrollHeight > this.tagsListElement.nativeElement.clientHeight;\n        });\n    }\n\n    private removeTagFromArray<T>(tags: T[], tag: T) {\n        tags.splice(tags.indexOf(tag), 1);\n    }\n\n    private updateExistingTagsListOnRemoveFromTagsToConfirm(tag: string) {\n        const entryForTagAddedToExistingTags = this._initialExistingTags?.find((tagEntry) => tagEntry.entry.tag === tag);\n        if (entryForTagAddedToExistingTags) {\n            this.existingTags.unshift(entryForTagAddedToExistingTags);\n            if (this.existingExactTag) {\n                if (tag !== this.existingExactTag.entry.tag) {\n                    this.removeTagFromArray(this.existingTags, this.existingExactTag);\n                    this.sortExistingTags();\n                    this.existingTags.unshift(this.existingExactTag);\n                }\n            } else {\n                this.sortExistingTags();\n            }\n            this.exactTagSet$.next();\n        }\n    }\n\n    private sortExistingTags() {\n        this.existingTags.sort((tagEntry1, tagEntry2) => tagEntry1.entry.tag.localeCompare(tagEntry2.entry.tag));\n    }\n\n    private excludeAlreadyAddedTags(tags: TagEntry[]) {\n        this._existingTags = tags.filter((tag) => !this.tags.includes(tag.entry.tag));\n    }\n\n    private clearTagNameInput() {\n        this.tagNameControl.setValue('');\n        this.tagNameControl.markAsUntouched();\n    }\n}\n","<div class=\"adf-tags-creation\">\n    <div *ngIf=\"tagNameControlVisible\" class=\"adf-tag-name-field\">\n        <input\n            #tagNameInput\n            class=\"adf-tag-search-field\"\n            matInput\n            autocomplete=\"off\"\n            [formControl]=\"tagNameControl\"\n            (keyup.enter)=\"addTag()\"\n            adf-auto-focus\n            placeholder=\"{{ 'TAG.TAGS_CREATOR.TAG_SEARCH_PLACEHOLDER' | translate }}\"\n        />\n        <mat-error *ngIf=\"tagNameControl.invalid && tagNameControl.touched\">\n            {{ tagNameErrorMessageKey | translate }}\n        </mat-error>\n    </div>\n    <p class=\"adf-no-tags-message\" *ngIf=\"showEmptyTagMessage\">\n        {{ 'TAG.TAGS_CREATOR.NO_TAGS_CREATED' | translate }}\n    </p>\n    <div class=\"adf-tags-list\" [class.adf-tags-list-fixed]=\"!tagNameControlVisible\" #tagsList>\n        <ng-container *ngIf=\"tags?.length > 0\">\n            <adf-dynamic-chip-list\n                class=\"adf-tags-chips-container\"\n                [chips]=\"tagsToDisplay\"\n                [disableDelete]=\"disabledTagsRemoving\"\n                (removedChip)=\"removeTag($event)\" />\n        </ng-container>\n    </div>\n</div>\n<div class=\"adf-existing-tags-panel\" *ngIf=\"existingTagsPanelVisible\">\n    <span\n        *ngIf=\"!spinnerVisible || existingTags\"\n        class=\"adf-create-tag-label\"\n        (click)=\"addTag()\"\n        role=\"button\"\n        tabindex=\"0\"\n        (keyup.enter)=\"addTag()\"\n        [hidden]=\"!tagNameControl.value || tagNameControl.invalid || typing\"\n    >\n        {{ 'TAG.TAGS_CREATOR.CREATE_TAG' | translate : { tag: tagNameControl.value } }}\n    </span>\n    <p *ngIf=\"!spinnerVisible && existingTags\" class=\"adf-existing-tags-label\">\n        {{ (isOnlyCreateMode() ? 'TAG.TAGS_CREATOR.EXISTING_TAGS' : 'TAG.TAGS_CREATOR.EXISTING_TAGS_SELECTION') | translate }}\n    </p>\n    <div class=\"adf-tags-list\">\n        <mat-list *ngIf=\"!spinnerVisible && existingTags\" [disabled]=\"isOnlyCreateMode()\">\n            <mat-list-item *ngFor=\"let tagRow of existingTags\" class=\"adf-tag\"\n                           (click)=\"addExistingTagToTagsToAssign(tagRow)\">\n                {{ tagRow.entry.tag }}\n            </mat-list-item>\n            <p *ngIf=\"!existingTags?.length\">{{ 'TAG.TAGS_CREATOR.NO_EXISTING_TAGS' | translate }}</p>\n        </mat-list>\n        <mat-spinner\n            *ngIf=\"spinnerVisible\"\n            class=\"adf-tags-creator-spinner\"\n            [diameter]=\"50\"\n            [attr.aria-label]=\"'TAG.TAGS_CREATOR.TAGS_LOADING' | translate\"\n        />\n    </div>\n</div>\n"]}

package/esm2022/lib/testing/content.testing.module.mjs

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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, APP_INITIALIZER } from '@angular/core';
+import { NoopAnimationsModule } from '@angular/platform-browser/animations';
+import { CoreModule, NoopTranslateModule, NoopAuthModule } from '@alfresco/adf-core';
+import { ContentModule } from '../content.module';
+import { versionCompatibilityFactory } from '../version-compatibility/version-compatibility-factory';
+import { AlfrescoApiService } from '../services/alfresco-api.service';
+import { VersionCompatibilityService } from '../version-compatibility/version-compatibility.service';
+import { MatIconTestingModule } from '@angular/material/icon/testing';
+import { AlfrescoApiServiceMock } from '../mock';
+import * as i0 from "@angular/core";
+export class ContentTestingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ContentTestingModule, imports: [NoopAnimationsModule, CoreModule, NoopAuthModule, NoopTranslateModule, ContentModule, MatIconTestingModule], exports: [NoopAnimationsModule, CoreModule, ContentModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTestingModule, providers: [
+            { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock },
+            {
+                provide: APP_INITIALIZER,
+                useFactory: versionCompatibilityFactory,
+                deps: [VersionCompatibilityService],
+                multi: true
+            }
+        ], imports: [NoopAnimationsModule, CoreModule, NoopAuthModule, NoopTranslateModule, ContentModule, MatIconTestingModule, NoopAnimationsModule, CoreModule, ContentModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [NoopAnimationsModule, CoreModule, NoopAuthModule, NoopTranslateModule, ContentModule, MatIconTestingModule],
+                    providers: [
+                        { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock },
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: versionCompatibilityFactory,
+                            deps: [VersionCompatibilityService],
+                            multi: true
+                        }
+                    ],
+                    exports: [NoopAnimationsModule, CoreModule, ContentModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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