@alfresco/adf-content-services 8.1.0-16116633181 → 8.1.0-16117584844

package/esm2022/lib/document-list/components/document-list.token.mjs

@@ -0,0 +1,21 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable rxjs/no-subject-value */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { InjectionToken } from '@angular/core';
+export const ADF_DOCUMENT_PARENT_COMPONENT = new InjectionToken('ADF_DOCUMENT_PARENT_COMPONENT');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtbGlzdC50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvZG9jdW1lbnQtbGlzdC9jb21wb25lbnRzL2RvY3VtZW50LWxpc3QudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsMENBQTBDO0FBQzFDLHlEQUF5RDtBQUV6RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLElBQUksY0FBYyxDQUMzRCwrQkFBK0IsQ0FDbEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLyogZXNsaW50LWRpc2FibGUgcnhqcy9uby1zdWJqZWN0LXZhbHVlICovXG4vKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb24gKi9cblxuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IEFERl9ET0NVTUVOVF9QQVJFTlRfQ09NUE9ORU5UID0gbmV3IEluamVjdGlvblRva2VuKFxuICAgICdBREZfRE9DVU1FTlRfUEFSRU5UX0NPTVBPTkVOVCdcbik7XG4iXX0=

package/esm2022/lib/document-list/components/file-auto-download/file-auto-download.component.mjs

