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

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

@@ -0,0 +1,43 @@
+/*!
+ * @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 { SiteEntry } from '@alfresco/js-api';
+import * as i0 from "@angular/core";
+import * as i1 from "./library-metadata-form.component";
+export class LibraryMetadataTabComponent {
+}
+LibraryMetadataTabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: LibraryMetadataTabComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibraryMetadataTabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: LibraryMetadataTabComponent, selector: "app-library-metadata-tab", inputs: { node: "node" }, host: { classAttribute: "app-metadata-tab" }, ngImport: i0, template: '<app-library-metadata-form [node]="node"></app-library-metadata-form>', isInline: true, dependencies: [{ kind: "component", type: i1.LibraryMetadataFormComponent, selector: "app-library-metadata-form", inputs: ["node"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: LibraryMetadataTabComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-library-metadata-tab',
+                    template: '<app-library-metadata-form [node]="node"></app-library-metadata-form>',
+                    host: { class: 'app-metadata-tab' }
+                }]
+        }], propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,89 @@
+/*!
+ * @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, ViewEncapsulation } from '@angular/core';
+import { MinimalNodeEntryEntity } from '@alfresco/js-api';
+import { NodePermissionService, isLocked, AppExtensionService } from '@alfresco/aca-shared';
+import { infoDrawerMetadataAspect } from '@alfresco/aca-shared/store';
+import { AppConfigService, NotificationService } from '@alfresco/adf-core';
+import { Subject } from 'rxjs';
+import { Store } from '@ngrx/store';
+import { ContentMetadataService } from '@alfresco/adf-content-services';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/aca-shared";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@ngrx/store";
+import * as i4 from "@alfresco/adf-content-services";
+import * as i5 from "@angular/common";
+export class MetadataTabComponent {
+    constructor(permission, extensions, appConfig, store, notificationService, contentMetadataService) {
+        this.permission = permission;
+        this.extensions = extensions;
+        this.appConfig = appConfig;
+        this.store = store;
+        this.notificationService = notificationService;
+        this.contentMetadataService = contentMetadataService;
+        this.onDestroy$ = new Subject();
+        if (this.extensions.contentMetadata) {
+            this.appConfig.config['content-metadata'].presets = this.extensions.contentMetadata.presets;
+        }
+        this.displayAspect$ = this.store.select(infoDrawerMetadataAspect);
+    }
+    get canUpdateNode() {
+        if (this.node && !isLocked({ entry: this.node })) {
+            return this.permission.check(this.node, ['update']);
+        }
+        return false;
+    }
+    ngOnInit() {
+        this.contentMetadataService.error.pipe(takeUntil(this.onDestroy$)).subscribe((err) => {
+            this.notificationService.showError(err.message);
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+}
+MetadataTabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MetadataTabComponent, deps: [{ token: i1.NodePermissionService }, { token: i1.AppExtensionService }, { token: i2.AppConfigService }, { token: i3.Store }, { token: i2.NotificationService }, { token: i4.ContentMetadataService }], target: i0.ɵɵFactoryTarget.Component });
+MetadataTabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: MetadataTabComponent, selector: "app-metadata-tab", inputs: { node: "node" }, host: { classAttribute: "app-metadata-tab" }, ngImport: i0, template: `
+    <adf-content-metadata-card [readOnly]="!canUpdateNode" [preset]="'custom'" [node]="node" [displayAspect]="displayAspect$ | async">
+    </adf-content-metadata-card>
+  `, isInline: true, dependencies: [{ kind: "component", type: i4.ContentMetadataCardComponent, selector: "adf-content-metadata-card", inputs: ["node", "displayEmpty", "displayAspect", "preset", "readOnly", "multi", "displayDefaultProperties"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MetadataTabComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-metadata-tab',
+                    template: `
+    <adf-content-metadata-card [readOnly]="!canUpdateNode" [preset]="'custom'" [node]="node" [displayAspect]="displayAspect$ | async">
+    </adf-content-metadata-card>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-metadata-tab' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NodePermissionService }, { type: i1.AppExtensionService }, { type: i2.AppConfigService }, { type: i3.Store }, { type: i2.NotificationService }, { type: i4.ContentMetadataService }]; }, propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEtdGFiLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvY29tcG9uZW50cy9pbmZvLWRyYXdlci9tZXRhZGF0YS10YWIvbWV0YWRhdGEtdGFiLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F1Qkc7QUFFSCxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBcUIsTUFBTSxlQUFlLENBQUM7QUFDdkYsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDMUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLFFBQVEsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzVGLE9BQU8sRUFBWSx3QkFBd0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2hGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzNFLE9BQU8sRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDM0MsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4RSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7Ozs7Ozs7QUFXM0MsTUFBTSxPQUFPLG9CQUFvQjtJQVEvQixZQUNVLFVBQWlDLEVBQy9CLFVBQStCLEVBQ2pDLFNBQTJCLEVBQzNCLEtBQXNCLEVBQ3RCLG1CQUF3QyxFQUN4QyxzQkFBOEM7UUFMOUMsZUFBVSxHQUFWLFVBQVUsQ0FBdUI7UUFDL0IsZUFBVSxHQUFWLFVBQVUsQ0FBcUI7UUFDakMsY0FBUyxHQUFULFNBQVMsQ0FBa0I7UUFDM0IsVUFBSyxHQUFMLEtBQUssQ0FBaUI7UUFDdEIsd0JBQW1CLEdBQW5CLG1CQUFtQixDQUFxQjtRQUN4QywyQkFBc0IsR0FBdEIsc0JBQXNCLENBQXdCO1FBYjlDLGVBQVUsR0FBRyxJQUFJLE9BQU8sRUFBVyxDQUFDO1FBZTVDLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxlQUFlLEVBQUU7WUFDbkMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDO1NBQzdGO1FBQ0QsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFFRCxJQUFJLGFBQWE7UUFDZixJQUFJLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLEVBQUU7WUFDaEQsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztTQUNyRDtRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLENBQUMsc0JBQXNCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBd0IsRUFBRSxFQUFFO1lBQ3hHLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMzQixJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzdCLENBQUM7O2lIQXZDVSxvQkFBb0I7cUdBQXBCLG9CQUFvQixnSUFQckI7OztHQUdUOzJGQUlVLG9CQUFvQjtrQkFUaEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsa0JBQWtCO29CQUM1QixRQUFRLEVBQUU7OztHQUdUO29CQUNELGFBQWEsRUFBRSxpQkFBaUIsQ0FBQyxJQUFJO29CQUNyQyxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsa0JBQWtCLEVBQUU7aUJBQ3BDO3dRQUtDLElBQUk7c0JBREgsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMjAgQWxmcmVzY28gU29mdHdhcmUgTGltaXRlZFxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuICBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBhbG9uZyB3aXRoIEFsZnJlc2NvLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgVmlld0VuY2Fwc3VsYXRpb24sIE9uSW5pdCwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNaW5pbWFsTm9kZUVudHJ5RW50aXR5IH0gZnJvbSAnQGFsZnJlc2NvL2pzLWFwaSc7XG5pbXBvcnQgeyBOb2RlUGVybWlzc2lvblNlcnZpY2UsIGlzTG9ja2VkLCBBcHBFeHRlbnNpb25TZXJ2aWNlIH0gZnJvbSAnQGFsZnJlc2NvL2FjYS1zaGFyZWQnO1xuaW1wb3J0IHsgQXBwU3RvcmUsIGluZm9EcmF3ZXJNZXRhZGF0YUFzcGVjdCB9IGZyb20gJ0BhbGZyZXNjby9hY2Etc2hhcmVkL3N0b3JlJztcbmltcG9ydCB7IEFwcENvbmZpZ1NlcnZpY2UsIE5vdGlmaWNhdGlvblNlcnZpY2UgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgU3RvcmUgfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBDb250ZW50TWV0YWRhdGFTZXJ2aWNlIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb250ZW50LXNlcnZpY2VzJztcbmltcG9ydCB7IHRha2VVbnRpbCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXBwLW1ldGFkYXRhLXRhYicsXG4gIHRlbXBsYXRlOiBgXG4gICAgPGFkZi1jb250ZW50LW1ldGFkYXRhLWNhcmQgW3JlYWRPbmx5XT1cIiFjYW5VcGRhdGVOb2RlXCIgW3ByZXNldF09XCInY3VzdG9tJ1wiIFtub2RlXT1cIm5vZGVcIiBbZGlzcGxheUFzcGVjdF09XCJkaXNwbGF5QXNwZWN0JCB8IGFzeW5jXCI+XG4gICAgPC9hZGYtY29udGVudC1tZXRhZGF0YS1jYXJkPlxuICBgLFxuICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lLFxuICBob3N0OiB7IGNsYXNzOiAnYXBwLW1ldGFkYXRhLXRhYicgfVxufSlcbmV4cG9ydCBjbGFzcyBNZXRhZGF0YVRhYkNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcbiAgcHJvdGVjdGVkIG9uRGVzdHJveSQgPSBuZXcgU3ViamVjdDxib29sZWFuPigpO1xuXG4gIEBJbnB1dCgpXG4gIG5vZGU6IE1pbmltYWxOb2RlRW50cnlFbnRpdHk7XG5cbiAgZGlzcGxheUFzcGVjdCQ6IE9ic2VydmFibGU8c3RyaW5nPjtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHBlcm1pc3Npb246IE5vZGVQZXJtaXNzaW9uU2VydmljZSxcbiAgICBwcm90ZWN0ZWQgZXh0ZW5zaW9uczogQXBwRXh0ZW5zaW9uU2VydmljZSxcbiAgICBwcml2YXRlIGFwcENvbmZpZzogQXBwQ29uZmlnU2VydmljZSxcbiAgICBwcml2YXRlIHN0b3JlOiBTdG9yZTxBcHBTdG9yZT4sXG4gICAgcHJpdmF0ZSBub3RpZmljYXRpb25TZXJ2aWNlOiBOb3RpZmljYXRpb25TZXJ2aWNlLFxuICAgIHByaXZhdGUgY29udGVudE1ldGFkYXRhU2VydmljZTogQ29udGVudE1ldGFkYXRhU2VydmljZVxuICApIHtcbiAgICBpZiAodGhpcy5leHRlbnNpb25zLmNvbnRlbnRNZXRhZGF0YSkge1xuICAgICAgdGhpcy5hcHBDb25maWcuY29uZmlnWydjb250ZW50LW1ldGFkYXRhJ10ucHJlc2V0cyA9IHRoaXMuZXh0ZW5zaW9ucy5jb250ZW50TWV0YWRhdGEucHJlc2V0cztcbiAgICB9XG4gICAgdGhpcy5kaXNwbGF5QXNwZWN0JCA9IHRoaXMuc3RvcmUuc2VsZWN0KGluZm9EcmF3ZXJNZXRhZGF0YUFzcGVjdCk7XG4gIH1cblxuICBnZXQgY2FuVXBkYXRlTm9kZSgpOiBib29sZWFuIHtcbiAgICBpZiAodGhpcy5ub2RlICYmICFpc0xvY2tlZCh7IGVudHJ5OiB0aGlzLm5vZGUgfSkpIHtcbiAgICAgIHJldHVybiB0aGlzLnBlcm1pc3Npb24uY2hlY2sodGhpcy5ub2RlLCBbJ3VwZGF0ZSddKTtcbiAgICB9XG5cbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICBuZ09uSW5pdCgpIHtcbiAgICB0aGlzLmNvbnRlbnRNZXRhZGF0YVNlcnZpY2UuZXJyb3IucGlwZSh0YWtlVW50aWwodGhpcy5vbkRlc3Ryb3kkKSkuc3Vic2NyaWJlKChlcnI6IHsgbWVzc2FnZTogc3RyaW5nIH0pID0+IHtcbiAgICAgIHRoaXMubm90aWZpY2F0aW9uU2VydmljZS5zaG93RXJyb3IoZXJyLm1lc3NhZ2UpO1xuICAgIH0pO1xuICB9XG5cbiAgbmdPbkRlc3Ryb3koKSB7XG4gICAgdGhpcy5vbkRlc3Ryb3kkLm5leHQodHJ1ZSk7XG4gICAgdGhpcy5vbkRlc3Ryb3kkLmNvbXBsZXRlKCk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,96 @@
+/*!
+ * @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 * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@alfresco/adf-content-services";
+import * as i4 from "@alfresco/adf-core";
+import * as i5 from "@ngx-translate/core";
+export class VersionsTabComponent {
+    constructor() {
+        this.isFileSelected = false;
+    }
+    ngOnInit() {
+        this.updateState();
+    }
+    ngOnChanges() {
+        this.updateState();
+    }
+    updateState() {
+        if (this.node && this.node.nodeId) {
+            // workaround for shared files type.
+            this.isFileSelected = true;
+        }
+        else {
+            this.isFileSelected = this.node.isFile;
+        }
+    }
+}
+VersionsTabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: VersionsTabComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+VersionsTabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: VersionsTabComponent, selector: "app-versions-tab", inputs: { node: "node" }, usesOnChanges: true, ngImport: i0, template: `
+    <ng-container *ngIf="isFileSelected; else empty">
+      <adf-version-manager
+        [showComments]="'adf-version-manager.allowComments' | adfAppConfig : true"
+        [allowDownload]="'adf-version-manager.allowDownload' | adfAppConfig : true"
+        [node]="node"
+      >
+      </adf-version-manager>
+    </ng-container>
+
+    <ng-template #empty>
+      <div class="adf-manage-versions-empty">
+        <mat-icon class="adf-manage-versions-empty-icon">face</mat-icon>
+        {{ 'VERSION.SELECTION.EMPTY' | translate }}
+      </div>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i3.VersionManagerComponent, selector: "adf-version-manager", inputs: ["node", "newFileVersion", "showComments", "showVersionComparison", "allowDownload"], outputs: ["uploadSuccess", "uploadError", "uploadCancel", "viewVersion"] }, { kind: "pipe", type: i4.AppConfigPipe, name: "adfAppConfig" }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: VersionsTabComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-versions-tab',
+                    template: `
+    <ng-container *ngIf="isFileSelected; else empty">
+      <adf-version-manager
+        [showComments]="'adf-version-manager.allowComments' | adfAppConfig : true"
+        [allowDownload]="'adf-version-manager.allowDownload' | adfAppConfig : true"
+        [node]="node"
+      >
+      </adf-version-manager>
+    </ng-container>
+
+    <ng-template #empty>
+      <div class="adf-manage-versions-empty">
+        <mat-icon class="adf-manage-versions-empty-icon">face</mat-icon>
+        {{ 'VERSION.SELECTION.EMPTY' | translate }}
+      </div>
+    </ng-template>
+  `
+                }]
+        }], propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/layout/app-layout/app-layout.component.mjs

@@ -0,0 +1,147 @@
+/*!
+ * @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 { AppConfigService, SidenavLayoutComponent, UserPreferencesService } from '@alfresco/adf-core';
+import { Component, ViewChild, ViewEncapsulation } from '@angular/core';
+import { NavigationEnd, Router, NavigationStart } from '@angular/router';
+import { Store } from '@ngrx/store';
+import { Subject } from 'rxjs';
+import { filter, takeUntil, map, withLatestFrom, delay } from 'rxjs/operators';
+import { NodePermissionService } from '@alfresco/aca-shared';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { getCurrentFolder, getFileUploadingDialog, ResetSelectionAction } from '@alfresco/aca-shared/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@angular/router";
+import * as i4 from "@alfresco/adf-core";
+import * as i5 from "@angular/cdk/layout";
+import * as i6 from "@angular/common";
+import * as i7 from "@alfresco/adf-content-services";
+import * as i8 from "../../sidenav/sidenav.component";
+import * as i9 from "../../header/header.component";
+export class AppLayoutComponent {
+    constructor(store, permission, router, userPreferenceService, appConfigService, breakpointObserver) {
+        this.store = store;
+        this.permission = permission;
+        this.router = router;
+        this.userPreferenceService = userPreferenceService;
+        this.appConfigService = appConfigService;
+        this.breakpointObserver = breakpointObserver;
+        this.onDestroy$ = new Subject();
+        this.canUpload = false;
+        this.minimizeSidenav = false;
+        this.hideSidenav = false;
+        this.minimizeConditions = ['search'];
+        this.hideConditions = ['/preview/'];
+    }
+    ngOnInit() {
+        this.isSmallScreen$ = this.breakpointObserver.observe(['(max-width: 600px)']).pipe(map((result) => result.matches));
+        this.hideSidenav = this.hideConditions.some((el) => this.router.routerState.snapshot.url.includes(el));
+        this.minimizeSidenav = this.minimizeConditions.some((el) => this.router.routerState.snapshot.url.includes(el));
+        if (!this.minimizeSidenav) {
+            this.expandedSidenav = this.getSidenavState();
+        }
+        else {
+            this.expandedSidenav = false;
+        }
+        this.store
+            .select(getCurrentFolder)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((node) => {
+            this.currentFolderId = node ? node.id : null;
+            this.canUpload = node && this.permission.check(node, ['create']);
+        });
+        this.router.events
+            .pipe(withLatestFrom(this.isSmallScreen$), filter(([event, isSmallScreen]) => isSmallScreen && event instanceof NavigationEnd), takeUntil(this.onDestroy$))
+            .subscribe(() => {
+            this.layout.container.sidenav.close();
+        });
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntil(this.onDestroy$))
+            .subscribe((event) => {
+            this.minimizeSidenav = this.minimizeConditions.some((el) => event.urlAfterRedirects.includes(el));
+            this.hideSidenav = this.hideConditions.some((el) => event.urlAfterRedirects.includes(el));
+            this.updateState();
+        });
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationStart), takeUntil(this.onDestroy$))
+            .subscribe(() => {
+            this.store.dispatch(new ResetSelectionAction());
+        });
+        this.store
+            .select(getFileUploadingDialog)
+            .pipe(delay(0), takeUntil(this.onDestroy$))
+            .subscribe((fileUploadingDialog) => {
+            this.showFileUploadingDialog = fileUploadingDialog;
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    hideMenu(event) {
+        if (this.layout.container.isMobileScreenSize) {
+            event.preventDefault();
+            this.layout.container.toggleMenu();
+        }
+    }
+    updateState() {
+        if (this.minimizeSidenav && !this.layout.isMenuMinimized) {
+            this.layout.isMenuMinimized = true;
+            if (!this.layout.container.isMobileScreenSize) {
+                this.layout.container.toggleMenu();
+            }
+        }
+        if (!this.minimizeSidenav) {
+            if (this.getSidenavState() && this.layout.isMenuMinimized) {
+                this.layout.isMenuMinimized = false;
+                this.layout.container.toggleMenu();
+            }
+        }
+    }
+    onExpanded(state) {
+        if (!this.minimizeSidenav && this.appConfigService.get('sideNav.preserveState')) {
+            this.userPreferenceService.set('expandedSidenav', state);
+        }
+    }
+    getSidenavState() {
+        const expand = this.appConfigService.get('sideNav.expandedSidenav', true);
+        const preserveState = this.appConfigService.get('sideNav.preserveState', true);
+        if (preserveState) {
+            return this.userPreferenceService.get('expandedSidenav', expand.toString()) === 'true';
+        }
+        return expand;
+    }
+}
+AppLayoutComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutComponent, deps: [{ token: i1.Store }, { token: i2.NodePermissionService }, { token: i3.Router }, { token: i4.UserPreferencesService }, { token: i4.AppConfigService }, { token: i5.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Component });
+AppLayoutComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: AppLayoutComponent, selector: "app-layout", host: { classAttribute: "app-layout" }, viewQueries: [{ propertyName: "layout", first: true, predicate: ["layout"], descendants: true, static: true }], ngImport: i0, template: "<adf-upload-drag-area [rootFolderId]=\"currentFolderId\" [disabled]=\"!canUpload\">\n  <adf-sidenav-layout\n    #layout\n    [sidenavMin]=\"70\"\n    [sidenavMax]=\"320\"\n    [stepOver]=\"600\"\n    [hideSidenav]=\"hideSidenav\"\n    [expandedSidenav]=\"expandedSidenav\"\n    (expanded)=\"onExpanded($event)\"\n  >\n    <adf-sidenav-layout-header>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-header role=\"heading\" aria-level=\"1\" *ngIf=\"!hideSidenav\" (toggleClicked)=\"layout.toggleMenu()\" [expandedSidenav]=\"!isMenuMinimized()\">\n        </app-header>\n      </ng-template>\n    </adf-sidenav-layout-header>\n\n    <adf-sidenav-layout-navigation>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-sidenav\n          [mode]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          [attr.data-automation-id]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          (swipeleft)=\"hideMenu($event)\"\n        >\n        </app-sidenav>\n      </ng-template>\n    </adf-sidenav-layout-navigation>\n\n    <adf-sidenav-layout-content>\n      <ng-template>\n        <router-outlet></router-outlet>\n      </ng-template>\n    </adf-sidenav-layout-content>\n  </adf-sidenav-layout>\n\n  <adf-file-uploading-dialog *ngIf=\"showFileUploadingDialog\" position=\"left\"></adf-file-uploading-dialog>\n</adf-upload-drag-area>\n\n<router-outlet name=\"viewer\"></router-outlet>\n", styles: [".app-layout{display:flex;flex-direction:column;flex:1;height:100%;overflow:hidden;min-height:0}.app-layout router-outlet[name=viewer]+*{width:100%;height:100%;z-index:999;position:absolute;top:0;right:0;background-color:#fff}.app-layout adf-file-uploading-dialog{z-index:1000}@media screen and (max-width: 599px){.adf-app-title{display:none}}@media screen and (max-width: 719px){.adf-app-logo{display:none}}\n"], dependencies: [{ kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "directive", type: i4.SidenavLayoutHeaderDirective, selector: "adf-sidenav-layout-header" }, { kind: "directive", type: i4.SidenavLayoutContentDirective, selector: "adf-sidenav-layout-content" }, { kind: "directive", type: i4.SidenavLayoutNavigationDirective, selector: "adf-sidenav-layout-navigation" }, { kind: "component", type: i4.SidenavLayoutComponent, selector: "adf-sidenav-layout", inputs: ["position", "sidenavMin", "sidenavMax", "stepOver", "hideSidenav", "expandedSidenav"], outputs: ["expanded"] }, { kind: "component", type: i7.UploadDragAreaComponent, selector: "adf-upload-drag-area" }, { kind: "component", type: i7.FileUploadingDialogComponent, selector: "adf-file-uploading-dialog", inputs: ["position", "alwaysVisible"], outputs: ["error"] }, { kind: "component", type: i8.SidenavComponent, selector: "app-sidenav", inputs: ["mode"] }, { kind: "component", type: i9.AppHeaderComponent, selector: "app-header", inputs: ["expandedSidenav", "data"], outputs: ["toggleClicked"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-layout', encapsulation: ViewEncapsulation.None, host: { class: 'app-layout' }, template: "<adf-upload-drag-area [rootFolderId]=\"currentFolderId\" [disabled]=\"!canUpload\">\n  <adf-sidenav-layout\n    #layout\n    [sidenavMin]=\"70\"\n    [sidenavMax]=\"320\"\n    [stepOver]=\"600\"\n    [hideSidenav]=\"hideSidenav\"\n    [expandedSidenav]=\"expandedSidenav\"\n    (expanded)=\"onExpanded($event)\"\n  >\n    <adf-sidenav-layout-header>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-header role=\"heading\" aria-level=\"1\" *ngIf=\"!hideSidenav\" (toggleClicked)=\"layout.toggleMenu()\" [expandedSidenav]=\"!isMenuMinimized()\">\n        </app-header>\n      </ng-template>\n    </adf-sidenav-layout-header>\n\n    <adf-sidenav-layout-navigation>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-sidenav\n          [mode]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          [attr.data-automation-id]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          (swipeleft)=\"hideMenu($event)\"\n        >\n        </app-sidenav>\n      </ng-template>\n    </adf-sidenav-layout-navigation>\n\n    <adf-sidenav-layout-content>\n      <ng-template>\n        <router-outlet></router-outlet>\n      </ng-template>\n    </adf-sidenav-layout-content>\n  </adf-sidenav-layout>\n\n  <adf-file-uploading-dialog *ngIf=\"showFileUploadingDialog\" position=\"left\"></adf-file-uploading-dialog>\n</adf-upload-drag-area>\n\n<router-outlet name=\"viewer\"></router-outlet>\n", styles: [".app-layout{display:flex;flex-direction:column;flex:1;height:100%;overflow:hidden;min-height:0}.app-layout router-outlet[name=viewer]+*{width:100%;height:100%;z-index:999;position:absolute;top:0;right:0;background-color:#fff}.app-layout adf-file-uploading-dialog{z-index:1000}@media screen and (max-width: 599px){.adf-app-title{display:none}}@media screen and (max-width: 719px){.adf-app-logo{display:none}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.NodePermissionService }, { type: i3.Router }, { type: i4.UserPreferencesService }, { type: i4.AppConfigService }, { type: i5.BreakpointObserver }]; }, propDecorators: { layout: [{
+                type: ViewChild,
+                args: ['layout', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-layout.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-content/src/lib/components/layout/app-layout/app-layout.component.ts","../../../../../../../../projects/aca-content/src/lib/components/layout/app-layout/app-layout.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACtG,OAAO,EAAE,SAAS,EAAqB,SAAS,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAc,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAY,gBAAgB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;;;;;;;;;;;AAUtH,MAAM,OAAO,kBAAkB;IAoB7B,YACY,KAAsB,EACxB,UAAiC,EACjC,MAAc,EACd,qBAA6C,EAC7C,gBAAkC,EAClC,kBAAsC;QALpC,UAAK,GAAL,KAAK,CAAiB;QACxB,eAAU,GAAV,UAAU,CAAuB;QACjC,WAAM,GAAN,MAAM,CAAQ;QACd,0BAAqB,GAArB,qBAAqB,CAAwB;QAC7C,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,uBAAkB,GAAlB,kBAAkB,CAAoB;QAtBhD,eAAU,GAAqB,IAAI,OAAO,EAAW,CAAC;QAKtD,cAAS,GAAG,KAAK,CAAC;QAElB,oBAAe,GAAG,KAAK,CAAC;QACxB,gBAAW,GAAG,KAAK,CAAC;QAKZ,uBAAkB,GAAa,CAAC,QAAQ,CAAC,CAAC;QAC1C,mBAAc,GAAa,CAAC,WAAW,CAAC,CAAC;IAS9C,CAAC;IAEJ,QAAQ;QACN,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QAEpH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QAEvG,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QAE/G,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;SAC/C;aAAM;YACL,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;SAC9B;QAED,IAAI,CAAC,KAAK;aACP,MAAM,CAAC,gBAAgB,CAAC;aACxB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YAClB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAC7C,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,EACnC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,aAAa,IAAI,KAAK,YAAY,aAAa,CAAC,EACnF,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACxC,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,aAAa,CAAC,EACjD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;aACA,SAAS,CAAC,CAAC,KAAoB,EAAE,EAAE;YAClC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YAClG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YAE1F,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,eAAe,CAAC,EACnD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,KAAK;aACP,MAAM,CAAC,sBAAsB,CAAC;aAC9B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,mBAA4B,EAAE,EAAE;YAC1C,IAAI,CAAC,uBAAuB,GAAG,mBAAmB,CAAC;QACrD,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,QAAQ,CAAC,KAAY;QACnB,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,kBAAkB,EAAE;YAC5C,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;SACpC;IACH,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE;YACxD,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,kBAAkB,EAAE;gBAC7C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;aACpC;SACF;QAED,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,IAAI,IAAI,CAAC,eAAe,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE;gBACzD,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,KAAK,CAAC;gBACpC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;aACpC;SACF;IACH,CAAC;IAED,UAAU,CAAC,KAAc;QACvB,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,uBAAuB,CAAC,EAAE;YAC/E,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;SAC1D;IACH,CAAC;IAEO,eAAe;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAU,yBAAyB,EAAE,IAAI,CAAC,CAAC;QACnF,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAU,uBAAuB,EAAE,IAAI,CAAC,CAAC;QAExF,IAAI,aAAa,EAAE;YACjB,OAAO,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,MAAM,CAAC;SACxF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;;+GApIU,kBAAkB;mGAAlB,kBAAkB,0MC3C/B,45CAuCA;2FDIa,kBAAkB;kBAP9B,SAAS;+BACE,YAAY,iBAGP,iBAAiB,CAAC,IAAI,QAC/B,EAAE,KAAK,EAAE,YAAY,EAAE;0PAI7B,MAAM;sBADL,SAAS;uBAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","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 { AppConfigService, SidenavLayoutComponent, UserPreferencesService } from '@alfresco/adf-core';\nimport { Component, OnDestroy, OnInit, ViewChild, ViewEncapsulation } from '@angular/core';\nimport { NavigationEnd, Router, NavigationStart } from '@angular/router';\nimport { Store } from '@ngrx/store';\nimport { Subject, Observable } from 'rxjs';\nimport { filter, takeUntil, map, withLatestFrom, delay } from 'rxjs/operators';\nimport { NodePermissionService } from '@alfresco/aca-shared';\nimport { BreakpointObserver } from '@angular/cdk/layout';\nimport { AppStore, getCurrentFolder, getFileUploadingDialog, ResetSelectionAction } from '@alfresco/aca-shared/store';\nimport { Directionality } from '@angular/cdk/bidi';\n\n@Component({\n  selector: 'app-layout',\n  templateUrl: './app-layout.component.html',\n  styleUrls: ['./app-layout.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-layout' }\n})\nexport class AppLayoutComponent implements OnInit, OnDestroy {\n  @ViewChild('layout', { static: true })\n  layout: SidenavLayoutComponent;\n\n  onDestroy$: Subject<boolean> = new Subject<boolean>();\n  isSmallScreen$: Observable<boolean>;\n\n  expandedSidenav: boolean;\n  currentFolderId: string;\n  canUpload = false;\n\n  minimizeSidenav = false;\n  hideSidenav = false;\n  direction: Directionality;\n\n  showFileUploadingDialog: boolean;\n\n  private minimizeConditions: string[] = ['search'];\n  private hideConditions: string[] = ['/preview/'];\n\n  constructor(\n    protected store: Store<AppStore>,\n    private permission: NodePermissionService,\n    private router: Router,\n    private userPreferenceService: UserPreferencesService,\n    private appConfigService: AppConfigService,\n    private breakpointObserver: BreakpointObserver\n  ) {}\n\n  ngOnInit() {\n    this.isSmallScreen$ = this.breakpointObserver.observe(['(max-width: 600px)']).pipe(map((result) => result.matches));\n\n    this.hideSidenav = this.hideConditions.some((el) => this.router.routerState.snapshot.url.includes(el));\n\n    this.minimizeSidenav = this.minimizeConditions.some((el) => this.router.routerState.snapshot.url.includes(el));\n\n    if (!this.minimizeSidenav) {\n      this.expandedSidenav = this.getSidenavState();\n    } else {\n      this.expandedSidenav = false;\n    }\n\n    this.store\n      .select(getCurrentFolder)\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((node) => {\n        this.currentFolderId = node ? node.id : null;\n        this.canUpload = node && this.permission.check(node, ['create']);\n      });\n\n    this.router.events\n      .pipe(\n        withLatestFrom(this.isSmallScreen$),\n        filter(([event, isSmallScreen]) => isSmallScreen && event instanceof NavigationEnd),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe(() => {\n        this.layout.container.sidenav.close();\n      });\n\n    this.router.events\n      .pipe(\n        filter((event) => event instanceof NavigationEnd),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe((event: NavigationEnd) => {\n        this.minimizeSidenav = this.minimizeConditions.some((el) => event.urlAfterRedirects.includes(el));\n        this.hideSidenav = this.hideConditions.some((el) => event.urlAfterRedirects.includes(el));\n\n        this.updateState();\n      });\n\n    this.router.events\n      .pipe(\n        filter((event) => event instanceof NavigationStart),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe(() => {\n        this.store.dispatch(new ResetSelectionAction());\n      });\n\n    this.store\n      .select(getFileUploadingDialog)\n      .pipe(delay(0), takeUntil(this.onDestroy$))\n      .subscribe((fileUploadingDialog: boolean) => {\n        this.showFileUploadingDialog = fileUploadingDialog;\n      });\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  hideMenu(event: Event) {\n    if (this.layout.container.isMobileScreenSize) {\n      event.preventDefault();\n      this.layout.container.toggleMenu();\n    }\n  }\n\n  private updateState() {\n    if (this.minimizeSidenav && !this.layout.isMenuMinimized) {\n      this.layout.isMenuMinimized = true;\n      if (!this.layout.container.isMobileScreenSize) {\n        this.layout.container.toggleMenu();\n      }\n    }\n\n    if (!this.minimizeSidenav) {\n      if (this.getSidenavState() && this.layout.isMenuMinimized) {\n        this.layout.isMenuMinimized = false;\n        this.layout.container.toggleMenu();\n      }\n    }\n  }\n\n  onExpanded(state: boolean) {\n    if (!this.minimizeSidenav && this.appConfigService.get('sideNav.preserveState')) {\n      this.userPreferenceService.set('expandedSidenav', state);\n    }\n  }\n\n  private getSidenavState(): boolean {\n    const expand = this.appConfigService.get<boolean>('sideNav.expandedSidenav', true);\n    const preserveState = this.appConfigService.get<boolean>('sideNav.preserveState', true);\n\n    if (preserveState) {\n      return this.userPreferenceService.get('expandedSidenav', expand.toString()) === 'true';\n    }\n\n    return expand;\n  }\n}\n","<adf-upload-drag-area [rootFolderId]=\"currentFolderId\" [disabled]=\"!canUpload\">\n  <adf-sidenav-layout\n    #layout\n    [sidenavMin]=\"70\"\n    [sidenavMax]=\"320\"\n    [stepOver]=\"600\"\n    [hideSidenav]=\"hideSidenav\"\n    [expandedSidenav]=\"expandedSidenav\"\n    (expanded)=\"onExpanded($event)\"\n  >\n    <adf-sidenav-layout-header>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-header role=\"heading\" aria-level=\"1\" *ngIf=\"!hideSidenav\" (toggleClicked)=\"layout.toggleMenu()\" [expandedSidenav]=\"!isMenuMinimized()\">\n        </app-header>\n      </ng-template>\n    </adf-sidenav-layout-header>\n\n    <adf-sidenav-layout-navigation>\n      <ng-template let-isMenuMinimized=\"isMenuMinimized\">\n        <app-sidenav\n          [mode]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          [attr.data-automation-id]=\"isMenuMinimized() ? 'collapsed' : 'expanded'\"\n          (swipeleft)=\"hideMenu($event)\"\n        >\n        </app-sidenav>\n      </ng-template>\n    </adf-sidenav-layout-navigation>\n\n    <adf-sidenav-layout-content>\n      <ng-template>\n        <router-outlet></router-outlet>\n      </ng-template>\n    </adf-sidenav-layout-content>\n  </adf-sidenav-layout>\n\n  <adf-file-uploading-dialog *ngIf=\"showFileUploadingDialog\" position=\"left\"></adf-file-uploading-dialog>\n</adf-upload-drag-area>\n\n<router-outlet name=\"viewer\"></router-outlet>\n"]}

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

@@ -0,0 +1,75 @@
+/*!
+ * @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 { AppLayoutComponent } from './app-layout/app-layout.component';
+import { ContentModule } from '@alfresco/adf-content-services';
+import { RouterModule } from '@angular/router';
+import { AppSidenavModule } from '../sidenav/sidenav.module';
+import { AppCommonModule } from '../common/common.module';
+import { AppHeaderModule } from '../header/header.module';
+import { HttpClientModule } from '@angular/common/http';
+import { PageLayoutModule } 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 AppLayoutModule {
+}
+AppLayoutModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppLayoutModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutModule, declarations: [AppLayoutComponent], imports: [CommonModule,
+        RouterModule, i1.CoreModule, i2.ContentModule, AppCommonModule,
+        AppSidenavModule,
+        AppHeaderModule,
+        HttpClientModule,
+        PageLayoutModule], exports: [AppLayoutComponent, PageLayoutModule] });
+AppLayoutModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutModule, imports: [CommonModule,
+        RouterModule,
+        CoreModule.forChild(),
+        ContentModule.forChild(),
+        AppCommonModule,
+        AppSidenavModule,
+        AppHeaderModule,
+        HttpClientModule,
+        PageLayoutModule, PageLayoutModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        RouterModule,
+                        CoreModule.forChild(),
+                        ContentModule.forChild(),
+                        AppCommonModule,
+                        AppSidenavModule,
+                        AppHeaderModule,
+                        HttpClientModule,
+                        PageLayoutModule
+                    ],
+                    declarations: [AppLayoutComponent],
+                    exports: [AppLayoutComponent, PageLayoutModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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