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

package/esm2020/lib/components/toolbar/toggle-join-library/toggle-join-library-button.component.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @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 { SetSelectedNodesAction, SnackbarErrorAction, SnackbarInfoAction, getAppSelection, getUserProfile } from '@alfresco/aca-shared/store';
+import { AppHookService } from '@alfresco/aca-shared';
+import { Component, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/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/common";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@alfresco/adf-content-services";
+import * as i7 from "@ngx-translate/core";
+export class ToggleJoinLibraryButtonComponent {
+    constructor(store, appHookService) {
+        this.store = store;
+        this.appHookService = appHookService;
+        this.selection$ = this.store.select(getAppSelection);
+        this.profile$ = this.store.select(getUserProfile);
+    }
+    onToggleEvent(event) {
+        this.store.dispatch(new SnackbarInfoAction(event.i18nKey));
+        if (event.shouldReload) {
+            this.appHookService.libraryJoined.next();
+        }
+        else {
+            if (event.updatedEntry) {
+                this.store.dispatch(new SetSelectedNodesAction([{ entry: event.updatedEntry, isLibrary: true }]));
+            }
+            this.appHookService.joinLibraryToggle.next();
+        }
+    }
+    onErrorEvent(event) {
+        this.store.dispatch(new SnackbarErrorAction(event.i18nKey));
+    }
+}
+ToggleJoinLibraryButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleJoinLibraryButtonComponent, deps: [{ token: i1.Store }, { token: i2.AppHookService }], target: i0.ɵɵFactoryTarget.Component });
+ToggleJoinLibraryButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleJoinLibraryButtonComponent, selector: "app-toggle-join-library-button", host: { classAttribute: "app-toggle-join-library" }, ngImport: i0, template: `
+    <button
+      mat-icon-button
+      color="primary"
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)" svgIcon="adf:join_library"></mat-icon>
+    </button>
+  `, isInline: true, dependencies: [{ 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: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i6.LibraryMembershipDirective, selector: "[adf-library-membership]", inputs: ["adf-library-membership", "isAdmin"], outputs: ["toggle", "error"], exportAs: ["libraryMembership"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleJoinLibraryButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-join-library-button',
+                    template: `
+    <button
+      mat-icon-button
+      color="primary"
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)" svgIcon="adf:join_library"></mat-icon>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-join-library' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppHookService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/toolbar/toggle-join-library/toggle-join-library-menu.component.mjs

@@ -0,0 +1,81 @@
+/*!
+ * @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 } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { AppHookService } from '@alfresco/aca-shared';
+import { ToggleJoinLibraryButtonComponent } from './toggle-join-library-button.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/menu";
+import * as i6 from "@alfresco/adf-content-services";
+import * as i7 from "@ngx-translate/core";
+export class ToggleJoinLibraryMenuComponent extends ToggleJoinLibraryButtonComponent {
+    constructor(store, appHookService) {
+        super(store, appHookService);
+    }
+}
+ToggleJoinLibraryMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleJoinLibraryMenuComponent, deps: [{ token: i1.Store }, { token: i2.AppHookService }], target: i0.ɵɵFactoryTarget.Component });
+ToggleJoinLibraryMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleJoinLibraryMenuComponent, selector: "app-toggle-join-library-menu", host: { classAttribute: "app-toggle-join-library" }, usesInheritance: true, ngImport: i0, template: `
+    <button
+      mat-menu-item
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)" svgIcon="adf:join_library"></mat-icon>
+      <span>{{ (membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate) }}</span>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i5.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i6.LibraryMembershipDirective, selector: "[adf-library-membership]", inputs: ["adf-library-membership", "isAdmin"], outputs: ["toggle", "error"], exportAs: ["libraryMembership"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleJoinLibraryMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-join-library-menu',
+                    template: `
+    <button
+      mat-menu-item
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)" svgIcon="adf:join_library"></mat-icon>
+      <span>{{ (membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate) }}</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-join-library' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppHookService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/toolbar/toolbar.module.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 { NgModule } from '@angular/core';
+import { DocumentDisplayModeComponent } from './document-display-mode/document-display-mode.component';
+import { ToggleFavoriteComponent } from './toggle-favorite/toggle-favorite.component';
+import { ToggleInfoDrawerComponent } from './toggle-info-drawer/toggle-info-drawer.component';
+import { CommonModule } from '@angular/common';
+import { CoreModule } from '@alfresco/adf-core';
+import { ExtensionsModule } from '@alfresco/adf-extensions';
+import { ToggleJoinLibraryButtonComponent } from './toggle-join-library/toggle-join-library-button.component';
+import { ToggleJoinLibraryMenuComponent } from './toggle-join-library/toggle-join-library-menu.component';
+import { DirectivesModule } from '../../directives/directives.module';
+import { ToggleFavoriteLibraryComponent } from './toggle-favorite-library/toggle-favorite-library.component';
+import { ToggleEditOfflineComponent } from './toggle-edit-offline/toggle-edit-offline.component';
+import { ViewNodeComponent } from './view-node/view-node.component';
+import { AppCommonModule } from '../common/common.module';
+import { SharedToolbarModule } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class AppToolbarModule {
+}
+AppToolbarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppToolbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppToolbarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppToolbarModule, declarations: [DocumentDisplayModeComponent,
+        ToggleFavoriteComponent,
+        ToggleInfoDrawerComponent,
+        ToggleJoinLibraryButtonComponent,
+        ToggleJoinLibraryMenuComponent,
+        ToggleFavoriteLibraryComponent,
+        ToggleEditOfflineComponent,
+        ViewNodeComponent], imports: [CommonModule, i1.CoreModule, AppCommonModule, ExtensionsModule, SharedToolbarModule, DirectivesModule], exports: [DocumentDisplayModeComponent,
+        ToggleFavoriteComponent,
+        ToggleInfoDrawerComponent,
+        ToggleJoinLibraryButtonComponent,
+        ToggleJoinLibraryMenuComponent,
+        ToggleFavoriteLibraryComponent,
+        ToggleEditOfflineComponent,
+        ViewNodeComponent,
+        SharedToolbarModule] });
+AppToolbarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppToolbarModule, imports: [CommonModule, CoreModule.forChild(), AppCommonModule, ExtensionsModule, SharedToolbarModule, DirectivesModule, SharedToolbarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppToolbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, CoreModule.forChild(), AppCommonModule, ExtensionsModule, SharedToolbarModule, DirectivesModule],
+                    declarations: [
+                        DocumentDisplayModeComponent,
+                        ToggleFavoriteComponent,
+                        ToggleInfoDrawerComponent,
+                        ToggleJoinLibraryButtonComponent,
+                        ToggleJoinLibraryMenuComponent,
+                        ToggleFavoriteLibraryComponent,
+                        ToggleEditOfflineComponent,
+                        ViewNodeComponent
+                    ],
+                    exports: [
+                        DocumentDisplayModeComponent,
+                        ToggleFavoriteComponent,
+                        ToggleInfoDrawerComponent,
+                        ToggleJoinLibraryButtonComponent,
+                        ToggleJoinLibraryMenuComponent,
+                        ToggleFavoriteLibraryComponent,
+                        ToggleEditOfflineComponent,
+                        ViewNodeComponent,
+                        SharedToolbarModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/toolbar/view-node/view-node.component.mjs

@@ -0,0 +1,102 @@
+/*!
+ * @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, Input } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ViewNodeAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { Router } from '@angular/router';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/menu";
+import * as i7 from "@ngx-translate/core";
+export class ViewNodeComponent {
+    constructor(store, router) {
+        this.store = store;
+        this.router = router;
+    }
+    onClick() {
+        this.store
+            .select(getAppSelection)
+            .pipe(take(1))
+            .subscribe((selection) => {
+            let id;
+            if (selection.file.entry.nodeType === 'app:filelink') {
+                id = selection.file.entry.properties['cm:destination'];
+            }
+            else {
+                id = selection.file.entry.nodeId || selection.file.entry.guid || selection.file.entry.id;
+            }
+            this.store.dispatch(new ViewNodeAction(id, { location: this.router.url }));
+        });
+    }
+}
+ViewNodeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ViewNodeComponent, deps: [{ token: i1.Store }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Component });
+ViewNodeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ViewNodeComponent, selector: "app-view-node", inputs: { data: "data" }, host: { classAttribute: "app-view-node" }, ngImport: i0, template: `
+    <button
+      *ngIf="data.iconButton"
+      mat-icon-button
+      [attr.aria-label]="data.title | translate"
+      [attr.title]="data.title | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>visibility</mat-icon>
+    </button>
+
+    <button *ngIf="data.menuButton" mat-menu-item (click)="onClick()">
+      <mat-icon>visibility</mat-icon>
+      <span>{{ data.title | translate }}</span>
+    </button>
+  `, isInline: true, dependencies: [{ 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: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i6.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ViewNodeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-view-node',
+                    template: `
+    <button
+      *ngIf="data.iconButton"
+      mat-icon-button
+      [attr.aria-label]="data.title | translate"
+      [attr.title]="data.title | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>visibility</mat-icon>
+    </button>
+
+    <button *ngIf="data.menuButton" mat-menu-item (click)="onClick()">
+      <mat-icon>visibility</mat-icon>
+      <span>{{ data.title | translate }}</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-view-node' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }]; }, propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+/*!
+ * @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 { getUserProfile } from '@alfresco/aca-shared/store';
+import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';
+import { Component } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ContentManagementService } from '../../services/content-management.service';
+import { AppExtensionService, PageComponent } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/content-management.service";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@ngrx/store";
+import * as i4 from "@angular/cdk/layout";
+import * as i5 from "@angular/common";
+import * as i6 from "@alfresco/adf-core";
+import * as i7 from "@alfresco/adf-content-services";
+import * as i8 from "../../directives/document-list.directive";
+import * as i9 from "@alfresco/adf-extensions";
+import * as i10 from "@ngx-translate/core";
+export class TrashcanComponent extends PageComponent {
+    constructor(content, extensions, store, breakpointObserver) {
+        super(store, extensions, content);
+        this.breakpointObserver = breakpointObserver;
+        this.isSmallScreen = false;
+        this.columns = [];
+        this.user$ = this.store.select(getUserProfile);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.subscriptions.push(this.breakpointObserver.observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape]).subscribe((result) => {
+            this.isSmallScreen = result.matches;
+        }));
+        this.columns = this.extensions.documentListPresets.trashcan || [];
+    }
+}
+TrashcanComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: TrashcanComponent, deps: [{ token: i1.ContentManagementService }, { token: i2.AppExtensionService }, { token: i3.Store }, { token: i4.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Component });
+TrashcanComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: TrashcanComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<aca-page-layout>\n  <aca-page-layout-header>\n    <adf-breadcrumb root=\"APP.BROWSE.TRASHCAN.TITLE\"> </adf-breadcrumb>\n\n    <adf-toolbar class=\"adf-toolbar--inline\">\n      <ng-container *ngFor=\"let entry of actions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"entry\"></aca-toolbar-action>\n      </ng-container>\n    </adf-toolbar>\n  </aca-page-layout-header>\n\n  <aca-page-layout-content>\n    <div class=\"main-content\">\n      <adf-document-list\n        #documentList\n        acaDocumentList\n        acaContextActions\n        [display]=\"documentDisplayMode$ | async\"\n        currentFolderId=\"-trashcan-\"\n        selectionMode=\"multiple\"\n        [navigate]=\"false\"\n        sortingMode=\"client\"\n        [imageResolver]=\"imageResolver\"\n        [sorting]=\"['archivedAt', 'desc']\"\n      >\n        <adf-custom-empty-content-template>\n          <adf-empty-content icon=\"delete\" [title]=\"'APP.BROWSE.TRASHCAN.EMPTY_STATE.TITLE'\">\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.FIRST_TEXT' | translate }}\n            </p>\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.SECOND_TEXT' | translate }}\n            </p>\n          </adf-empty-content>\n        </adf-custom-empty-content-template>\n\n        <data-columns>\n          <ng-container *ngFor=\"let column of columns; trackBy: trackByColumnId\">\n            <ng-container *ngIf=\"column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n                <ng-template let-context>\n                  <adf-dynamic-column [id]=\"column.template\" [context]=\"context\"> </adf-dynamic-column>\n                </ng-template>\n              </data-column>\n            </ng-container>\n\n            <ng-container *ngIf=\"!column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n              </data-column>\n            </ng-container>\n          </ng-container>\n\n          <data-column\n            *ngIf=\"!isSmallScreen && (user$ | async)?.isAdmin\"\n            class=\"adf-ellipsis-cell\"\n            key=\"archivedByUser.displayName\"\n            title=\"APP.DOCUMENT_LIST.COLUMNS.DELETED_BY\"\n          >\n          </data-column>\n        </data-columns>\n      </adf-document-list>\n\n      <adf-pagination acaPagination [target]=\"documentList\"> </adf-pagination>\n    </div>\n  </aca-page-layout-content>\n</aca-page-layout>\n", dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.PaginationComponent, selector: "adf-pagination", inputs: ["target", "supportedPageSizes", "pagination"], outputs: ["change", "changePageNumber", "changePageSize", "nextPage", "prevPage"] }, { kind: "component", type: i6.ToolbarComponent, selector: "adf-toolbar", inputs: ["title", "color"] }, { kind: "directive", type: i6.CustomEmptyContentTemplateDirective, selector: "adf-custom-empty-content-template, empty-folder-content" }, { kind: "component", type: i6.DataColumnComponent, selector: "data-column", inputs: ["id", "key", "customData", "type", "format", "sortable", "draggable", "isHidden", "title", "formatTooltip", "sr-title", "class", "copyContent", "editable", "focus", "sortingKey"] }, { kind: "component", type: i6.DataColumnListComponent, selector: "data-columns" }, { kind: "component", type: i6.EmptyContentComponent, selector: "adf-empty-content", inputs: ["icon", "title", "subtitle"] }, { kind: "component", type: i7.DocumentListComponent, selector: "adf-document-list", inputs: ["includeFields", "where", "display", "permissionsStyle", "locationFormat", "navigate", "showHeader", "navigationMode", "thumbnails", "selectionMode", "multiselect", "contentActions", "contentActionsPosition", "contextMenuActions", "emptyFolderImageUrl", "allowDropFiles", "sorting", "additionalSorting", "sortingMode", "rowStyle", "rowStyleClass", "loading", "_rowFilter", "rowFilter", "imageResolver", "stickyHeader", "headerFilters", "filterValue", "currentFolderId", "preselectNodes", "node", "maxItems"], outputs: ["nodeClick", "nodeDblClick", "folderChange", "preview", "ready", "error", "nodeSelected", "filterSelection"] }, { kind: "component", type: i7.BreadcrumbComponent, selector: "adf-breadcrumb", inputs: ["folderNode", "root", "rootId", "target", "transform", "maxItems", "readOnly"], outputs: ["navigate"] }, { kind: "directive", type: i8.DocumentListDirective, selector: "[acaDocumentList]" }, { kind: "directive", type: i2.PaginationDirective, selector: "[acaPagination]" }, { kind: "directive", type: i2.ContextActionsDirective, selector: "[acaContextActions]", inputs: ["acaContextEnable"], exportAs: ["acaContextActions"] }, { kind: "component", type: i9.DynamicColumnComponent, selector: "adf-dynamic-column", inputs: ["id", "context"] }, { kind: "component", type: i2.ToolbarActionComponent, selector: "aca-toolbar-action", inputs: ["type", "color", "actionRef"] }, { kind: "component", type: i2.PageLayoutContentComponent, selector: "aca-page-layout-content", inputs: ["scrollable"] }, { kind: "component", type: i2.PageLayoutHeaderComponent, selector: "aca-page-layout-header" }, { kind: "component", type: i2.PageLayoutComponent, selector: "aca-page-layout", inputs: ["hasError"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: TrashcanComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<aca-page-layout>\n  <aca-page-layout-header>\n    <adf-breadcrumb root=\"APP.BROWSE.TRASHCAN.TITLE\"> </adf-breadcrumb>\n\n    <adf-toolbar class=\"adf-toolbar--inline\">\n      <ng-container *ngFor=\"let entry of actions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"entry\"></aca-toolbar-action>\n      </ng-container>\n    </adf-toolbar>\n  </aca-page-layout-header>\n\n  <aca-page-layout-content>\n    <div class=\"main-content\">\n      <adf-document-list\n        #documentList\n        acaDocumentList\n        acaContextActions\n        [display]=\"documentDisplayMode$ | async\"\n        currentFolderId=\"-trashcan-\"\n        selectionMode=\"multiple\"\n        [navigate]=\"false\"\n        sortingMode=\"client\"\n        [imageResolver]=\"imageResolver\"\n        [sorting]=\"['archivedAt', 'desc']\"\n      >\n        <adf-custom-empty-content-template>\n          <adf-empty-content icon=\"delete\" [title]=\"'APP.BROWSE.TRASHCAN.EMPTY_STATE.TITLE'\">\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.FIRST_TEXT' | translate }}\n            </p>\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.SECOND_TEXT' | translate }}\n            </p>\n          </adf-empty-content>\n        </adf-custom-empty-content-template>\n\n        <data-columns>\n          <ng-container *ngFor=\"let column of columns; trackBy: trackByColumnId\">\n            <ng-container *ngIf=\"column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n                <ng-template let-context>\n                  <adf-dynamic-column [id]=\"column.template\" [context]=\"context\"> </adf-dynamic-column>\n                </ng-template>\n              </data-column>\n            </ng-container>\n\n            <ng-container *ngIf=\"!column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n              </data-column>\n            </ng-container>\n          </ng-container>\n\n          <data-column\n            *ngIf=\"!isSmallScreen && (user$ | async)?.isAdmin\"\n            class=\"adf-ellipsis-cell\"\n            key=\"archivedByUser.displayName\"\n            title=\"APP.DOCUMENT_LIST.COLUMNS.DELETED_BY\"\n          >\n          </data-column>\n        </data-columns>\n      </adf-document-list>\n\n      <adf-pagination acaPagination [target]=\"documentList\"> </adf-pagination>\n    </div>\n  </aca-page-layout-content>\n</aca-page-layout>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ContentManagementService }, { type: i2.AppExtensionService }, { type: i3.Store }, { type: i4.BreakpointObserver }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trashcan.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/components/trashcan/trashcan.component.ts","../../../../../../../projects/aca-content/src/lib/components/trashcan/trashcan.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAY,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,SAAS,EAAU,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;AAK1E,MAAM,OAAO,iBAAkB,SAAQ,aAAa;IAMlD,YACE,OAAiC,EACjC,UAA+B,EAC/B,KAAsB,EACd,kBAAsC;QAE9C,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAF1B,uBAAkB,GAAlB,kBAAkB,CAAoB;QAThD,kBAAa,GAAG,KAAK,CAAC;QAGtB,YAAO,GAA4B,EAAE,CAAC;QASpC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IACjD,CAAC;IAED,QAAQ;QACN,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,eAAe,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YAChH,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC;QACtC,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,QAAQ,IAAI,EAAE,CAAC;IACpE,CAAC;;8GA1BU,iBAAiB;kGAAjB,iBAAiB,2ECrC9B,2gGAgFA;2FD3Ca,iBAAiB;kBAH7B,SAAS","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 { AppStore, getUserProfile } from '@alfresco/aca-shared/store';\nimport { DocumentListPresetRef, ProfileState } from '@alfresco/adf-extensions';\nimport { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';\nimport { Component, OnInit } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { Observable } from 'rxjs';\nimport { ContentManagementService } from '../../services/content-management.service';\nimport { AppExtensionService, PageComponent } from '@alfresco/aca-shared';\n\n@Component({\n  templateUrl: './trashcan.component.html'\n})\nexport class TrashcanComponent extends PageComponent implements OnInit {\n  isSmallScreen = false;\n  user$: Observable<ProfileState>;\n\n  columns: DocumentListPresetRef[] = [];\n\n  constructor(\n    content: ContentManagementService,\n    extensions: AppExtensionService,\n    store: Store<AppStore>,\n    private breakpointObserver: BreakpointObserver\n  ) {\n    super(store, extensions, content);\n    this.user$ = this.store.select(getUserProfile);\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    this.subscriptions.push(\n      this.breakpointObserver.observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape]).subscribe((result) => {\n        this.isSmallScreen = result.matches;\n      })\n    );\n\n    this.columns = this.extensions.documentListPresets.trashcan || [];\n  }\n}\n","<aca-page-layout>\n  <aca-page-layout-header>\n    <adf-breadcrumb root=\"APP.BROWSE.TRASHCAN.TITLE\"> </adf-breadcrumb>\n\n    <adf-toolbar class=\"adf-toolbar--inline\">\n      <ng-container *ngFor=\"let entry of actions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"entry\"></aca-toolbar-action>\n      </ng-container>\n    </adf-toolbar>\n  </aca-page-layout-header>\n\n  <aca-page-layout-content>\n    <div class=\"main-content\">\n      <adf-document-list\n        #documentList\n        acaDocumentList\n        acaContextActions\n        [display]=\"documentDisplayMode$ | async\"\n        currentFolderId=\"-trashcan-\"\n        selectionMode=\"multiple\"\n        [navigate]=\"false\"\n        sortingMode=\"client\"\n        [imageResolver]=\"imageResolver\"\n        [sorting]=\"['archivedAt', 'desc']\"\n      >\n        <adf-custom-empty-content-template>\n          <adf-empty-content icon=\"delete\" [title]=\"'APP.BROWSE.TRASHCAN.EMPTY_STATE.TITLE'\">\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.FIRST_TEXT' | translate }}\n            </p>\n            <p class=\"adf-empty-content__text\">\n              {{ 'APP.BROWSE.TRASHCAN.EMPTY_STATE.SECOND_TEXT' | translate }}\n            </p>\n          </adf-empty-content>\n        </adf-custom-empty-content-template>\n\n        <data-columns>\n          <ng-container *ngFor=\"let column of columns; trackBy: trackByColumnId\">\n            <ng-container *ngIf=\"column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n                <ng-template let-context>\n                  <adf-dynamic-column [id]=\"column.template\" [context]=\"context\"> </adf-dynamic-column>\n                </ng-template>\n              </data-column>\n            </ng-container>\n\n            <ng-container *ngIf=\"!column.template && !(column.desktopOnly && isSmallScreen)\">\n              <data-column\n                [key]=\"column.key\"\n                [title]=\"column.title\"\n                [type]=\"column.type\"\n                [format]=\"column.format\"\n                [class]=\"column.class\"\n                [sortable]=\"column.sortable\"\n              >\n              </data-column>\n            </ng-container>\n          </ng-container>\n\n          <data-column\n            *ngIf=\"!isSmallScreen && (user$ | async)?.isAdmin\"\n            class=\"adf-ellipsis-cell\"\n            key=\"archivedByUser.displayName\"\n            title=\"APP.DOCUMENT_LIST.COLUMNS.DELETED_BY\"\n          >\n          </data-column>\n        </data-columns>\n      </adf-document-list>\n\n      <adf-pagination acaPagination [target]=\"documentList\"> </adf-pagination>\n    </div>\n  </aca-page-layout-content>\n</aca-page-layout>\n"]}

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