@@ -0,0 +1,42 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
+import { NodeEntry } from '@alfresco/js-api';
+import { CommonModule } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { MatButtonModule } from '@angular/material/button';
+import { NodeDownloadDirective } from '../../../directives/node-download.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@alfresco/js-api";
+export class FileAutoDownloadComponent {
+    constructor(node) {
+        this.node = node;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileAutoDownloadComponent, deps: [{ token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FileAutoDownloadComponent, isStandalone: true, selector: "adf-file-auto-download", ngImport: i0, template: "<div mat-dialog-title>\n    <h3>{{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.HEADER' | translate }}</h3>\n</div>\n<mat-dialog-content>\n    {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.LABEL' | translate }}\n</mat-dialog-content>\n<mat-dialog-actions align=\"end\">\n    <button\n        mat-button\n        mat-dialog-close\n        id=\"cancelButton\"\n        [attr.aria-label]=\"'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.CANCEL' | translate\">\n        {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.CANCEL' | translate }}\n    </button>\n    <button\n        mat-button\n        mat-dialog-close\n        id=\"downloadButton\"\n        color=\"primary\"\n        [attr.aria-label]=\"'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.DOWNLOAD' | translate\"\n        [adfNodeDownload]=\"node\">\n        {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.DOWNLOAD' | translate }}\n    </button>\n</mat-dialog-actions>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "directive", type: i1.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: NodeDownloadDirective, selector: "[adfNodeDownload]", inputs: ["adfNodeDownload", "version"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileAutoDownloadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-file-auto-download', standalone: true, imports: [CommonModule, MatDialogModule, TranslatePipe, MatButtonModule, NodeDownloadDirective], template: "<div mat-dialog-title>\n    <h3>{{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.HEADER' | translate }}</h3>\n</div>\n<mat-dialog-content>\n    {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.LABEL' | translate }}\n</mat-dialog-content>\n<mat-dialog-actions align=\"end\">\n    <button\n        mat-button\n        mat-dialog-close\n        id=\"cancelButton\"\n        [attr.aria-label]=\"'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.CANCEL' | translate\">\n        {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.CANCEL' | translate }}\n    </button>\n    <button\n        mat-button\n        mat-dialog-close\n        id=\"downloadButton\"\n        color=\"primary\"\n        [attr.aria-label]=\"'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.DOWNLOAD' | translate\"\n        [adfNodeDownload]=\"node\">\n        {{ 'ADF-DOCUMENT-LIST.FILE_AUTO_DOWNLOAD_DIALOG.ACTIONS.DOWNLOAD' | translate }}\n    </button>\n</mat-dialog-actions>\n" }]
+        }], ctorParameters: () => [{ type: i3.NodeEntry, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/components/filter-header/filter-header.component.mjs

@@ -0,0 +1,107 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, DestroyRef, EventEmitter, Inject, inject, Input, Output } from '@angular/core';
+import { HeaderFilterTemplateDirective } from '@alfresco/adf-core';
+import { SearchHeaderQueryBuilderService } from '../../../search/services/search-header-query-builder.service';
+import { ADF_DOCUMENT_PARENT_COMPONENT } from '../document-list.token';
+import { CommonModule } from '@angular/common';
+import { SearchFilterContainerComponent } from '../../../search/components/search-filter-container/search-filter-container.component';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../search/services/search-header-query-builder.service";
+import * as i2 from "@angular/common";
+export class FilterHeaderComponent {
+    constructor(documentList, searchFilterQueryBuilder) {
+        this.documentList = documentList;
+        this.searchFilterQueryBuilder = searchFilterQueryBuilder;
+        /** (optional) Initial filter value to sort . */
+        this.value = {};
+        /** Emitted when a filter value is selected */
+        this.filterSelection = new EventEmitter();
+        this.destroyRef = inject(DestroyRef);
+        this.isFilterServiceActive = this.searchFilterQueryBuilder.isFilterServiceActive();
+    }
+    ngOnInit() {
+        this.searchFilterQueryBuilder.executed.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newNodePaging) => {
+            this.documentList.node = newNodePaging;
+            this.documentList.reload();
+        });
+        this.initDataPagination();
+        this.initDataSorting();
+    }
+    ngOnChanges(changes) {
+        if (changes['currentFolderId']?.currentValue) {
+            this.resetFilterHeader();
+            this.configureSearchParent(changes['currentFolderId'].currentValue);
+        }
+    }
+    onFilterSelectionChange() {
+        this.filterSelection.emit(this.searchFilterQueryBuilder.getActiveFilters());
+        if (this.searchFilterQueryBuilder.isNoFilterActive()) {
+            this.documentList.node = null;
+            this.documentList.reload();
+        }
+    }
+    resetFilterHeader() {
+        this.searchFilterQueryBuilder.resetActiveFilters();
+    }
+    initDataPagination() {
+        this.documentList.pagination.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newPagination) => {
+            this.searchFilterQueryBuilder.setupCurrentPagination(newPagination.maxItems, newPagination.skipCount);
+        });
+    }
+    initDataSorting() {
+        this.documentList.sortingSubject.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((sorting) => {
+            this.searchFilterQueryBuilder.setSorting(sorting);
+        });
+    }
+    configureSearchParent(currentFolderId) {
+        if (this.searchFilterQueryBuilder.isCustomSourceNode(currentFolderId)) {
+            this.searchFilterQueryBuilder.getNodeIdForCustomSource(currentFolderId).subscribe((node) => {
+                this.initSearchHeader(node.id);
+            });
+        }
+        else {
+            this.initSearchHeader(currentFolderId);
+        }
+    }
+    initSearchHeader(currentFolderId) {
+        this.searchFilterQueryBuilder.setCurrentRootFolderId(currentFolderId);
+        if (this.value) {
+            Object.keys(this.value).forEach((columnKey) => {
+                this.searchFilterQueryBuilder.setActiveFilter(columnKey, this.value[columnKey]);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FilterHeaderComponent, deps: [{ token: ADF_DOCUMENT_PARENT_COMPONENT }, { token: i1.SearchHeaderQueryBuilderService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FilterHeaderComponent, isStandalone: true, selector: "adf-filter-header", inputs: { value: "value", currentFolderId: "currentFolderId" }, outputs: { filterSelection: "filterSelection" }, usesOnChanges: true, ngImport: i0, template: "<div *ngIf=\"isFilterServiceActive\">\n    <adf-header-filter-template>\n        <ng-template let-col>\n            <adf-search-filter-container [col]=\"col\"\n                                         [value]=\"value\"\n                                         (filterChange)=\"onFilterSelectionChange()\" />\n        </ng-template>\n    </adf-header-filter-template>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: HeaderFilterTemplateDirective, selector: "adf-header-filter-template" }, { kind: "component", type: SearchFilterContainerComponent, selector: "adf-search-filter-container", inputs: ["col", "value"], outputs: ["filterChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FilterHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-filter-header', standalone: true, imports: [CommonModule, HeaderFilterTemplateDirective, SearchFilterContainerComponent], template: "<div *ngIf=\"isFilterServiceActive\">\n    <adf-header-filter-template>\n        <ng-template let-col>\n            <adf-search-filter-container [col]=\"col\"\n                                         [value]=\"value\"\n                                         (filterChange)=\"onFilterSelectionChange()\" />\n        </ng-template>\n    </adf-header-filter-template>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ADF_DOCUMENT_PARENT_COMPONENT]
+                }] }, { type: i1.SearchHeaderQueryBuilderService }], propDecorators: { value: [{
+                type: Input
+            }], currentFolderId: [{
+                type: Input,
+                args: [{ required: true }]
+            }], filterSelection: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-header.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/document-list/components/filter-header/filter-header.component.ts","../../../../../../../../lib/content-services/src/lib/document-list/components/filter-header/filter-header.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Component, DestroyRef, EventEmitter, Inject, inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\nimport { DataSorting, HeaderFilterTemplateDirective, PaginationModel } from '@alfresco/adf-core';\nimport { SearchHeaderQueryBuilderService } from '../../../search/services/search-header-query-builder.service';\nimport { FilterSearch } from './../../../search/models/filter-search.interface';\nimport { ADF_DOCUMENT_PARENT_COMPONENT } from '../document-list.token';\nimport { CommonModule } from '@angular/common';\nimport { SearchFilterContainerComponent } from '../../../search/components/search-filter-container/search-filter-container.component';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Component({\n    selector: 'adf-filter-header',\n    standalone: true,\n    imports: [CommonModule, HeaderFilterTemplateDirective, SearchFilterContainerComponent],\n    templateUrl: './filter-header.component.html'\n})\nexport class FilterHeaderComponent implements OnInit, OnChanges {\n    /** (optional) Initial filter value to sort . */\n    @Input()\n    value: any = {};\n\n    /** The id of the current folder of the document list. */\n    @Input({ required: true })\n    currentFolderId: string;\n\n    /** Emitted when a filter value is selected */\n    @Output()\n    filterSelection: EventEmitter<FilterSearch[]> = new EventEmitter();\n\n    isFilterServiceActive: boolean;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    constructor(@Inject(ADF_DOCUMENT_PARENT_COMPONENT) private documentList: any, private searchFilterQueryBuilder: SearchHeaderQueryBuilderService) {\n        this.isFilterServiceActive = this.searchFilterQueryBuilder.isFilterServiceActive();\n    }\n\n    ngOnInit() {\n        this.searchFilterQueryBuilder.executed.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newNodePaging) => {\n            this.documentList.node = newNodePaging;\n            this.documentList.reload();\n        });\n\n        this.initDataPagination();\n        this.initDataSorting();\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['currentFolderId']?.currentValue) {\n            this.resetFilterHeader();\n            this.configureSearchParent(changes['currentFolderId'].currentValue);\n        }\n    }\n\n    onFilterSelectionChange() {\n        this.filterSelection.emit(this.searchFilterQueryBuilder.getActiveFilters());\n        if (this.searchFilterQueryBuilder.isNoFilterActive()) {\n            this.documentList.node = null;\n            this.documentList.reload();\n        }\n    }\n\n    resetFilterHeader() {\n        this.searchFilterQueryBuilder.resetActiveFilters();\n    }\n\n    initDataPagination() {\n        this.documentList.pagination.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((newPagination: PaginationModel) => {\n            this.searchFilterQueryBuilder.setupCurrentPagination(newPagination.maxItems, newPagination.skipCount);\n        });\n    }\n\n    initDataSorting() {\n        this.documentList.sortingSubject.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((sorting: DataSorting[]) => {\n            this.searchFilterQueryBuilder.setSorting(sorting);\n        });\n    }\n\n    private configureSearchParent(currentFolderId: string) {\n        if (this.searchFilterQueryBuilder.isCustomSourceNode(currentFolderId)) {\n            this.searchFilterQueryBuilder.getNodeIdForCustomSource(currentFolderId).subscribe((node) => {\n                this.initSearchHeader(node.id);\n            });\n        } else {\n            this.initSearchHeader(currentFolderId);\n        }\n    }\n\n    private initSearchHeader(currentFolderId: string) {\n        this.searchFilterQueryBuilder.setCurrentRootFolderId(currentFolderId);\n        if (this.value) {\n            Object.keys(this.value).forEach((columnKey) => {\n                this.searchFilterQueryBuilder.setActiveFilter(columnKey, this.value[columnKey]);\n            });\n        }\n    }\n}\n","<div *ngIf=\"isFilterServiceActive\">\n    <adf-header-filter-template>\n        <ng-template let-col>\n            <adf-search-filter-container [col]=\"col\"\n                                         [value]=\"value\"\n                                         (filterChange)=\"onFilterSelectionChange()\" />\n        </ng-template>\n    </adf-header-filter-template>\n</div>\n"]}

