@alfresco/aca-content 4.0.0-A.2-9984

package/esm2020/lib/components/header/header.component.mjs

@@ -0,0 +1,98 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, ViewEncapsulation, Output, EventEmitter, Input } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Subject } from 'rxjs';
+import { getHeaderColor, getAppName, getLogoPath, getHeaderImagePath, getHeaderTextColor } from '@alfresco/aca-shared/store';
+import { AppExtensionService } from '@alfresco/aca-shared';
+import { takeUntil } from 'rxjs/operators';
+import { AppConfigService } from '@alfresco/adf-core';
+import { isContentServiceEnabled } from '@alfresco/aca-shared/rules';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@alfresco/adf-core";
+import * as i4 from "@angular/common";
+import * as i5 from "../search/search-input/search-input.component";
+export class AppHeaderComponent {
+    constructor(store, appExtensions, appConfigService) {
+        this.store = store;
+        this.appExtensions = appExtensions;
+        this.appConfigService = appConfigService;
+        this.onDestroy$ = new Subject();
+        this.toggleClicked = new EventEmitter();
+        this.expandedSidenav = true;
+        this.data = {};
+        this.actions = [];
+        this.headerColor$ = store.select(getHeaderColor);
+        this.headerTextColor$ = store.select(getHeaderTextColor);
+        this.appName$ = store.select(getAppName);
+        this.logo$ = store.select(getLogoPath);
+        this.landingPage = this.appConfigService.get('landingPage', '/personal-files');
+        store.select(getHeaderImagePath).subscribe((path) => {
+            document.body.style.setProperty('--header-background-image', `url('${path}')`);
+        });
+    }
+    get isSidenavExpanded() {
+        return !this.data.isMenuMinimized ?? this.expandedSidenav;
+    }
+    ngOnInit() {
+        this.appExtensions
+            .getHeaderActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.actions = actions;
+        });
+        this.headerTextColor$.subscribe((color) => {
+            document.documentElement.style.setProperty('--adf-header-text-color', color);
+        });
+    }
+    onToggleSidenav(_event) {
+        this.data.layout.toggleMenu();
+    }
+    isContentServiceEnabled() {
+        return isContentServiceEnabled();
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    trackByActionId(_, action) {
+        return action.id;
+    }
+}
+AppHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderComponent, deps: [{ token: i1.Store }, { token: i2.AppExtensionService }, { token: i3.AppConfigService }], target: i0.ɵɵFactoryTarget.Component });
+AppHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: AppHeaderComponent, selector: "app-header", inputs: { expandedSidenav: "expandedSidenav", data: "data" }, outputs: { toggleClicked: "toggleClicked" }, host: { classAttribute: "app-header" }, ngImport: i0, template: "<adf-layout-header\n  [logo]=\"logo$ | async\"\n  [redirectUrl]=\"landingPage\"\n  [tooltip]=\"appName$ | async\"\n  [color]=\"headerColor$ | async\"\n  [title]=\"appName$ | async\"\n  (clicked)=\"onToggleSidenav($event)\"\n  [expandedSidenav]=\"isSidenavExpanded\"\n>\n  <div class=\"adf-toolbar--spacer adf-toolbar-divider\"></div>\n\n  <aca-search-input *ngIf=\"isContentServiceEnabled()\"></aca-search-input>\n\n  <adf-toolbar-divider></adf-toolbar-divider>\n\n  <ng-container *ngFor=\"let actionRef of actions; trackBy: trackByActionId\">\n    <aca-toolbar-action [actionRef]=\"actionRef\"> </aca-toolbar-action>\n  </ng-container>\n</adf-layout-header>\n", styles: [".app-header{box-shadow:0 3px 5px -1px #00000005,0 6px 10px #00000004,0 1px 18px #00000003;z-index:2}.app-header .mat-toolbar{background-image:var(--header-background-image)!important;background-repeat:no-repeat!important}.app-header .mat-toolbar .aca-current-user{color:var(--theme-foreground-text-color)!important}.app-header .mat-toolbar .adf-toolbar-divider div{background-color:var(--theme-foreground-text-color)!important}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.HeaderLayoutComponent, selector: "adf-layout-header", inputs: ["title", "logo", "redirectUrl", "tooltip", "color", "showSidenavToggle", "expandedSidenav", "position"], outputs: ["clicked"] }, { kind: "component", type: i3.ToolbarDividerComponent, selector: "adf-toolbar-divider" }, { kind: "component", type: i5.SearchInputComponent, selector: "aca-search-input" }, { kind: "component", type: i2.ToolbarActionComponent, selector: "aca-toolbar-action", inputs: ["type", "color", "actionRef"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-header', encapsulation: ViewEncapsulation.None, host: { class: 'app-header' }, template: "<adf-layout-header\n  [logo]=\"logo$ | async\"\n  [redirectUrl]=\"landingPage\"\n  [tooltip]=\"appName$ | async\"\n  [color]=\"headerColor$ | async\"\n  [title]=\"appName$ | async\"\n  (clicked)=\"onToggleSidenav($event)\"\n  [expandedSidenav]=\"isSidenavExpanded\"\n>\n  <div class=\"adf-toolbar--spacer adf-toolbar-divider\"></div>\n\n  <aca-search-input *ngIf=\"isContentServiceEnabled()\"></aca-search-input>\n\n  <adf-toolbar-divider></adf-toolbar-divider>\n\n  <ng-container *ngFor=\"let actionRef of actions; trackBy: trackByActionId\">\n    <aca-toolbar-action [actionRef]=\"actionRef\"> </aca-toolbar-action>\n  </ng-container>\n</adf-layout-header>\n", styles: [".app-header{box-shadow:0 3px 5px -1px #00000005,0 6px 10px #00000004,0 1px 18px #00000003;z-index:2}.app-header .mat-toolbar{background-image:var(--header-background-image)!important;background-repeat:no-repeat!important}.app-header .mat-toolbar .aca-current-user{color:var(--theme-foreground-text-color)!important}.app-header .mat-toolbar .adf-toolbar-divider div{background-color:var(--theme-foreground-text-color)!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppExtensionService }, { type: i3.AppConfigService }]; }, propDecorators: { toggleClicked: [{
+                type: Output
+            }], expandedSidenav: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/components/header/header.component.ts","../../../../../../../projects/aca-content/src/lib/components/header/header.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, ViewEncapsulation, Output, EventEmitter, OnInit, Input, OnDestroy } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { Observable, Subject } from 'rxjs';\nimport { ContentActionRef } from '@alfresco/adf-extensions';\nimport { AppStore, getHeaderColor, getAppName, getLogoPath, getHeaderImagePath, getHeaderTextColor } from '@alfresco/aca-shared/store';\nimport { AppExtensionService } from '@alfresco/aca-shared';\nimport { takeUntil } from 'rxjs/operators';\nimport { AppConfigService, SidenavLayoutComponent } from '@alfresco/adf-core';\nimport { isContentServiceEnabled } from '@alfresco/aca-shared/rules';\n\n@Component({\n  selector: 'app-header',\n  templateUrl: './header.component.html',\n  styleUrls: ['./header.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-header' }\n})\nexport class AppHeaderComponent implements OnInit, OnDestroy {\n  private onDestroy$: Subject<boolean> = new Subject<boolean>();\n\n  @Output()\n  toggleClicked = new EventEmitter();\n\n  @Input() expandedSidenav = true;\n\n  @Input() data: { layout?: SidenavLayoutComponent; isMenuMinimized?: boolean } = {};\n\n  get isSidenavExpanded(): boolean {\n    return !this.data.isMenuMinimized ?? this.expandedSidenav;\n  }\n\n  appName$: Observable<string>;\n  headerColor$: Observable<any>;\n  headerTextColor$: Observable<string>;\n  logo$: Observable<string>;\n  landingPage: string;\n\n  actions: Array<ContentActionRef> = [];\n\n  constructor(public store: Store<AppStore>, private appExtensions: AppExtensionService, private appConfigService: AppConfigService) {\n    this.headerColor$ = store.select(getHeaderColor);\n    this.headerTextColor$ = store.select(getHeaderTextColor);\n    this.appName$ = store.select(getAppName);\n    this.logo$ = store.select(getLogoPath);\n    this.landingPage = this.appConfigService.get('landingPage', '/personal-files');\n\n    store.select(getHeaderImagePath).subscribe((path) => {\n      document.body.style.setProperty('--header-background-image', `url('${path}')`);\n    });\n  }\n\n  ngOnInit() {\n    this.appExtensions\n      .getHeaderActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.actions = actions;\n      });\n\n    this.headerTextColor$.subscribe((color) => {\n      document.documentElement.style.setProperty('--adf-header-text-color', color);\n    });\n  }\n\n  onToggleSidenav(_event: boolean): void {\n    this.data.layout.toggleMenu();\n  }\n\n  isContentServiceEnabled(): boolean {\n    return isContentServiceEnabled();\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  trackByActionId(_: number, action: ContentActionRef) {\n    return action.id;\n  }\n}\n","<adf-layout-header\n  [logo]=\"logo$ | async\"\n  [redirectUrl]=\"landingPage\"\n  [tooltip]=\"appName$ | async\"\n  [color]=\"headerColor$ | async\"\n  [title]=\"appName$ | async\"\n  (clicked)=\"onToggleSidenav($event)\"\n  [expandedSidenav]=\"isSidenavExpanded\"\n>\n  <div class=\"adf-toolbar--spacer adf-toolbar-divider\"></div>\n\n  <aca-search-input *ngIf=\"isContentServiceEnabled()\"></aca-search-input>\n\n  <adf-toolbar-divider></adf-toolbar-divider>\n\n  <ng-container *ngFor=\"let actionRef of actions; trackBy: trackByActionId\">\n    <aca-toolbar-action [actionRef]=\"actionRef\"> </aca-toolbar-action>\n  </ng-container>\n</adf-layout-header>\n"]}

