@uploadcare/file-uploader 1.15.0-alpha.2 → 1.15.0-alpha.21

package/abstract/UploaderPublicApi.d.ts

@@ -1,6 +1,6 @@
 export class UploaderPublicApi {
     /** @param {import('./UploaderBlock.js').UploaderBlock} ctx */
-    constructor(ctx: import('./UploaderBlock.js').UploaderBlock);
+    constructor(ctx: import("./UploaderBlock.js").UploaderBlock);
     /**
      * @private
      * @type {import('./UploaderBlock.js').UploaderBlock}
@@ -20,41 +20,41 @@ export class UploaderPublicApi {
      * @returns {import('../types').OutputFileEntry<'idle'>}
      */
     addFileFromUrl: (url: string, { silent, fileName, source }?: {
-        silent?: boolean | undefined;
-        fileName?: string | undefined;
-        source?: string | undefined;
-    } | undefined) => import('../types').OutputFileEntry<'idle'>;
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
     /**
      * @param {string} uuid
      * @param {{ silent?: boolean; fileName?: string; source?: string }} [options]
      * @returns {import('../types').OutputFileEntry<'idle'>}
      */
     addFileFromUuid: (uuid: string, { silent, fileName, source }?: {
-        silent?: boolean | undefined;
-        fileName?: string | undefined;
-        source?: string | undefined;
-    } | undefined) => import('../types').OutputFileEntry<'idle'>;
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
     /**
      * @param {string} cdnUrl
      * @param {{ silent?: boolean; fileName?: string; source?: string }} [options]
      * @returns {import('../types').OutputFileEntry<'idle'>}
      */
     addFileFromCdnUrl: (cdnUrl: string, { silent, fileName, source }?: {
-        silent?: boolean | undefined;
-        fileName?: string | undefined;
-        source?: string | undefined;
-    } | undefined) => import('../types').OutputFileEntry<'idle'>;
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
     /**
      * @param {File} file
      * @param {{ silent?: boolean; fileName?: string; source?: string; fullPath?: string }} [options]
      * @returns {import('../types').OutputFileEntry<'idle'>}
      */
     addFileFromObject: (file: File, { silent, fileName, source, fullPath }?: {
-        silent?: boolean | undefined;
-        fileName?: string | undefined;
-        source?: string | undefined;
-        fullPath?: string | undefined;
-    } | undefined) => import('../types').OutputFileEntry<'idle'>;
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+        fullPath?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
     /** @param {string} internalId */
     removeFileByInternalId: (internalId: string) => void;
     removeAllFiles(): void;
@@ -62,18 +62,18 @@ export class UploaderPublicApi {
     /** @param {{ captureCamera?: boolean; modeCamera?: import('../blocks/CameraSource/constants.js').ModeCameraType }} options */
     openSystemDialog: (options?: {
         captureCamera?: boolean;
-        modeCamera?: import('../blocks/CameraSource/constants.js').ModeCameraType;
+        modeCamera?: import("../blocks/CameraSource/constants.js").ModeCameraType;
     }) => void;
     /**
      * @template {import('../types').OutputFileStatus} TStatus
      * @param {string} entryId
      * @returns {import('../types/exported.js').OutputFileEntry<TStatus>}
      */
-    getOutputItem: <TStatus extends import("../types").OutputFileStatus>(entryId: string) => import("../types").OutputFileEntry<TStatus>;
+    getOutputItem: (entryId: string) => import("../types/exported.js").OutputFileEntry<TStatus>;
     /** @template {import('../types').OutputCollectionStatus} TStatus */
-    getOutputCollectionState: <TStatus_1 extends import("../types").OutputCollectionStatus>() => import("../types").OutputCollectionState<TStatus_1, "maybe-has-group">;
+    getOutputCollectionState: () => ReturnType<typeof buildOutputCollectionState<TStatus>>;
     /** @param {Boolean} [force] */
-    initFlow: (force?: boolean | undefined) => void;
+    initFlow: (force?: boolean) => void;
     doneFlow: () => void;
     /**
      * @type {<T extends import('./ActivityBlock.js').ActivityType>(
@@ -87,7 +87,7 @@ export class UploaderPublicApi {
      */
     setCurrentActivity: <T extends import("./ActivityBlock.js").ActivityType>(activityType: T, ...params: T extends keyof import("./ActivityBlock.js").ActivityParamsMap ? [import("./ActivityBlock.js").ActivityParamsMap[T]] : T extends import("./ActivityBlock.js").RegisteredActivityType ? [undefined?] : [any?]) => void;
     /** @returns {import('./ActivityBlock.js').ActivityType} */
-    getCurrentActivity: () => import('./ActivityBlock.js').ActivityType;
+    getCurrentActivity: () => import("./ActivityBlock.js").ActivityType;
     /** @param {boolean} opened */
     setModalState: (opened: boolean) => void;
     /**
@@ -96,4 +96,5 @@ export class UploaderPublicApi {
      */
     private get _sourceList();
 }
+import { buildOutputCollectionState } from './buildOutputCollectionState.js';
 //# sourceMappingURL=UploaderPublicApi.d.ts.map

package/abstract/UploaderPublicApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UploaderPublicApi.d.ts","sourceRoot":"","sources":["UploaderPublicApi.js"],"names":[],"mappings":"AAeA;IAOE,8DAA8D;IAC9D,iBADY,OAAO,oBAAoB,EAAE,aAAa,EAGrD;IATD;;;OAGG;IACH,aAAK;IAOL,eAAe;IACf,gCAEC;IAED,yCAEC;IAED;;iBAEC;IAED;;;;;;OAMG;IACH,sBAJW,MAAM;;;;sBAEJ,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,wBAJW,MAAM;;;;sBAEJ,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,4BAJW,MAAM;;;;sBAEJ,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAgBrD;IAEF;;;;OAIG;IACH,0BAJW,IAAI;;;;;sBAEF,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAcrD;IAEF,iCAAiC;IACjC,qCADY,MAAM,UAMhB;IAEF,uBAEC;IAED,sBAeE;IAEF,8HAA8H;IAC9H,6BADY;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,qCAAqC,EAAE,cAAc,CAAA;KAAE,UAyDhH;IAEF;;;;OAIG;IACH,8EAHW,MAAM,iDA8Cf;IAEF,oEAAoE;IACpE,oKAIE;IAEF,+BAA+B;IAC/B,gDA6DE;IAEF,qBAQE;IAEF;;;;;;;;;OASG;IACH,uTAFQ,IAAI,CAWV;IAEF,2DAA2D;IAC3D,0BADc,OAAO,oBAAoB,EAAE,YAAY,CAGrD;IAEF,8BAA8B;IAC9B,wBADY,OAAO,UAajB;IAEF;;;OAGG;IACH,0BAOC;CACF"}
+{"version":3,"file":"UploaderPublicApi.d.ts","sourceRoot":"","sources":["UploaderPublicApi.js"],"names":[],"mappings":"AAqBA;IAOE,8DAA8D;IAC9D,iBADY,OAAO,oBAAoB,EAAE,aAAa,EAGrD;IATD;;;OAGG;IACH,aAAK;IAOL,eAAe;IACf,gCAEC;IAED,yCAEC;IAED;;iBAEC;IAED;;;;;;OAMG;IACH,iBAAkB,KAJP,MAIU,EAAE,+BAHZ;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGT,KAF3C,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,kBAAmB,MAJR,MAIY,EAAE,+BAHd;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGP,KAF7C,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,oBAAqB,QAJV,MAIgB,EAAE,+BAHlB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGH,KAFjD,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAgBrD;IAEF;;;;OAIG;IACH,oBAAqB,MAJV,IAIc,EAAE,yCAHhB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAGd,KAFzD,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAcrD;IAEF,iCAAiC;IACjC,yBAA0B,YADd,MACwB,UAKlC;IAEF,uBAEC;IAED,sBAgBE;IAEF,8HAA8H;IAC9H,mBAAoB,UADR;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,qCAAqC,EAAE,cAAc,CAAA;KAChF,UA0D9B;IAEF;;;;OAIG;IACH,gBAAiB,SAHN,MAGa,KAFX,OAAO,sBAAsB,EAAE,eAAe,CAAC,OAAO,CAAC,CA+ClE;IAEF,oEAAoE;IACpE,gCACoB,UAAU,CAAC,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAGxE;IAEF,+BAA+B;IAC/B,WAAY,eAAa,UA6DvB;IAEF,qBAQE;IAEF;;;;;;;;;OASG;IACH,oBATU,CAAC,CAAC,SAAS,OAAO,oBAAoB,EAAE,YAAY,EACzD,YAAY,EAAE,CAAC,EACnB,GAAO,MAAM,EAAE,CAAC,SAAS,MAAM,OAAO,oBAAoB,EAAE,iBAAiB,GACrE,CAAC,OAAO,oBAAoB,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACnD,CAAC,SAAS,OAAO,oBAAoB,EAAE,sBAAsB,GAC3D,CAAC,SAAS,CAAC,CAAC,GACZ,CAAC,GAAG,CAAC,CAAC,KACT,IAAI,CAWV;IAEF,2DAA2D;IAC3D,0BADc,OAAO,oBAAoB,EAAE,YAAY,CAGrD;IAEF,8BAA8B;IAC9B,gBAAiB,QADL,OACW,UAYrB;IAEF;;;OAGG;IACH,0BAOC;CACF;2CAxX0C,iCAAiC"}

package/abstract/UploaderPublicApi.js

@@ -2,16 +2,22 @@
 import { ActivityBlock } from './ActivityBlock.js';
 
 import { applyStyles, Data } from '@symbiotejs/symbiote';
+import { calcCameraModes } from '../blocks/CameraSource/calcCameraModes.js';
+import { CameraSourceTypes } from '../blocks/CameraSource/constants.js';
 import { EventType } from '../blocks/UploadCtxProvider/EventEmitter.js';
 import { UploadSource } from '../blocks/utils/UploadSource.js';
 import { serializeCsv } from '../blocks/utils/comma-separated.js';
-import { IMAGE_ACCEPT_LIST, fileIsImage, mergeFileTypes } from '../utils/fileTypes.js';
+import { browserFeatures } from '../utils/browser-info.js';
+import {
+  BASIC_IMAGE_WILDCARD,
+  BASIC_VIDEO_WILDCARD,
+  fileIsImage,
+  IMAGE_ACCEPT_LIST,
+  mergeFileTypes,
+} from '../utils/fileTypes.js';
 import { parseCdnUrl } from '../utils/parseCdnUrl.js';
-import { buildOutputCollectionState } from './buildOutputCollectionState.js';
 import { stringToArray } from '../utils/stringToArray.js';
-import { calcCameraModes } from '../blocks/CameraSource/calcCameraModes.js';
-import { CameraSourceTypes } from '../blocks/CameraSource/constants.js';
-import { isSupportCapture } from '../blocks/utils/supportCapture.js';
+import { buildOutputCollectionState } from './buildOutputCollectionState.js';
 
 export class UploaderPublicApi {
   /**
@@ -125,6 +131,7 @@ export class UploaderPublicApi {
   uploadAll = () => {
     const itemsToUpload = this._uploadCollection.items().filter((id) => {
       const entry = this._uploadCollection.read(id);
+      if (!entry) return false;
       return !entry.getValue('isRemoved') && !entry.getValue('isUploading') && !entry.getValue('fileInfo');
     });
 
@@ -160,11 +167,13 @@ export class UploaderPublicApi {
       const { isPhotoEnabled, isVideoRecordingEnabled } = calcCameraModes(this.cfg);
 
       if (options.modeCamera === CameraSourceTypes.PHOTO && isPhotoEnabled) {
-        fileInput.accept = 'image/*';
+        fileInput.accept = BASIC_IMAGE_WILDCARD;
       } else if (options.modeCamera === CameraSourceTypes.VIDEO && isVideoRecordingEnabled) {
-        fileInput.accept = 'video/*';
+        fileInput.accept = BASIC_VIDEO_WILDCARD;
       } else {
-        fileInput.accept = ['image/*', isVideoRecordingEnabled && 'video/*'].filter(Boolean).join(',');
+        fileInput.accept = [BASIC_IMAGE_WILDCARD, isVideoRecordingEnabled && BASIC_VIDEO_WILDCARD]
+          .filter(Boolean)
+          .join(',');
       }
     } else {
       fileInput.accept = accept;
@@ -204,7 +213,9 @@ export class UploaderPublicApi {
    * @returns {import('../types/exported.js').OutputFileEntry<TStatus>}
    */
   getOutputItem = (entryId) => {
-    const uploadEntryData = /** @type {import('./uploadEntrySchema.js').UploadEntry} */ (Data.getCtx(entryId).store);
+    const uploadEntryData = /** @type {import('./uploadEntrySchema.js').UploadEntryData} */ (
+      Data.getCtx(entryId).store
+    );
 
     /** @type {import('@uploadcare/upload-client').UploadcareFile?} */
     const fileInfo = uploadEntryData.fileInfo;
@@ -273,7 +284,7 @@ export class UploaderPublicApi {
           return;
         }
 
-        if (srcKey === 'camera' && isSupportCapture()) {
+        if (srcKey === 'camera' && browserFeatures.htmlMediaCapture) {
           const { isPhotoEnabled, isVideoRecordingEnabled } = calcCameraModes(this.cfg);
 
           if (isPhotoEnabled && isVideoRecordingEnabled) {

package/abstract/ValidationManager.d.ts

@@ -1,6 +1,6 @@
 export class ValidationManager {
     /** @param {import('./UploaderBlock.js').UploaderBlock} blockInstance */
-    constructor(blockInstance: import('./UploaderBlock.js').UploaderBlock);
+    constructor(blockInstance: import("./UploaderBlock.js").UploaderBlock);
     /**
      * @private
      * @type {import('./UploaderBlock.js').UploaderBlock}
@@ -10,13 +10,132 @@ export class ValidationManager {
     _fileValidators: FuncFileValidator[];
     /** @type {FuncCollectionValidator[]} */
     _collectionValidators: FuncCollectionValidator[];
-    _uploadCollection: import("./TypedCollection.js").TypedCollection;
+    _uploadCollection: import("./TypedCollection.js").TypedCollection<Readonly<{
+        file: Readonly<{
+            type: {
+                new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+                prototype: File;
+            };
+            value: null;
+            nullable: true;
+        }>;
+        externalUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileName: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileSize: Readonly<{
+            type: NumberConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        lastModified: Readonly<{
+            type: NumberConstructor;
+            value: number;
+        }>;
+        uploadProgress: Readonly<{
+            type: NumberConstructor;
+            value: 0;
+        }>;
+        uuid: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        isImage: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        mimeType: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        ctxName: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        cdnUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        cdnUrlModifiers: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileInfo: Readonly<{
+            type: typeof import("@uploadcare/upload-client").UploadcareFile;
+            value: null;
+            nullable: true;
+        }>;
+        isUploading: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        abortController: Readonly<{
+            type: {
+                new (): AbortController;
+                prototype: AbortController;
+            };
+            value: null;
+            nullable: true;
+        }>;
+        thumbUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        silent: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        source: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fullPath: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        metadata: Readonly<{
+            type: ObjectConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        errors: Readonly<{
+            type: ArrayConstructor;
+            value: Error[];
+        }>;
+        uploadError: Readonly<{
+            type: ErrorConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        isRemoved: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        isQueued: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+    }>>;
     /** @param {string[]} [entryIds] */
-    runFileValidators(entryIds?: string[] | undefined): void;
+    runFileValidators(entryIds?: string[]): void;
     runCollectionValidators(): void;
     /**
      * @private
-     * @param {import('./TypedData.js').TypedData} entry
+     * @param {import('./TypedData.js').TypedData<typeof import('./uploadEntrySchema.js').uploadEntrySchema>} entry
      */
     private _runFileValidatorsForEntry;
     /**
@@ -26,6 +145,6 @@ export class ValidationManager {
      */
     _addCustomTypeToValidators<T>(validators: T[]): T[];
 }
-export type FuncFileValidator = (outputEntry: import('../types').OutputFileEntry, api: import('./UploaderPublicApi.js').UploaderPublicApi) => undefined | import('../types').OutputErrorFile;
-export type FuncCollectionValidator = (collection: ReturnType<typeof import('./buildOutputCollectionState.js').buildOutputCollectionState<import('../types').OutputCollectionStatus>>, api: import('./UploaderPublicApi.js').UploaderPublicApi) => undefined | import('../types').OutputErrorCollection;
+export type FuncFileValidator = (outputEntry: import("../types").OutputFileEntry, api: import("./UploaderPublicApi.js").UploaderPublicApi) => undefined | import("../types").OutputErrorFile;
+export type FuncCollectionValidator = (collection: ReturnType<typeof import("./buildOutputCollectionState.js").buildOutputCollectionState<import("../types").OutputCollectionStatus>>, api: import("./UploaderPublicApi.js").UploaderPublicApi) => undefined | import("../types").OutputErrorCollection;
 //# sourceMappingURL=ValidationManager.d.ts.map

package/abstract/ValidationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ValidationManager.d.ts","sourceRoot":"","sources":["ValidationManager.js"],"names":[],"mappings":"AAkCA;IAaE,wEAAwE;IACxE,2BADY,OAAO,oBAAoB,EAAE,aAAa,EAiBrD;IA7BD;;;OAGG;IACH,uBAAe;IAEf,kCAAkC;IAClC,iBADW,iBAAiB,EAAE,CACmE;IAEjG,wCAAwC;IACxC,uBADW,uBAAuB,EAAE,CACsC;IAMxE,kEAA6D;IAe/D,mCAAmC;IACnC,yDAQC;IAED,gCAqCC;IAED;;;OAGG;IACH,mCAyBC;IAED;;;;OAIG;IACH,oDAQC;CACF;8CArJiB,OAAO,UAAU,EAAE,eAAe,OAC1C,OAAO,wBAAwB,EAAE,iBAAiB,KACpD,SAAS,GAAG,OAAO,UAAU,EAAE,eAAe;mDAKrC,WAChB,cAAoB,iCAAiC,EAAE,0BAA0B,CACjF,OAAe,UAAU,EAAE,sBAAsB,CAC1C,CACF,OACI,OAAO,wBAAwB,EAAE,iBAAiB,KACpD,SAAS,GAAG,OAAO,UAAU,EAAE,qBAAqB"}
+{"version":3,"file":"ValidationManager.d.ts","sourceRoot":"","sources":["ValidationManager.js"],"names":[],"mappings":"AAkCA;IAaE,wEAAwE;IACxE,2BADY,OAAO,oBAAoB,EAAE,aAAa,EAiBrD;IA7BD;;;OAGG;IACH,uBAAe;IAEf,kCAAkC;IAClC,iBADW,iBAAiB,EAAE,CACmE;IAEjG,wCAAwC;IACxC,uBADW,uBAAuB,EAAE,CACsC;IAMxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAA6D;IAe/D,mCAAmC;IACnC,6BADY,MAAM,EAAE,QASnB;IAED,gCAqCC;IAED;;;OAGG;IACH,mCAyBC;IAED;;;;OAIG;IACH,2BAJa,CAAC,cACH,CAAC,EAAE,GACD,CAAC,EAAE,CAUf;CACF;gCAtJY,CACR,WAAW,EAAE,OAAO,UAAU,EAAE,eAAe,EAC/C,GAAG,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,KACpD,SAAS,GAAG,OAAO,UAAU,EAAE,eAAe;sCAIzC,CACR,UAAU,EAAE,UAAU,CAC1B,cAAoB,iCAAiC,EAAE,0BAA0B,CACjF,OAAe,UAAU,EAAE,sBAAsB,CAC1C,CACF,EACD,GAAG,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,KACpD,SAAS,GAAG,OAAO,UAAU,EAAE,qBAAqB"}

package/abstract/ValidationManager.js

@@ -116,7 +116,7 @@ export class ValidationManager {
 
   /**
    * @private
-   * @param {import('./TypedData.js').TypedData} entry
+   * @param {import('./TypedData.js').TypedData<typeof import('./uploadEntrySchema.js').uploadEntrySchema>} entry
    */
   _runFileValidatorsForEntry(entry) {
     const outputEntry = this._blockInstance.api.getOutputItem(entry.uid);

package/abstract/a11y.d.ts

@@ -10,11 +10,11 @@ export class A11y {
      */
     private _scopedWindow;
     /** @param {import('./Block.js').Block} scope */
-    registerBlock(scope: import('./Block.js').Block): void;
+    registerBlock(scope: import("./Block.js").Block): void;
     destroy(): void;
 }
 /**
  * MinimalWindow interface is not exported by keyux, so we import it here using tricky way.
  */
-export type MinimalWindow = Parameters<import('keyux').KeyUXModule>[0];
+export type MinimalWindow = Parameters<import("keyux").KeyUXModule>[0];
 //# sourceMappingURL=a11y.d.ts.map

package/abstract/a11y.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["a11y.js"],"names":[],"mappings":"AAqFA;IACE;;;OAGG;IACH,sBAAc;IAEd;;;OAGG;IACH,sBAAc;IAYd,gDAAgD;IAChD,qBADY,OAAO,YAAY,EAAE,KAAK,QAGrC;IAED,gBAGC;CACF;;;;4BA/GY,WAAW,OAAO,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"a11y.d.ts","sourceRoot":"","sources":["a11y.js"],"names":[],"mappings":"AAqFA;IACE;;;OAGG;IACH,sBAAc;IAEd;;;OAGG;IACH,sBAAc;IAYd,gDAAgD;IAChD,qBADY,OAAO,YAAY,EAAE,KAAK,QAGrC;IAED,gBAGC;CACF;;;;4BA/GY,UAAU,CAAC,OAAO,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/abstract/buildOutputCollectionState.d.ts

@@ -4,5 +4,5 @@
  * @param {import('./UploaderBlock.js').UploaderBlock} uploaderBlock
  * @returns {import('../index.js').OutputCollectionState<TCollectionStatus, TGroupFlag>}
  */
-export function buildOutputCollectionState<TCollectionStatus extends import("../index.js").OutputCollectionStatus, TGroupFlag extends import("../index.js").GroupFlag = "maybe-has-group">(uploaderBlock: import('./UploaderBlock.js').UploaderBlock): import("../index.js").OutputCollectionState<TCollectionStatus, TGroupFlag>;
+export function buildOutputCollectionState<TCollectionStatus extends import("../index.js").OutputCollectionStatus, TGroupFlag extends import("../index.js").GroupFlag = "maybe-has-group">(uploaderBlock: import("./UploaderBlock.js").UploaderBlock): import("../index.js").OutputCollectionState<TCollectionStatus, TGroupFlag>;
 //# sourceMappingURL=buildOutputCollectionState.d.ts.map

package/abstract/buildOutputCollectionState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildOutputCollectionState.d.ts","sourceRoot":"","sources":["buildOutputCollectionState.js"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,0MAHW,OAAO,oBAAoB,EAAE,aAAa,8EAmGpD"}
+{"version":3,"file":"buildOutputCollectionState.d.ts","sourceRoot":"","sources":["buildOutputCollectionState.js"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,2CAL4D,iBAAiB,SAAhE,OAAQ,aAAa,EAAE,sBAAuB,EACX,UAAU,SAA7C,OAAQ,aAAa,EAAE,SAAU,qCACnC,OAAO,oBAAoB,EAAE,aAAa,GACxC,OAAO,aAAa,EAAE,qBAAqB,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAkGtF"}

package/abstract/defineComponents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defineComponents.d.ts","sourceRoot":"","sources":["defineComponents.js"],"names":[],"mappings":"AAAA,gDAAgD;AAChD;QADmB,MAAM,GAAE,GAAG;SAoB7B"}
+{"version":3,"file":"defineComponents.d.ts","sourceRoot":"","sources":["defineComponents.js"],"names":[],"mappings":"AAAA,gDAAgD;AAChD;;SAmBC"}

package/abstract/l10nProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"l10nProcessor.d.ts","sourceRoot":"","sources":["l10nProcessor.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wEAHW,gBAAgB,kBAe1B"}
+{"version":3,"file":"l10nProcessor.d.ts","sourceRoot":"","sources":["l10nProcessor.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8BAJ0C,CAAC,SAA9B,OAAQ,YAAY,EAAE,KAAM,MAC9B,gBAAgB,SAChB,CAAC,QAcX"}

package/abstract/loadFileUploaderFrom.d.ts

@@ -3,6 +3,6 @@
  * @param {Boolean} [register] Register connected package, if it not registered yet
  * @returns {Promise<import('../index.js')>}
  */
-export function loadFileUploaderFrom(url: string, register?: boolean | undefined): Promise<typeof import("../index.js")>;
+export function loadFileUploaderFrom(url: string, register?: boolean): Promise<typeof import("../index.js")>;
 export const UC_WINDOW_KEY: "UC";
 //# sourceMappingURL=loadFileUploaderFrom.d.ts.map

package/abstract/loadFileUploaderFrom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadFileUploaderFrom.d.ts","sourceRoot":"","sources":["loadFileUploaderFrom.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,mFAFa,qCAA8B,CA0B1C;AA/BD,iCAAkC"}
+{"version":3,"file":"loadFileUploaderFrom.d.ts","sourceRoot":"","sources":["loadFileUploaderFrom.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,uEAFa,OAAO,CAAC,4BAAqB,CAAC,CA0B1C;AA/BD,4BAA6B,IAAI,CAAC"}

package/abstract/localeRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeRegistry.d.ts","sourceRoot":"","sources":["localeRegistry.js"],"names":[],"mappings":"AAoCO,yCAHI,MAAM,wBACN,gBAAgB,GAAG,wBAAwB,QAQrD;AAMM,oDAHI,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAcrC;+BAnDa,OAAO,MAAM,EAAE,MAAM,CAAC;uCACtB,MAAM,QAAQ,gBAAgB,CAAC"}
+{"version":3,"file":"localeRegistry.d.ts","sourceRoot":"","sources":["localeRegistry.js"],"names":[],"mappings":"AAoCO,yCAHI,MAAM,wBACN,gBAAgB,GAAG,wBAAwB,QAQrD;AAMM,oDAHI,MAAM,GACJ,OAAO,CAAC,gBAAgB,CAAC,CAcrC;+BAnDa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;uCACtB,MAAM,OAAO,CAAC,gBAAgB,CAAC"}

package/abstract/sharedConfigKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sharedConfigKey.d.ts","sourceRoot":"","sources":["sharedConfigKey.js"],"names":[],"mappings":"AAOO,oGAA8C"}
+{"version":3,"file":"sharedConfigKey.d.ts","sourceRoot":"","sources":["sharedConfigKey.js"],"names":[],"mappings":"AAOO,gCAJ4C,CAAC,SAAvC,MAAO,OAAO,UAAU,EAAE,UAAW,OACvC,CAAC,GACC,QAAQ,CAAC,EAAE,CAE6B"}

package/abstract/uploadEntrySchema.d.ts

@@ -1,66 +1,126 @@
-/**
- * @typedef {Object} UploadEntry
- * @property {File} file
- * @property {String} externalUrl
- * @property {String} fileName
- * @property {number} fileSize
- * @property {number} lastModified
- * @property {number} uploadProgress
- * @property {String} uuid
- * @property {Boolean} isImage
- * @property {String} mimeType
- * @property {String} ctxName
- * @property {String} cdnUrl
- * @property {String} cdnUrlModifiers
- * @property {UploadcareFile} fileInfo
- * @property {Boolean} isUploading
- * @property {String} thumbUrl
- * @property {Boolean} silent
- * @property {({
- *   type: import('..').OutputFileErrorType | import('..').OutputCollectionErrorType;
- *   message: string;
- * } & Record<string, unknown>)[]} errors
- * @property {Error | null} uploadError
- * @property {string | null} fullPath
- * @property {import('@uploadcare/upload-client').Metadata | null} metadata
- * @property {boolean} isRemoved
- * @property {String} source
- */
-/**
- * @template {keyof UploadEntry} K
- * @type {Record<K, { type: Function; value: any; nullable?: Boolean }>}
- */
-export const uploadEntrySchema: Record<K, {
-    type: Function;
-    value: any;
-    nullable?: boolean;
+/** @constant */
+export const uploadEntrySchema: Readonly<{
+    file: Readonly<{
+        type: {
+            new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+            prototype: File;
+        };
+        value: null;
+        nullable: true;
+    }>;
+    externalUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileName: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileSize: Readonly<{
+        type: NumberConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    lastModified: Readonly<{
+        type: NumberConstructor;
+        value: number;
+    }>;
+    uploadProgress: Readonly<{
+        type: NumberConstructor;
+        value: 0;
+    }>;
+    uuid: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    isImage: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    mimeType: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    ctxName: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    cdnUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    cdnUrlModifiers: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileInfo: Readonly<{
+        type: typeof UploadcareFile;
+        value: null;
+        nullable: true;
+    }>;
+    isUploading: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    abortController: Readonly<{
+        type: {
+            new (): AbortController;
+            prototype: AbortController;
+        };
+        value: null;
+        nullable: true;
+    }>;
+    thumbUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    silent: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    source: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fullPath: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    metadata: Readonly<{
+        type: ObjectConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    errors: Readonly<{
+        type: ArrayConstructor;
+        value: Error[];
+    }>;
+    uploadError: Readonly<{
+        type: ErrorConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    isRemoved: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isQueued: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
 }>;
-export type UploadEntry = {
-    file: File;
-    externalUrl: string;
-    fileName: string;
-    fileSize: number;
-    lastModified: number;
-    uploadProgress: number;
-    uuid: string;
-    isImage: boolean;
-    mimeType: string;
-    ctxName: string;
-    cdnUrl: string;
-    cdnUrlModifiers: string;
-    fileInfo: UploadcareFile;
-    isUploading: boolean;
-    thumbUrl: string;
-    silent: boolean;
-    errors: ({
-        type: import('..').OutputFileErrorType | import('..').OutputCollectionErrorType;
-        message: string;
-    } & Record<string, unknown>)[];
-    uploadError: Error | null;
-    fullPath: string | null;
-    metadata: import('@uploadcare/upload-client').Metadata | null;
-    isRemoved: boolean;
-    source: string;
-};
+export type UploadEntryData = import("./TypedData").ExtractDataFromSchema<typeof uploadEntrySchema>;
+export type UploadEntryTypedData = import("./TypedData.js").TypedData<typeof uploadEntrySchema>;
+export type UploadEntryKeys = import("./TypedData.js").ExtractKeysFromSchema<typeof uploadEntrySchema>;
 import { UploadcareFile } from '@uploadcare/upload-client';
 //# sourceMappingURL=uploadEntrySchema.d.ts.map

package/abstract/uploadEntrySchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadEntrySchema.d.ts","sourceRoot":"","sources":["uploadEntrySchema.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;GAGG;AACH,gCAFU,OAAO,CAAC,EAAE;IAAE,IAAI,WAAW;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,UAAS;CAAE,CAAC,CAwGpE;;UArIW,IAAI;;;cAGJ,MAAM;kBACN,MAAM;oBACN,MAAM;;;;;;;cAON,cAAc;;;;YAId,CAAC;QACd,IAAQ,EAAE,OAAO,IAAI,EAAE,mBAAmB,GAAG,OAAO,IAAI,EAAE,yBAAyB,CAAC;QACpF,OAAW,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE;iBACnB,KAAK,GAAG,IAAI;cACZ,MAAM,GAAG,IAAI;cACb,OAAO,2BAA2B,EAAE,QAAQ,GAAG,IAAI;eACnD,OAAO;;;+BA3BU,2BAA2B"}
+{"version":3,"file":"uploadEntrySchema.d.ts","sourceRoot":"","sources":["uploadEntrySchema.js"],"names":[],"mappings":"AAGA,gBAAgB;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAkGsB,KAAK,EAAE;;;;;;;;;;;;;;;GAe1B;8BAEW,OAAO,aAAa,EAAE,qBAAqB,CAAC,OAAO,iBAAiB,CAAC;mCAErE,OAAO,gBAAgB,EAAE,SAAS,CAAC,OAAO,iBAAiB,CAAC;8BAE5D,OAAO,gBAAgB,EAAE,qBAAqB,CAAC,OAAO,iBAAiB,CAAC;+BA1HvD,2BAA2B"}