@alfresco/aca-content 4.0.0-4895233349

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

@@ -0,0 +1,98 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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,80 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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,88 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", ngImport: i0, type: AppToolbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppToolbarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", 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.3", ngImport: i0, type: AppToolbarModule, imports: [CommonModule, CoreModule.forChild(), AppCommonModule, ExtensionsModule, SharedToolbarModule, DirectivesModule, SharedToolbarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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,109 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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 { AcaFileAutoDownloadService } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@alfresco/aca-shared";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@angular/material/menu";
+import * as i8 from "@ngx-translate/core";
+export class ViewNodeComponent {
+    constructor(store, router, fileAutoDownloadService) {
+        this.store = store;
+        this.router = router;
+        this.fileAutoDownloadService = fileAutoDownloadService;
+    }
+    onClick() {
+        this.store
+            .select(getAppSelection)
+            .pipe(take(1))
+            .subscribe((selection) => {
+            if (this.fileAutoDownloadService.shouldFileAutoDownload(selection.file.entry?.content?.sizeInBytes)) {
+                this.fileAutoDownloadService.autoDownloadFile(selection.file);
+            }
+            else {
+                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.3", ngImport: i0, type: ViewNodeComponent, deps: [{ token: i1.Store }, { token: i2.Router }, { token: i3.AcaFileAutoDownloadService }], target: i0.ɵɵFactoryTarget.Component });
+ViewNodeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", 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: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.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: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i7.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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 }, { type: i3.AcaFileAutoDownloadService }]; }, propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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: ["data", "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.3", 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;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,2ECpC9B,2gGAgFA;2FD5Ca,iBAAiB;kBAH7B,SAAS","sourcesContent":["/*!\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. 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,74 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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 { AppSearchInputModule } from '../search/search-input.module';
+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 AppTrashcanModule {
+}
+AppTrashcanModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppTrashcanModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppTrashcanModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AppTrashcanModule, declarations: [TrashcanComponent], imports: [CommonModule, i1.CoreModule, i2.ContentModule, DirectivesModule,
+        AppCommonModule,
+        AppToolbarModule,
+        ContextMenuModule,
+        PageLayoutModule,
+        AppSearchInputModule], exports: [TrashcanComponent] });
+AppTrashcanModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppTrashcanModule, imports: [CommonModule,
+        CoreModule.forChild(),
+        ContentModule.forChild(),
+        DirectivesModule,
+        AppCommonModule,
+        AppToolbarModule,
+        ContextMenuModule,
+        PageLayoutModule,
+        AppSearchInputModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppTrashcanModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        CoreModule.forChild(),
+                        ContentModule.forChild(),
+                        DirectivesModule,
+                        AppCommonModule,
+                        AppToolbarModule,
+                        ContextMenuModule,
+                        PageLayoutModule,
+                        AppSearchInputModule
+                    ],
+                    declarations: [TrashcanComponent],
+                    exports: [TrashcanComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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