package/esm2020/lib/components/header/header.module.mjs

@@ -0,0 +1,46 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CoreModule } from '@alfresco/adf-core';
+import { AppHeaderComponent } from './header.component';
+import { AppSearchInputModule } from '../search/search-input.module';
+import { AppToolbarModule } from '../toolbar/toolbar.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class AppHeaderModule {
+}
+AppHeaderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppHeaderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderModule, declarations: [AppHeaderComponent], imports: [CommonModule, i1.CoreModule, AppSearchInputModule, AppToolbarModule], exports: [AppHeaderComponent] });
+AppHeaderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderModule, imports: [CommonModule, CoreModule.forChild(), AppSearchInputModule, AppToolbarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppHeaderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, CoreModule.forChild(), AppSearchInputModule, AppToolbarModule],
+                    declarations: [AppHeaderComponent],
+                    exports: [AppHeaderComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/home/home.component.mjs

@@ -0,0 +1,50 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component } from '@angular/core';
+import { Router } from '@angular/router';
+import { AppConfigService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@angular/router";
+export class HomeComponent {
+    constructor(appConfig, router) {
+        this.appConfig = appConfig;
+        this.router = router;
+        this.DEFAULT_LANDING_PAGE = '/personal-files';
+    }
+    ngOnInit() {
+        const landingPage = this.appConfig.get('landingPage', this.DEFAULT_LANDING_PAGE);
+        this.router.navigateByUrl(landingPage);
+    }
+}
+HomeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: HomeComponent, deps: [{ token: i1.AppConfigService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Component });
+HomeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: HomeComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: HomeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AppConfigService }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/info-drawer/comments-tab/comments-tab.component.mjs

