@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/directives/tooltip-card/tooltip-card.component.mjs

@@ -0,0 +1,60 @@
+/*!
+ * @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, Input, SecurityContext } from '@angular/core';
+import { animate, style, transition, trigger } from '@angular/animations';
+import { DomSanitizer } from '@angular/platform-browser';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "@angular/common";
+export class TooltipCardComponent {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+        this.image = '';
+        this.text = '';
+        this.htmlContent = '';
+        this.width = '300';
+    }
+    sanitizedHtmlContent() {
+        return this.sanitizer.sanitize(SecurityContext.HTML, this.htmlContent);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipCardComponent, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TooltipCardComponent, isStandalone: true, selector: "adf-tooltip-card-component", inputs: { image: "image", text: "text", htmlContent: "htmlContent", width: "width" }, ngImport: i0, template: "<div @tooltip class=\"adf-tooltip-card\" [style.width.px]=\"width\">\n    <img *ngIf=\"image \" [src]=\"image\" [width]=\"width\" alt=\"{{text}}\">\n    <hr *ngIf=\"image\" />\n    <p *ngIf=\"text\">{{text}}</p>\n    <div *ngIf=\"htmlContent\" [innerHTML]=\"sanitizedHtmlContent()\" class=\"adf-tooltip-card-content\"></div>\n</div>\n", styles: [":host{display:block}div.adf-tooltip-card{box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f;background-color:var(--adf-theme-background-card-color);border:1px solid var(--theme-primary-color);padding:12px;border-radius:6px}div.adf-tooltip-card p,div.adf-tooltip-card div{font-size:var(--theme-caption-font-size);color:var(--adf-theme-foreground-text-color-075);margin:0}div.adf-tooltip-card hr{border:1px solid var(--theme-primary-color);margin:6px 0}div.adf-tooltip-card img{border-radius:6px}::ng-deep .cdk-overlay-connected-position-bounding-box{margin-top:10px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], animations: [
+            trigger('tooltip', [
+                transition(':enter', [style({ opacity: 0 }), animate(200, style({ opacity: 1 }))]),
+                transition(':leave', [animate(200, style({ opacity: 0 }))])
+            ])
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tooltip-card-component', standalone: true, imports: [CommonModule], animations: [
+                        trigger('tooltip', [
+                            transition(':enter', [style({ opacity: 0 }), animate(200, style({ opacity: 1 }))]),
+                            transition(':leave', [animate(200, style({ opacity: 0 }))])
+                        ])
+                    ], template: "<div @tooltip class=\"adf-tooltip-card\" [style.width.px]=\"width\">\n    <img *ngIf=\"image \" [src]=\"image\" [width]=\"width\" alt=\"{{text}}\">\n    <hr *ngIf=\"image\" />\n    <p *ngIf=\"text\">{{text}}</p>\n    <div *ngIf=\"htmlContent\" [innerHTML]=\"sanitizedHtmlContent()\" class=\"adf-tooltip-card-content\"></div>\n</div>\n", styles: [":host{display:block}div.adf-tooltip-card{box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f;background-color:var(--adf-theme-background-card-color);border:1px solid var(--theme-primary-color);padding:12px;border-radius:6px}div.adf-tooltip-card p,div.adf-tooltip-card div{font-size:var(--theme-caption-font-size);color:var(--adf-theme-foreground-text-color-075);margin:0}div.adf-tooltip-card hr{border:1px solid var(--theme-primary-color);margin:6px 0}div.adf-tooltip-card img{border-radius:6px}::ng-deep .cdk-overlay-connected-position-bounding-box{margin-top:10px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }], propDecorators: { image: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], htmlContent: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/tooltip-card/tooltip-card.directive.mjs

@@ -0,0 +1,104 @@
+/*!
+ * @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 { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { TooltipCardComponent } from './tooltip-card.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class TooltipCardDirective {
+    constructor(overlay, overlayPositionBuilder, elementRef) {
+        this.overlay = overlay;
+        this.overlayPositionBuilder = overlayPositionBuilder;
+        this.elementRef = elementRef;
+        this.text = '';
+        this.image = '';
+        this.width = '300';
+        this.htmlContent = '';
+        this.originX = 'start';
+        this.originY = 'top';
+        this.overlayX = 'start';
+        this.overlayY = 'bottom';
+        this.offsetX = 0;
+        this.offsetY = -8;
+    }
+    ngOnDestroy() {
+        if (this.overlayRef) {
+            this.hide();
+        }
+    }
+    ngOnInit() {
+        const positionStrategy = this.overlayPositionBuilder.flexibleConnectedTo(this.elementRef).withPositions([
+            {
+                originX: this.originX,
+                originY: this.originY,
+                overlayX: this.overlayX,
+                overlayY: this.overlayY,
+                offsetY: this.offsetY,
+                offsetX: this.offsetX
+            }
+        ]);
+        this.overlayRef = this.overlay.create({ positionStrategy });
+    }
+    show() {
+        const tooltipRef = this.overlayRef?.attach(new ComponentPortal(TooltipCardComponent));
+        tooltipRef.instance.text = this.text;
+        tooltipRef.instance.image = this.image;
+        tooltipRef.instance.width = this.width;
+        tooltipRef.instance.htmlContent = this.htmlContent;
+    }
+    hide() {
+        this.overlayRef?.detach();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipCardDirective, deps: [{ token: i1.Overlay }, { token: i1.OverlayPositionBuilder }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TooltipCardDirective, isStandalone: true, selector: "[adf-tooltip-card]", inputs: { text: ["adf-tooltip-card", "text"], image: "image", width: "width", htmlContent: "htmlContent", originX: "originX", originY: "originY", overlayX: "overlayX", overlayY: "overlayY", offsetX: "offsetX", offsetY: "offsetY" }, host: { listeners: { "mouseenter": "show()", "mouseleave": "hide()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipCardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-tooltip-card]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i1.OverlayPositionBuilder }, { type: i0.ElementRef }], propDecorators: { text: [{
+                type: Input,
+                args: ['adf-tooltip-card']
+            }], image: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], htmlContent: [{
+                type: Input
+            }], originX: [{
+                type: Input
+            }], originY: [{
+                type: Input
+            }], overlayX: [{
+                type: Input
+            }], overlayY: [{
+                type: Input
+            }], offsetX: [{
+                type: Input
+            }], offsetY: [{
+                type: Input
+            }], show: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], hide: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/upload.directive.mjs

@@ -0,0 +1,241 @@
+/*!
+ * @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 @angular-eslint/no-input-rename */
+import { Directive, ElementRef, HostListener, Input, NgZone, Renderer2 } from '@angular/core';
+import { FileUtils } from '../common/utils/file-utils';
+import * as i0 from "@angular/core";
+export class UploadDirective {
+    constructor(el, renderer, ngZone) {
+        this.el = el;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        /** Enables/disables uploading. */
+        this.enabled = true;
+        /**
+         * Upload mode. Can be "drop" (receives dropped files) or "click"
+         * (clicking opens a file dialog). Both modes can be active at once.
+         */
+        this.mode = ['drop']; // click|drop
+        this.isDragging = false;
+        this.cssClassName = 'adf-upload__dragging';
+        this.element = el.nativeElement;
+    }
+    ngOnInit() {
+        if (this.isClickMode() && this.renderer) {
+            const inputUpload = this.renderer.createElement('input');
+            this.upload = this.el.nativeElement.parentElement.appendChild(inputUpload);
+            this.upload.type = 'file';
+            this.upload.style.display = 'none';
+            this.upload.addEventListener('change', (event) => this.onSelectFiles(event));
+            if (this.multiple) {
+                this.upload.setAttribute('multiple', '');
+            }
+            if (this.accept) {
+                this.upload.setAttribute('accept', this.accept);
+            }
+            if (this.directory) {
+                this.upload.setAttribute('webkitdirectory', '');
+            }
+        }
+        if (this.isDropMode()) {
+            this.ngZone.runOutsideAngular(() => {
+                this.element.addEventListener('dragenter', this.onDragEnter.bind(this));
+                this.element.addEventListener('dragover', this.onDragOver.bind(this));
+                this.element.addEventListener('dragleave', this.onDragLeave.bind(this));
+                this.element.addEventListener('drop', this.onDrop.bind(this));
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.element.removeEventListener('dragenter', this.onDragEnter);
+        this.element.removeEventListener('dragover', this.onDragOver);
+        this.element.removeEventListener('dragleave', this.onDragLeave);
+        this.element.removeEventListener('drop', this.onDrop);
+    }
+    onClick(event) {
+        if (this.isClickMode() && this.upload) {
+            event.preventDefault();
+            this.upload.click();
+        }
+    }
+    onDragEnter(event) {
+        if (this.isDropMode()) {
+            event.dataTransfer.dropEffect = 'copy';
+            this.element.classList.add(this.cssClassName);
+            this.isDragging = true;
+        }
+    }
+    onDragOver(event) {
+        event.preventDefault();
+        if (this.isDropMode()) {
+            event.dataTransfer.dropEffect = 'copy';
+            this.element.classList.add(this.cssClassName);
+            this.isDragging = true;
+        }
+        return false;
+    }
+    onDragLeave() {
+        if (this.isDropMode()) {
+            this.element.classList.remove(this.cssClassName);
+            this.isDragging = false;
+        }
+    }
+    onDrop(event) {
+        if (this.isDropMode()) {
+            event.stopPropagation();
+            event.preventDefault();
+            this.element.classList.remove(this.cssClassName);
+            this.isDragging = false;
+            const dataTransfer = this.getDataTransfer(event);
+            if (dataTransfer) {
+                this.getFilesDropped(dataTransfer).then((files) => {
+                    this.onUploadFiles(files);
+                });
+            }
+        }
+        return false;
+    }
+    onUploadFiles(files) {
+        if (this.enabled && files.length > 0) {
+            const customEvent = new CustomEvent('upload-files', {
+                detail: {
+                    sender: this,
+                    data: this.data,
+                    files
+                },
+                bubbles: true
+            });
+            this.el.nativeElement.dispatchEvent(customEvent);
+        }
+    }
+    hasMode(mode) {
+        return this.enabled && mode && this.mode && this.mode.indexOf(mode) > -1;
+    }
+    isDropMode() {
+        return this.hasMode('drop');
+    }
+    isClickMode() {
+        return this.hasMode('click');
+    }
+    getDataTransfer(event) {
+        if (event?.dataTransfer) {
+            return event.dataTransfer;
+        }
+        if (event?.originalEvent?.dataTransfer) {
+            return event.originalEvent.dataTransfer;
+        }
+        return null;
+    }
+    /**
+     * Extract files from the DataTransfer object used to hold the data that is being dragged during a drag and drop operation.
+     *
+     * @param dataTransfer DataTransfer object
+     * @returns a list of file info objects
+     */
+    getFilesDropped(dataTransfer) {
+        return new Promise((resolve) => {
+            const iterations = [];
+            if (dataTransfer) {
+                const items = dataTransfer.items;
+                if (items) {
+                    for (let i = 0; i < items.length; i++) {
+                        if (typeof items[i].webkitGetAsEntry !== 'undefined') {
+                            const item = items[i].webkitGetAsEntry();
+                            if (item) {
+                                if (item.isFile) {
+                                    iterations.push(Promise.resolve({
+                                        entry: item,
+                                        file: items[i].getAsFile(),
+                                        relativeFolder: '/'
+                                    }));
+                                }
+                                else if (item.isDirectory) {
+                                    iterations.push(new Promise((resolveFolder) => {
+                                        FileUtils.flatten(item).then((files) => resolveFolder(files));
+                                    }));
+                                }
+                            }
+                        }
+                        else {
+                            iterations.push(Promise.resolve({
+                                entry: null,
+                                file: items[i].getAsFile(),
+                                relativeFolder: '/'
+                            }));
+                        }
+                    }
+                }
+                else {
+                    // safari or FF
+                    const files = FileUtils.toFileArray(dataTransfer.files).map((file) => ({
+                        entry: null,
+                        file,
+                        relativeFolder: '/'
+                    }));
+                    iterations.push(Promise.resolve(files));
+                }
+            }
+            Promise.all(iterations).then((result) => {
+                resolve(result.reduce((a, b) => a.concat(b), []));
+            });
+        });
+    }
+    /**
+     * Invoked when user selects files or folders by means of File Dialog
+     *
+     * @param event DOM event
+     */
+    onSelectFiles(event) {
+        if (this.isClickMode()) {
+            const input = event.currentTarget;
+            const files = FileUtils.toFileArray(input.files);
+            this.onUploadFiles(files.map((file) => ({
+                entry: null,
+                file,
+                relativeFolder: '/'
+            })));
+            event.target.value = '';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: UploadDirective, isStandalone: true, selector: "[adf-upload]", inputs: { enabled: ["adf-upload", "enabled"], data: ["adf-upload-data", "data"], mode: "mode", multiple: "multiple", accept: "accept", directory: "directory" }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-upload]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }], propDecorators: { enabled: [{
+                type: Input,
+                args: ['adf-upload']
+            }], data: [{
+                type: Input,
+                args: ['adf-upload-data']
+            }], mode: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], accept: [{
+                type: Input
+            }], directory: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.directive.js","sourceRoot":"","sources":["../../../../../../lib/core/src/lib/directives/upload.directive.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\n/* eslint-disable @angular-eslint/no-input-rename */\n\nimport { Directive, ElementRef, HostListener, Input, NgZone, OnDestroy, OnInit, Renderer2 } from '@angular/core';\nimport { FileInfo, FileUtils } from '../common/utils/file-utils';\n\n@Directive({\n    selector: '[adf-upload]',\n    standalone: true\n})\nexport class UploadDirective implements OnInit, OnDestroy {\n    /** Enables/disables uploading. */\n    @Input('adf-upload')\n    enabled: boolean = true;\n\n    /** Data to upload. */\n    @Input('adf-upload-data')\n    data: any;\n\n    /**\n     * Upload mode. Can be \"drop\" (receives dropped files) or \"click\"\n     * (clicking opens a file dialog). Both modes can be active at once.\n     */\n    @Input()\n    mode: string[] = ['drop']; // click|drop\n\n    /** Toggles multiple file uploads. */\n    @Input()\n    multiple: boolean;\n\n    /** (Click mode only) MIME type filter for files to accept. */\n    @Input()\n    accept: string;\n\n    /** (Click mode only) Toggles uploading of directories. */\n    @Input()\n    directory: boolean;\n\n    isDragging: boolean = false;\n\n    private cssClassName: string = 'adf-upload__dragging';\n    private upload: HTMLInputElement;\n    private element: HTMLElement;\n\n    constructor(private el: ElementRef, private renderer: Renderer2, private ngZone: NgZone) {\n        this.element = el.nativeElement;\n    }\n\n    ngOnInit() {\n        if (this.isClickMode() && this.renderer) {\n            const inputUpload = this.renderer.createElement('input');\n            this.upload = this.el.nativeElement.parentElement.appendChild(inputUpload);\n\n            this.upload.type = 'file';\n            this.upload.style.display = 'none';\n            this.upload.addEventListener('change', (event) => this.onSelectFiles(event));\n\n            if (this.multiple) {\n                this.upload.setAttribute('multiple', '');\n            }\n\n            if (this.accept) {\n                this.upload.setAttribute('accept', this.accept);\n            }\n\n            if (this.directory) {\n                this.upload.setAttribute('webkitdirectory', '');\n            }\n        }\n\n        if (this.isDropMode()) {\n            this.ngZone.runOutsideAngular(() => {\n                this.element.addEventListener('dragenter', this.onDragEnter.bind(this));\n                this.element.addEventListener('dragover', this.onDragOver.bind(this));\n                this.element.addEventListener('dragleave', this.onDragLeave.bind(this));\n                this.element.addEventListener('drop', this.onDrop.bind(this));\n            });\n        }\n    }\n\n    ngOnDestroy() {\n        this.element.removeEventListener('dragenter', this.onDragEnter);\n        this.element.removeEventListener('dragover', this.onDragOver);\n        this.element.removeEventListener('dragleave', this.onDragLeave);\n        this.element.removeEventListener('drop', this.onDrop);\n    }\n\n    @HostListener('click', ['$event'])\n    onClick(event: Event) {\n        if (this.isClickMode() && this.upload) {\n            event.preventDefault();\n            this.upload.click();\n        }\n    }\n\n    onDragEnter(event: DragEvent) {\n        if (this.isDropMode()) {\n            event.dataTransfer.dropEffect = 'copy';\n            this.element.classList.add(this.cssClassName);\n            this.isDragging = true;\n        }\n    }\n\n    onDragOver(event: DragEvent) {\n        event.preventDefault();\n        if (this.isDropMode()) {\n            event.dataTransfer.dropEffect = 'copy';\n            this.element.classList.add(this.cssClassName);\n            this.isDragging = true;\n        }\n        return false;\n    }\n\n    onDragLeave() {\n        if (this.isDropMode()) {\n            this.element.classList.remove(this.cssClassName);\n            this.isDragging = false;\n        }\n    }\n\n    onDrop(event: Event) {\n        if (this.isDropMode()) {\n            event.stopPropagation();\n            event.preventDefault();\n\n            this.element.classList.remove(this.cssClassName);\n            this.isDragging = false;\n\n            const dataTransfer = this.getDataTransfer(event);\n            if (dataTransfer) {\n                this.getFilesDropped(dataTransfer).then((files) => {\n                    this.onUploadFiles(files);\n                });\n            }\n        }\n        return false;\n    }\n\n    onUploadFiles(files: FileInfo[]) {\n        if (this.enabled && files.length > 0) {\n            const customEvent = new CustomEvent('upload-files', {\n                detail: {\n                    sender: this,\n                    data: this.data,\n                    files\n                },\n                bubbles: true\n            });\n\n            this.el.nativeElement.dispatchEvent(customEvent);\n        }\n    }\n\n    protected hasMode(mode: string): boolean {\n        return this.enabled && mode && this.mode && this.mode.indexOf(mode) > -1;\n    }\n\n    protected isDropMode(): boolean {\n        return this.hasMode('drop');\n    }\n\n    protected isClickMode(): boolean {\n        return this.hasMode('click');\n    }\n\n    getDataTransfer(event: Event | any): DataTransfer {\n        if (event?.dataTransfer) {\n            return event.dataTransfer;\n        }\n        if (event?.originalEvent?.dataTransfer) {\n            return event.originalEvent.dataTransfer;\n        }\n        return null;\n    }\n\n    /**\n     * Extract files from the DataTransfer object used to hold the data that is being dragged during a drag and drop operation.\n     *\n     * @param dataTransfer DataTransfer object\n     * @returns a list of file info objects\n     */\n    getFilesDropped(dataTransfer: DataTransfer): Promise<FileInfo[]> {\n        return new Promise((resolve) => {\n            const iterations = [];\n\n            if (dataTransfer) {\n                const items = dataTransfer.items;\n                if (items) {\n                    for (let i = 0; i < items.length; i++) {\n                        if (typeof items[i].webkitGetAsEntry !== 'undefined') {\n                            const item = items[i].webkitGetAsEntry();\n                            if (item) {\n                                if (item.isFile) {\n                                    iterations.push(\n                                        Promise.resolve({\n                                            entry: item,\n                                            file: items[i].getAsFile(),\n                                            relativeFolder: '/'\n                                        })\n                                    );\n                                } else if (item.isDirectory) {\n                                    iterations.push(\n                                        new Promise((resolveFolder) => {\n                                            FileUtils.flatten(item).then((files) => resolveFolder(files));\n                                        })\n                                    );\n                                }\n                            }\n                        } else {\n                            iterations.push(\n                                Promise.resolve({\n                                    entry: null,\n                                    file: items[i].getAsFile(),\n                                    relativeFolder: '/'\n                                })\n                            );\n                        }\n                    }\n                } else {\n                    // safari or FF\n                    const files = FileUtils.toFileArray(dataTransfer.files).map((file) => ({\n                        entry: null,\n                        file,\n                        relativeFolder: '/'\n                    }));\n\n                    iterations.push(Promise.resolve(files));\n                }\n            }\n\n            Promise.all(iterations).then((result) => {\n                resolve(result.reduce((a, b) => a.concat(b), []));\n            });\n        });\n    }\n\n    /**\n     * Invoked when user selects files or folders by means of File Dialog\n     *\n     * @param event DOM event\n     */\n    onSelectFiles(event: any): void {\n        if (this.isClickMode()) {\n            const input = event.currentTarget;\n            const files = FileUtils.toFileArray(input.files);\n            this.onUploadFiles(\n                files.map((file) => ({\n                    entry: null,\n                    file,\n                    relativeFolder: '/'\n                }))\n            );\n            event.target.value = '';\n        }\n    }\n}\n"]}

package/esm2022/lib/dynamic-chip-list/chip.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hpcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZHluYW1pYy1jaGlwLWxpc3QvY2hpcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2hpcCB7XG4gICAgbmFtZTogc3RyaW5nO1xuICAgIGlkOiBzdHJpbmc7XG59XG4iXX0=