@alfresco/adf-content-services 8.1.0-16120632321 → 8.1.0-16121703802

package/esm2022/lib/document-list/data/share-datatable-adapter.mjs

@@ -0,0 +1,258 @@
+/*!
+ * @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 { DataSorting } from '@alfresco/adf-core';
+import { ShareDataRow } from './share-data-row.model';
+export const ERR_ROW_NOT_FOUND = 'Row not found';
+export const ERR_COL_NOT_FOUND = 'Column not found';
+export class ShareDataTableAdapter {
+    set sortingMode(value) {
+        let newValue = (value || 'client').toLowerCase();
+        if (newValue !== 'client' && newValue !== 'server') {
+            newValue = 'client';
+        }
+        this._sortingMode = newValue;
+    }
+    get sortingMode() {
+        return this._sortingMode;
+    }
+    constructor(thumbnailService, contentService, schema = [], sorting, sortingMode = 'client', allowDropFiles = false) {
+        this.thumbnailService = thumbnailService;
+        this.contentService = contentService;
+        this.thumbnails = false;
+        this.rows = [];
+        this.columns = schema || [];
+        this.sorting = sorting;
+        this.sortingMode = sortingMode;
+        this.allowDropFiles = allowDropFiles;
+    }
+    getColumnType(_row, col) {
+        return col.type;
+    }
+    getRows() {
+        return this.rows;
+    }
+    // TODO: disable this api
+    setRows(rows) {
+        this.rows = rows || [];
+        this.sort();
+    }
+    getColumns() {
+        return this.columns;
+    }
+    setColumns(columns) {
+        this.columns = columns || [];
+    }
+    getValue(row, col) {
+        if (!row) {
+            throw new Error(ERR_ROW_NOT_FOUND);
+        }
+        if (!col) {
+            throw new Error(ERR_COL_NOT_FOUND);
+        }
+        const dataRow = row;
+        const value = row.getValue(col.key);
+        if (dataRow.cache[col.key]) {
+            return dataRow.cache[col.key];
+        }
+        if (col.key === '$thumbnail') {
+            if (this.imageResolver) {
+                const resolved = this.imageResolver(row, col);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+            const node = row.node;
+            if (node.entry.isFolder) {
+                return this.getFolderIcon(node);
+            }
+            if (node.entry.isFile) {
+                if (this.thumbnails) {
+                    return this.getDocumentThumbnailUrl(node);
+                }
+            }
+            if (node.entry.content) {
+                const mimeType = node.entry.content.mimeType;
+                if (mimeType) {
+                    return this.thumbnailService.getMimeTypeIcon(mimeType);
+                }
+            }
+            return this.thumbnailService.getDefaultMimeTypeIcon();
+        }
+        if (col.type === 'image') {
+            if (this.imageResolver) {
+                const resolved = this.imageResolver(row, col);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        return dataRow.cacheValue(col.key, value);
+    }
+    /**
+     * Gets a thumbnail URL for the given document node.
+     *
+     * @param node Node or Node ID to get URL for.
+     * @param attachment Toggles whether to retrieve content as an attachment for download
+     * @param ticket Custom ticket to use for authentication
+     * @returns URL string
+     */
+    getDocumentThumbnailUrl(node, attachment, ticket) {
+        let resultUrl;
+        if (node) {
+            let nodeId;
+            if (typeof node === 'string') {
+                nodeId = node;
+            }
+            else if (node.entry) {
+                nodeId = node.entry.id;
+            }
+            resultUrl = this.contentService.getDocumentThumbnailUrl(nodeId, attachment, ticket);
+        }
+        return resultUrl || this.thumbnailService.getMimeTypeIcon(node.entry.content.mimeType);
+    }
+    getSorting() {
+        return this.sorting;
+    }
+    setSorting(sorting) {
+        this.sorting = sorting;
+        this.sortRows(this.rows, this.sorting);
+    }
+    sort(key, direction) {
+        const sorting = this.sorting || new DataSorting();
+        if (key) {
+            sorting.key = key;
+            sorting.direction = direction || 'asc';
+        }
+        this.setSorting(sorting);
+    }
+    setFilter(filter) {
+        this.filter = filter;
+    }
+    setImageResolver(resolver) {
+        this.imageResolver = resolver;
+    }
+    getFolderIcon(node) {
+        if (this.isSmartFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('smartFolder');
+        }
+        else if (this.isRuleFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('ruleFolder');
+        }
+        else if (this.isALinkFolder(node)) {
+            return this.thumbnailService.getMimeTypeIcon('linkFolder');
+        }
+        else {
+            return this.thumbnailService.getMimeTypeIcon('folder');
+        }
+    }
+    isSmartFolder(node) {
+        const nodeAspects = this.getNodeAspectNames(node);
+        return nodeAspects.indexOf('smf:customConfigSmartFolder') > -1 || nodeAspects.indexOf('smf:systemConfigSmartFolder') > -1;
+    }
+    isRuleFolder(node) {
+        const nodeAspects = this.getNodeAspectNames(node);
+        return nodeAspects.indexOf('rule:rules') > -1;
+    }
+    isALinkFolder(node) {
+        const nodeType = node.entry ? node.entry.nodeType : node.nodeType;
+        return nodeType === 'app:folderlink';
+    }
+    getNodeAspectNames(node) {
+        return node.entry?.aspectNames ? node.entry.aspectNames : node.aspectNames ? node.aspectNames : [];
+    }
+    sortRows(rows, sorting) {
+        if (this.sortingMode === 'server') {
+            return;
+        }
+        const options = {};
+        if (sorting?.key && rows?.length) {
+            if (sorting.key.includes('sizeInBytes') || sorting.key === 'name') {
+                options.numeric = true;
+            }
+            rows.sort((a, b) => {
+                if (a.node.entry.isFolder !== b.node.entry.isFolder) {
+                    return a.node.entry.isFolder ? -1 : 1;
+                }
+                let left = a.getValue(sorting.key);
+                if (left) {
+                    left = left instanceof Date ? left.valueOf().toString() : left.toString();
+                }
+                else {
+                    left = '';
+                }
+                let right = b.getValue(sorting.key);
+                if (right) {
+                    right = right instanceof Date ? right.valueOf().toString() : right.toString();
+                }
+                else {
+                    right = '';
+                }
+                return sorting.direction === 'asc' ? left.localeCompare(right, undefined, options) : right.localeCompare(left, undefined, options);
+            });
+        }
+    }
+    loadPage(nodePaging, merge = false, allowDropFiles) {
+        let shareDataRows = [];
+        if (allowDropFiles !== undefined) {
+            this.allowDropFiles = allowDropFiles;
+        }
+        if (nodePaging?.list) {
+            const nodeEntries = nodePaging.list.entries;
+            if (nodeEntries?.length) {
+                shareDataRows = nodeEntries.map((item) => new ShareDataRow(item, this.contentService, this.permissionsStyle, this.thumbnailService, this.allowDropFiles));
+                if (this.filter) {
+                    shareDataRows = shareDataRows.filter(this.filter);
+                }
+                if (this.sortingMode !== 'server') {
+                    // Sort by first sortable or just first column
+                    if (this.columns?.length) {
+                        const sorting = this.getSorting();
+                        if (sorting) {
+                            this.sortRows(shareDataRows, sorting);
+                        }
+                        else {
+                            const sortable = this.columns.filter((c) => c.sortable);
+                            if (sortable.length > 0) {
+                                this.sort(sortable[0].key, 'asc');
+                            }
+                            else {
+                                this.sort(this.columns[0].key, 'asc');
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (merge) {
+            const listPrunedDuplicate = shareDataRows.filter((elementToFilter) => {
+                const isPresent = this.rows.find((currentRow) => currentRow.obj.entry.id === elementToFilter.obj.entry.id);
+                return !isPresent;
+            });
+            this.rows = this.rows.concat(listPrunedDuplicate);
+        }
+        else {
+            this.rows = shareDataRows;
+        }
+    }
+    getSelectedRows() {
+        return this.rows.filter((row) => row.isSelected);
+    }
+    getRowByNodeId(nodeId) {
+        return this.rows.find((row) => row.node.entry.id === nodeId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"share-datatable-adapter.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/data/share-datatable-adapter.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 { DataColumn, DataRow, DataSorting, DataTableAdapter, ThumbnailService } from '@alfresco/adf-core';\nimport { NodePaging, NodeEntry } from '@alfresco/js-api';\nimport { PermissionStyleModel } from './../models/permissions-style.model';\nimport { ShareDataRow } from './share-data-row.model';\nimport { RowFilter } from './row-filter.model';\nimport { ContentService } from '../../common/services/content.service';\n\nexport const ERR_ROW_NOT_FOUND: string = 'Row not found';\nexport const ERR_COL_NOT_FOUND: string = 'Column not found';\n\nexport class ShareDataTableAdapter implements DataTableAdapter {\n    private _sortingMode: string;\n    private sorting: DataSorting;\n    private rows: DataRow[];\n    private columns: DataColumn[];\n\n    private filter: RowFilter;\n    private imageResolver: any;\n\n    thumbnails: boolean = false;\n    permissionsStyle: PermissionStyleModel[];\n    selectedRow: DataRow;\n    allowDropFiles: boolean;\n\n    set sortingMode(value: string) {\n        let newValue = (value || 'client').toLowerCase();\n        if (newValue !== 'client' && newValue !== 'server') {\n            newValue = 'client';\n        }\n        this._sortingMode = newValue;\n    }\n\n    get sortingMode(): string {\n        return this._sortingMode;\n    }\n\n    constructor(\n        private thumbnailService: ThumbnailService,\n        private contentService: ContentService,\n        schema: DataColumn[] = [],\n        sorting?: DataSorting,\n        sortingMode: string = 'client',\n        allowDropFiles: boolean = false\n    ) {\n        this.rows = [];\n        this.columns = schema || [];\n        this.sorting = sorting;\n        this.sortingMode = sortingMode;\n        this.allowDropFiles = allowDropFiles;\n    }\n\n    getColumnType(_row: DataRow, col: DataColumn): string {\n        return col.type;\n    }\n\n    getRows(): Array<DataRow> {\n        return this.rows;\n    }\n\n    // TODO: disable this api\n    setRows(rows: Array<DataRow>) {\n        this.rows = rows || [];\n        this.sort();\n    }\n\n    getColumns(): Array<DataColumn> {\n        return this.columns;\n    }\n\n    setColumns(columns: Array<DataColumn>) {\n        this.columns = columns || [];\n    }\n\n    getValue(row: DataRow, col: DataColumn): any {\n        if (!row) {\n            throw new Error(ERR_ROW_NOT_FOUND);\n        }\n        if (!col) {\n            throw new Error(ERR_COL_NOT_FOUND);\n        }\n        const dataRow = row as ShareDataRow;\n        const value: any = row.getValue(col.key);\n        if (dataRow.cache[col.key]) {\n            return dataRow.cache[col.key];\n        }\n\n        if (col.key === '$thumbnail') {\n            if (this.imageResolver) {\n                const resolved = this.imageResolver(row, col);\n                if (resolved) {\n                    return resolved;\n                }\n            }\n\n            const node = row.node;\n\n            if (node.entry.isFolder) {\n                return this.getFolderIcon(node);\n            }\n\n            if (node.entry.isFile) {\n                if (this.thumbnails) {\n                    return this.getDocumentThumbnailUrl(node);\n                }\n            }\n\n            if (node.entry.content) {\n                const mimeType = node.entry.content.mimeType;\n                if (mimeType) {\n                    return this.thumbnailService.getMimeTypeIcon(mimeType);\n                }\n            }\n\n            return this.thumbnailService.getDefaultMimeTypeIcon();\n        }\n\n        if (col.type === 'image') {\n            if (this.imageResolver) {\n                const resolved = this.imageResolver(row, col);\n                if (resolved) {\n                    return resolved;\n                }\n            }\n        }\n\n        return dataRow.cacheValue(col.key, value);\n    }\n\n    /**\n     * Gets a thumbnail URL for the given document node.\n     *\n     * @param node Node or Node ID to get URL for.\n     * @param attachment Toggles whether to retrieve content as an attachment for download\n     * @param ticket Custom ticket to use for authentication\n     * @returns URL string\n     */\n    private getDocumentThumbnailUrl(node: NodeEntry, attachment?: boolean, ticket?: string): string {\n        let resultUrl: string;\n\n        if (node) {\n            let nodeId: string;\n\n            if (typeof node === 'string') {\n                nodeId = node;\n            } else if (node.entry) {\n                nodeId = node.entry.id;\n            }\n\n            resultUrl = this.contentService.getDocumentThumbnailUrl(nodeId, attachment, ticket);\n        }\n\n        return resultUrl || this.thumbnailService.getMimeTypeIcon(node.entry.content.mimeType);\n    }\n\n    getSorting(): DataSorting {\n        return this.sorting;\n    }\n\n    setSorting(sorting: DataSorting): void {\n        this.sorting = sorting;\n\n        this.sortRows(this.rows, this.sorting);\n    }\n\n    sort(key?: string, direction?: string): void {\n        const sorting = this.sorting || new DataSorting();\n        if (key) {\n            sorting.key = key;\n            sorting.direction = direction || 'asc';\n        }\n        this.setSorting(sorting);\n    }\n\n    setFilter(filter: RowFilter) {\n        this.filter = filter;\n    }\n\n    setImageResolver(resolver: any) {\n        this.imageResolver = resolver;\n    }\n\n    private getFolderIcon(node: any) {\n        if (this.isSmartFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('smartFolder');\n        } else if (this.isRuleFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('ruleFolder');\n        } else if (this.isALinkFolder(node)) {\n            return this.thumbnailService.getMimeTypeIcon('linkFolder');\n        } else {\n            return this.thumbnailService.getMimeTypeIcon('folder');\n        }\n    }\n\n    isSmartFolder(node: any) {\n        const nodeAspects = this.getNodeAspectNames(node);\n        return nodeAspects.indexOf('smf:customConfigSmartFolder') > -1 || nodeAspects.indexOf('smf:systemConfigSmartFolder') > -1;\n    }\n\n    isRuleFolder(node: any) {\n        const nodeAspects = this.getNodeAspectNames(node);\n        return nodeAspects.indexOf('rule:rules') > -1;\n    }\n\n    isALinkFolder(node: any) {\n        const nodeType = node.entry ? node.entry.nodeType : node.nodeType;\n        return nodeType === 'app:folderlink';\n    }\n\n    private getNodeAspectNames(node: any): any[] {\n        return node.entry?.aspectNames ? node.entry.aspectNames : node.aspectNames ? node.aspectNames : [];\n    }\n\n    private sortRows(rows: DataRow[], sorting: DataSorting) {\n        if (this.sortingMode === 'server') {\n            return;\n        }\n\n        const options: Intl.CollatorOptions = {};\n\n        if (sorting?.key && rows?.length) {\n            if (sorting.key.includes('sizeInBytes') || sorting.key === 'name') {\n                options.numeric = true;\n            }\n\n            rows.sort((a: ShareDataRow, b: ShareDataRow) => {\n                if (a.node.entry.isFolder !== b.node.entry.isFolder) {\n                    return a.node.entry.isFolder ? -1 : 1;\n                }\n\n                let left = a.getValue(sorting.key);\n                if (left) {\n                    left = left instanceof Date ? left.valueOf().toString() : left.toString();\n                } else {\n                    left = '';\n                }\n\n                let right = b.getValue(sorting.key);\n                if (right) {\n                    right = right instanceof Date ? right.valueOf().toString() : right.toString();\n                } else {\n                    right = '';\n                }\n\n                return sorting.direction === 'asc' ? left.localeCompare(right, undefined, options) : right.localeCompare(left, undefined, options);\n            });\n        }\n    }\n\n    public loadPage(nodePaging: NodePaging, merge: boolean = false, allowDropFiles?: boolean) {\n        let shareDataRows: ShareDataRow[] = [];\n        if (allowDropFiles !== undefined) {\n            this.allowDropFiles = allowDropFiles;\n        }\n        if (nodePaging?.list) {\n            const nodeEntries: NodeEntry[] = nodePaging.list.entries;\n            if (nodeEntries?.length) {\n                shareDataRows = nodeEntries.map(\n                    (item) => new ShareDataRow(item, this.contentService, this.permissionsStyle, this.thumbnailService, this.allowDropFiles)\n                );\n\n                if (this.filter) {\n                    shareDataRows = shareDataRows.filter(this.filter);\n                }\n\n                if (this.sortingMode !== 'server') {\n                    // Sort by first sortable or just first column\n                    if (this.columns?.length) {\n                        const sorting = this.getSorting();\n                        if (sorting) {\n                            this.sortRows(shareDataRows, sorting);\n                        } else {\n                            const sortable = this.columns.filter((c) => c.sortable);\n                            if (sortable.length > 0) {\n                                this.sort(sortable[0].key, 'asc');\n                            } else {\n                                this.sort(this.columns[0].key, 'asc');\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        if (merge) {\n            const listPrunedDuplicate = shareDataRows.filter((elementToFilter: any) => {\n                const isPresent = this.rows.find((currentRow: any) => currentRow.obj.entry.id === elementToFilter.obj.entry.id);\n\n                return !isPresent;\n            });\n\n            this.rows = this.rows.concat(listPrunedDuplicate);\n        } else {\n            this.rows = shareDataRows;\n        }\n    }\n\n    getSelectedRows(): DataRow[] {\n        return this.rows.filter((row: DataRow) => row.isSelected);\n    }\n\n    getRowByNodeId(nodeId: string): DataRow {\n        return this.rows.find((row: DataRow) => row.node.entry.id === nodeId);\n    }\n}\n"]}

package/esm2022/lib/document-list/document-list.module.mjs

@@ -0,0 +1,75 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { ContentActionListComponent } from './components/content-action/content-action-list.component';
+import { ContentActionComponent } from './components/content-action/content-action.component';
+import { DocumentListComponent } from './components/document-list.component';
+import { TrashcanNameColumnComponent } from './components/trashcan-name-column/trashcan-name-column.component';
+import { LibraryStatusColumnComponent } from './components/library-status-column/library-status-column.component';
+import { LibraryRoleColumnComponent } from './components/library-role-column/library-role-column.component';
+import { LibraryNameColumnComponent } from './components/library-name-column/library-name-column.component';
+import { NameColumnComponent } from './components/name-column/name-column.component';
+import { FilterHeaderComponent } from './components/filter-header/filter-header.component';
+import { FileAutoDownloadComponent } from './components/file-auto-download/file-auto-download.component';
+import * as i0 from "@angular/core";
+export const DOCUMENT_LIST_DIRECTIVES = [
+    ContentActionComponent,
+    FileAutoDownloadComponent,
+    FilterHeaderComponent,
+    LibraryNameColumnComponent,
+    LibraryRoleColumnComponent,
+    LibraryStatusColumnComponent,
+    NameColumnComponent,
+    TrashcanNameColumnComponent,
+    ContentActionListComponent,
+    DocumentListComponent
+];
+/** @deprecated use `...DOCUMENT_LIST_DIRECTIVES` or import standalone components */
+export class DocumentListModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: DocumentListModule, imports: [ContentActionComponent,
+            FileAutoDownloadComponent,
+            FilterHeaderComponent,
+            LibraryNameColumnComponent,
+            LibraryRoleColumnComponent,
+            LibraryStatusColumnComponent,
+            NameColumnComponent,
+            TrashcanNameColumnComponent,
+            ContentActionListComponent,
+            DocumentListComponent], exports: [ContentActionComponent,
+            FileAutoDownloadComponent,
+            FilterHeaderComponent,
+            LibraryNameColumnComponent,
+            LibraryRoleColumnComponent,
+            LibraryStatusColumnComponent,
+            NameColumnComponent,
+            TrashcanNameColumnComponent,
+            ContentActionListComponent,
+            DocumentListComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListModule, imports: [FileAutoDownloadComponent,
+            FilterHeaderComponent,
+            TrashcanNameColumnComponent,
+            DocumentListComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...DOCUMENT_LIST_DIRECTIVES],
+                    exports: [...DOCUMENT_LIST_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/index.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 * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL2RvY3VtZW50LWxpc3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/document-list/interfaces/document-list-loader.interface.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtbGlzdC1sb2FkZXIuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9kb2N1bWVudC1saXN0L2ludGVyZmFjZXMvZG9jdW1lbnQtbGlzdC1sb2FkZXIuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgUGFnaW5hdGlvbk1vZGVsIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IERvY3VtZW50TG9hZGVyTm9kZSB9IGZyb20gJy4uL21vZGVscy9kb2N1bWVudC1mb2xkZXIubW9kZWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERvY3VtZW50TGlzdExvYWRlciB7XG5cbiAgICBsb2FkRm9sZGVyQnlOb2RlSWQobm9kZUlkOiBzdHJpbmcsIHBhZ2luYXRpb246IFBhZ2luYXRpb25Nb2RlbCwgaW5jbHVkZUZpZWxkczogc3RyaW5nW10sIHdoZXJlPzogc3RyaW5nKTogT2JzZXJ2YWJsZSA8RG9jdW1lbnRMb2FkZXJOb2RlPjtcbn1cbiJdfQ==

package/esm2022/lib/document-list/models/content-action.model.mjs

@@ -0,0 +1,59 @@
+/*!
+ * @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 no-shadow */
+/* eslint-disable @typescript-eslint/naming-convention */
+export class ContentActionModel {
+    constructor(obj) {
+        this.disableWithNoPermission = false;
+        this.disabled = false;
+        this.visible = true;
+        if (obj) {
+            this.icon = obj.icon;
+            this.title = obj.title;
+            this.handler = obj.handler;
+            this.execute = obj.execute;
+            this.target = obj.target;
+            this.permission = obj.permission;
+            this.disableWithNoPermission = obj.disableWithNoPermission;
+            if (Object.prototype.hasOwnProperty.call(obj, 'disabled')) {
+                this.disabled = obj.disabled;
+            }
+            if (Object.prototype.hasOwnProperty.call(obj, 'visible')) {
+                this.visible = obj.visible;
+            }
+        }
+    }
+}
+export var ContentActionTarget;
+(function (ContentActionTarget) {
+    ContentActionTarget["Document"] = "document";
+    ContentActionTarget["Folder"] = "folder";
+    ContentActionTarget["All"] = "all";
+})(ContentActionTarget || (ContentActionTarget = {}));
+export class DocumentActionModel extends ContentActionModel {
+    constructor(json) {
+        super(json);
+        this.target = 'document';
+    }
+}
+export class FolderActionModel extends ContentActionModel {
+    constructor(json) {
+        super(json);
+        this.target = 'folder';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/models/document-folder.model.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @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 class DocumentLoaderNode {
+    constructor(currentNode, children) {
+        this.currentNode = currentNode;
+        this.children = children;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQtZm9sZGVyLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvbnRlbnQtc2VydmljZXMvc3JjL2xpYi9kb2N1bWVudC1saXN0L21vZGVscy9kb2N1bWVudC1mb2xkZXIubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBSUgsTUFBTSxPQUFPLGtCQUFrQjtJQUkzQixZQUFZLFdBQXNCLEVBQUUsUUFBb0I7UUFDcEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDN0IsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBOb2RlRW50cnksIE5vZGVQYWdpbmcgfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcblxuZXhwb3J0IGNsYXNzIERvY3VtZW50TG9hZGVyTm9kZSB7XG4gICAgY3VycmVudE5vZGU6IE5vZGVFbnRyeTtcbiAgICBjaGlsZHJlbjogTm9kZVBhZ2luZztcblxuICAgIGNvbnN0cnVjdG9yKGN1cnJlbnROb2RlOiBOb2RlRW50cnksIGNoaWxkcmVuOiBOb2RlUGFnaW5nKSB7XG4gICAgICAgIHRoaXMuY3VycmVudE5vZGUgPSBjdXJyZW50Tm9kZTtcbiAgICAgICAgdGhpcy5jaGlsZHJlbiA9IGNoaWxkcmVuO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/lib/document-list/models/node-action.enum.mjs

@@ -0,0 +1,27 @@
+/*!
+ * @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 no-shadow */
+/* eslint-disable @typescript-eslint/naming-convention */
+export var NodeAction;
+(function (NodeAction) {
+    NodeAction["ATTACH"] = "ATTACH";
+    NodeAction["CHOOSE"] = "CHOOSE";
+    NodeAction["COPY"] = "COPY";
+    NodeAction["MOVE"] = "MOVE";
+    NodeAction["NEXT"] = "NEXT";
+})(NodeAction || (NodeAction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZS1hY3Rpb24uZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvZG9jdW1lbnQtbGlzdC9tb2RlbHMvbm9kZS1hY3Rpb24uZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCw4QkFBOEI7QUFDOUIseURBQXlEO0FBRXpELE1BQU0sQ0FBTixJQUFZLFVBTVg7QUFORCxXQUFZLFVBQVU7SUFDbEIsK0JBQWlCLENBQUE7SUFDakIsK0JBQWlCLENBQUE7SUFDakIsMkJBQWEsQ0FBQTtJQUNiLDJCQUFhLENBQUE7SUFDYiwyQkFBYSxDQUFBO0FBQ2pCLENBQUMsRUFOVyxVQUFVLEtBQVYsVUFBVSxRQU1yQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLyogZXNsaW50LWRpc2FibGUgbm8tc2hhZG93ICovXG4vKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb24gKi9cblxuZXhwb3J0IGVudW0gTm9kZUFjdGlvbiB7XG4gICAgQVRUQUNIID0gJ0FUVEFDSCcsXG4gICAgQ0hPT1NFID0gJ0NIT09TRScsXG4gICAgQ09QWSA9ICdDT1BZJyxcbiAgICBNT1ZFID0gJ01PVkUnLFxuICAgIE5FWFQgPSAnTkVYVCdcbn1cbiJdfQ==

package/esm2022/lib/document-list/models/permissions-style.model.mjs

@@ -0,0 +1,27 @@
+/*!
+ * @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 class PermissionStyleModel {
+    constructor(css, permission, isFile = true, isFolder = true) {
+        this.isFolder = true;
+        this.isFile = true;
+        this.css = css;
+        this.permission = permission;
+        this.isFile = isFile;
+        this.isFolder = isFolder;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/document-list/models/permissions.model.mjs

@@ -0,0 +1,26 @@
+/*!
+ * @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 class PermissionModel {
+    constructor(obj) {
+        if (obj) {
+            this.type = obj.type || null;
+            this.action = obj.action || null;
+            this.permission = obj.permission || null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbnMubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL2RvY3VtZW50LWxpc3QvbW9kZWxzL3Blcm1pc3Npb25zLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE1BQU0sT0FBTyxlQUFlO0lBS3hCLFlBQVksR0FBUztRQUNqQixJQUFJLEdBQUcsRUFBRSxDQUFDO1lBQ04sSUFBSSxDQUFDLElBQUksR0FBRyxHQUFHLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQztZQUM3QixJQUFJLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDO1lBQ2pDLElBQUksQ0FBQyxVQUFVLEdBQUcsR0FBRyxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUM7UUFDN0MsQ0FBQztJQUNMLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0IGNsYXNzIFBlcm1pc3Npb25Nb2RlbCB7XG4gICAgdHlwZTogc3RyaW5nO1xuICAgIGFjdGlvbjogc3RyaW5nO1xuICAgIHBlcm1pc3Npb246IHN0cmluZztcblxuICAgIGNvbnN0cnVjdG9yKG9iaj86IGFueSkge1xuICAgICAgICBpZiAob2JqKSB7XG4gICAgICAgICAgICB0aGlzLnR5cGUgPSBvYmoudHlwZSB8fCBudWxsO1xuICAgICAgICAgICAgdGhpcy5hY3Rpb24gPSBvYmouYWN0aW9uIHx8IG51bGw7XG4gICAgICAgICAgICB0aGlzLnBlcm1pc3Npb24gPSBvYmoucGVybWlzc2lvbiB8fCBudWxsO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19