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

package/esm2020/lib/directives/directives.module.mjs

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

package/esm2020/lib/directives/document-list.directive.mjs

@@ -0,0 +1,142 @@
+/*!
+ * @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 { Directive, HostListener } from '@angular/core';
+import { DocumentListComponent } from '@alfresco/adf-content-services';
+import { ActivatedRoute, Router } from '@angular/router';
+import { UserPreferencesService } from '@alfresco/adf-core';
+import { Subject } from 'rxjs';
+import { Store } from '@ngrx/store';
+import { AppHookService } from '@alfresco/aca-shared';
+import { SetSelectedNodesAction } from '@alfresco/aca-shared/store';
+import { takeUntil, filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/adf-content-services";
+import * as i3 from "@alfresco/adf-core";
+import * as i4 from "@angular/router";
+import * as i5 from "@alfresco/aca-shared";
+export class DocumentListDirective {
+    constructor(store, documentList, preferences, route, router, appHookService) {
+        this.store = store;
+        this.documentList = documentList;
+        this.preferences = preferences;
+        this.route = route;
+        this.router = router;
+        this.appHookService = appHookService;
+        this.isLibrary = false;
+        this.onDestroy$ = new Subject();
+    }
+    get sortingPreferenceKey() {
+        return this.route.snapshot.data.sortingPreferenceKey;
+    }
+    ngOnInit() {
+        this.documentList.stickyHeader = true;
+        this.documentList.includeFields = ['isFavorite', 'aspectNames', 'definition'];
+        this.isLibrary =
+            this.documentList.currentFolderId === '-mysites-' ||
+                // workaround for custom node list
+                this.router.url.endsWith('/libraries') ||
+                this.router.url.startsWith('/search-libraries');
+        if (this.sortingPreferenceKey) {
+            const current = this.documentList.sorting;
+            const key = this.preferences.get(`${this.sortingPreferenceKey}.sorting.key`, current[0]);
+            const direction = this.preferences.get(`${this.sortingPreferenceKey}.sorting.direction`, current[1]);
+            this.documentList.sorting = [key, direction];
+            // TODO: bug in ADF, the `sorting` binding is not updated when changed from code
+            this.documentList.data.setSorting({ key, direction });
+        }
+        this.documentList.ready
+            .pipe(filter(() => !this.router.url.includes('viewer:view')), takeUntil(this.onDestroy$))
+            .subscribe(() => this.onReady());
+        this.appHookService.reload.pipe(takeUntil(this.onDestroy$)).subscribe(() => {
+            this.reload(this.selectedNode);
+        });
+        this.appHookService.reset.pipe(takeUntil(this.onDestroy$)).subscribe(() => {
+            this.reset();
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    onSortingChanged(event) {
+        if (this.sortingPreferenceKey) {
+            this.preferences.set(`${this.sortingPreferenceKey}.sorting.key`, event.detail.key);
+            this.preferences.set(`${this.sortingPreferenceKey}.sorting.direction`, event.detail.direction);
+        }
+    }
+    onNodeSelect(event) {
+        if (!!event.detail && !!event.detail.node) {
+            this.updateSelection();
+            this.selectedNode = event.detail.node;
+        }
+    }
+    onNodeUnselect() {
+        this.updateSelection();
+    }
+    onReady() {
+        this.updateSelection();
+    }
+    updateSelection() {
+        const selection = this.documentList.selection.map((node) => {
+            node['isLibrary'] = this.isLibrary;
+            return node;
+        });
+        this.store.dispatch(new SetSelectedNodesAction(selection));
+    }
+    reload(selectedNode) {
+        this.documentList.resetSelection();
+        if (selectedNode) {
+            this.store.dispatch(new SetSelectedNodesAction([selectedNode]));
+        }
+        else {
+            this.store.dispatch(new SetSelectedNodesAction([]));
+        }
+        this.documentList.reload();
+    }
+    reset() {
+        this.selectedNode = null;
+        this.documentList.resetSelection();
+        this.store.dispatch(new SetSelectedNodesAction([]));
+    }
+}
+DocumentListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DocumentListDirective, deps: [{ token: i1.Store }, { token: i2.DocumentListComponent }, { token: i3.UserPreferencesService }, { token: i4.ActivatedRoute }, { token: i4.Router }, { token: i5.AppHookService }], target: i0.ɵɵFactoryTarget.Directive });
+DocumentListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.2", type: DocumentListDirective, selector: "[acaDocumentList]", host: { listeners: { "sorting-changed": "onSortingChanged($event)", "node-select": "onNodeSelect($event)", "node-unselect": "onNodeUnselect()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DocumentListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[acaDocumentList]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.DocumentListComponent }, { type: i3.UserPreferencesService }, { type: i4.ActivatedRoute }, { type: i4.Router }, { type: i5.AppHookService }]; }, propDecorators: { onSortingChanged: [{
+                type: HostListener,
+                args: ['sorting-changed', ['$event']]
+            }], onNodeSelect: [{
+                type: HostListener,
+                args: ['node-select', ['$event']]
+            }], onNodeUnselect: [{
+                type: HostListener,
+                args: ['node-unselect']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-list.directive.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/directives/document-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Directive, OnDestroy, OnInit, HostListener } from '@angular/core';\nimport { DocumentListComponent } from '@alfresco/adf-content-services';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { UserPreferencesService } from '@alfresco/adf-core';\nimport { Subject } from 'rxjs';\nimport { Store } from '@ngrx/store';\nimport { AppHookService } from '@alfresco/aca-shared';\nimport { SetSelectedNodesAction } from '@alfresco/aca-shared/store';\nimport { takeUntil, filter } from 'rxjs/operators';\nimport { MinimalNodeEntity } from '@alfresco/js-api';\n\n@Directive({\n  selector: '[acaDocumentList]'\n})\nexport class DocumentListDirective implements OnInit, OnDestroy {\n  private isLibrary = false;\n  selectedNode: MinimalNodeEntity;\n\n  onDestroy$ = new Subject<boolean>();\n\n  get sortingPreferenceKey(): string {\n    return this.route.snapshot.data.sortingPreferenceKey;\n  }\n\n  constructor(\n    private store: Store<any>,\n    private documentList: DocumentListComponent,\n    private preferences: UserPreferencesService,\n    private route: ActivatedRoute,\n    private router: Router,\n    private appHookService: AppHookService\n  ) {}\n\n  ngOnInit() {\n    this.documentList.stickyHeader = true;\n    this.documentList.includeFields = ['isFavorite', 'aspectNames', 'definition'];\n    this.isLibrary =\n      this.documentList.currentFolderId === '-mysites-' ||\n      // workaround for custom node list\n      this.router.url.endsWith('/libraries') ||\n      this.router.url.startsWith('/search-libraries');\n\n    if (this.sortingPreferenceKey) {\n      const current = this.documentList.sorting;\n\n      const key = this.preferences.get(`${this.sortingPreferenceKey}.sorting.key`, current[0]);\n      const direction = this.preferences.get(`${this.sortingPreferenceKey}.sorting.direction`, current[1]);\n\n      this.documentList.sorting = [key, direction];\n      // TODO: bug in ADF, the `sorting` binding is not updated when changed from code\n      this.documentList.data.setSorting({ key, direction });\n    }\n\n    this.documentList.ready\n      .pipe(\n        filter(() => !this.router.url.includes('viewer:view')),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe(() => this.onReady());\n\n    this.appHookService.reload.pipe(takeUntil(this.onDestroy$)).subscribe(() => {\n      this.reload(this.selectedNode);\n    });\n\n    this.appHookService.reset.pipe(takeUntil(this.onDestroy$)).subscribe(() => {\n      this.reset();\n    });\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  @HostListener('sorting-changed', ['$event'])\n  onSortingChanged(event: CustomEvent) {\n    if (this.sortingPreferenceKey) {\n      this.preferences.set(`${this.sortingPreferenceKey}.sorting.key`, event.detail.key);\n      this.preferences.set(`${this.sortingPreferenceKey}.sorting.direction`, event.detail.direction);\n    }\n  }\n\n  @HostListener('node-select', ['$event'])\n  onNodeSelect(event: CustomEvent) {\n    if (!!event.detail && !!event.detail.node) {\n      this.updateSelection();\n      this.selectedNode = event.detail.node;\n    }\n  }\n\n  @HostListener('node-unselect')\n  onNodeUnselect() {\n    this.updateSelection();\n  }\n\n  onReady() {\n    this.updateSelection();\n  }\n\n  private updateSelection() {\n    const selection = this.documentList.selection.map((node) => {\n      node['isLibrary'] = this.isLibrary;\n      return node;\n    });\n\n    this.store.dispatch(new SetSelectedNodesAction(selection));\n  }\n\n  private reload(selectedNode?: MinimalNodeEntity) {\n    this.documentList.resetSelection();\n    if (selectedNode) {\n      this.store.dispatch(new SetSelectedNodesAction([selectedNode]));\n    } else {\n      this.store.dispatch(new SetSelectedNodesAction([]));\n    }\n    this.documentList.reload();\n  }\n\n  private reset() {\n    this.selectedNode = null;\n    this.documentList.resetSelection();\n    this.store.dispatch(new SetSelectedNodesAction([]));\n  }\n}\n"]}

package/esm2020/lib/extensions/core.extensions.module.mjs

@@ -0,0 +1,66 @@
+/*!
+ * @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 { CoreModule } from '@alfresco/adf-core';
+import { CommonModule } from '@angular/common';
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { ExtensionsModule } from '@alfresco/adf-extensions';
+import { AppExtensionService } from '@alfresco/aca-shared';
+import { ContentServiceExtensionService } from '../services/content-service-extension.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+export function setupExtensions(service) {
+    return () => service.load();
+}
+export class CoreExtensionsModule {
+    static forRoot() {
+        return {
+            ngModule: CoreExtensionsModule,
+            providers: [
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: setupExtensions,
+                    deps: [AppExtensionService, ContentServiceExtensionService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild() {
+        return {
+            ngModule: CoreExtensionsModule
+        };
+    }
+}
+CoreExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: CoreExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: CoreExtensionsModule, imports: [CommonModule, i1.CoreModule, ExtensionsModule] });
+CoreExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: CoreExtensionsModule, imports: [CommonModule, CoreModule.forChild(), ExtensionsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: CoreExtensionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, CoreModule.forChild(), ExtensionsModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/material.module.mjs

@@ -0,0 +1,58 @@
+/*!
+ * @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 { MatMenuModule } from '@angular/material/menu';
+import { MatIconModule } from '@angular/material/icon';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule, MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
+import { MatInputModule } from '@angular/material/input';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatCardModule } from '@angular/material/card';
+import * as i0 from "@angular/core";
+export class MaterialModule {
+}
+MaterialModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MaterialModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MaterialModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: MaterialModule, imports: [MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule], exports: [MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule] });
+MaterialModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MaterialModule, providers: [
+        {
+            provide: MAT_DIALOG_DEFAULT_OPTIONS,
+            useValue: { closeOnNavigation: true, hasBackdrop: true, autoFocus: true }
+        }
+    ], imports: [MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule, MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MaterialModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule],
+                    exports: [MatMenuModule, MatIconModule, MatButtonModule, MatDialogModule, MatInputModule, MatSnackBarModule, MatProgressBarModule, MatCardModule],
+                    providers: [
+                        {
+                            provide: MAT_DIALOG_DEFAULT_OPTIONS,
+                            useValue: { closeOnNavigation: true, hasBackdrop: true, autoFocus: true }
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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