package/esm2022/lib/document-list/components/library-name-column/library-name-column.component.mjs

@@ -0,0 +1,131 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, ViewEncapsulation } from '@angular/core';
+import { NodesApiService } from '../../../common/services/nodes-api.service';
+import { BehaviorSubject } from 'rxjs';
+import { AsyncPipe } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/services/nodes-api.service";
+export class LibraryNameColumnComponent {
+    constructor(element, nodesApiService) {
+        this.element = element;
+        this.nodesApiService = nodesApiService;
+        this.displayTooltip$ = new BehaviorSubject('');
+        this.displayText$ = new BehaviorSubject('');
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.updateValue();
+        this.nodesApiService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node) => {
+            const row = this.context.row;
+            if (row) {
+                const { entry } = row.node;
+                if (entry === node) {
+                    row.node = { entry };
+                    this.updateValue();
+                }
+            }
+        });
+    }
+    updateValue() {
+        this.node = this.context.row.node;
+        const rows = this.context.data.rows || [];
+        if (this.node?.entry) {
+            this.displayText$.next(this.makeLibraryTitle(this.node.entry, rows));
+            this.displayTooltip$.next(this.makeLibraryTooltip(this.node.entry));
+        }
+    }
+    onClick() {
+        this.element.nativeElement.dispatchEvent(new CustomEvent('name-click', {
+            bubbles: true,
+            detail: {
+                node: this.node
+            }
+        }));
+    }
+    makeLibraryTooltip(library) {
+        const { description, title } = library;
+        return description || title || '';
+    }
+    makeLibraryTitle(library, rows) {
+        const entries = rows.map((row) => row.node.entry);
+        const { title, id } = library;
+        let isDuplicate = false;
+        if (entries) {
+            isDuplicate = entries.some((entry) => entry.id !== id && entry.title === title);
+        }
+        return isDuplicate ? `${title} (${id})` : `${title}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryNameColumnComponent, deps: [{ token: i0.ElementRef }, { token: i1.NodesApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LibraryNameColumnComponent, isStandalone: true, selector: "adf-library-name-column", inputs: { context: "context" }, host: { classAttribute: "adf-datatable-content-cell adf-datatable-link adf-library-name-column" }, ngImport: i0, template: `
+        <span
+            role="link"
+            [attr.aria-label]="
+                'NAME_COLUMN_LINK.ACCESSIBILITY.ARIA_LABEL'
+                    | translate
+                        : {
+                              name: displayText$ | async
+                          }
+            "
+            class="adf-datatable-cell-value"
+            title="{{ displayTooltip$ | async }}"
+            (click)="onClick()"
+            tabindex="0"
+            (keyup.enter)="onClick()"
+        >
+            {{ displayText$ | async }}
+        </span>
+    `, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryNameColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-library-name-column',
+                    standalone: true,
+                    imports: [AsyncPipe, TranslatePipe],
+                    template: `
+        <span
+            role="link"
+            [attr.aria-label]="
+                'NAME_COLUMN_LINK.ACCESSIBILITY.ARIA_LABEL'
+                    | translate
+                        : {
+                              name: displayText$ | async
+                          }
+            "
+            class="adf-datatable-cell-value"
+            title="{{ displayTooltip$ | async }}"
+            (click)="onClick()"
+            tabindex="0"
+            (keyup.enter)="onClick()"
+        >
+            {{ displayText$ | async }}
+        </span>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'adf-datatable-content-cell adf-datatable-link adf-library-name-column'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.NodesApiService }], propDecorators: { context: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"library-name-column.component.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/document-list/components/library-name-column/library-name-column.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, OnInit, ViewEncapsulation } from '@angular/core';\nimport { NodeEntry, Site } from '@alfresco/js-api';\nimport { ShareDataRow } from '../../data/share-data-row.model';\nimport { NodesApiService } from '../../../common/services/nodes-api.service';\nimport { BehaviorSubject } from 'rxjs';\nimport { AsyncPipe } from '@angular/common';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Component({\n    selector: 'adf-library-name-column',\n    standalone: true,\n    imports: [AsyncPipe, TranslatePipe],\n    template: `\n        <span\n            role=\"link\"\n            [attr.aria-label]=\"\n                'NAME_COLUMN_LINK.ACCESSIBILITY.ARIA_LABEL'\n                    | translate\n                        : {\n                              name: displayText$ | async\n                          }\n            \"\n            class=\"adf-datatable-cell-value\"\n            title=\"{{ displayTooltip$ | async }}\"\n            (click)=\"onClick()\"\n            tabindex=\"0\"\n            (keyup.enter)=\"onClick()\"\n        >\n            {{ displayText$ | async }}\n        </span>\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        class: 'adf-datatable-content-cell adf-datatable-link adf-library-name-column'\n    }\n})\nexport class LibraryNameColumnComponent implements OnInit {\n    @Input({ required: true })\n    context: any;\n\n    displayTooltip$ = new BehaviorSubject<string>('');\n    displayText$ = new BehaviorSubject<string>('');\n    node: NodeEntry;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    constructor(private element: ElementRef, private nodesApiService: NodesApiService) {}\n\n    ngOnInit() {\n        this.updateValue();\n\n        this.nodesApiService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node) => {\n            const row: ShareDataRow = this.context.row;\n            if (row) {\n                const { entry } = row.node;\n\n                if (entry === node) {\n                    row.node = { entry };\n                    this.updateValue();\n                }\n            }\n        });\n    }\n\n    protected updateValue() {\n        this.node = this.context.row.node;\n        const rows: Array<ShareDataRow> = this.context.data.rows || [];\n        if (this.node?.entry) {\n            this.displayText$.next(this.makeLibraryTitle(this.node.entry as any, rows));\n            this.displayTooltip$.next(this.makeLibraryTooltip(this.node.entry));\n        }\n    }\n\n    onClick() {\n        this.element.nativeElement.dispatchEvent(\n            new CustomEvent('name-click', {\n                bubbles: true,\n                detail: {\n                    node: this.node\n                }\n            })\n        );\n    }\n\n    makeLibraryTooltip(library: any): string {\n        const { description, title } = library;\n\n        return description || title || '';\n    }\n\n    makeLibraryTitle(library: Site, rows: Array<ShareDataRow>): string {\n        const entries = rows.map((row: ShareDataRow) => row.node.entry);\n        const { title, id } = library;\n\n        let isDuplicate = false;\n\n        if (entries) {\n            isDuplicate = entries.some((entry: any) => entry.id !== id && entry.title === title);\n        }\n\n        return isDuplicate ? `${title} (${id})` : `${title}`;\n    }\n}\n"]}