@@ -0,0 +1,71 @@
+/*!
+ * @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 { TrashcanComponent } from './trashcan.component';
+import { ContentModule } from '@alfresco/adf-content-services';
+import { AppCommonModule } from '../common/common.module';
+import { AppToolbarModule } from '../toolbar/toolbar.module';
+import { DirectivesModule } from '../../directives/directives.module';
+import { ContextMenuModule } from '../context-menu/context-menu.module';
+import { AppLayoutModule } from '../layout/layout.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@alfresco/adf-content-services";
+export class AppTrashcanModule {
+}
+AppTrashcanModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppTrashcanModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppTrashcanModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppTrashcanModule, declarations: [TrashcanComponent], imports: [CommonModule, i1.CoreModule, i2.ContentModule, DirectivesModule,
+        AppCommonModule,
+        AppToolbarModule,
+        ContextMenuModule,
+        AppLayoutModule], exports: [TrashcanComponent] });
+AppTrashcanModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppTrashcanModule, imports: [CommonModule,
+        CoreModule.forChild(),
+        ContentModule.forChild(),
+        DirectivesModule,
+        AppCommonModule,
+        AppToolbarModule,
+        ContextMenuModule,
+        AppLayoutModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppTrashcanModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        CoreModule.forChild(),
+                        ContentModule.forChild(),
+                        DirectivesModule,
+                        AppCommonModule,
+                        AppToolbarModule,
+                        ContextMenuModule,
+                        AppLayoutModule
+                    ],
+                    declarations: [TrashcanComponent],
+                    exports: [TrashcanComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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