@uploadcare/file-uploader 1.21.0 → 1.23.0

package/abstract/UploaderBlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UploaderBlock.d.ts","sourceRoot":"","sources":["UploaderBlock.js"],"names":[],"mappings":"AAmBA;IACE,iBAAiB;IACjB,mCAAwB;IAExB,eAAe;IACf,mBAAmB;IAEnB;;;;;;;;;;;;;;MAA+B;IAE/B,eAAe;IACf,0BAOC;IA2BD;;;OAGG;IACH,mCAHa,iBAAiB,CAQ7B;IAED,mCAAmC;IACnC,WADc,iBAAiB,CAM9B;IAED,4BAEC;IAED,2DAA2D;IAC3D,wBADc,eAAe,CAAC,OAAO,iBAAiB,CAAC,CAMtD;IAgCD,eAAe;IACf,sBAYC;IAED,eAAe;IACf,iCAUC;IAPC,eAAe;IACf,6BAAiG;IAEjG,eAAe;IACf,uCAEC;IAGH,eAAe;IACf,mCAMC;IAED;;;OAGG;IACH,qBAkBC;IAED,eAAe;IACf,0BAYQ;IAER;;;OAGG;IACH,gCAkCE;IAEF;;;OAGG;IACH,0CA6FE;IAEF,eAAe;IACf,mCAsBE;IAEF,6BAiBC;IAED,eAAe;IACf,uBAyDC;IAED;;;OAGG;IACH,kCAHW,MAAM,qEAWhB;IAED;;;OAGG;IACH,oCAHa,OAAO,CAAC,OAAO,2BAA2B,EAAE,eAAe,CAAC,CA4BxE;IAED,kEAAkE;IAClE,iBADc,OAAO,sBAAsB,EAAE,eAAe,EAAE,CAK7D;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA7e6B,oBAAoB;qCAWb,oCAAoC;kCAGvC,iCAAiC;kCADjC,wBAAwB;gCAD1B,sBAAsB;kCAGpB,wBAAwB"}
+{"version":3,"file":"UploaderBlock.d.ts","sourceRoot":"","sources":["UploaderBlock.js"],"names":[],"mappings":"AAmBA;IACE,iBAAiB;IACjB,mCAAwB;IAExB,eAAe;IACf,mBAAmB;IAEnB;;;;;;;;;;;;;;MAA+B;IAE/B,eAAe;IACf,0BAOC;IAmCD;;;OAGG;IACH,mCAHa,iBAAiB,CAQ7B;IAED,mCAAmC;IACnC,WADc,iBAAiB,CAM9B;IAED,4BAEC;IAED,2DAA2D;IAC3D,wBADc,eAAe,CAAC,OAAO,iBAAiB,CAAC,CAMtD;IAgCD,eAAe;IACf,sBAYC;IAED,eAAe;IACf,iCAUC;IAPC,eAAe;IACf,6BAAiG;IAEjG,eAAe;IACf,uCAEC;IAGH,eAAe;IACf,mCAMC;IAED;;;OAGG;IACH,qBAkBC;IAED,eAAe;IACf,0BAYQ;IAER;;;OAGG;IACH,gCAwCE;IAEF;;;OAGG;IACH,0CAqGE;IAEF,eAAe;IACf,mCAsBE;IAEF,6BAiBC;IAED,eAAe;IACf,uBAyDC;IAED;;;OAGG;IACH,kCAHW,MAAM,qEAWhB;IAED;;;OAGG;IACH,oCAHa,OAAO,CAAC,OAAO,2BAA2B,EAAE,eAAe,CAAC,CA4BxE;IAED,kEAAkE;IAClE,iBADc,OAAO,sBAAsB,EAAE,eAAe,EAAE,CAK7D;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAngB6B,oBAAoB;qCAWb,oCAAoC;kCAGvC,iCAAiC;kCADjC,wBAAwB;gCAD1B,sBAAsB;kCAGpB,wBAAwB"}

package/abstract/UploaderBlock.js

