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

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

@@ -0,0 +1,118 @@
+/*!
+ * @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 { BehaviorSubject } from 'rxjs';
+import { NodesApiService } from '../../../common/services/nodes-api.service';
+import { AsyncPipe } from '@angular/common';
+import { TranslatePipe } from '@ngx-translate/core';
+import { NodeNameTooltipPipe } from '../../../pipes/node-name-tooltip.pipe';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/services/nodes-api.service";
+export class NameColumnComponent {
+    constructor(element, nodesApiService) {
+        this.element = element;
+        this.nodesApiService = nodesApiService;
+        this.key = 'name';
+        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;
+        if (this.node?.entry) {
+            const displayText = this.context.row.getValue(this.key);
+            this.displayText$.next(displayText || this.node.entry.id);
+        }
+    }
+    onClick() {
+        this.element.nativeElement.dispatchEvent(new CustomEvent('name-click', {
+            bubbles: true,
+            detail: {
+                node: this.node
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NameColumnComponent, 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: NameColumnComponent, isStandalone: true, selector: "adf-name-column", inputs: { context: "context", key: "key" }, host: { classAttribute: "adf-datatable-content-cell adf-datatable-link adf-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="{{ node | adfNodeNameTooltip }}"
+            (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" }, { kind: "pipe", type: NodeNameTooltipPipe, name: "adfNodeNameTooltip" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NameColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-name-column',
+                    standalone: true,
+                    imports: [AsyncPipe, TranslatePipe, NodeNameTooltipPipe],
+                    template: `
+        <span
+            role="link"
+            [attr.aria-label]="
+                'NAME_COLUMN_LINK.ACCESSIBILITY.ARIA_LABEL'
+                    | translate
+                        : {
+                              name: displayText$ | async
+                          }
+            "
+            class="adf-datatable-cell-value"
+            title="{{ node | adfNodeNameTooltip }}"
+            (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-name-column' }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.NodesApiService }], propDecorators: { context: [{
+                type: Input,
+                args: [{ required: true }]
+            }], key: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/components/node.event.mjs

@@ -0,0 +1,30 @@
+/*!
+ * @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 { BaseEvent } from '@alfresco/adf-core';
+export class NodeEntityEvent extends BaseEvent {
+    constructor(nodeEntry) {
+        super();
+        this.value = nodeEntry;
+    }
+}
+export class NodeEntryEvent extends BaseEvent {
+    constructor(node) {
+        super();
+        this.value = node;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS5ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvZG9jdW1lbnQtbGlzdC9jb21wb25lbnRzL25vZGUuZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRy9DLE1BQU0sT0FBTyxlQUFnQixTQUFRLFNBQW9CO0lBQ3JELFlBQVksU0FBb0I7UUFDNUIsS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQztJQUMzQixDQUFDO0NBQ0o7QUFFRCxNQUFNLE9BQU8sY0FBZSxTQUFRLFNBQWU7SUFDL0MsWUFBWSxJQUFVO1FBQ2xCLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7SUFDdEIsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBCYXNlRXZlbnQgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvcmUnO1xuaW1wb3J0IHsgTm9kZUVudHJ5LCBOb2RlIH0gZnJvbSAnQGFsZnJlc2NvL2pzLWFwaSc7XG5cbmV4cG9ydCBjbGFzcyBOb2RlRW50aXR5RXZlbnQgZXh0ZW5kcyBCYXNlRXZlbnQ8Tm9kZUVudHJ5PiB7XG4gICAgY29uc3RydWN0b3Iobm9kZUVudHJ5OiBOb2RlRW50cnkpIHtcbiAgICAgICAgc3VwZXIoKTtcbiAgICAgICAgdGhpcy52YWx1ZSA9IG5vZGVFbnRyeTtcbiAgICB9XG59XG5cbmV4cG9ydCBjbGFzcyBOb2RlRW50cnlFdmVudCBleHRlbmRzIEJhc2VFdmVudDxOb2RlPiB7XG4gICAgY29uc3RydWN0b3Iobm9kZTogTm9kZSkge1xuICAgICAgICBzdXBlcigpO1xuICAgICAgICB0aGlzLnZhbHVlID0gbm9kZTtcbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,83 @@
+/*!
+ * @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, Input, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NodeNameTooltipPipe } from '../../../pipes/node-name-tooltip.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class TrashcanNameColumnComponent {
+    constructor() {
+        this.isLibrary = false;
+    }
+    ngOnInit() {
+        this.node = this.context.row.node;
+        const rows = this.context.data.rows || [];
+        if (this.node?.entry) {
+            this.isLibrary = this.node.entry.nodeType === 'st:site';
+            if (this.isLibrary) {
+                const { properties } = this.node.entry;
+                this.displayText = this.makeLibraryTitle(this.node.entry, rows);
+                this.displayTooltip = properties['cm:description'] || properties['cm:title'];
+            }
+            else {
+                this.displayText = this.node.entry.name || this.node.entry.id;
+            }
+        }
+    }
+    makeLibraryTitle(library, rows) {
+        const entries = rows.map((r) => r.node.entry);
+        const { id } = library;
+        const title = library.properties['cm:title'];
+        let isDuplicate = false;
+        if (entries) {
+            isDuplicate = entries.some((entry) => entry.id !== id && entry.properties['cm:title'] === title);
+        }
+        return isDuplicate ? `${library.properties['cm:title']} (${library.name})` : `${library.properties['cm:title']}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrashcanNameColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TrashcanNameColumnComponent, isStandalone: true, selector: "adf-trashcan-name-column", inputs: { context: "context" }, host: { classAttribute: "adf-datatable-content-cell adf-trashcan-name-column" }, ngImport: i0, template: `
+        <ng-container *ngIf="!isLibrary">
+            <span class="adf-datatable-cell-value" title="{{ node | adfNodeNameTooltip }}">{{ displayText }}</span>
+        </ng-container>
+        <ng-container *ngIf="isLibrary">
+            <span class="adf-datatable-cell-value" title="{{ displayTooltip }}">{{ displayText }}</span>
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: NodeNameTooltipPipe, name: "adfNodeNameTooltip" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrashcanNameColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-trashcan-name-column',
+                    standalone: true,
+                    imports: [CommonModule, NodeNameTooltipPipe],
+                    template: `
+        <ng-container *ngIf="!isLibrary">
+            <span class="adf-datatable-cell-value" title="{{ node | adfNodeNameTooltip }}">{{ displayText }}</span>
+        </ng-container>
+        <ng-container *ngIf="isLibrary">
+            <span class="adf-datatable-cell-value" title="{{ displayTooltip }}">{{ displayText }}</span>
+        </ng-container>
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'adf-datatable-content-cell adf-trashcan-name-column' }
+                }]
+        }], propDecorators: { context: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhc2hjYW4tbmFtZS1jb2x1bW4uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9kb2N1bWVudC1saXN0L2NvbXBvbmVudHMvdHJhc2hjYW4tbmFtZS1jb2x1bW4vdHJhc2hjYW4tbmFtZS1jb2x1bW4uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFVLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR3JHLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQzs7O0FBa0I1RSxNQUFNLE9BQU8sMkJBQTJCO0lBaEJ4QztRQW9CSSxjQUFTLEdBQUcsS0FBSyxDQUFDO0tBb0NyQjtJQS9CRyxRQUFRO1FBQ0osSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUM7UUFDbEMsTUFBTSxJQUFJLEdBQXdCLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxFQUFFLENBQUM7UUFFL0QsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxLQUFLLFNBQVMsQ0FBQztZQUV4RCxJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztnQkFDakIsTUFBTSxFQUFFLFVBQVUsRUFBRSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO2dCQUV2QyxJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDaEUsSUFBSSxDQUFDLGNBQWMsR0FBRyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDakYsQ0FBQztpQkFBTSxDQUFDO2dCQUNKLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUNsRSxDQUFDO1FBQ0wsQ0FBQztJQUNMLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxPQUFZLEVBQUUsSUFBeUI7UUFDcEQsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQWUsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM1RCxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBQ3ZCLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFN0MsSUFBSSxXQUFXLEdBQUcsS0FBSyxDQUFDO1FBRXhCLElBQUksT0FBTyxFQUFFLENBQUM7WUFDVixXQUFXLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLEtBQVUsRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQUUsS0FBSyxFQUFFLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsS0FBSyxLQUFLLENBQUMsQ0FBQztRQUMxRyxDQUFDO1FBRUQsT0FBTyxXQUFXLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsS0FBSyxPQUFPLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO0lBQ3JILENBQUM7K0dBdkNRLDJCQUEyQjttR0FBM0IsMkJBQTJCLHFNQVoxQjs7Ozs7OztLQU9ULDJEQVJTLFlBQVksOEhBQUUsbUJBQW1COzs0RkFhbEMsMkJBQTJCO2tCQWhCdkMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsMEJBQTBCO29CQUNwQyxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLG1CQUFtQixDQUFDO29CQUM1QyxRQUFRLEVBQUU7Ozs7Ozs7S0FPVDtvQkFDRCxlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTtvQkFDL0MsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7b0JBQ3JDLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSxxREFBcUQsRUFBRTtpQkFDekU7OEJBR0csT0FBTztzQkFETixLQUFLO3VCQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgSW5wdXQsIE9uSW5pdCwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE5vZGVFbnRyeSB9IGZyb20gJ0BhbGZyZXNjby9qcy1hcGknO1xuaW1wb3J0IHsgU2hhcmVEYXRhUm93IH0gZnJvbSAnLi4vLi4vZGF0YS9zaGFyZS1kYXRhLXJvdy5tb2RlbCc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTm9kZU5hbWVUb29sdGlwUGlwZSB9IGZyb20gJy4uLy4uLy4uL3BpcGVzL25vZGUtbmFtZS10b29sdGlwLnBpcGUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2FkZi10cmFzaGNhbi1uYW1lLWNvbHVtbicsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBOb2RlTmFtZVRvb2x0aXBQaXBlXSxcbiAgICB0ZW1wbGF0ZTogYFxuICAgICAgICA8bmctY29udGFpbmVyICpuZ0lmPVwiIWlzTGlicmFyeVwiPlxuICAgICAgICAgICAgPHNwYW4gY2xhc3M9XCJhZGYtZGF0YXRhYmxlLWNlbGwtdmFsdWVcIiB0aXRsZT1cInt7IG5vZGUgfCBhZGZOb2RlTmFtZVRvb2x0aXAgfX1cIj57eyBkaXNwbGF5VGV4dCB9fTwvc3Bhbj5cbiAgICAgICAgPC9uZy1jb250YWluZXI+XG4gICAgICAgIDxuZy1jb250YWluZXIgKm5nSWY9XCJpc0xpYnJhcnlcIj5cbiAgICAgICAgICAgIDxzcGFuIGNsYXNzPVwiYWRmLWRhdGF0YWJsZS1jZWxsLXZhbHVlXCIgdGl0bGU9XCJ7eyBkaXNwbGF5VG9vbHRpcCB9fVwiPnt7IGRpc3BsYXlUZXh0IH19PC9zcGFuPlxuICAgICAgICA8L25nLWNvbnRhaW5lcj5cbiAgICBgLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICAgIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gICAgaG9zdDogeyBjbGFzczogJ2FkZi1kYXRhdGFibGUtY29udGVudC1jZWxsIGFkZi10cmFzaGNhbi1uYW1lLWNvbHVtbicgfVxufSlcbmV4cG9ydCBjbGFzcyBUcmFzaGNhbk5hbWVDb2x1bW5Db21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICAgIEBJbnB1dCh7IHJlcXVpcmVkOiB0cnVlIH0pXG4gICAgY29udGV4dDogYW55O1xuXG4gICAgaXNMaWJyYXJ5ID0gZmFsc2U7XG4gICAgZGlzcGxheVRleHQ6IHN0cmluZztcbiAgICBkaXNwbGF5VG9vbHRpcDogc3RyaW5nO1xuICAgIG5vZGU6IE5vZGVFbnRyeTtcblxuICAgIG5nT25Jbml0KCkge1xuICAgICAgICB0aGlzLm5vZGUgPSB0aGlzLmNvbnRleHQucm93Lm5vZGU7XG4gICAgICAgIGNvbnN0IHJvd3M6IEFycmF5PFNoYXJlRGF0YVJvdz4gPSB0aGlzLmNvbnRleHQuZGF0YS5yb3dzIHx8IFtdO1xuXG4gICAgICAgIGlmICh0aGlzLm5vZGU/LmVudHJ5KSB7XG4gICAgICAgICAgICB0aGlzLmlzTGlicmFyeSA9IHRoaXMubm9kZS5lbnRyeS5ub2RlVHlwZSA9PT0gJ3N0OnNpdGUnO1xuXG4gICAgICAgICAgICBpZiAodGhpcy5pc0xpYnJhcnkpIHtcbiAgICAgICAgICAgICAgICBjb25zdCB7IHByb3BlcnRpZXMgfSA9IHRoaXMubm9kZS5lbnRyeTtcblxuICAgICAgICAgICAgICAgIHRoaXMuZGlzcGxheVRleHQgPSB0aGlzLm1ha2VMaWJyYXJ5VGl0bGUodGhpcy5ub2RlLmVudHJ5LCByb3dzKTtcbiAgICAgICAgICAgICAgICB0aGlzLmRpc3BsYXlUb29sdGlwID0gcHJvcGVydGllc1snY206ZGVzY3JpcHRpb24nXSB8fCBwcm9wZXJ0aWVzWydjbTp0aXRsZSddO1xuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICB0aGlzLmRpc3BsYXlUZXh0ID0gdGhpcy5ub2RlLmVudHJ5Lm5hbWUgfHwgdGhpcy5ub2RlLmVudHJ5LmlkO1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgfVxuXG4gICAgbWFrZUxpYnJhcnlUaXRsZShsaWJyYXJ5OiBhbnksIHJvd3M6IEFycmF5PFNoYXJlRGF0YVJvdz4pOiBzdHJpbmcge1xuICAgICAgICBjb25zdCBlbnRyaWVzID0gcm93cy5tYXAoKHI6IFNoYXJlRGF0YVJvdykgPT4gci5ub2RlLmVudHJ5KTtcbiAgICAgICAgY29uc3QgeyBpZCB9ID0gbGlicmFyeTtcbiAgICAgICAgY29uc3QgdGl0bGUgPSBsaWJyYXJ5LnByb3BlcnRpZXNbJ2NtOnRpdGxlJ107XG5cbiAgICAgICAgbGV0IGlzRHVwbGljYXRlID0gZmFsc2U7XG5cbiAgICAgICAgaWYgKGVudHJpZXMpIHtcbiAgICAgICAgICAgIGlzRHVwbGljYXRlID0gZW50cmllcy5zb21lKChlbnRyeTogYW55KSA9PiBlbnRyeS5pZCAhPT0gaWQgJiYgZW50cnkucHJvcGVydGllc1snY206dGl0bGUnXSA9PT0gdGl0bGUpO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIGlzRHVwbGljYXRlID8gYCR7bGlicmFyeS5wcm9wZXJ0aWVzWydjbTp0aXRsZSddfSAoJHtsaWJyYXJ5Lm5hbWV9KWAgOiBgJHtsaWJyYXJ5LnByb3BlcnRpZXNbJ2NtOnRpdGxlJ119YDtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/document-list/data/image-resolver.model.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtcmVzb2x2ZXIubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL2RvY3VtZW50LWxpc3QvZGF0YS9pbWFnZS1yZXNvbHZlci5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IERhdGFDb2x1bW4sIERhdGFSb3cgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvcmUnO1xuXG5leHBvcnQgdHlwZSBJbWFnZVJlc29sdmVyID0gKHJvdzogRGF0YVJvdywgY29sdW1uOiBEYXRhQ29sdW1uKSA9PiBzdHJpbmc7XG4iXX0=

package/esm2022/lib/document-list/data/row-filter.model.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LWZpbHRlci5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvZG9jdW1lbnQtbGlzdC9kYXRhL3Jvdy1maWx0ZXIubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBTaGFyZURhdGFSb3cgfSBmcm9tICcuL3NoYXJlLWRhdGEtcm93Lm1vZGVsJztcblxuZXhwb3J0IHR5cGUgUm93RmlsdGVyID0gKHZhbHVlOiBTaGFyZURhdGFSb3csIGluZGV4OiBudW1iZXIsIGFycmF5OiBTaGFyZURhdGFSb3dbXSkgPT4gYW55O1xuIl19

package/esm2022/lib/document-list/data/share-data-row.model.mjs

@@ -0,0 +1,102 @@
+/*!
+ * @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 { ObjectUtils } from '@alfresco/adf-core';
+export const ERR_OBJECT_NOT_FOUND = 'Object source not found';
+export class ShareDataRow {
+    get node() {
+        return this.obj;
+    }
+    set node(value) {
+        this.obj = value;
+        this.cache = {};
+    }
+    constructor(obj, contentService, permissionsStyle, thumbnailService, allowDropFiles) {
+        this.obj = obj;
+        this.contentService = contentService;
+        this.permissionsStyle = permissionsStyle;
+        this.thumbnailService = thumbnailService;
+        this.allowDropFiles = allowDropFiles;
+        this.cache = {};
+        this.isSelected = false;
+        this.isSelectable = true;
+        this.cssClass = '';
+        if (!obj) {
+            throw new Error(ERR_OBJECT_NOT_FOUND);
+        }
+        this.isDropTarget =
+            allowDropFiles !== undefined ? this.allowDropFiles && this.checkNodeTypeAndPermissions(obj) : this.checkNodeTypeAndPermissions(obj);
+        if (permissionsStyle) {
+            this.cssClass = this.getPermissionClass(obj);
+        }
+        this.id = this.getId();
+    }
+    checkNodeTypeAndPermissions(nodeEntry) {
+        return this.isFolderAndHasPermissionToUpload(nodeEntry) || this.isFileAndHasParentFolderPermissionToUpload(nodeEntry);
+    }
+    getPermissionClass(nodeEntity) {
+        let permissionsClasses = '';
+        this.permissionsStyle.forEach((currentPermissionsStyle) => {
+            if (this.applyPermissionStyleToFolder(nodeEntity.entry, currentPermissionsStyle) ||
+                this.applyPermissionStyleToFile(nodeEntity.entry, currentPermissionsStyle)) {
+                if (this.contentService.hasAllowableOperations(nodeEntity.entry, currentPermissionsStyle.permission)) {
+                    permissionsClasses += ` ${currentPermissionsStyle.css}`;
+                }
+            }
+        });
+        return permissionsClasses;
+    }
+    applyPermissionStyleToFile(node, currentPermissionsStyle) {
+        return currentPermissionsStyle.isFile && node.isFile;
+    }
+    applyPermissionStyleToFolder(node, currentPermissionsStyle) {
+        return currentPermissionsStyle.isFolder && node.isFolder;
+    }
+    isFolderAndHasPermissionToUpload(nodeEntry) {
+        return this.isFolder(nodeEntry) && this.contentService.hasAllowableOperations(nodeEntry.entry, 'create');
+    }
+    isFileAndHasParentFolderPermissionToUpload(nodeEntry) {
+        return this.isFile(nodeEntry) && this.contentService.hasAllowableOperations(nodeEntry.entry, 'update');
+    }
+    isFile(nodeEntry) {
+        return nodeEntry.entry?.isFile;
+    }
+    isFolder(nodeEntry) {
+        return nodeEntry.entry?.isFolder;
+    }
+    cacheValue(key, value) {
+        this.cache[key] = value;
+        return value;
+    }
+    getValue(key) {
+        if (this.cache[key]) {
+            return this.cache[key];
+        }
+        return ObjectUtils.getValue(this.obj.entry, key);
+    }
+    imageErrorResolver() {
+        if (this.obj.entry.content) {
+            return this.thumbnailService.getMimeTypeIcon(this.obj.entry.content.mimeType);
+        }
+    }
+    hasValue(key) {
+        return this.getValue(key) !== undefined;
+    }
+    getId() {
+        return this.obj.entry.id || undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"share-data-row.model.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/data/share-data-row.model.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 { DataRow, ObjectUtils, ThumbnailService } from '@alfresco/adf-core';\nimport { Node, NodeEntry } from '@alfresco/js-api';\nimport { PermissionStyleModel } from './../models/permissions-style.model';\nimport { ContentService } from './../../common/services/content.service';\n\nexport const ERR_OBJECT_NOT_FOUND: string = 'Object source not found';\n\nexport class ShareDataRow implements DataRow {\n    cache: { [key: string]: any } = {};\n    isSelected: boolean = false;\n    isSelectable: boolean = true;\n    isDropTarget: boolean;\n    cssClass: string = '';\n    id: string;\n\n    get node(): NodeEntry {\n        return this.obj;\n    }\n\n    set node(value: NodeEntry) {\n        this.obj = value;\n        this.cache = {};\n    }\n\n    constructor(\n        private obj: NodeEntry,\n        private contentService: ContentService,\n        private permissionsStyle: PermissionStyleModel[],\n        private thumbnailService?: ThumbnailService,\n        private allowDropFiles?: boolean\n    ) {\n        if (!obj) {\n            throw new Error(ERR_OBJECT_NOT_FOUND);\n        }\n\n        this.isDropTarget =\n            allowDropFiles !== undefined ? this.allowDropFiles && this.checkNodeTypeAndPermissions(obj) : this.checkNodeTypeAndPermissions(obj);\n        if (permissionsStyle) {\n            this.cssClass = this.getPermissionClass(obj);\n        }\n        this.id = this.getId();\n    }\n\n    checkNodeTypeAndPermissions(nodeEntry: NodeEntry) {\n        return this.isFolderAndHasPermissionToUpload(nodeEntry) || this.isFileAndHasParentFolderPermissionToUpload(nodeEntry);\n    }\n\n    getPermissionClass(nodeEntity: NodeEntry): string {\n        let permissionsClasses = '';\n\n        this.permissionsStyle.forEach((currentPermissionsStyle: PermissionStyleModel) => {\n            if (\n                this.applyPermissionStyleToFolder(nodeEntity.entry, currentPermissionsStyle) ||\n                this.applyPermissionStyleToFile(nodeEntity.entry, currentPermissionsStyle)\n            ) {\n                if (this.contentService.hasAllowableOperations(nodeEntity.entry, currentPermissionsStyle.permission)) {\n                    permissionsClasses += ` ${currentPermissionsStyle.css}`;\n                }\n            }\n        });\n\n        return permissionsClasses;\n    }\n\n    private applyPermissionStyleToFile(node: Node, currentPermissionsStyle: PermissionStyleModel): boolean {\n        return currentPermissionsStyle.isFile && node.isFile;\n    }\n\n    private applyPermissionStyleToFolder(node: Node, currentPermissionsStyle: PermissionStyleModel): boolean {\n        return currentPermissionsStyle.isFolder && node.isFolder;\n    }\n\n    isFolderAndHasPermissionToUpload(nodeEntry: NodeEntry): boolean {\n        return this.isFolder(nodeEntry) && this.contentService.hasAllowableOperations(nodeEntry.entry, 'create');\n    }\n\n    isFileAndHasParentFolderPermissionToUpload(nodeEntry: NodeEntry): boolean {\n        return this.isFile(nodeEntry) && this.contentService.hasAllowableOperations(nodeEntry.entry, 'update');\n    }\n\n    isFile(nodeEntry: NodeEntry): boolean {\n        return nodeEntry.entry?.isFile;\n    }\n\n    isFolder(nodeEntry: NodeEntry): boolean {\n        return nodeEntry.entry?.isFolder;\n    }\n\n    cacheValue(key: string, value: any): any {\n        this.cache[key] = value;\n        return value;\n    }\n\n    getValue(key: string): any {\n        if (this.cache[key]) {\n            return this.cache[key];\n        }\n        return ObjectUtils.getValue(this.obj.entry, key);\n    }\n\n    imageErrorResolver(): any {\n        if (this.obj.entry.content) {\n            return this.thumbnailService.getMimeTypeIcon(this.obj.entry.content.mimeType);\n        }\n    }\n\n    hasValue(key: string): boolean {\n        return this.getValue(key) !== undefined;\n    }\n\n    getId(): string {\n        return this.obj.entry.id || undefined;\n    }\n}\n"]}