@genexus/genexus-ide-ui 1.1.1 → 1.1.3

package/dist/collection/components/file-uploader/file-uploader.js

@@ -0,0 +1,750 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m")
+        throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f)
+        throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+        throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _FileUploader_instances, _FileUploader__componentLocale, _FileUploader_fileInputEl, _FileUploader_dragCounter, _FileUploader_generateId, _FileUploader_isValidFile, _FileUploader_getValidFiles, _FileUploader_handleDragEnter, _FileUploader_handleDragLeave, _FileUploader_handleDragOver, _FileUploader_handleDrop, _FileUploader_handleFileSelect, _FileUploader_handleFileInput, _FileUploader_handleFiles, _FileUploader_handleNameChange, _FileUploader_handleFileCancel, _FileUploader_handleConfirm, _FileUploader_handleCancel;
+/* eslint-disable @stencil-community/own-methods-must-be-private */
+/* eslint-disable @stencil-community/own-props-must-be-private */
+/* STENCIL IMPORTS */
+import { Host, h } from "@stencil/core";
+import { getIconPath } from "@genexus/mercury";
+import { Locale } from "../../common/locale";
+const PLUS_ICON = getIconPath({
+    category: "gemini-tools",
+    name: "add",
+    colorType: "primary"
+});
+const CSS_BUNDLES = [
+    "resets/box-sizing",
+    "components/button",
+    "components/icon",
+    "components/list-box",
+    "components/edit",
+    "utils/typography",
+    "utils/spacing",
+    "utils/form",
+    "utils/layout",
+    "utils/elevation",
+    "chameleon/scrollbar"
+];
+export class FileUploader {
+    constructor() {
+        _FileUploader_instances.add(this);
+        _FileUploader__componentLocale.set(this, void 0);
+        _FileUploader_fileInputEl.set(this, void 0);
+        _FileUploader_dragCounter.set(this, 0);
+        /** Generates a unique ID for file identification */
+        _FileUploader_generateId.set(this, () => {
+            return Math.random().toString(36).substr(2, 9);
+        });
+        /** Handles drag enter event */
+        _FileUploader_handleDragEnter.set(this, (e) => {
+            var _a;
+            e.preventDefault();
+            e.stopPropagation();
+            __classPrivateFieldSet(this, _FileUploader_dragCounter, (_a = __classPrivateFieldGet(this, _FileUploader_dragCounter, "f"), _a++, _a), "f");
+            this.isDragging = true;
+        });
+        /** Handles drag leave event */
+        _FileUploader_handleDragLeave.set(this, (e) => {
+            var _a;
+            e.preventDefault();
+            e.stopPropagation();
+            __classPrivateFieldSet(this, _FileUploader_dragCounter, (_a = __classPrivateFieldGet(this, _FileUploader_dragCounter, "f"), _a--, _a), "f");
+            if (__classPrivateFieldGet(this, _FileUploader_dragCounter, "f") === 0) {
+                this.isDragging = false;
+            }
+        });
+        /** Handles drag over event */
+        _FileUploader_handleDragOver.set(this, (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+        });
+        /** Handles drop event */
+        _FileUploader_handleDrop.set(this, (e) => {
+            var _a;
+            e.preventDefault();
+            e.stopPropagation();
+            this.isDragging = false;
+            __classPrivateFieldSet(this, _FileUploader_dragCounter, 0, "f");
+            const files = (_a = e.dataTransfer) === null || _a === void 0 ? void 0 : _a.files;
+            if (files) {
+                __classPrivateFieldGet(this, _FileUploader_handleFiles, "f").call(this, files);
+            }
+        });
+        /** Triggers file input click */
+        _FileUploader_handleFileSelect.set(this, () => {
+            var _a;
+            (_a = __classPrivateFieldGet(this, _FileUploader_fileInputEl, "f")) === null || _a === void 0 ? void 0 : _a.click();
+        });
+        /** Handles file input change event */
+        _FileUploader_handleFileInput.set(this, (e) => {
+            const files = e.target.files;
+            if (files) {
+                __classPrivateFieldGet(this, _FileUploader_handleFiles, "f").call(this, files);
+            }
+        });
+        /** Processes files and starts upload */
+        _FileUploader_handleFiles.set(this, (files) => {
+            const validFiles = __classPrivateFieldGet(this, _FileUploader_instances, "m", _FileUploader_getValidFiles).call(this, files);
+            validFiles.forEach(async (file) => {
+                var _a, _b;
+                const id = __classPrivateFieldGet(this, _FileUploader_generateId, "f").call(this);
+                const fileState = {
+                    id,
+                    name: file.name,
+                    file,
+                    pending: true,
+                    progress: 0
+                };
+                if (!this.multiple) {
+                    this.fileStates.clear();
+                }
+                this.fileStates = new Map(this.fileStates.set(id, fileState));
+                if (this.uploadFunction) {
+                    try {
+                        const uploadPromise = this.uploadFunction(file, progress => {
+                            const state = this.fileStates.get(id);
+                            if (state) {
+                                const updatedState = Object.assign(Object.assign({}, state), { progress: progress, pending: progress < 100 });
+                                this.fileStates = new Map(this.fileStates.set(id, updatedState));
+                            }
+                        });
+                        // Store the upload promise/object for potential cancellation
+                        const stateWithPromise = Object.assign(Object.assign({}, this.fileStates.get(id)), { uploadPromise });
+                        this.fileStates = new Map(this.fileStates.set(id, stateWithPromise));
+                        const result = await uploadPromise;
+                        console.log("Upload result:", { id, result });
+                        const state = this.fileStates.get(id);
+                        if (state) {
+                            if (result.success && result.remoteId) {
+                                const updatedState = Object.assign(Object.assign({}, state), { remoteId: result.remoteId, pending: false, progress: 100 });
+                                this.fileStates = new Map(this.fileStates.set(id, updatedState));
+                                console.log("File uploaded successfully:", updatedState);
+                                await ((_a = this.fileUploadedCallback) === null || _a === void 0 ? void 0 : _a.call(this, {
+                                    name: state.name,
+                                    originalName: state.file.name,
+                                    remoteId: result.remoteId
+                                }));
+                            }
+                            else {
+                                const updatedState = Object.assign(Object.assign({}, state), { error: ((_b = result.errors) === null || _b === void 0 ? void 0 : _b.upload) || "Upload failed", pending: false });
+                                this.fileStates = new Map(this.fileStates.set(id, updatedState));
+                                console.log("File upload failed:", updatedState);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        const state = this.fileStates.get(id);
+                        if (state) {
+                            const updatedState = Object.assign(Object.assign({}, state), { error: error instanceof Error
+                                    ? error.message
+                                    : "Unknown error occurred", pending: false });
+                            this.fileStates = new Map(this.fileStates.set(id, updatedState));
+                            console.log("File upload error:", updatedState);
+                        }
+                    }
+                }
+            });
+            if (__classPrivateFieldGet(this, _FileUploader_fileInputEl, "f")) {
+                __classPrivateFieldGet(this, _FileUploader_fileInputEl, "f").value = "";
+            }
+        });
+        /** Handles file name change */
+        _FileUploader_handleNameChange.set(this, async (event) => {
+            var _a;
+            const { id, name } = event.detail;
+            const file = this.fileStates.get(id);
+            if (file) {
+                const updatedFile = Object.assign(Object.assign({}, file), { name: name.trim(), isEditing: false });
+                this.fileStates = new Map(this.fileStates.set(id, updatedFile));
+                await ((_a = this.fileRenamedCallback) === null || _a === void 0 ? void 0 : _a.call(this, { fileId: id, newName: name.trim() }));
+            }
+        });
+        /** Handles individual file cancellation or deletion */
+        _FileUploader_handleFileCancel.set(this, async (event) => {
+            var _a, _b, _c, _d;
+            const id = event.detail;
+            const state = this.fileStates.get(id);
+            if (state) {
+                try {
+                    if (state.pending) {
+                        // Cancel upload in progress
+                        if (state.uploadPromise &&
+                            typeof state.uploadPromise.cancel === "function") {
+                            state.uploadPromise.cancel();
+                        }
+                        else if (this.cancelUploadFunction) {
+                            await this.cancelUploadFunction(id);
+                        }
+                        await ((_a = this.uploadCancelledCallback) === null || _a === void 0 ? void 0 : _a.call(this, id));
+                        this.fileStates.delete(id);
+                        this.fileStates = new Map(this.fileStates);
+                    }
+                    else {
+                        const fileToDelete = {
+                            name: state.name,
+                            originalName: state.file.name,
+                            remoteId: state.remoteId
+                        };
+                        const shouldDelete = await ((_b = this.onBeforeDelete) === null || _b === void 0 ? void 0 : _b.call(this, fileToDelete));
+                        if (shouldDelete) {
+                            await ((_c = this.fileDeletedCallback) === null || _c === void 0 ? void 0 : _c.call(this, fileToDelete));
+                            this.fileStates.delete(id);
+                            this.fileStates = new Map(this.fileStates);
+                        }
+                    }
+                }
+                catch (error) {
+                    await ((_d = this.fileDeletionErrorCallback) === null || _d === void 0 ? void 0 : _d.call(this, {
+                        fileName: state.name,
+                        error: error instanceof Error ? error.message : "Unknown error occurred"
+                    }));
+                }
+            }
+        });
+        /** Handles dialog confirmation */
+        _FileUploader_handleConfirm.set(this, async () => {
+            var _a;
+            // Verificar si hay subidas en progreso
+            const hasPendingUploads = Array.from(this.fileStates.values()).some(file => file.pending);
+            if (hasPendingUploads) {
+                return; // No permitir confirmar si hay subidas en progreso
+            }
+            // Obtener todos los archivos que están completamente subidos
+            const uploadedFiles = Array.from(this.fileStates.values())
+                .filter(file => {
+                const isValid = !file.pending && file.remoteId && !file.error;
+                console.log("File validation:", {
+                    id: file.id,
+                    name: file.name,
+                    pending: file.pending,
+                    remoteId: file.remoteId,
+                    error: file.error,
+                    isValid
+                });
+                return isValid;
+            })
+                .map(file => ({
+                name: file.name,
+                originalName: file.file.name,
+                remoteId: file.remoteId
+            }));
+            console.log("Files to be confirmed:", uploadedFiles);
+            if (uploadedFiles.length > 0) {
+                await ((_a = this.dialogConfirmedCallback) === null || _a === void 0 ? void 0 : _a.call(this, uploadedFiles));
+            }
+            // Clear file states
+            this.fileStates.clear();
+            this.fileStates = new Map();
+            // Reset file input
+            if (__classPrivateFieldGet(this, _FileUploader_fileInputEl, "f")) {
+                __classPrivateFieldGet(this, _FileUploader_fileInputEl, "f").value = "";
+            }
+        });
+        /** Handles dialog cancellation */
+        _FileUploader_handleCancel.set(this, async () => {
+            var _a, _b, _c;
+            try {
+                // Cancelamos todas las subidas en progreso
+                for (const [id, state] of this.fileStates.entries()) {
+                    if (state.pending && this.cancelUploadFunction) {
+                        try {
+                            await this.cancelUploadFunction(id);
+                            await ((_a = this.uploadCancelledCallback) === null || _a === void 0 ? void 0 : _a.call(this, id));
+                        }
+                        catch (error) {
+                            // Error handling for upload cancellation
+                        }
+                    }
+                }
+                // Limpiamos todos los estados
+                this.fileStates.clear();
+                this.fileStates = new Map();
+                if (__classPrivateFieldGet(this, _FileUploader_fileInputEl, "f")) {
+                    __classPrivateFieldGet(this, _FileUploader_fileInputEl, "f").value = "";
+                }
+                await ((_b = this.dialogCanceledCallback) === null || _b === void 0 ? void 0 : _b.call(this));
+            }
+            catch (error) {
+                this.fileStates.clear();
+                this.fileStates = new Map();
+                await ((_c = this.dialogCanceledCallback) === null || _c === void 0 ? void 0 : _c.call(this));
+            }
+        });
+        this.types = [];
+        this.multiple = false;
+        this.canEditName = false;
+        this.label = undefined;
+        this.uploadFunction = undefined;
+        this.cancelUploadFunction = undefined;
+        this.fileUploadedCallback = undefined;
+        this.dialogCanceledCallback = undefined;
+        this.dialogConfirmedCallback = undefined;
+        this.uploadCancelledCallback = undefined;
+        this.fileRenamedCallback = undefined;
+        this.fileValidationErrorCallback = undefined;
+        this.fileDeletionErrorCallback = undefined;
+        this.fileDeletedCallback = undefined;
+        this.onBeforeDelete = undefined;
+        this.fileStates = new Map();
+        this.isDragging = false;
+    }
+    /** Initializes component with locale strings */
+    async componentWillLoad() {
+        __classPrivateFieldSet(this, _FileUploader__componentLocale, await Locale.getComponentStrings(this.el), "f");
+    }
+    /** Clears the current file selection */
+    async clear() {
+        var _a;
+        for (const [id, state] of this.fileStates.entries()) {
+            if (state.pending && this.cancelUploadFunction) {
+                try {
+                    await this.cancelUploadFunction(id);
+                    await ((_a = this.uploadCancelledCallback) === null || _a === void 0 ? void 0 : _a.call(this, id));
+                }
+                catch (error) {
+                    // Error handling for upload cancellation
+                }
+            }
+        }
+        this.fileStates.clear();
+    }
+    render() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return (h(Host, { class: "widget" }, h("ch-theme", { model: CSS_BUNDLES }), h("input", { type: "file", class: "hidden-input", multiple: this.multiple, accept: (_a = this.types) === null || _a === void 0 ? void 0 : _a.map(type => (type.startsWith(".") ? type : `.${type}`)).join(","), onChange: __classPrivateFieldGet(this, _FileUploader_handleFileInput, "f"), ref: el => (__classPrivateFieldSet(this, _FileUploader_fileInputEl, el, "f")), "aria-hidden": "true", tabIndex: -1, style: { display: "none" } }), h("div", { class: "file-uploader-dialog" }, h("div", { class: "dialog-content" }, this.isDragging || this.fileStates.size === 0 ? (h("div", { class: {
+                "file-uploader__drop-zone": true,
+                "file-uploader__drop-zone--dragging": this.isDragging
+            }, onDragEnter: __classPrivateFieldGet(this, _FileUploader_handleDragEnter, "f"), onDragLeave: __classPrivateFieldGet(this, _FileUploader_handleDragLeave, "f"), onDragOver: __classPrivateFieldGet(this, _FileUploader_handleDragOver, "f"), onDrop: __classPrivateFieldGet(this, _FileUploader_handleDrop, "f") }, h("button", { class: "button-tertiary button-icon-and-text", type: "button", onClick: __classPrivateFieldGet(this, _FileUploader_handleFileSelect, "f") }, h("ch-image", { class: "icon-md", src: PLUS_ICON }), h("label", { class: "label" }, this.multiple
+            ? (_b = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _b === void 0 ? void 0 : _b.header.uploadButtonMultiple
+            : (_c = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _c === void 0 ? void 0 : _c.header.uploadButtonSingle)), h("div", { class: "text-container" }, h("div", { class: "label-primary-row" }, h("label", { class: "label" }, this.label || ((_d = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _d === void 0 ? void 0 : _d.header.orText)), h("label", { class: "label" }, (_e = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _e === void 0 ? void 0 : _e.header.dragAndDrop)), h("span", { class: "caption" }, this.types && this.types.length > 0
+            ? (_f = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _f === void 0 ? void 0 : _f.header.acceptedFiles.replace("{0}", this.types.join(", "))
+            : (_g = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _g === void 0 ? void 0 : _g.header.allFilesAccepted)))) : (h("div", { class: "file-uploader__list" }, h("div", { class: "file-uploader__list-header spacing-body-block-end" }, h("div", { class: "file-uploader__list-title-container" }, h("label", { class: "label" }, this.label ||
+            ((_h = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _h === void 0 ? void 0 : _h.fileList.attachedFiles)), h("span", { class: "caption" }, (_j = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _j === void 0 ? void 0 : _j.fileList.filesCount.replace("{0}", this.fileStates.size.toString()))), this.multiple && (h("button", { class: "button-tertiary button-icon-and-text", type: "button", onClick: __classPrivateFieldGet(this, _FileUploader_handleFileSelect, "f") }, h("ch-image", { class: "icon-md", src: PLUS_ICON }), h("label", { class: "label" }, this.multiple
+            ? (_k = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _k === void 0 ? void 0 : _k.header.uploadButtonMultiple
+            : (_l = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _l === void 0 ? void 0 : _l.header.uploadButtonSingle)))), h("div", { class: "file-uploader__list-content scrollable" }, Array.from(this.fileStates.values()).map(file => (h("gx-ide-file-item", { key: file.id, file: file, editable: this.canEditName, onFileNameChange: __classPrivateFieldGet(this, _FileUploader_handleNameChange, "f"), onFileDelete: __classPrivateFieldGet(this, _FileUploader_handleFileCancel, "f"), onFileCancel: __classPrivateFieldGet(this, _FileUploader_handleFileCancel, "f") }))))))), h("div", { class: "dialog-footer control-footer control-footer-with-border" }, h("div", { class: "buttons-spacer" }, h("button", { class: "button-secondary", type: "button", onClick: __classPrivateFieldGet(this, _FileUploader_handleCancel, "f") }, (_m = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _m === void 0 ? void 0 : _m.buttons.cancel), h("button", { class: "button-primary", type: "button", onClick: __classPrivateFieldGet(this, _FileUploader_handleConfirm, "f"), disabled: this.fileStates.size === 0 ||
+                Array.from(this.fileStates.values()).some(file => file.pending) }, (_o = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _o === void 0 ? void 0 : _o.buttons.confirm))))));
+    }
+    static get is() { return "gx-ide-file-uploader"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["file-uploader.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["file-uploader.css"]
+        };
+    }
+    static get assetsDirs() { return ["gx-ide-assets/file-uploader"]; }
+    static get properties() {
+        return {
+            "types": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "string[]",
+                    "resolved": "string[]",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Allowed file types/extensions (e.g. ['.jpg', '.png', 'image/*', 'application/pdf'])"
+                },
+                "defaultValue": "[]"
+            },
+            "multiple": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Whether multiple files can be selected"
+                },
+                "attribute": "multiple",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "canEditName": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Whether file names can be edited"
+                },
+                "attribute": "can-edit-name",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Label to display in the uploader dialog"
+                },
+                "attribute": "label",
+                "reflect": false
+            },
+            "uploadFunction": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(\n    file: File,\n    progressCallback: (progress: number) => void\n  ) => Promise<UploadResult>",
+                    "resolved": "(file: File, progressCallback: (progress: number) => void) => Promise<UploadResult>",
+                    "references": {
+                        "File": {
+                            "location": "global",
+                            "id": "global::File"
+                        },
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "UploadResult": {
+                            "location": "import",
+                            "path": "./types",
+                            "id": "src/components/file-uploader/types.ts::UploadResult"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Function to handle file upload"
+                }
+            },
+            "cancelUploadFunction": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(fileId: string) => Promise<void>",
+                    "resolved": "(fileId: string) => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Function to cancel file upload"
+                }
+            },
+            "fileUploadedCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(file: UploadedFile) => Promise<void>",
+                    "resolved": "(file: UploadedFile) => Promise<void>",
+                    "references": {
+                        "UploadedFile": {
+                            "location": "import",
+                            "path": "./types",
+                            "id": "src/components/file-uploader/types.ts::UploadedFile"
+                        },
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when a file is uploaded successfully"
+                }
+            },
+            "dialogCanceledCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "() => Promise<void>",
+                    "resolved": "() => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when the dialog is canceled"
+                }
+            },
+            "dialogConfirmedCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(\n    files: UploadedFile[]\n  ) => Promise<void>",
+                    "resolved": "(files: UploadedFile[]) => Promise<void>",
+                    "references": {
+                        "UploadedFile": {
+                            "location": "import",
+                            "path": "./types",
+                            "id": "src/components/file-uploader/types.ts::UploadedFile"
+                        },
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when the dialog is confirmed with files"
+                }
+            },
+            "uploadCancelledCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(fileId: string) => Promise<void>",
+                    "resolved": "(fileId: string) => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when upload is cancelled"
+                }
+            },
+            "fileRenamedCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(data: {\n    fileId: string;\n    newName: string;\n  }) => Promise<void>",
+                    "resolved": "(data: { fileId: string; newName: string; }) => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when file is renamed"
+                }
+            },
+            "fileValidationErrorCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(data: {\n    fileName: string;\n    error: string;\n  }) => Promise<void>",
+                    "resolved": "(data: { fileName: string; error: string; }) => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when a file validation error occurs"
+                }
+            },
+            "fileDeletionErrorCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(data: {\n    fileName: string;\n    error: string;\n  }) => Promise<void>",
+                    "resolved": "(data: { fileName: string; error: string; }) => Promise<void>",
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when a file deletion error occurs"
+                }
+            },
+            "fileDeletedCallback": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(file: UploadedFile) => Promise<void>",
+                    "resolved": "(file: UploadedFile) => Promise<void>",
+                    "references": {
+                        "UploadedFile": {
+                            "location": "import",
+                            "path": "./types",
+                            "id": "src/components/file-uploader/types.ts::UploadedFile"
+                        },
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback when a file is deleted"
+                }
+            },
+            "onBeforeDelete": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "(file: UploadedFile) => Promise<boolean>",
+                    "resolved": "(file: UploadedFile) => Promise<boolean>",
+                    "references": {
+                        "UploadedFile": {
+                            "location": "import",
+                            "path": "./types",
+                            "id": "src/components/file-uploader/types.ts::UploadedFile"
+                        },
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Callback before deleting a file to get confirmation"
+                }
+            }
+        };
+    }
+    static get states() {
+        return {
+            "fileStates": {},
+            "isDragging": {}
+        };
+    }
+    static get methods() {
+        return {
+            "clear": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Clears the current file selection",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+}
+_FileUploader__componentLocale = new WeakMap(), _FileUploader_fileInputEl = new WeakMap(), _FileUploader_dragCounter = new WeakMap(), _FileUploader_generateId = new WeakMap(), _FileUploader_handleDragEnter = new WeakMap(), _FileUploader_handleDragLeave = new WeakMap(), _FileUploader_handleDragOver = new WeakMap(), _FileUploader_handleDrop = new WeakMap(), _FileUploader_handleFileSelect = new WeakMap(), _FileUploader_handleFileInput = new WeakMap(), _FileUploader_handleFiles = new WeakMap(), _FileUploader_handleNameChange = new WeakMap(), _FileUploader_handleFileCancel = new WeakMap(), _FileUploader_handleConfirm = new WeakMap(), _FileUploader_handleCancel = new WeakMap(), _FileUploader_instances = new WeakSet(), _FileUploader_isValidFile = function _FileUploader_isValidFile(file) {
+    var _a, _b;
+    // If no types specified, accept any file
+    if (!this.types || this.types.length === 0) {
+        return { isValid: true };
+    }
+    for (const type of this.types) {
+        // Handle wildcards like 'image/*'
+        if (type.includes("/*")) {
+            const baseType = type.split("/")[0];
+            if (file.type.startsWith(baseType)) {
+                return { isValid: true };
+            }
+        }
+        // Handle extensions like '.jpg'
+        else if (type.startsWith(".")) {
+            if (file.name.toLowerCase().endsWith(type.toLowerCase())) {
+                return { isValid: true };
+            }
+        }
+        // Handle specific MIME types
+        else if (file.type === type || file.type === `application/${type}`) {
+            return { isValid: true };
+        }
+    }
+    return {
+        isValid: false,
+        error: ((_b = (_a = __classPrivateFieldGet(this, _FileUploader__componentLocale, "f")) === null || _a === void 0 ? void 0 : _a.errors) === null || _b === void 0 ? void 0 : _b.invalidFileType) || "Invalid file type"
+    };
+}, _FileUploader_getValidFiles = function _FileUploader_getValidFiles(files) {
+    const validFiles = [];
+    Array.from(files).forEach(file => {
+        var _a;
+        const validation = __classPrivateFieldGet(this, _FileUploader_instances, "m", _FileUploader_isValidFile).call(this, file);
+        if (validation.isValid) {
+            validFiles.push(file);
+        }
+        else {
+            (_a = this.fileValidationErrorCallback) === null || _a === void 0 ? void 0 : _a.call(this, {
+                fileName: file.name,
+                error: validation.error
+            });
+        }
+    });
+    return validFiles;
+};
+//# sourceMappingURL=file-uploader.js.map