@uploadcare/file-uploader 1.15.0-alpha.8 → 1.15.0

package/blocks/FileItem/FileItem.d.ts

@@ -1,17 +1,4 @@
-export class FileItem extends UploaderBlock {
-    /** @private */
-    private _entrySubs;
-    /**
-     * @private
-     * @type {any} TODO: Add types for upload entry
-     */
-    private _entry;
-    /** @private */
-    private _isIntersecting;
-    /** @private */
-    private _debouncedGenerateThumb;
-    /** @private */
-    private _debouncedCalculateState;
+export class FileItem extends FileItemConfig {
     /** @private */
     private _renderedOnce;
     init$: {
@@ -28,17 +15,17 @@ export class FileItem extends UploaderBlock {
         isUploading: boolean;
         isFocused: boolean;
         isEditable: boolean;
-        isFileName: boolean;
+        showFileNames: boolean;
         state: symbol;
         ariaLabelStatusFile: string;
-        onEdit: () => void;
+        onEdit: (...args: any[]) => void;
         onRemove: () => void;
         onUpload: () => void;
         '*commonProgress': number;
         '*uploadList': never[];
         '*uploadQueue': import("@uploadcare/upload-client").Queue;
-        '*collectionErrors': any[];
-        '*collectionState': import("../../index.js").OutputCollectionState<import("../../index.js").OutputCollectionStatus, "maybe-has-group"> | null;
+        '*collectionErrors': ReturnType<import("../../index.js").OutputErrorCollection>[];
+        '*collectionState': import("../../index.js").OutputCollectionState | null;
         '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
         '*uploadTrigger': Set<string>;
         '*secureUploadsManager': import("../../abstract/SecureUploadsManager.js").SecureUploadsManager | null;
@@ -48,33 +35,26 @@ export class FileItem extends UploaderBlock {
         '*historyBack': null;
         '*closeModal': () => void;
     };
-    _reset(): void;
     /**
      * @private
      * @param {IntersectionObserverEntry[]} entries
      */
     private _observerCallback;
+    _isIntersecting: boolean | undefined;
     _thumbRect: DOMRectReadOnly | undefined;
     /** @private */
     private _calculateState;
     /** @private */
-    private _generateThumbnail;
-    /**
-     * @private
-     * @param {string} prop
-     * @param {(value: any) => void} handler
-     */
-    private _subEntry;
-    _updateHint: (() => void) & {
-        readonly cancel: () => void;
-    };
+    private _debouncedCalculateState;
+    _updateHint: (...args: any[]) => void;
     /**
      * @private
      * @param {String} id
      */
     private _handleEntryId;
-    /** @param {(typeof FileItemState)[keyof typeof FileItemState]} state */
-    _handleState(state: (typeof FileItemState)[keyof typeof FileItemState]): void;
+    /** @param {boolean} value */
+    _updateShowFileNames(value: boolean): void;
+    _handleState: (...args: any[]) => void;
     /** @private */
     private _observer;
     _settingsOfShrink(): {
@@ -86,18 +66,11 @@ export class FileItem extends UploaderBlock {
      * @param {File} file
      */
     private _processShrink;
-    upload(): Promise<void>;
+    upload: (...args: any[]) => Promise<void>;
 }
 export namespace FileItem {
     let template: string;
     let activeInstances: Set<any>;
 }
-import { UploaderBlock } from '../../abstract/UploaderBlock.js';
-declare const FileItemState: Readonly<{
-    FINISHED: symbol;
-    FAILED: symbol;
-    UPLOADING: symbol;
-    IDLE: symbol;
-}>;
-export {};
+import { FileItemConfig } from './FileItemConfig.js';
 //# sourceMappingURL=FileItem.d.ts.map

package/blocks/FileItem/FileItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileItem.d.ts","sourceRoot":"","sources":["FileItem.js"],"names":[],"mappings":"AAoBA;IAIE,eAAe;IACf,mBAAuB;IACvB;;;OAGG;IACH,eAAc;IACd,eAAe;IACf,wBAAwB;IACxB,eAAe;IACf,gCAA4E;IAC5E,eAAe;IACf,iCAA0E;IAE1E,eAAe;IACf,sBAAsB;IAKpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BC;IAGH,eASC;IAED;;;OAGG;IACH,0BAeC;IAXC,wCAA0C;IAa5C,eAAe;IACf,wBAgBC;IAED,eAAe;IACf,2BAuCC;IAED;;;;OAIG;IACH,kBAUC;IAED;;MAaQ;IAER;;;OAGG;IACH,uBAmDC;IA+CD,wEAAwE;IACxE,oBADY,CAAC,oBAAoB,CAAC,CAAC,MAAM,oBAAoB,CAAC,QA0B7D;IAaC,eAAe;IACf,kBAEE;IAWJ;;;MAEC;IAED;;;OAGG;IACH,uBAEC;IAED,wBAsFC;CACF;;;;;8BArc6B,iCAAiC;AAS/D;;;;;GAKG"}
+{"version":3,"file":"FileItem.d.ts","sourceRoot":"","sources":["FileItem.js"],"names":[],"mappings":"AAiBA;IAIE,eAAe;IACf,sBAAsB;IAKpB;;;;;;;;;;;;;;;;;;;;;;;+CAVoB,gBAAU;mCAIlB,gBACR;6BAMM,2BAET;;wCAMC,wCACK;;;;;;MAqBN;IAQH;;;OAGG;IACH,0BAUC;IAPC,qCAA2C;IAC3C,wCAA0C;IAQ5C,eAAe;IACf,wBAYG;IAEH,eAAe;IACf,iCAA0E;IAE1E,sCA4BE;IAEF;;;OAGG;IACH,uBAqCC;IAED,6BAA6B;IAC7B,4BADY,OAAO,QASlB;IAgDD,uCA+BE;IAaA,eAAe;IACf,kBAEE;IAUJ;;;MAEC;IAED;;;OAGG;IACH,uBAEC;IAED,0CAwGG;CACJ;;;;;+BA5Y8B,qBAAqB"}

package/blocks/FileItem/FileItem.js

@@ -1,15 +1,12 @@
 // @ts-check
-import { CancelError, uploadFile } from '@uploadcare/upload-client';
 import { shrinkFile } from '@uploadcare/image-shrink';
+import { CancelError, UploadcareError, uploadFile } from '@uploadcare/upload-client';
 import { ActivityBlock } from '../../abstract/ActivityBlock.js';
-import { UploaderBlock } from '../../abstract/UploaderBlock.js';
-import { createCdnUrl, createCdnUrlModifiers, createOriginalUrl } from '../../utils/cdn-utils.js';
-import { fileCssBg } from '../svg-backgrounds/svg-backgrounds.js';
 import { debounce } from '../utils/debounce.js';
-import { generateThumb } from '../utils/resizeImage.js';
 import { parseShrink } from '../../utils/parseShrink.js';
 import { UploadSource } from '../utils/UploadSource.js';
 import { throttle } from '../utils/throttle.js';
+import { FileItemConfig } from './FileItemConfig.js';
 
 const FileItemState = Object.freeze({
   FINISHED: Symbol('FINISHED'),
@@ -18,24 +15,10 @@ const FileItemState = Object.freeze({
   IDLE: Symbol('IDLE'),
 });
 
-export class FileItem extends UploaderBlock {
+export class FileItem extends FileItemConfig {
   couldBeCtxOwner = true;
   pauseRender = true;
 
-  /** @private */
-  _entrySubs = new Set();
-  /**
-   * @private
-   * @type {any} TODO: Add types for upload entry
-   */
-  _entry = null;
-  /** @private */
-  _isIntersecting = false;
-  /** @private */
-  _debouncedGenerateThumb = debounce(this._generateThumbnail.bind(this), 100);
-  /** @private */
-  _debouncedCalculateState = debounce(this._calculateState.bind(this), 100);
-
   /** @private */
   _renderedOnce = false;
 
@@ -57,16 +40,16 @@ export class FileItem extends UploaderBlock {
       isUploading: false,
       isFocused: false,
       isEditable: false,
-      isFileName: false,
+      showFileNames: false,
       state: FileItemState.IDLE,
       ariaLabelStatusFile: '',
-      onEdit: () => {
+      onEdit: this._withEntry((entry) => {
         this.$['*currentActivityParams'] = {
-          internalId: this._entry.uid,
+          internalId: entry.uid,
         };
         this.modalManager.open(ActivityBlock.activities.CLOUD_IMG_EDIT);
         this.$['*currentActivity'] = ActivityBlock.activities.CLOUD_IMG_EDIT;
-      },
+      }),
       onRemove: () => {
         this.uploadCollection.remove(this.$.uid);
       },
@@ -77,14 +60,8 @@ export class FileItem extends UploaderBlock {
   }
 
   _reset() {
-    for (let sub of this._entrySubs) {
-      sub.remove();
-    }
-
-    this._debouncedGenerateThumb.cancel();
+    super._reset();
     this._debouncedCalculateState.cancel();
-    this._entrySubs = new Set();
-    this._entry = null;
   }
 
   /**
@@ -101,19 +78,10 @@ export class FileItem extends UploaderBlock {
       this.render();
       this._renderedOnce = true;
     }
-    if (entry.intersectionRatio === 0) {
-      this._debouncedGenerateThumb.cancel();
-    } else {
-      this._debouncedGenerateThumb();
-    }
   }
 
   /** @private */
-  _calculateState() {
-    if (!this._entry) {
-      return;
-    }
-    let entry = this._entry;
+  _calculateState = this._withEntry((entry) => {
     let state = FileItemState.IDLE;
 
     if (entry.getValue('errors').length > 0) {
@@ -125,81 +93,40 @@ export class FileItem extends UploaderBlock {
     }
 
     this.$.state = state;
-  }
+  });
 
   /** @private */
-  async _generateThumbnail() {
-    if (!this._entry) {
-      return;
-    }
-    let entry = this._entry;
-
-    if (entry.getValue('fileInfo') && entry.getValue('isImage')) {
-      let size = Math.max(
-        parseInt(String(this?._thumbRect?.height || 0)),
-        parseInt(String(this?._thumbRect?.width || 0)),
-        this.cfg.thumbSize,
-      );
-
-      let thumbUrl = await this.proxyUrl(
-        createCdnUrl(
-          createOriginalUrl(this.cfg.cdnCname, this._entry.getValue('uuid')),
-          createCdnUrlModifiers(entry.getValue('cdnUrlModifiers'), `scale_crop/${size}x${size}/center`),
-        ),
-      );
-      let currentThumbUrl = entry.getValue('thumbUrl');
-      if (currentThumbUrl !== thumbUrl) {
-        entry.setValue('thumbUrl', thumbUrl);
-        currentThumbUrl?.startsWith('blob:') && URL.revokeObjectURL(currentThumbUrl);
-      }
-      return;
-    }
+  _debouncedCalculateState = debounce(this._calculateState.bind(this), 100);
 
-    if (entry.getValue('file')?.type.includes('image')) {
-      try {
-        let thumbUrl = await generateThumb(entry.getValue('file'), this.cfg.thumbSize);
-        entry.setValue('thumbUrl', thumbUrl);
-      } catch (err) {
-        let color = window.getComputedStyle(this).getPropertyValue('--uc-muted-foreground');
-        entry.setValue('thumbUrl', fileCssBg(color));
+  _updateHint = this._withEntry(
+    throttle((entry) => {
+      const source = entry.getValue('source');
+      const externalUrl = entry.getValue('externalUrl');
+      const noErrors = entry.getValue('errors').length === 0;
+      const noProgress = this.$.progressValue === 0;
+      const isUploading = this.$.state === FileItemState.UPLOADING;
+      const isQueued = entry.getValue('isQueued');
+
+      if (!noErrors || !isUploading || !noProgress) {
+        this.$.hint = '';
+        return;
       }
-    } else {
-      let color = window.getComputedStyle(this).getPropertyValue('--uc-muted-foreground');
-      entry.setValue('thumbUrl', fileCssBg(color));
-    }
-  }
-
-  /**
-   * @private
-   * @param {string} prop
-   * @param {(value: any) => void} handler
-   */
-  _subEntry(prop, handler) {
-    let sub = this._entry.subscribe(
-      prop,
-      /** @param {any} value */ (value) => {
-        if (this.isConnected) {
-          handler(value);
-        }
-      },
-    );
-    this._entrySubs.add(sub);
-  }
 
-  _updateHint = throttle(() => {
-    const showHint =
-      this.$.state === FileItemState.UPLOADING &&
-      this._entry.getValue('externalUrl') &&
-      this._entry.getValue('source') !== UploadSource.URL &&
-      this._entry.getValue('errors').length === 0 &&
-      this.$.progressValue === 0;
+      if (isQueued) {
+        const hint = this.l10n('queued');
+        this.$.hint = hint;
+        return;
+      }
 
-    const hint = showHint
-      ? this.l10n('waiting-for', { source: this.l10n(`src-type-${this._entry.getValue('source')}`) })
-      : '';
+      if (externalUrl && source && source !== UploadSource.URL) {
+        const hint = this.l10n('waiting-for', { source: this.l10n(`src-type-${source}`) });
+        this.$.hint = hint;
+        return;
+      }
 
-    this.$.hint = hint;
-  }, 100);
+      this.$.hint = '';
+    }, 100),
+  );
 
   /**
    * @private
@@ -208,7 +135,6 @@ export class FileItem extends UploaderBlock {
   _handleEntryId(id) {
     this._reset();
 
-    /** @type {import('../../abstract/TypedData.js').TypedData} */
     let entry = this.uploadCollection?.read(id);
     this._entry = entry;
 
@@ -221,6 +147,10 @@ export class FileItem extends UploaderBlock {
       this._updateHint();
     });
 
+    this._subEntry('isQueued', () => {
+      this._updateHint();
+    });
+
     this._subEntry('fileName', (name) => {
       this.$.itemName = name || entry.getValue('externalUrl') || this.l10n('file-no-name');
       this._debouncedCalculateState();
@@ -230,21 +160,8 @@ export class FileItem extends UploaderBlock {
       this.$.itemName = entry.getValue('fileName') || externalUrl || this.l10n('file-no-name');
     });
 
-    this._subEntry('fileInfo', (fileInfo) => {
+    this._subEntry('fileInfo', () => {
       this._debouncedCalculateState();
-      if (fileInfo && this._isIntersecting) {
-        this._debouncedGenerateThumb();
-      }
-    });
-
-    this._subEntry('cdnUrlModifiers', () => {
-      if (this._isIntersecting) {
-        this._debouncedGenerateThumb();
-      }
-    });
-
-    this._subEntry('thumbUrl', (thumbUrl) => {
-      this.$.thumbUrl = thumbUrl ? `url(${thumbUrl})` : '';
     });
 
     this._subEntry('errors', () => this._debouncedCalculateState());
@@ -252,10 +169,17 @@ export class FileItem extends UploaderBlock {
     this._subEntry('fileSize', () => this._debouncedCalculateState());
     this._subEntry('mimeType', () => this._debouncedCalculateState());
     this._subEntry('isImage', () => this._debouncedCalculateState());
+  }
 
-    if (this._isIntersecting) {
-      this._debouncedGenerateThumb();
+  /** @param {boolean} value */
+  _updateShowFileNames(value) {
+    const isListMode = this.cfg.filesViewMode === 'list';
+    if (isListMode) {
+      this.$.showFileNames = true;
+      return;
     }
+
+    this.$.showFileNames = value;
   }
 
   initCallback() {
@@ -270,16 +194,17 @@ export class FileItem extends UploaderBlock {
     });
 
     this.subConfigValue('useCloudImageEditor', () => this._debouncedCalculateState());
+
     this.subConfigValue('filesViewMode', (mode) => {
-      if (mode === 'grid') {
-        this.subConfigValue('gridShowFileNames', (value) => (this.$.isFileName = !value));
-      } else {
-        this.$.isFileName = false;
-      }
+      this._updateShowFileNames(this.cfg.gridShowFileNames);
 
       this.setAttribute('mode', mode);
     });
 
+    this.subConfigValue('gridShowFileNames', (value) => {
+      this._updateShowFileNames(value);
+    });
+
     this.onclick = () => {
       FileItem.activeInstances.forEach((inst) => {
         if (inst === this) {
@@ -294,7 +219,7 @@ export class FileItem extends UploaderBlock {
       '*uploadTrigger',
       /** @param {Set<string>} itemsToUpload */
       (itemsToUpload) => {
-        if (!itemsToUpload.has(this._entry.uid)) {
+        if (this._entry && !itemsToUpload.has(this._entry.uid)) {
           return;
         }
         setTimeout(() => this.isConnected && this.upload());
@@ -303,33 +228,38 @@ export class FileItem extends UploaderBlock {
     FileItem.activeInstances.add(this);
   }
 
-  /** @param {(typeof FileItemState)[keyof typeof FileItemState]} state */
-  _handleState(state) {
-    if (state === FileItemState.FAILED) {
-      this.$.badgeIcon = 'badge-error';
-    } else if (state === FileItemState.FINISHED) {
-      this.$.badgeIcon = 'badge-success';
-    }
-
-    if (state === FileItemState.UPLOADING) {
-      this.$.isFocused = false;
-    }
+  _handleState = this._withEntry(
+    /** @param {(typeof FileItemState)[keyof typeof FileItemState]} state */
+    (entry, state) => {
+      if (state === FileItemState.FAILED) {
+        this.$.badgeIcon = 'badge-error';
+      } else if (state === FileItemState.FINISHED) {
+        this.$.badgeIcon = 'badge-success';
+      }
 
-    this.set$({
-      isFailed: state === FileItemState.FAILED,
-      isUploading: state === FileItemState.UPLOADING,
-      isFinished: state === FileItemState.FINISHED,
-      progressVisible: state === FileItemState.UPLOADING,
-      isEditable: this.cfg.useCloudImageEditor && this._entry?.getValue('isImage') && this._entry?.getValue('cdnUrl'),
-      errorText: this._entry.getValue('errors')?.[0]?.message,
-      ariaLabelStatusFile: this.l10n('a11y-file-item-status', {
-        fileName: this._entry?.getValue('fileName'),
-        status: this.l10n(state?.description?.toLocaleLowerCase() ?? '').toLocaleLowerCase(),
-      }),
-    });
+      if (state === FileItemState.UPLOADING) {
+        this.$.isFocused = false;
+      }
+      const fileName = entry.getValue('fileName');
+
+      this.set$({
+        isFailed: state === FileItemState.FAILED,
+        isUploading: state === FileItemState.UPLOADING,
+        isFinished: state === FileItemState.FINISHED,
+        progressVisible: state === FileItemState.UPLOADING,
+        isEditable: this.cfg.useCloudImageEditor && this._entry?.getValue('isImage') && this._entry?.getValue('cdnUrl'),
+        errorText: entry.getValue('errors')?.[0]?.message,
+        ariaLabelStatusFile:
+          fileName &&
+          this.l10n('a11y-file-item-status', {
+            fileName,
+            status: this.l10n(state?.description?.toLocaleLowerCase() ?? '').toLocaleLowerCase(),
+          }),
+      });
 
-    this._updateHint();
-  }
+      this._updateHint();
+    },
+  );
 
   destroyCallback() {
     super.destroyCallback();
@@ -352,7 +282,6 @@ export class FileItem extends UploaderBlock {
   disconnectedCallback() {
     super.disconnectedCallback();
 
-    this._debouncedGenerateThumb.cancel();
     this._observer?.disconnect();
   }
 
@@ -368,9 +297,7 @@ export class FileItem extends UploaderBlock {
     return shrinkFile(file, this._settingsOfShrink());
   }
 
-  async upload() {
-    let entry = this._entry;
-
+  upload = this._withEntry(async (entry) => {
     if (!this.uploadCollection.read(entry.uid)) {
       return;
     }
@@ -384,26 +311,35 @@ export class FileItem extends UploaderBlock {
     }
 
     this._debouncedCalculateState();
-    entry.setValue('isUploading', true);
-    entry.setValue('errors', []);
+
+    entry.setMultipleValues({
+      isUploading: true,
+      errors: [],
+      isQueued: true,
+    });
 
     try {
       let abortController = new AbortController();
       entry.setValue('abortController', abortController);
 
       const uploadTask = async () => {
+        entry.setValue('isQueued', false);
+        /** @type {Blob | File | null} */
         let file = entry.getValue('file');
         if (file && this.cfg.imageShrink) {
-          file = await this._processShrink(file).catch(() => file);
+          file = await this._processShrink(/** @type {File} */ (file)).catch(() => file);
         }
 
         const fileInput = file || entry.getValue('externalUrl') || entry.getValue('uuid');
+        if (!fileInput) {
+          throw new Error('No file input');
+        }
         const baseUploadClientOptions = await this.getUploadClientOptions();
         /** @type {import('@uploadcare/upload-client').FileFromOptions} */
         const uploadClientOptions = {
           ...baseUploadClientOptions,
-          fileName: entry.getValue('fileName'),
-          source: entry.getValue('source'),
+          fileName: entry.getValue('fileName') ?? undefined,
+          source: entry.getValue('source') ?? undefined,
           onProgress: (progress) => {
             if (progress.isComputable) {
               let percentage = progress.value * 100;
@@ -421,10 +357,11 @@ export class FileItem extends UploaderBlock {
       let fileInfo = await this.$['*uploadQueue'].add(uploadTask);
       entry.setMultipleValues({
         fileInfo,
+        isQueued: false,
         isUploading: false,
         fileName: fileInfo.originalFilename,
         fileSize: fileInfo.size,
-        isImage: fileInfo.isImage,
+        isImage: fileInfo.isImage ?? false,
         mimeType: fileInfo.contentInfo?.mime?.mime ?? fileInfo.mimeType,
         uuid: fileInfo.uuid,
         cdnUrl: entry.getValue('cdnUrl') ?? fileInfo.cdnUrl,
@@ -442,27 +379,37 @@ export class FileItem extends UploaderBlock {
           isUploading: false,
           uploadProgress: 0,
         });
-      } else {
+      } else if (cause instanceof UploadcareError) {
         entry.setMultipleValues({
           isUploading: false,
           uploadProgress: 0,
           uploadError: cause,
         });
+      } else {
+        console.error('Unknown upload error', cause);
+        entry.setMultipleValues({
+          isUploading: false,
+          uploadProgress: 0,
+          // TODO: Add translation?
+          uploadError: new Error('Something went wrong', {
+            cause,
+          }),
+        });
       }
 
       if (entry === this._entry) {
         this._debouncedCalculateState();
       }
     }
-  }
+  });
 }
 
 FileItem.template = /* HTML */ `
   <div class="uc-inner" set="@finished: isFinished; @uploading: isUploading; @failed: isFailed; @focused: isFocused">
-    <uc-thumb set="thumbUrl:thumbUrl;badgeIcon:badgeIcon"></uc-thumb>
+    <uc-thumb set="uid:uid;badgeIcon:badgeIcon"></uc-thumb>
 
     <div aria-atomic="true" aria-live="polite" class="uc-file-name-wrapper" set="@aria-label:ariaLabelStatusFile;">
-      <span class="uc-file-name" set="@hidden: isFileName">{{itemName}}</span>
+      <span class="uc-file-name" set="@hidden: !showFileNames">{{itemName}}</span>
       <span class="uc-file-error" set="@hidden: !errorText;">{{errorText}}</span>
       <span class="uc-file-hint" set="@hidden: !hint">{{hint}}</span>
     </div>
@@ -489,7 +436,7 @@ FileItem.template = /* HTML */ `
     </div>
     <uc-progress-bar
       class="uc-progress-bar"
-      set="value: progressValue; visible: progressVisible; @hasFileName: !isFileName"
+      set="value: progressValue; visible: progressVisible; @hasFileName: showFileNames;"
     >
     </uc-progress-bar>
   </div>

package/blocks/FileItem/FileItemConfig.d.ts

@@ -0,0 +1,28 @@
+export class FileItemConfig extends UploaderBlock {
+    /** @protected */
+    protected _entrySubs: Set<any>;
+    /**
+     * @type {import('../../abstract/uploadEntrySchema.js').UploadEntryTypedData | null}
+     * @protected
+     */
+    protected _entry: import("../../abstract/uploadEntrySchema.js").UploadEntryTypedData | null;
+    /**
+     * @template {any[]} A
+     * @template {(entry: import('../../abstract/uploadEntrySchema.js').UploadEntryTypedData, ...args: A) => any} T
+     * @param {T} fn
+     * @returns {(...args: A) => ReturnType<T>}
+     * @protected
+     */
+    protected _withEntry<A extends any[], T extends (entry: import("../../abstract/uploadEntrySchema.js").UploadEntryTypedData, ...args: A) => any>(fn: T): (...args: A) => ReturnType<T>;
+    /**
+     * @template {import('../../abstract/uploadEntrySchema.js').UploadEntryKeys} K
+     * @param {K} prop_
+     * @param {(value: import('../../abstract/uploadEntrySchema.js').UploadEntryData[K]) => void} handler_
+     * @protected
+     */
+    protected _subEntry: (prop_: K, handler_: (value: import("../../abstract/uploadEntrySchema.js").UploadEntryData[K]) => void) => void;
+    /** @protected */
+    protected _reset(): void;
+}
+import { UploaderBlock } from '../../abstract/UploaderBlock.js';
+//# sourceMappingURL=FileItemConfig.d.ts.map

package/blocks/FileItem/FileItemConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileItemConfig.d.ts","sourceRoot":"","sources":["FileItemConfig.js"],"names":[],"mappings":"AAIA;IACE,iBAAiB;IACjB,+BAAuB;IAEvB;;;OAGG;IACH,kBAHU,OAAO,qCAAqC,EAAE,oBAAoB,GAAG,IAAI,CAGrE;IAEd;;;;;;OAMG;IACH,qBANqB,CAAC,SAAR,GAAG,EAAG,EAC0F,CAAC,SAAlG,CAAE,KAAK,EAAE,OAAO,qCAAqC,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,GAAI,MAClG,CAAC,GACC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAezC;IAED;;;;;OAKG;IACH,sBAAa,OAJF,CAIO,EAAE,UAHT,CAAC,KAAK,EAAE,OAAO,qCAAqC,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAG5D,UAgBP;IAErB,iBAAiB;IACjB,yBAOC;CAMF;8BAvE6B,iCAAiC"}