@@ -0,0 +1,57 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, Input } from '@angular/core';
+import { MinimalNodeEntryEntity } from '@alfresco/js-api';
+import { NodePermissionService, isLocked } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/aca-shared";
+import * as i2 from "@angular/material/card";
+import * as i3 from "@alfresco/adf-content-services";
+export class CommentsTabComponent {
+    constructor(permission) {
+        this.permission = permission;
+    }
+    get canUpdateNode() {
+        if (!this.node) {
+            return false;
+        }
+        if (this.node.isFolder || (this.node.isFile && !isLocked({ entry: this.node }))) {
+            return this.permission.check(this.node, ['update']);
+        }
+        return false;
+    }
+}
+CommentsTabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: CommentsTabComponent, deps: [{ token: i1.NodePermissionService }], target: i0.ɵɵFactoryTarget.Component });
+CommentsTabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: CommentsTabComponent, selector: "app-comments-tab", inputs: { node: "node" }, ngImport: i0, template: `<mat-card><adf-node-comments [readOnly]="!canUpdateNode" [nodeId]="node?.id"></adf-node-comments></mat-card>`, isInline: true, dependencies: [{ kind: "component", type: i2.MatCard, selector: "mat-card", exportAs: ["matCard"] }, { kind: "component", type: i3.NodeCommentsComponent, selector: "adf-node-comments", inputs: ["nodeId", "readOnly"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: CommentsTabComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-comments-tab',
+                    template: `<mat-card><adf-node-comments [readOnly]="!canUpdateNode" [nodeId]="node?.id"></adf-node-comments></mat-card>`
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NodePermissionService }]; }, propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/info-drawer/info.drawer.module.mjs