package/esm2022/lib/document-list/components/library-role-column/library-role-column.component.mjs

@@ -0,0 +1,91 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, DestroyRef, inject, Input, ViewEncapsulation } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Site } from '@alfresco/js-api';
+import { NodesApiService } from '../../../common/services/nodes-api.service';
+import { AsyncPipe } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/services/nodes-api.service";
+export class LibraryRoleColumnComponent {
+    constructor(nodesApiService) {
+        this.nodesApiService = nodesApiService;
+        this.displayText$ = new BehaviorSubject('');
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.updateValue();
+        this.nodesApiService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node) => {
+            const row = this.context.row;
+            if (row) {
+                const { entry } = row.node;
+                if (entry === node) {
+                    row.node = { entry };
+                    this.updateValue();
+                }
+            }
+        });
+    }
+    updateValue() {
+        const role = this.context.row.node?.entry.role ?? this.context.row.obj.role;
+        switch (role) {
+            case Site.RoleEnum.SiteManager:
+                this.displayText$.next('LIBRARY.ROLE.MANAGER');
+                break;
+            case Site.RoleEnum.SiteCollaborator:
+                this.displayText$.next('LIBRARY.ROLE.COLLABORATOR');
+                break;
+            case Site.RoleEnum.SiteContributor:
+                this.displayText$.next('LIBRARY.ROLE.CONTRIBUTOR');
+                break;
+            case Site.RoleEnum.SiteConsumer:
+                this.displayText$.next('LIBRARY.ROLE.CONSUMER');
+                break;
+            default:
+                this.displayText$.next('LIBRARY.ROLE.NONE');
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryRoleColumnComponent, deps: [{ token: i1.NodesApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LibraryRoleColumnComponent, isStandalone: true, selector: "adf-library-role-column", inputs: { context: "context" }, host: { classAttribute: "adf-library-role-column adf-datatable-content-cell" }, ngImport: i0, template: `
+        <span class="adf-datatable-cell-value" title="{{ displayText$ | async | translate }}">
+            {{ displayText$ | async | translate }}
+        </span>
+    `, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryRoleColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-library-role-column',
+                    standalone: true,
+                    imports: [AsyncPipe, TranslatePipe],
+                    template: `
+        <span class="adf-datatable-cell-value" title="{{ displayText$ | async | translate }}">
+            {{ displayText$ | async | translate }}
+        </span>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'adf-library-role-column adf-datatable-content-cell' }
+                }]
+        }], ctorParameters: () => [{ type: i1.NodesApiService }], propDecorators: { context: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/components/library-status-column/library-status-column.component.mjs

@@ -0,0 +1,86 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, DestroyRef, inject, Input } from '@angular/core';
+import { NodesApiService } from '../../../common/services/nodes-api.service';
+import { BehaviorSubject } from 'rxjs';
+import { Site } from '@alfresco/js-api';
+import { AsyncPipe } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/services/nodes-api.service";
+export class LibraryStatusColumnComponent {
+    constructor(nodesApiService) {
+        this.nodesApiService = nodesApiService;
+        this.displayText$ = new BehaviorSubject('');
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngOnInit() {
+        this.updateValue();
+        this.nodesApiService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node) => {
+            const row = this.context.row;
+            if (row) {
+                const { entry } = row.node;
+                if (entry === node) {
+                    row.node = { entry };
+                    this.updateValue();
+                }
+            }
+        });
+    }
+    updateValue() {
+        const visibility = this.context.row.node?.entry.visibility ?? this.context.row.obj.visibility;
+        switch (visibility) {
+            case Site.VisibilityEnum.PUBLIC:
+                this.displayText$.next('LIBRARY.VISIBILITY.PUBLIC');
+                break;
+            case Site.VisibilityEnum.PRIVATE:
+                this.displayText$.next('LIBRARY.VISIBILITY.PRIVATE');
+                break;
+            case Site.VisibilityEnum.MODERATED:
+                this.displayText$.next('LIBRARY.VISIBILITY.MODERATED');
+                break;
+            default:
+                this.displayText$.next('UNKNOWN');
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryStatusColumnComponent, deps: [{ token: i1.NodesApiService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LibraryStatusColumnComponent, isStandalone: true, selector: "adf-library-status-column", inputs: { context: "context" }, host: { classAttribute: "adf-library-status-column adf-datatable-content-cell" }, ngImport: i0, template: `
+        <span class="adf-datatable-cell-value" title="{{ displayText$ | async | translate }}">
+            {{ displayText$ | async | translate }}
+        </span>
+    `, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LibraryStatusColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-library-status-column',
+                    standalone: true,
+                    imports: [AsyncPipe, TranslatePipe],
+                    template: `
+        <span class="adf-datatable-cell-value" title="{{ displayText$ | async | translate }}">
+            {{ displayText$ | async | translate }}
+        </span>
+    `,
+                    host: { class: 'adf-library-status-column adf-datatable-content-cell' }
+                }]
+        }], ctorParameters: () => [{ type: i1.NodesApiService }], propDecorators: { context: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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