@@ -43,7 +43,15 @@ export class UploaderBlock extends ActivityBlock {
     if (!this.has('*uploadCollection')) {
       let uploadCollection = new TypedCollection({
         typedSchema: uploadEntrySchema,
-        watchList: ['uploadProgress', 'uploadError', 'fileInfo', 'errors', 'cdnUrl', 'isUploading'],
+        watchList: [
+          'uploadProgress',
+          'uploadError',
+          'fileInfo',
+          'errors',
+          'cdnUrl',
+          'isUploading',
+          'isValidationPending',
+        ],
       });
       this.add('*uploadCollection', uploadCollection);
     }
@@ -206,8 +214,11 @@ export class UploaderBlock extends ActivityBlock {
     if (added.size || removed.size) {
       this.$['*groupInfo'] = null;
     }
-    this.validationManager.runFileValidators();
-    this.validationManager.runCollectionValidators();
+
+    this.validationManager.runFileValidators(
+      'add',
+      [...added].map((e) => e.uid),
+    );
 
     for (const entry of added) {
       if (!entry.getValue('silent')) {
@@ -215,9 +226,12 @@ export class UploaderBlock extends ActivityBlock {
       }
     }
 
+    this.validationManager.runCollectionValidators();
+
     for (const entry of removed) {
       /** @type {Set<string>} */ (this.$['*uploadTrigger']).delete(entry.uid);
 
+      this.validationManager.cleanupValidationForEntry(entry);
       entry.getValue('abortController')?.abort();
       entry.setMultipleValues({
         isRemoved: true,
@@ -249,7 +263,7 @@ export class UploaderBlock extends ActivityBlock {
     const entriesToRunValidation = [
       ...new Set(
         Object.entries(changeMap)
-          .filter(([key]) => ['uploadError', 'fileInfo'].includes(key))
+          .filter(([key]) => ['uploadError', 'fileInfo', 'cdnUrl', 'cdnUrlModifiers'].includes(key))
           .map(([, ids]) => [...ids])
           .flat(),
       ),
@@ -258,7 +272,13 @@ export class UploaderBlock extends ActivityBlock {
     entriesToRunValidation.length > 0 &&
       setTimeout(() => {
         // We can't modify entry properties in the same tick, so we need to wait a bit
-        this.validationManager.runFileValidators(entriesToRunValidation);
+        const entriesToRunOnUpload = entriesToRunValidation.filter(
+          (entryId) => changeMap.fileInfo?.has(entryId) && !!Data.getCtx(entryId).store.fileInfo,
+        );
+        if (entriesToRunOnUpload.length > 0) {
+          this.validationManager.runFileValidators('upload', entriesToRunOnUpload);
+        }
+        this.validationManager.runFileValidators('change', entriesToRunValidation);
       });
 
     if (changeMap.uploadProgress) {
@@ -295,6 +315,8 @@ export class UploaderBlock extends ActivityBlock {
       }
     }
     if (changeMap.errors) {
+      this.validationManager.runCollectionValidators();
+
       for (const entryId of changeMap.errors) {
         const { errors } = Data.getCtx(entryId).store;
         if (errors.length > 0) {

package/abstract/UploaderPublicApi.d.ts.map

@@ -1 +1 @@
-{"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,UA6D9B;IAEF;;;;OAIG;IACH,cAJmD,OAAO,SAA7C,OAAQ,UAAU,EAAE,gBAAiB,WACvC,MAAM,GACJ,OAAO,sBAAsB,EAAE,eAAe,CAAC,OAAO,CAAC,CA+CnE;IAED,oEAAoE;IACpE,yBAD0D,OAAO,SAAnD,OAAQ,UAAU,EAAE,sBAAuB,KAErC,UAAU,CAAC,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAGzE;IAED,+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;2CA3X0C,iCAAiC"}
+{"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,sBAuBE;IAEF,8HAA8H;IAC9H,mBAAoB,UADR;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,qCAAqC,EAAE,cAAc,CAAA;KAChF,UA6D9B;IAEF;;;;OAIG;IACH,cAJmD,OAAO,SAA7C,OAAQ,UAAU,EAAE,gBAAiB,WACvC,MAAM,GACJ,OAAO,sBAAsB,EAAE,eAAe,CAAC,OAAO,CAAC,CAgDnE;IAED,oEAAoE;IACpE,yBAD0D,OAAO,SAAnD,OAAQ,UAAU,EAAE,sBAAuB,KAErC,UAAU,CAAC,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAGzE;IAED,+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;2CAnY0C,iCAAiC"}

package/abstract/UploaderPublicApi.js

@@ -132,7 +132,14 @@ export class UploaderPublicApi {
     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');
+      return (
+        !entry.getValue('isRemoved') &&
+        !entry.getValue('isUploading') &&
+        !entry.getValue('fileInfo') &&
+        entry.getValue('errors').length === 0 &&
+        !entry.getValue('isValidationPending') &&
+        !entry.getValue('isQueuedForValidation')
+      );
     });
 
     if (itemsToUpload.length === 0) {
@@ -254,6 +261,7 @@ export class UploaderPublicApi {
       isUploading: status === 'uploading',
       isFailed: status === 'failed',
       isRemoved: status === 'removed',
+      isValidationPending: uploadEntryData.isValidationPending,
       errors: /** @type {import('../types/exported.js').OutputFileEntry['errors']} */ (uploadEntryData.errors),
       status,
       source: uploadEntryData?.source,

package/abstract/managers/ValidationManager.d.ts

@@ -7,9 +7,30 @@ export class ValidationManager {
      */
     private _blockInstance;
     /** @type {FuncFileValidator[]} */
-    _fileValidators: FuncFileValidator[];
+    _commonFileValidators: FuncFileValidator[];
     /** @type {FuncCollectionValidator[]} */
-    _collectionValidators: FuncCollectionValidator[];
+    _commonCollectionValidators: FuncCollectionValidator[];
+    _queue: Queue;
+    _runQueueDebounced: (() => void) & {
+        cancel: () => void;
+    };
+    /**
+     * @type {Map<
+     *   string,
+     *   {
+     *     abortController?: AbortController;
+     *     skippedValidators: WeakSet<FuncFileValidator>;
+     *     promise?: Promise<void>;
+     *     lastErrorThrownByValidator: WeakMap<FuncFileValidator, import('../../types').OutputErrorFile | undefined>;
+     *   }
+     * >}
+     */
+    _entryValidationState: Map<string, {
+        abortController?: AbortController;
+        skippedValidators: WeakSet<FuncFileValidator>;
+        promise?: Promise<void>;
+        lastErrorThrownByValidator: WeakMap<FuncFileValidator, import("../../types").OutputErrorFile | undefined>;
+    }>;
     _uploadCollection: import("../TypedCollection.js").TypedCollection<Readonly<{
         file: Readonly<{
             type: {
@@ -114,7 +135,7 @@ export class ValidationManager {
         }>;
         errors: Readonly<{
             type: ArrayConstructor;
-            value: Error[];
+            value: import("../../types").OutputErrorFile[];
         }>;
         uploadError: Readonly<{
             type: ErrorConstructor;
@@ -125,26 +146,64 @@ export class ValidationManager {
             type: BooleanConstructor;
             value: false;
         }>;
-        isQueued: Readonly<{
+        isQueuedForUploading: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        isValidationPending: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        isQueuedForValidation: Readonly<{
             type: BooleanConstructor;
             value: false;
         }>;
     }>>;
-    /** @param {string[]} [entryIds] */
-    runFileValidators(entryIds?: string[]): void;
+    /**
+     * @param {FileValidatorDescriptor['runOn']} runOn
+     * @param {string[]} [entryIds]
+     */
+    runFileValidators(runOn: FileValidatorDescriptor["runOn"], entryIds?: string[]): void;
     runCollectionValidators(): void;
+    /** @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry */
+    cleanupValidationForEntry(entry: import("../TypedData.js").TypedData<typeof import("../uploadEntrySchema.js").uploadEntrySchema>): void;
     /**
      * @private
      * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
+     * @param {FileValidatorDescriptor['runOn']} runOn
      */
     private _runFileValidatorsForEntry;
     /**
-     * @template T
-     * @param {T[]} validators
-     * @returns {T[]}
+     * @private
+     * @template {import('../../types').OutputError<
+     *   import('../../types').OutputFileErrorType | import('../../types').OutputCollectionErrorType
+     * >} T
+     * @param {T} error
+     * @returns {T}
+     */
+    private _addCustomTypeToValidationError;
+    /**
+     * @private
+     * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
+     */
+    private _getEntryValidationState;
+    /** @private */
+    private _getValidatorDescriptors;
+    /**
+     * @private
+     * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
+     * @param {FileValidatorDescriptor['runOn']} runOn
      */
-    _addCustomTypeToValidators<T>(validators: T[]): T[];
+    private _getValidatorDescriptorsForEntry;
 }
-export type FuncFileValidator = (outputEntry: import("../../types/index.js").OutputFileEntry, api: import("../UploaderPublicApi.js").UploaderPublicApi) => undefined | import("../../types/index.js").OutputErrorFile;
-export type FuncCollectionValidator = (collection: ReturnType<typeof import("../buildOutputCollectionState.js").buildOutputCollectionState<import("../../types/index.js").OutputCollectionStatus>>, api: import("../UploaderPublicApi.js").UploaderPublicApi) => undefined | import("../../types/index.js").OutputErrorCollection;
+export type FuncFileValidator = (outputEntry: import("../../types").OutputFileEntry, api: import("../UploaderPublicApi.js").UploaderPublicApi, options?: {
+    signal?: AbortSignal;
+}) => (undefined | import("../../types").OutputErrorFile) | Promise<undefined | import("../../types").OutputErrorFile>;
+export type FileValidatorDescriptor = {
+    runOn: "add" | "upload" | "change";
+    validator: FuncFileValidator;
+};
+export type FileValidator = FileValidatorDescriptor | FuncFileValidator;
+export type FuncCollectionValidator = (collection: ReturnType<typeof import("../buildOutputCollectionState.js").buildOutputCollectionState<import("../../types").OutputCollectionStatus>>, api: import("../UploaderPublicApi.js").UploaderPublicApi) => undefined | import("../../types").OutputErrorCollection;
+import { Queue } from '@uploadcare/upload-client';
 //# sourceMappingURL=ValidationManager.d.ts.map

package/abstract/managers/ValidationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ValidationManager.d.ts","sourceRoot":"","sources":["ValidationManager.js"],"names":[],"mappings":"AAkCA;IAaE,yEAAyE;IACzE,2BADY,OAAO,qBAAqB,EAAE,aAAa,EAiBtD;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,gCAsCC;IAED;;;OAGG;IACH,mCA0BC;IAED;;;;OAIG;IACH,2BAJa,CAAC,cACH,CAAC,EAAE,GACD,CAAC,EAAE,CAUf;CACF;gCAxJY,CACR,WAAW,EAAE,OAAO,sBAAsB,EAAE,eAAe,EAC3D,GAAG,EAAE,OAAO,yBAAyB,EAAE,iBAAiB,KACrD,SAAS,GAAG,OAAO,sBAAsB,EAAE,eAAe;sCAIrD,CACR,UAAU,EAAE,UAAU,CAC1B,cAAoB,kCAAkC,EAAE,0BAA0B,CAClF,OAAe,sBAAsB,EAAE,sBAAsB,CACtD,CACF,EACD,GAAG,EAAE,OAAO,yBAAyB,EAAE,iBAAiB,KACrD,SAAS,GAAG,OAAO,sBAAsB,EAAE,qBAAqB"}
+{"version":3,"file":"ValidationManager.d.ts","sourceRoot":"","sources":["ValidationManager.js"],"names":[],"mappings":"AA6DA;IA+BE,yEAAyE;IACzE,2BADY,OAAO,qBAAqB,EAAE,aAAa,EAqBtD;IAnDD;;;OAGG;IACH,uBAAe;IAEf,kCAAkC;IAClC,uBADW,iBAAiB,EAAE,CACyE;IAEvG,wCAAwC;IACxC,6BADW,uBAAuB,EAAE,CAC4C;IAEhF,cAAuB;IACvB;;MAEQ;IAER;;;;;;;;;;OAUG;IACH,uBAVU,GAAG,CACZ,MAAU,EACV;QACM,eAAe,CAAC,EAAE,eAAe,CAAC;QAClC,iBAAiB,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC9C,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QACxB,0BAA0B,EAAE,OAAO,CAAC,iBAAiB,EAAE,OAAO,aAAa,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC;KAC3G,CACF,CAE8B;IAMhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAA6D;IAmB/D;;;OAGG;IACH,yBAHW,uBAAuB,CAAC,OAAO,CAAC,aAChC,MAAM,EAAE,QAUlB;IAED,gCAkCC;IAED,qHAAqH;IACrH,iCADY,OAAO,iBAAiB,EAAE,SAAS,CAAC,cAAc,yBAAyB,EAAE,iBAAiB,CAAC,QAO1G;IAED;;;;OAIG;IACH,mCAyGC;IAED;;;;;;;OAOG;IACH,wCAKC;IAED;;;OAGG;IACH,iCAgBC;IAED,eAAe;IACf,iCAEC;IAED;;;;OAIG;IACH,yCAKC;CACF;gCArUY,CACR,WAAW,EAAE,OAAO,aAAa,EAAE,eAAe,EAClD,GAAG,EAAE,OAAO,yBAAyB,EAAE,iBAAiB,EACxD,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,KAEhC,CAAC,SAAS,GAAG,OAAO,aAAa,EAAE,eAAe,CAAC,GACnD,OAAO,CAAC,SAAS,GAAG,OAAO,aAAa,EAAE,eAAe,CAAC;sCAIpD;IACR,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACnC,SAAS,EAAE,iBAAiB,CAAC;CAC9B;4BAGU,uBAAuB,GAAG,iBAAiB;sCAG5C,CACR,UAAU,EAAE,UAAU,CAC1B,cAAoB,kCAAkC,EAAE,0BAA0B,CAClF,OAAe,aAAa,EAAE,sBAAsB,CAC7C,CACF,EACD,GAAG,EAAE,OAAO,yBAAyB,EAAE,iBAAiB,KACrD,SAAS,GAAG,OAAO,aAAa,EAAE,qBAAqB;sBA/BzC,2BAA2B"}

package/abstract/managers/ValidationManager.js

@@ -7,29 +7,56 @@ import {
   validateUploadError,
 } from '../../utils/validators/file/index.js';
 import { validateMultiple, validateCollectionUploadError } from '../../utils/validators/collection/index.js';
+import { Queue } from '@uploadcare/upload-client';
+import { withResolvers } from '../../utils/withResolvers.js';
+import { debounce } from '../../blocks/utils/debounce.js';
 
 /**
  * @typedef {(
- *   outputEntry: import('../../types/index.js').OutputFileEntry,
+ *   outputEntry: import('../../types').OutputFileEntry,
  *   api: import('../UploaderPublicApi.js').UploaderPublicApi,
- * ) => undefined | import('../../types/index.js').OutputErrorFile} FuncFileValidator
+ *   options?: { signal?: AbortSignal },
+ * ) =>
+ *   | (undefined | import('../../types').OutputErrorFile)
+ *   | Promise<undefined | import('../../types').OutputErrorFile>} FuncFileValidator
  */
 
+/**
+ * @typedef {{
+ *   runOn: 'add' | 'upload' | 'change';
+ *   validator: FuncFileValidator;
+ * }} FileValidatorDescriptor
+ */
+
+/** @typedef {FileValidatorDescriptor | FuncFileValidator} FileValidator */
+
 /**
  * @typedef {(
  *   collection: ReturnType<
  *     typeof import('../buildOutputCollectionState.js').buildOutputCollectionState<
- *       import('../../types/index.js').OutputCollectionStatus
+ *       import('../../types').OutputCollectionStatus
  *     >
  *   >,
  *   api: import('../UploaderPublicApi.js').UploaderPublicApi,
- * ) => undefined | import('../../types/index.js').OutputErrorCollection} FuncCollectionValidator
+ * ) => undefined | import('../../types').OutputErrorCollection} FuncCollectionValidator
  */
 
-const LOGGER = {
-  file: 'File validator execution has failed',
-  collection: 'Collection validator execution has failed',
-  message: 'Missing message. We recommend adding message: value.',
+const LOG_TEXT = {
+  FILE_VALIDATION_FAILED: 'File validator execution has failed',
+  FILE_VALIDATION_TIMEOUT: 'File validator execution has timed out',
+  COLLECTION_VALIDATION_FAILED: 'Collection validator execution has failed',
+  MISSING_ERROR_MESSAGE: 'Missing message. We recommend adding message: value.',
+};
+
+/**
+ * @param {FileValidator} validator
+ * @returns {FileValidatorDescriptor}
+ */
+const getValidatorDescriptor = (validator) => {
+  if (typeof validator === 'function') {
+    return { runOn: 'change', validator };
+  }
+  return validator;
 };
 
 export class ValidationManager {
@@ -40,10 +67,28 @@ export class ValidationManager {
   _blockInstance;
 
   /** @type {FuncFileValidator[]} */
-  _fileValidators = [validateIsImage, validateFileType, validateMaxSizeLimit, validateUploadError];
+  _commonFileValidators = [validateIsImage, validateFileType, validateMaxSizeLimit, validateUploadError];
 
   /** @type {FuncCollectionValidator[]} */
-  _collectionValidators = [validateMultiple, validateCollectionUploadError];
+  _commonCollectionValidators = [validateMultiple, validateCollectionUploadError];
+
+  _queue = new Queue(20);
+  _runQueueDebounced = debounce(() => {
+    this._queue.run();
+  }, 500);
+
+  /**
+   * @type {Map<
+   *   string,
+   *   {
+   *     abortController?: AbortController;
+   *     skippedValidators: WeakSet<FuncFileValidator>;
+   *     promise?: Promise<void>;
+   *     lastErrorThrownByValidator: WeakMap<FuncFileValidator, import('../../types').OutputErrorFile | undefined>;
+   *   }
+   * >}
+   */
+  _entryValidationState = new Map();
 
   /** @param {import('../UploaderBlock.js').UploaderBlock} blockInstance */
   constructor(blockInstance) {
@@ -52,7 +97,7 @@ export class ValidationManager {
     this._uploadCollection = this._blockInstance.uploadCollection;
 
     const runAllValidators = () => {
-      this.runFileValidators();
+      this.runFileValidators('change');
       this.runCollectionValidators();
     };
 
@@ -62,15 +107,22 @@ export class ValidationManager {
     this._blockInstance.subConfigValue('multiple', runAllValidators);
     this._blockInstance.subConfigValue('imgOnly', runAllValidators);
     this._blockInstance.subConfigValue('accept', runAllValidators);
+
+    this._blockInstance.subConfigValue('validationConcurrency', (concurrency) => {
+      this._queue.concurrency = concurrency;
+    });
   }
 
-  /** @param {string[]} [entryIds] */
-  runFileValidators(entryIds) {
+  /**
+   * @param {FileValidatorDescriptor['runOn']} runOn
+   * @param {string[]} [entryIds]
+   */
+  runFileValidators(runOn, entryIds) {
     const ids = entryIds ?? this._uploadCollection.items();
     for (const id of ids) {
       const entry = this._uploadCollection.read(id);
       if (entry) {
-        this._runFileValidatorsForEntry(entry);
+        void this._runFileValidatorsForEntry(entry, runOn);
       }
     }
   }
@@ -79,25 +131,21 @@ export class ValidationManager {
     const collection = this._blockInstance.api.getOutputCollectionState();
     const errors = [];
 
-    for (const validator of [
-      ...this._collectionValidators,
-      ...this._addCustomTypeToValidators(this._blockInstance.cfg.collectionValidators),
-    ]) {
+    for (const validator of [...this._commonCollectionValidators, ...this._blockInstance.cfg.collectionValidators]) {
       try {
-        const errorOrErrors = validator(collection, this._blockInstance.api);
-        if (!errorOrErrors) {
+        const error = validator(collection, this._blockInstance.api);
+        if (!error) {
           continue;
         }
-        if (errorOrErrors) {
-          errors.push(errorOrErrors);
+        if (error) {
+          errors.push(this._addCustomTypeToValidationError(error));
 
-          if (!errorOrErrors.message) {
-            console.warn(LOGGER.message);
+          if (!error.message) {
+            console.warn(LOG_TEXT.MISSING_ERROR_MESSAGE);
           }
         }
       } catch (error) {
-        console.warn(LOGGER.collection, error);
-        this._blockInstance.telemetryManager.sendEventError(error, `collection validator. ${LOGGER.collection}`);
+        console.warn(LOG_TEXT.COLLECTION_VALIDATION_FAILED, error);
       }
     }
 
@@ -107,7 +155,7 @@ export class ValidationManager {
       this._blockInstance.emit(
         EventType.COMMON_UPLOAD_FAILED,
         () =>
-          /** @type {import('../../types/index.js').OutputCollectionState<'failed'>} */ (
+          /** @type {import('../../types').OutputCollectionState<'failed'>} */ (
             this._blockInstance.api.getOutputCollectionState()
           ),
         { debounce: true },
@@ -115,50 +163,178 @@ export class ValidationManager {
     }
   }
 
+  /** @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry */
+  cleanupValidationForEntry(entry) {
+    const state = this._entryValidationState.get(entry.uid);
+    if (state) {
+      state.abortController?.abort();
+      this._entryValidationState.delete(entry.uid);
+    }
+  }
+
   /**
    * @private
    * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
+   * @param {FileValidatorDescriptor['runOn']} runOn
    */
-  _runFileValidatorsForEntry(entry) {
+  async _runFileValidatorsForEntry(entry, runOn) {
+    const entryDescriptors = this._getValidatorDescriptorsForEntry(entry, runOn);
+    if (entryDescriptors.length === 0) {
+      return;
+    }
+    entry.setMultipleValues({
+      isQueuedForValidation: true,
+      isValidationPending: true,
+    });
     const outputEntry = this._blockInstance.api.getOutputItem(entry.uid);
+    const state = this._getEntryValidationState(entry);
+
+    if (state.promise) {
+      await state.promise;
+    }
+
+    const { promise, resolve } = withResolvers();
+    state.promise = promise;
+    const abortController = new AbortController();
+    state.abortController = abortController;
+
+    const timeoutMs = this._blockInstance.cfg.validationTimeout;
+    const allDescriptors = this._getValidatorDescriptors();
+
+    const entryValidatorSet = new Set(entryDescriptors.map((d) => d.validator));
+    /** @type {import('../../types').OutputErrorFile[]} */
     const errors = [];
+    for (const descriptor of allDescriptors) {
+      if (!entryValidatorSet.has(descriptor.validator)) {
+        const error = state.lastErrorThrownByValidator.get(descriptor.validator);
+        if (error) errors.push(error);
+      }
+    }
+
+    const tasks = entryDescriptors.map((validatorDescriptor) => async () => {
+      if (!this._blockInstance.isConnected) {
+        return;
+      }
+      const timeoutId = setTimeout(() => {
+        state.skippedValidators.add(validatorDescriptor.validator);
+        abortController.abort();
+        console.warn(LOG_TEXT.FILE_VALIDATION_TIMEOUT);
+      }, timeoutMs);
 
-    for (const validator of [
-      ...this._fileValidators,
-      ...this._addCustomTypeToValidators(this._blockInstance.cfg.fileValidators),
-    ]) {
       try {
-        const error = validator(outputEntry, this._blockInstance.api);
-        if (!error) {
-          continue;
+        const error = await validatorDescriptor.validator(outputEntry, this._blockInstance.api, {
+          signal: abortController.signal,
+        });
+        if (!error || abortController.signal.aborted) {
+          state.lastErrorThrownByValidator.set(validatorDescriptor.validator, undefined);
+          return;
         }
-        if (error) {
-          errors.push(error);
+        const normalizedError = this._addCustomTypeToValidationError(error);
+        state.lastErrorThrownByValidator.set(validatorDescriptor.validator, normalizedError);
+        errors.push(normalizedError);
 
-          if (!error.message) {
-            console.warn(LOGGER.message);
-          }
+        if (!error.message) {
+          console.warn(LOG_TEXT.MISSING_ERROR_MESSAGE);
         }
       } catch (error) {
-        console.warn(LOGGER.file, error);
-        this._blockInstance.telemetryManager.sendEventError(error, `file validator. ${LOGGER.file}`);
+        if (!abortController.signal.aborted) {
+          state.skippedValidators.add(validatorDescriptor.validator);
+
+          console.warn(LOG_TEXT.FILE_VALIDATION_FAILED, error);
+          this._blockInstance.telemetryManager.sendEventError(
+            error,
+            `file validator. ${LOG_TEXT.FILE_VALIDATION_FAILED}`,
+          );
+        }
+      } finally {
+        clearTimeout(timeoutId);
+        if (validatorDescriptor.runOn !== 'change') {
+          state.skippedValidators.add(validatorDescriptor.validator);
+        }
       }
+    });
+
+    this._runQueueDebounced();
+
+    await this._queue.add(
+      async () => {
+        entry.setValue('isQueuedForValidation', false);
+        await Promise.all(tasks.map((task) => task())).catch(() => {});
+      },
+      {
+        autoRun: false,
+      },
+    );
+
+    if (abortController.signal.aborted) {
+      entry.setMultipleValues({
+        isQueuedForValidation: false,
+        isValidationPending: false,
+      });
+      resolve();
+      return;
     }
-    entry.setValue('errors', errors);
+
+    entry.setMultipleValues({
+      isValidationPending: false,
+      isQueuedForValidation: false,
+      errors,
+    });
+
+    resolve();
+  }
+
+  /**
+   * @private
+   * @template {import('../../types').OutputError<
+   *   import('../../types').OutputFileErrorType | import('../../types').OutputCollectionErrorType
+   * >} T
+   * @param {T} error
+   * @returns {T}
+   */
+  _addCustomTypeToValidationError(error) {
+    return {
+      ...error,
+      type: error.type ?? 'CUSTOM_ERROR',
+    };
   }
 
   /**
-   * @template T
-   * @param {T[]} validators
-   * @returns {T[]}
+   * @private
+   * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
    */
-  _addCustomTypeToValidators(validators) {
-    // @ts-ignore
-    return validators.map((fn) => (...args) => {
-      // @ts-ignore
-      const result = fn(...args);
+  _getEntryValidationState(entry) {
+    const currentState = this._entryValidationState.get(entry.uid);
+    if (currentState) {
+      return currentState;
+    }
 
-      return result ? { ...result, ...{ type: 'CUSTOM_ERROR' } } : undefined;
-    });
+    const newState = {
+      abortController: undefined,
+      skippedValidators: new WeakSet(),
+      promise: undefined,
+      lastErrorThrownByValidator: /** @type {WeakMap<FuncFileValidator, import('../../types').OutputErrorFile>} */ (
+        new WeakMap()
+      ),
+    };
+    this._entryValidationState.set(entry.uid, newState);
+    return newState;
+  }
+
+  /** @private */
+  _getValidatorDescriptors() {
+    return [...this._commonFileValidators, ...this._blockInstance.cfg.fileValidators].map(getValidatorDescriptor);
+  }
+
+  /**
+   * @private
+   * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
+   * @param {FileValidatorDescriptor['runOn']} runOn
+   */
+  _getValidatorDescriptorsForEntry(entry, runOn) {
+    const state = this._getEntryValidationState(entry);
+    return this._getValidatorDescriptors()
+      .filter((descriptor) => !state.skippedValidators.has(descriptor.validator))
+      .filter((descriptor) => descriptor.runOn === runOn);
   }
 }

package/abstract/uploadEntrySchema.d.ts

@@ -103,7 +103,7 @@ export const uploadEntrySchema: Readonly<{
     }>;
     errors: Readonly<{
         type: ArrayConstructor;
-        value: Error[];
+        value: import("../types").OutputErrorFile[];
     }>;
     uploadError: Readonly<{
         type: ErrorConstructor;
@@ -114,7 +114,15 @@ export const uploadEntrySchema: Readonly<{
         type: BooleanConstructor;
         value: false;
     }>;
-    isQueued: Readonly<{
+    isQueuedForUploading: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isValidationPending: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isQueuedForValidation: Readonly<{
         type: BooleanConstructor;
         value: false;
     }>;

package/abstract/uploadEntrySchema.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"uploadEntrySchema.d.ts","sourceRoot":"","sources":["uploadEntrySchema.js"],"names":[],"mappings":"AAGA,gBAAgB;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAkGsB,OAAO,UAAU,EAAE,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;;;;GAuBvD;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;+BAlIvD,2BAA2B"}