@@ -0,0 +1,93 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ContentMetadataModule, ContentModule, VersionManagerModule } from '@alfresco/adf-content-services';
+import { CoreModule } from '@alfresco/adf-core';
+import { ExtensionsModule } from '@alfresco/adf-extensions';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { DirectivesModule } from '../../directives/directives.module';
+import { MaterialModule } from '../../material.module';
+import { CommentsTabComponent } from './comments-tab/comments-tab.component';
+import { MetadataTabComponent } from './metadata-tab/metadata-tab.component';
+import { LibraryMetadataTabComponent } from './library-metadata-tab/library-metadata-tab.component';
+import { LibraryMetadataFormComponent } from './library-metadata-tab/library-metadata-form.component';
+import { VersionsTabComponent } from './versions-tab/versions-tab.component';
+import { A11yModule } from '@angular/cdk/a11y';
+import { SharedInfoDrawerModule } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@alfresco/adf-content-services";
+export class AppInfoDrawerModule {
+}
+AppInfoDrawerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppInfoDrawerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppInfoDrawerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppInfoDrawerModule, declarations: [MetadataTabComponent, CommentsTabComponent, VersionsTabComponent, LibraryMetadataTabComponent, LibraryMetadataFormComponent], imports: [CommonModule,
+        MaterialModule, i1.CoreModule, i2.ContentModule, ExtensionsModule,
+        ContentMetadataModule,
+        VersionManagerModule,
+        DirectivesModule,
+        A11yModule,
+        SharedInfoDrawerModule], exports: [MetadataTabComponent,
+        CommentsTabComponent,
+        VersionsTabComponent,
+        LibraryMetadataTabComponent,
+        LibraryMetadataFormComponent,
+        SharedInfoDrawerModule] });
+AppInfoDrawerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppInfoDrawerModule, imports: [CommonModule,
+        MaterialModule,
+        CoreModule.forChild(),
+        ContentModule.forChild(),
+        ExtensionsModule,
+        ContentMetadataModule,
+        VersionManagerModule,
+        DirectivesModule,
+        A11yModule,
+        SharedInfoDrawerModule, SharedInfoDrawerModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppInfoDrawerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MaterialModule,
+                        CoreModule.forChild(),
+                        ContentModule.forChild(),
+                        ExtensionsModule,
+                        ContentMetadataModule,
+                        VersionManagerModule,
+                        DirectivesModule,
+                        A11yModule,
+                        SharedInfoDrawerModule
+                    ],
+                    declarations: [MetadataTabComponent, CommentsTabComponent, VersionsTabComponent, LibraryMetadataTabComponent, LibraryMetadataFormComponent],
+                    exports: [
+                        MetadataTabComponent,
+                        CommentsTabComponent,
+                        VersionsTabComponent,
+                        LibraryMetadataTabComponent,
+                        LibraryMetadataFormComponent,
+                        SharedInfoDrawerModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/info-drawer/library-metadata-tab/library-metadata-form.component.mjs

@@ -0,0 +1,144 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, Input } from '@angular/core';
+import { UntypedFormGroup, UntypedFormControl, Validators } from '@angular/forms';
+import { QueriesApi, SiteEntry } from '@alfresco/js-api';
+import { Store } from '@ngrx/store';
+import { UpdateLibraryAction } from '@alfresco/aca-shared/store';
+import { debounceTime, mergeMap, takeUntil } from 'rxjs/operators';
+import { AlfrescoApiService } from '@alfresco/adf-core';
+import { from, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/input";
+import * as i7 from "@angular/material/card";
+import * as i8 from "@angular/forms";
+import * as i9 from "@angular/material/core";
+import * as i10 from "@angular/material/select";
+import * as i11 from "@ngx-translate/core";
+export class InstantErrorStateMatcher {
+    isErrorState(control, form) {
+        const isSubmitted = form && form.submitted;
+        return !!(control && control.invalid && (control.dirty || control.touched || isSubmitted));
+    }
+}
+export class LibraryMetadataFormComponent {
+    constructor(alfrescoApiService, store) {
+        this.alfrescoApiService = alfrescoApiService;
+        this.store = store;
+        this.libraryTitleExists = false;
+        this.libraryType = [
+            { value: 'PUBLIC', label: 'LIBRARY.VISIBILITY.PUBLIC' },
+            { value: 'PRIVATE', label: 'LIBRARY.VISIBILITY.PRIVATE' },
+            { value: 'MODERATED', label: 'LIBRARY.VISIBILITY.MODERATED' }
+        ];
+        this.form = new UntypedFormGroup({
+            id: new UntypedFormControl({ value: '', disabled: true }),
+            title: new UntypedFormControl({ value: '' }, [Validators.required, Validators.maxLength(256)]),
+            description: new UntypedFormControl({ value: '' }, [Validators.maxLength(512)]),
+            visibility: new UntypedFormControl(this.libraryType[0].value)
+        });
+        this.matcher = new InstantErrorStateMatcher();
+        this.onDestroy$ = new Subject();
+    }
+    get queriesApi() {
+        this._queriesApi = this._queriesApi ?? new QueriesApi(this.alfrescoApiService.getInstance());
+        return this._queriesApi;
+    }
+    get canUpdateLibrary() {
+        return this.node && this.node.entry && this.node.entry.role === 'SiteManager';
+    }
+    getVisibilityLabel(value) {
+        return this.libraryType.find((type) => type.value === value).label;
+    }
+    toggleEdit() {
+        this.edit = !this.edit;
+    }
+    cancel() {
+        this.updateForm(this.node);
+        this.toggleEdit();
+    }
+    ngOnInit() {
+        this.updateForm(this.node);
+        this.form.controls['title'].valueChanges
+            .pipe(debounceTime(300), mergeMap((title) => this.findLibraryByTitle(title)), takeUntil(this.onDestroy$))
+            .subscribe((result) => {
+            const { entries } = result.list;
+            if (entries.length) {
+                if (this.form.controls.title.value === this.node.entry.title) {
+                    this.libraryTitleExists = false;
+                }
+                else {
+                    this.libraryTitleExists = this.form.controls.title.value === entries[0].entry.title;
+                }
+            }
+            else {
+                this.libraryTitleExists = false;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    ngOnChanges() {
+        this.updateForm(this.node);
+    }
+    update() {
+        if (this.canUpdateLibrary && this.form.valid) {
+            this.store.dispatch(new UpdateLibraryAction(this.form.value));
+        }
+    }
+    updateForm(node) {
+        const { entry } = node;
+        this.form.setValue({
+            id: entry.id,
+            title: entry.title,
+            description: entry.description || '',
+            visibility: entry.visibility
+        });
+    }
+    findLibraryByTitle(libraryTitle) {
+        return from(this.queriesApi
+            .findSites(libraryTitle, {
+            maxItems: 1,
+            fields: ['title']
+        })
+            .catch(() => ({ list: { entries: [] } })));
+    }
+}
+LibraryMetadataFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: LibraryMetadataFormComponent, deps: [{ token: i1.AlfrescoApiService }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Component });
+LibraryMetadataFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: LibraryMetadataFormComponent, selector: "app-library-metadata-form", inputs: { node: "node" }, usesOnChanges: true, ngImport: i0, template: "<mat-card *ngIf=\"node\">\n  <mat-card-content *ngIf=\"!edit\">\n    <div class=\"mat-form-field mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.title.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.id.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ getVisibilityLabel(form.controls.visibility.value) | translate }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.description?.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"!edit && canUpdateLibrary\">\n    <button mat-button color=\"primary\" (click)=\"toggleEdit()\">\n      {{ 'LIBRARY.DIALOG.EDIT' | translate }}\n    </button>\n  </mat-card-actions>\n\n  <mat-card-content *ngIf=\"edit\">\n    <form [formGroup]=\"form\" autocomplete=\"off\">\n      <mat-form-field class=\"adf-full-width\">\n        <input\n          matInput\n          cdkFocusInitial\n          required\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\"\n          formControlName=\"title\"\n          [errorStateMatcher]=\"matcher\"\n        />\n        <mat-hint *ngIf=\"libraryTitleExists\">{{ 'LIBRARY.HINTS.SITE_TITLE_EXISTS' | translate }}</mat-hint>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.TITLE_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <input matInput placeholder=\"{{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\" formControlName=\"id\" />\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <mat-select placeholder=\"{{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\" formControlName=\"visibility\">\n          <mat-option [value]=\"type.value\" *ngFor=\"let type of libraryType\">\n            {{ type.label | translate }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <textarea\n          matInput\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\"\n          rows=\"3\"\n          formControlName=\"description\"\n          [errorStateMatcher]=\"matcher\"\n        ></textarea>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.DESCRIPTION_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n    </form>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"edit && canUpdateLibrary\">\n    <button mat-button (click)=\"cancel()\">\n      {{ 'LIBRARY.DIALOG.CANCEL' | translate }}\n    </button>\n    <button mat-button color=\"primary\" [disabled]=\"form.invalid || form.pristine\" (click)=\"update()\">\n      {{ 'LIBRARY.DIALOG.UPDATE' | translate }}\n    </button>\n  </mat-card-actions>\n</mat-card>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i5.MatError, selector: "mat-error", inputs: ["id"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i6.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: "component", type: i7.MatCard, selector: "mat-card", exportAs: ["matCard"] }, { kind: "directive", type: i7.MatCardContent, selector: "mat-card-content, [mat-card-content], [matCardContent]" }, { kind: "directive", type: i7.MatCardActions, selector: "mat-card-actions", inputs: ["align"], exportAs: ["matCardActions"] }, { kind: "directive", type: i8.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i8.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: i8.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i8.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i8.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i8.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i8.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i9.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "component", type: i10.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { kind: "pipe", type: i11.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: LibraryMetadataFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-library-metadata-form', template: "<mat-card *ngIf=\"node\">\n  <mat-card-content *ngIf=\"!edit\">\n    <div class=\"mat-form-field mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.title.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.id.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ getVisibilityLabel(form.controls.visibility.value) | translate }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.description?.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"!edit && canUpdateLibrary\">\n    <button mat-button color=\"primary\" (click)=\"toggleEdit()\">\n      {{ 'LIBRARY.DIALOG.EDIT' | translate }}\n    </button>\n  </mat-card-actions>\n\n  <mat-card-content *ngIf=\"edit\">\n    <form [formGroup]=\"form\" autocomplete=\"off\">\n      <mat-form-field class=\"adf-full-width\">\n        <input\n          matInput\n          cdkFocusInitial\n          required\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\"\n          formControlName=\"title\"\n          [errorStateMatcher]=\"matcher\"\n        />\n        <mat-hint *ngIf=\"libraryTitleExists\">{{ 'LIBRARY.HINTS.SITE_TITLE_EXISTS' | translate }}</mat-hint>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.TITLE_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <input matInput placeholder=\"{{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\" formControlName=\"id\" />\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <mat-select placeholder=\"{{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\" formControlName=\"visibility\">\n          <mat-option [value]=\"type.value\" *ngFor=\"let type of libraryType\">\n            {{ type.label | translate }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <textarea\n          matInput\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\"\n          rows=\"3\"\n          formControlName=\"description\"\n          [errorStateMatcher]=\"matcher\"\n        ></textarea>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.DESCRIPTION_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n    </form>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"edit && canUpdateLibrary\">\n    <button mat-button (click)=\"cancel()\">\n      {{ 'LIBRARY.DIALOG.CANCEL' | translate }}\n    </button>\n    <button mat-button color=\"primary\" [disabled]=\"form.invalid || form.pristine\" (click)=\"update()\">\n      {{ 'LIBRARY.DIALOG.UPDATE' | translate }}\n    </button>\n  </mat-card-actions>\n</mat-card>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.AlfrescoApiService }, { type: i2.Store }]; }, propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"library-metadata-form.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-content/src/lib/components/info-drawer/library-metadata-tab/library-metadata-form.component.ts","../../../../../../../../projects/aca-content/src/lib/components/info-drawer/library-metadata-tab/library-metadata-form.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, Input, OnInit, OnChanges, OnDestroy } from '@angular/core';\nimport { UntypedFormGroup, UntypedFormControl, Validators, FormGroupDirective, NgForm } from '@angular/forms';\nimport { QueriesApi, SiteEntry, SitePaging } from '@alfresco/js-api';\nimport { Store } from '@ngrx/store';\nimport { AppStore, UpdateLibraryAction } from '@alfresco/aca-shared/store';\nimport { debounceTime, mergeMap, takeUntil } from 'rxjs/operators';\nimport { AlfrescoApiService } from '@alfresco/adf-core';\nimport { Observable, from, Subject } from 'rxjs';\nimport { ErrorStateMatcher } from '@angular/material/core';\n\nexport class InstantErrorStateMatcher implements ErrorStateMatcher {\n  isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean {\n    const isSubmitted = form && form.submitted;\n    return !!(control && control.invalid && (control.dirty || control.touched || isSubmitted));\n  }\n}\n\n@Component({\n  selector: 'app-library-metadata-form',\n  templateUrl: './library-metadata-form.component.html'\n})\nexport class LibraryMetadataFormComponent implements OnInit, OnChanges, OnDestroy {\n  _queriesApi: QueriesApi;\n  get queriesApi(): QueriesApi {\n    this._queriesApi = this._queriesApi ?? new QueriesApi(this.alfrescoApiService.getInstance());\n    return this._queriesApi;\n  }\n\n  @Input()\n  node: SiteEntry;\n\n  edit: boolean;\n  libraryTitleExists = false;\n\n  libraryType = [\n    { value: 'PUBLIC', label: 'LIBRARY.VISIBILITY.PUBLIC' },\n    { value: 'PRIVATE', label: 'LIBRARY.VISIBILITY.PRIVATE' },\n    { value: 'MODERATED', label: 'LIBRARY.VISIBILITY.MODERATED' }\n  ];\n\n  form: UntypedFormGroup = new UntypedFormGroup({\n    id: new UntypedFormControl({ value: '', disabled: true }),\n    title: new UntypedFormControl({ value: '' }, [Validators.required, Validators.maxLength(256)]),\n    description: new UntypedFormControl({ value: '' }, [Validators.maxLength(512)]),\n    visibility: new UntypedFormControl(this.libraryType[0].value)\n  });\n\n  matcher = new InstantErrorStateMatcher();\n\n  onDestroy$: Subject<boolean> = new Subject<boolean>();\n\n  constructor(private alfrescoApiService: AlfrescoApiService, protected store: Store<AppStore>) {}\n\n  get canUpdateLibrary() {\n    return this.node && this.node.entry && this.node.entry.role === 'SiteManager';\n  }\n\n  getVisibilityLabel(value: string) {\n    return this.libraryType.find((type) => type.value === value).label;\n  }\n\n  toggleEdit() {\n    this.edit = !this.edit;\n  }\n\n  cancel() {\n    this.updateForm(this.node);\n    this.toggleEdit();\n  }\n\n  ngOnInit() {\n    this.updateForm(this.node);\n\n    this.form.controls['title'].valueChanges\n      .pipe(\n        debounceTime(300),\n        mergeMap((title) => this.findLibraryByTitle(title)),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe((result) => {\n        const { entries } = result.list;\n\n        if (entries.length) {\n          if (this.form.controls.title.value === this.node.entry.title) {\n            this.libraryTitleExists = false;\n          } else {\n            this.libraryTitleExists = this.form.controls.title.value === entries[0].entry.title;\n          }\n        } else {\n          this.libraryTitleExists = false;\n        }\n      });\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  ngOnChanges() {\n    this.updateForm(this.node);\n  }\n\n  update() {\n    if (this.canUpdateLibrary && this.form.valid) {\n      this.store.dispatch(new UpdateLibraryAction(this.form.value));\n    }\n  }\n\n  private updateForm(node: SiteEntry) {\n    const { entry } = node;\n\n    this.form.setValue({\n      id: entry.id,\n      title: entry.title,\n      description: entry.description || '',\n      visibility: entry.visibility\n    });\n  }\n\n  private findLibraryByTitle(libraryTitle: string): Observable<SitePaging | { list: { entries: any[] } }> {\n    return from(\n      this.queriesApi\n        .findSites(libraryTitle, {\n          maxItems: 1,\n          fields: ['title']\n        })\n        .catch(() => ({ list: { entries: [] } }))\n    );\n  }\n}\n","<mat-card *ngIf=\"node\">\n  <mat-card-content *ngIf=\"!edit\">\n    <div class=\"mat-form-field mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.title.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.id.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ getVisibilityLabel(form.controls.visibility.value) | translate }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <div class=\"mat-form-field mat-primary mat-form-field-type-mat-input mat-form-field-can-float mat-form-field-should-float adf-full-width\">\n      <div class=\"mat-form-field-wrapper\">\n        <div class=\"mat-form-field-flex\">\n          <div class=\"mat-form-field-infix\">\n            <span class=\"mat-form-field-label-wrapper\">\n              <span class=\"mat-form-field-label\">\n                {{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\n              </span>\n            </span>\n\n            <span class=\"mat-input-element\">\n              {{ form.controls.description?.value }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"!edit && canUpdateLibrary\">\n    <button mat-button color=\"primary\" (click)=\"toggleEdit()\">\n      {{ 'LIBRARY.DIALOG.EDIT' | translate }}\n    </button>\n  </mat-card-actions>\n\n  <mat-card-content *ngIf=\"edit\">\n    <form [formGroup]=\"form\" autocomplete=\"off\">\n      <mat-form-field class=\"adf-full-width\">\n        <input\n          matInput\n          cdkFocusInitial\n          required\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.NAME' | translate }}\"\n          formControlName=\"title\"\n          [errorStateMatcher]=\"matcher\"\n        />\n        <mat-hint *ngIf=\"libraryTitleExists\">{{ 'LIBRARY.HINTS.SITE_TITLE_EXISTS' | translate }}</mat-hint>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.TITLE_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <input matInput placeholder=\"{{ 'LIBRARY.DIALOG.FORM.SITE_ID' | translate }}\" formControlName=\"id\" />\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <mat-select placeholder=\"{{ 'LIBRARY.DIALOG.FORM.VISIBILITY' | translate }}\" formControlName=\"visibility\">\n          <mat-option [value]=\"type.value\" *ngFor=\"let type of libraryType\">\n            {{ type.label | translate }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n\n      <mat-form-field class=\"adf-full-width\">\n        <textarea\n          matInput\n          placeholder=\"{{ 'LIBRARY.DIALOG.FORM.DESCRIPTION' | translate }}\"\n          rows=\"3\"\n          formControlName=\"description\"\n          [errorStateMatcher]=\"matcher\"\n        ></textarea>\n        <mat-error>\n          {{ 'LIBRARY.ERRORS.DESCRIPTION_TOO_LONG' | translate }}\n        </mat-error>\n      </mat-form-field>\n    </form>\n  </mat-card-content>\n\n  <mat-card-actions align=\"end\" *ngIf=\"edit && canUpdateLibrary\">\n    <button mat-button (click)=\"cancel()\">\n      {{ 'LIBRARY.DIALOG.CANCEL' | translate }}\n    </button>\n    <button mat-button color=\"primary\" [disabled]=\"form.invalid || form.pristine\" (click)=\"update()\">\n      {{ 'LIBRARY.DIALOG.UPDATE' | translate }}\n    </button>\n  </mat-card-actions>\n</mat-card>\n"]}