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

package/abstract/TypedCollection.js

@@ -1,23 +1,30 @@
+// @ts-check
 import { Data, UID } from '@symbiotejs/symbiote';
 import { TypedData } from './TypedData.js';
 
+/**
+ * @template {import('./TypedData.js').TypedSchema} T
+ * @typedef {(list: string[], added: Set<import('./TypedData.js').TypedData<T>>, removed: Set<TypedData<T>>) => void} TypedCollectionObserverHandler
+ */
+
+/** @template {import('./TypedData.js').TypedSchema} T */
 export class TypedCollection {
   /**
    * @param {Object} options
-   * @param {Object<string, { type: any; value: any }>} options.typedSchema
-   * @param {String[]} [options.watchList]
-   * @param {(list: string[], added: Set<any>, removed: Set<any>) => void} [options.handler]
-   * @param {String} [options.ctxName]
+   * @param {T} options.typedSchema
+   * @param {import('./TypedData.js').ExtractKeysFromSchema<T>[]} [options.watchList]
+   * @param {TypedCollectionObserverHandler<T>} [options.handler]
+   * @param {string} [options.ctxName]
    */
   constructor(options) {
     /**
      * @private
-     * @type {Object<string, { type: any; value: any }>}
+     * @type {T}
      */
     this.__typedSchema = options.typedSchema;
     /**
      * @private
-     * @type {String}
+     * @type {string}
      */
     this.__ctxId = options.ctxName || UID.generate();
     /**
@@ -27,12 +34,12 @@ export class TypedCollection {
     this.__data = Data.registerCtx({}, this.__ctxId);
     /**
      * @private
-     * @type {string[]}
+     * @type {import('./TypedData.js').ExtractKeysFromSchema<T>[]}
      */
     this.__watchList = options.watchList || [];
     /**
      * @private
-     * @type {Object<string, any>}
+     * @type {Object<string, ReturnType<TypedData<T>['subscribe']>[]>}
      */
     this.__subsMap = Object.create(null);
     /**
@@ -42,7 +49,7 @@ export class TypedCollection {
     this.__propertyObservers = new Set();
     /**
      * @private
-     * @type {Set<(list: string[], added: Set<any>, removed: Set<any>) => void>}
+     * @type {Set<TypedCollectionObserverHandler<T>>}
      */
     this.__collectionObservers = new Set();
     /**
@@ -52,12 +59,12 @@ export class TypedCollection {
     this.__items = new Set();
     /**
      * @private
-     * @type {Set<any>}
+     * @type {Set<import('./TypedData.js').TypedData<T>>}
      */
     this.__removed = new Set();
     /**
      * @private
-     * @type {Set<any>}
+     * @type {Set<import('./TypedData.js').TypedData<T>>}
      */
     this.__added = new Set();
 
@@ -105,7 +112,7 @@ export class TypedCollection {
     });
   }
 
-  /** @param {(list: string[], added: Set<any>, removed: Set<any>) => void} handler */
+  /** @param {TypedCollectionObserverHandler<T>} handler */
   observeCollection(handler) {
     this.__collectionObservers.add(handler);
 
@@ -118,19 +125,19 @@ export class TypedCollection {
     };
   }
 
-  /** @param {Function} handler */
+  /** @param {TypedCollectionObserverHandler<T>} handler */
   unobserveCollection(handler) {
     this.__collectionObservers?.delete(handler);
   }
 
   /**
-   * @param {Object<string, any>} init
+   * @param {Partial<import('./TypedData.js').ExtractDataFromSchema<T>>} init
    * @returns {string}
    */
   add(init) {
     let item = new TypedData(this.__typedSchema);
-    for (let prop in init) {
-      item.setValue(prop, init[prop]);
+    for (let [prop, value] of Object.entries(init)) {
+      item.setValue(/** @type {import('./TypedData.js').ExtractKeysFromSchema<T>} */ (prop), value);
     }
     this.__items.add(item.uid);
     this.notify();
@@ -139,7 +146,7 @@ export class TypedCollection {
     this.__added.add(item);
     this.__watchList.forEach((propName) => {
       if (!this.__subsMap[item.uid]) {
-        this.__subsMap[item.uid] = [];
+        this.__subsMap[item.uid] = /** @type {ReturnType<TypedData<T>['subscribe']>[]} */ ([]);
       }
       this.__subsMap[item.uid].push(
         item.subscribe(propName, () => {
@@ -151,37 +158,49 @@ export class TypedCollection {
   }
 
   /**
-   * @param {String} id
-   * @returns {TypedData}
+   * @param {string} id
+   * @returns {TypedData<T> | null}
    */
   read(id) {
     return this.__data.read(id);
   }
 
   /**
-   * @param {String} id
-   * @param {String} propName
-   * @returns {any}
+   * @template {import('./TypedData.js').ExtractKeysFromSchema<T>} K
+   * @param {string} id
+   * @param {K} propName
+   * @returns {import('./TypedData.js').ExtractDataFromSchema<T>[propName] | null}
    */
   readProp(id, propName) {
     let item = this.read(id);
+    if (!item) {
+      console.warn(`Item with id ${id} not found`);
+      return null;
+    }
     return item.getValue(propName);
   }
 
   /**
-   * @template T
-   * @param {String} id
-   * @param {String} propName
-   * @param {T} value
+   * @template {import('./TypedData.js').ExtractKeysFromSchema<T>} K
+   * @param {string} id
+   * @param {K} propName
+   * @param {import('./TypedData.js').ExtractDataFromSchema<T>[K]} value
    */
   publishProp(id, propName, value) {
     let item = this.read(id);
+    if (!item) {
+      console.warn(`Item with id ${id} not found`);
+      return;
+    }
     item.setValue(propName, value);
   }
 
-  /** @param {String} id */
+  /** @param {string} id */
   remove(id) {
-    this.__removed.add(this.__data.read(id));
+    let item = this.read(id);
+    if (item) {
+      this.__removed.add(item);
+    }
     this.__items.delete(id);
     this.notify();
     this.__data.pub(id, null);
@@ -209,14 +228,15 @@ export class TypedCollection {
   }
 
   /**
-   * @param {(item: TypedData) => Boolean} checkFn
-   * @returns {String[]}
+   * @param {(item: TypedData<T>) => Boolean} checkFn
+   * @returns {string[]}
    */
   findItems(checkFn) {
+    /** @type {string[]} */
     let result = [];
     this.__items.forEach((id) => {
       let item = this.read(id);
-      if (checkFn(item)) {
+      if (item && checkFn(item)) {
         result.push(id);
       }
     });
@@ -233,8 +253,8 @@ export class TypedCollection {
 
   destroy() {
     Data.deleteCtx(this.__ctxId);
-    this.__propertyObservers = null;
-    this.__collectionObservers = null;
+    this.__propertyObservers = new Set();
+    this.__collectionObservers = new Set();
     for (let id in this.__subsMap) {
       this.__subsMap[id].forEach((sub) => {
         sub.remove();

package/abstract/TypedData.d.ts

@@ -1,47 +1,93 @@
-export class TypedData {
+/** @typedef {Record<string, { type: unknown; value: unknown; nullable?: boolean }>} TypedSchema */
+/**
+ * @template {any} [T=any] Default is `any`
+ * @typedef {new (...args: any[]) => T} Constructor
+ */
+/**
+ * @template {unknown} T
+ * @template {unknown} V
+ * @typedef {T extends StringConstructor
+ *   ? string
+ *   : T extends BooleanConstructor
+ *     ? boolean
+ *     : T extends NumberConstructor
+ *       ? number
+ *       : T extends ArrayConstructor
+ *         ? V
+ *         : T extends Constructor
+ *           ? InstanceType<T>
+ *           : T} ExtractType
+ */
+/**
+ * @template {TypedSchema} T
+ * @typedef {{
+ *   [K in keyof T]: ExtractType<T[K]['type'], T[K]['value']> | (T[K]['nullable'] extends true ? null : never);
+ * }} ExtractDataFromSchema
+ */
+/**
+ * @template {TypedSchema} T
+ * @typedef {Extract<keyof T, string>} ExtractKeysFromSchema
+ */
+/** @template {TypedSchema} T */
+export class TypedData<T extends TypedSchema> {
     /**
-     * @param {Object<string, { type: any; value: any; nullable?: Boolean }>} typedSchema
+     * @param {T} typedSchema
      * @param {String} [ctxName]
      */
-    constructor(typedSchema: {
-        [x: string]: {
-            type: any;
-            value: any;
-            nullable?: boolean;
-        };
-    }, ctxName?: string | undefined);
-    /** @private */
+    constructor(typedSchema: T, ctxName?: string);
+    /**
+     * @private
+     * @type {T}
+     */
     private __typedSchema;
-    /** @private */
+    /**
+     * @private
+     * @type {string}
+     */
     private __ctxId;
-    /** @private */
+    /**
+     * @private
+     * @type {ExtractDataFromSchema<T>}
+     */
     private __schema;
     /**
      * @private
      * @type {Data}
      */
     private __data;
-    /** @returns {String} */
+    /** @returns {string} */
     get uid(): string;
     /**
-     * @param {String} prop
-     * @param {any} value
+     * @param {ExtractKeysFromSchema<T>} prop
+     * @param {ExtractDataFromSchema<T>[prop]} value
+     */
+    setValue(prop: ExtractKeysFromSchema<T>, value: ExtractDataFromSchema<T>[Extract<keyof T, string>]): void;
+    /** @param {Partial<ExtractDataFromSchema<T>>} updObj */
+    setMultipleValues(updObj: Partial<ExtractDataFromSchema<T>>): void;
+    /**
+     * @template {ExtractKeysFromSchema<T>} K
+     * @param {K} prop
+     * @returns {ExtractDataFromSchema<T>[K]}
      */
-    setValue(prop: string, value: any): void;
-    /** @param {Object<string, any>} updObj */
-    setMultipleValues(updObj: {
-        [x: string]: any;
-    }): void;
-    /** @param {String} prop */
-    getValue(prop: string): any;
+    getValue<K extends ExtractKeysFromSchema<T>>(prop: K): ExtractDataFromSchema<T>[K];
     /**
-     * @param {String} prop
-     * @param {(newVal: any) => void} handler
+     * @template {ExtractKeysFromSchema<T>} K
+     * @param {K} prop
+     * @param {(newVal: ExtractDataFromSchema<T>[K]) => void} handler
      */
-    subscribe(prop: string, handler: (newVal: any) => void): {
+    subscribe<K extends ExtractKeysFromSchema<T>>(prop: K, handler: (newVal: ExtractDataFromSchema<T>[K]) => void): {
         remove: () => void;
         callback: Function;
     };
     remove(): void;
 }
+export type TypedSchema = Record<string, {
+    type: unknown;
+    value: unknown;
+    nullable?: boolean;
+}>;
+export type Constructor<T extends unknown = any> = new (...args: any[]) => T;
+export type ExtractType<T extends unknown, V extends unknown> = T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends NumberConstructor ? number : T extends ArrayConstructor ? V : T extends Constructor ? InstanceType<T> : T;
+export type ExtractDataFromSchema<T extends TypedSchema> = { [K in keyof T]: ExtractType<T[K]["type"], T[K]["value"]> | (T[K]["nullable"] extends true ? null : never); };
+export type ExtractKeysFromSchema<T extends TypedSchema> = Extract<keyof T, string>;
 //# sourceMappingURL=TypedData.d.ts.map

package/abstract/TypedData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypedData.d.ts","sourceRoot":"","sources":["TypedData.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH;YAHkB,MAAM,GAAE;YAAE,IAAI,EAAE,GAAG,CAAC;YAAC,KAAK,EAAE,GAAG,CAAC;YAAC,QAAQ,CAAC,UAAS;SAAE;qCAkBtE;IAdC,eAAe;IACf,sBAAgC;IAChC,eAAe;IACf,gBAAwC;IACxC,eAAe;IACf,iBAGM;IACN;;;OAGG;IACH,eAA2D;IAG7D,wBAAwB;IACxB,kBAEC;IAED;;;OAGG;IACH,8BAFW,GAAG,QAab;IAED,0CAA0C;IAC1C;YADmB,MAAM,GAAE,GAAG;aAK7B;IAED,2BAA2B;IAC3B,4BAMC;IAED;;;OAGG;IACH,0CAFoB,GAAG,KAAK,IAAI;;;MAI/B;IAED,eAEC;CACF"}
+{"version":3,"file":"TypedData.d.ts","sourceRoot":"","sources":["TypedData.js"],"names":[],"mappings":"AAMA,mGAAmG;AAEnG;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AAEH;;;GAGG;AAEH,gCAAgC;AAChC,uBAD4B,CAAC,SAAd,WAAY;IAEzB;;;OAGG;IACH,yBAHW,CAAC,oBA6BX;IAzBC;;;OAGG;IACH,sBAAgC;IAEhC;;;OAGG;IACH,gBAAwC;IAExC;;;OAGG;IACH,iBAGgD;IAChD;;;OAGG;IACH,eAA2D;IAG7D,wBAAwB;IACxB,WADc,MAAM,CAGnB;IAED;;;OAGG;IACH,eAHW,qBAAqB,CAAC,CAAC,CAAC,SACxB,qBAAqB,CAAC,CAAC,CAAC,0BAAM,QAkBxC;IAED,wDAAwD;IACxD,0BADY,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,QAK5C;IAED;;;;OAIG;IACH,SAJwC,CAAC,SAA3B,qBAAqB,CAAC,CAAC,CAAE,QAC5B,CAAC,GACC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAOvC;IAED;;;;OAIG;IACH,UAJwC,CAAC,SAA3B,qBAAqB,CAAC,CAAC,CAAE,QAC5B,CAAC,WACD,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;;;MAIvD;IAED,eAEC;CACF;0BA/Ha,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;wBAG/D,CAAC,0BACR,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;wBAIf,CAAC,SAAX,OAAS,EACC,CAAC,SAAX,OAAS,IACT,CAAC,SAAS,iBAAiB,GACjC,MAAM,GACN,CAAC,SAAS,kBAAkB,GAC1B,OAAO,GACP,CAAC,SAAS,iBAAiB,GACzB,MAAM,GACN,CAAC,SAAS,gBAAgB,GACxB,CAAC,GACD,CAAC,SAAS,WAAW,GACnB,YAAY,CAAC,CAAC,CAAC,GACf,CAAC;kCAIW,CAAC,SAAd,WAAY,IACb,GACP,CAAC,IAAI,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC1G;kCAIuB,CAAC,SAAd,WAAY,IACb,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC"}

package/abstract/TypedData.js

@@ -1,23 +1,71 @@
+// @ts-check
 import { Data, UID } from '@symbiotejs/symbiote';
 
 const MSG_NAME = '[Typed State] Wrong property name: ';
 const MSG_TYPE = '[Typed State] Wrong property type: ';
 
+/** @typedef {Record<string, { type: unknown; value: unknown; nullable?: boolean }>} TypedSchema */
+
+/**
+ * @template {any} [T=any] Default is `any`
+ * @typedef {new (...args: any[]) => T} Constructor
+ */
+
+/**
+ * @template {unknown} T
+ * @template {unknown} V
+ * @typedef {T extends StringConstructor
+ *   ? string
+ *   : T extends BooleanConstructor
+ *     ? boolean
+ *     : T extends NumberConstructor
+ *       ? number
+ *       : T extends ArrayConstructor
+ *         ? V
+ *         : T extends Constructor
+ *           ? InstanceType<T>
+ *           : T} ExtractType
+ */
+
+/**
+ * @template {TypedSchema} T
+ * @typedef {{
+ *   [K in keyof T]: ExtractType<T[K]['type'], T[K]['value']> | (T[K]['nullable'] extends true ? null : never);
+ * }} ExtractDataFromSchema
+ */
+
+/**
+ * @template {TypedSchema} T
+ * @typedef {Extract<keyof T, string>} ExtractKeysFromSchema
+ */
+
+/** @template {TypedSchema} T */
 export class TypedData {
   /**
-   * @param {Object<string, { type: any; value: any; nullable?: Boolean }>} typedSchema
+   * @param {T} typedSchema
    * @param {String} [ctxName]
    */
   constructor(typedSchema, ctxName) {
-    /** @private */
+    /**
+     * @private
+     * @type {T}
+     */
     this.__typedSchema = typedSchema;
-    /** @private */
+
+    /**
+     * @private
+     * @type {string}
+     */
     this.__ctxId = ctxName || UID.generate();
-    /** @private */
+
+    /**
+     * @private
+     * @type {ExtractDataFromSchema<T>}
+     */
     this.__schema = Object.keys(typedSchema).reduce((acc, key) => {
-      acc[key] = typedSchema[key].value;
+      /** @type {any} */ (acc)[key] = typedSchema[key].value;
       return acc;
-    }, {});
+    }, /** @type {ExtractDataFromSchema<T>} */ ({}));
     /**
      * @private
      * @type {Data}
@@ -25,14 +73,14 @@ export class TypedData {
     this.__data = Data.registerCtx(this.__schema, this.__ctxId);
   }
 
-  /** @returns {String} */
+  /** @returns {string} */
   get uid() {
     return this.__ctxId;
   }
 
   /**
-   * @param {String} prop
-   * @param {any} value
+   * @param {ExtractKeysFromSchema<T>} prop
+   * @param {ExtractDataFromSchema<T>[prop]} value
    */
   setValue(prop, value) {
     if (!this.__typedSchema.hasOwnProperty(prop)) {
@@ -40,32 +88,41 @@ export class TypedData {
       return;
     }
     let pDesc = this.__typedSchema[prop];
-    if (value?.constructor === pDesc.type || value instanceof pDesc.type || (pDesc.nullable && value === null)) {
+
+    let isMatchConstructorType = value?.constructor === pDesc.type;
+    let isMatchInstanceType = /** @type {any} */ (value) instanceof /** @type {any} */ (pDesc['type']);
+    let isMatchNullable = pDesc.nullable && value === null;
+
+    if (isMatchConstructorType || isMatchInstanceType || isMatchNullable) {
       this.__data.pub(prop, value);
       return;
     }
     console.warn(MSG_TYPE + prop);
   }
 
-  /** @param {Object<string, any>} updObj */
+  /** @param {Partial<ExtractDataFromSchema<T>>} updObj */
   setMultipleValues(updObj) {
-    for (let prop in updObj) {
-      this.setValue(prop, updObj[prop]);
+    for (let [prop, value] of Object.entries(updObj)) {
+      this.setValue(/** @type {ExtractKeysFromSchema<T>} */ (prop), value);
     }
   }
 
-  /** @param {String} prop */
+  /**
+   * @template {ExtractKeysFromSchema<T>} K
+   * @param {K} prop
+   * @returns {ExtractDataFromSchema<T>[K]}
+   */
   getValue(prop) {
     if (!this.__typedSchema.hasOwnProperty(prop)) {
       console.warn(MSG_NAME + prop);
-      return undefined;
     }
     return this.__data.read(prop);
   }
 
   /**
-   * @param {String} prop
-   * @param {(newVal: any) => void} handler
+   * @template {ExtractKeysFromSchema<T>} K
+   * @param {K} prop
+   * @param {(newVal: ExtractDataFromSchema<T>[K]) => void} handler
    */
   subscribe(prop, handler) {
     return this.__data.sub(prop, handler);

package/abstract/UploaderBlock.d.ts

@@ -7,11 +7,11 @@ export class UploaderBlock extends ActivityBlock {
         '*commonProgress': number;
         '*uploadList': never[];
         '*uploadQueue': import("@uploadcare/upload-client").Queue;
-        '*collectionErrors': any[];
-        '*collectionState': import("../types").OutputCollectionState<import("../types").OutputCollectionStatus, "maybe-has-group"> | null;
+        '*collectionErrors': ReturnType<import("../types").OutputErrorCollection>[];
+        '*collectionState': import("../types").OutputCollectionState | null;
         '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
         '*uploadTrigger': Set<string>;
-        '*secureUploadsManager': SecureUploadsManager | null;
+        '*secureUploadsManager': import("./SecureUploadsManager.js").SecureUploadsManager | null;
         '*currentActivity': null;
         '*currentActivityParams': {};
         '*history': never[];
@@ -28,8 +28,8 @@ export class UploaderBlock extends ActivityBlock {
     /** @returns {UploaderPublicApi} */
     get api(): UploaderPublicApi;
     getAPI(): UploaderPublicApi;
-    /** @returns {TypedCollection} */
-    get uploadCollection(): TypedCollection;
+    /** @returns {TypedCollection<typeof uploadEntrySchema>} */
+    get uploadCollection(): TypedCollection<typeof uploadEntrySchema>;
     /** @private */
     private initCtxOwner;
     /** @private */
@@ -45,13 +45,12 @@ export class UploaderBlock extends ActivityBlock {
     private _flushOutputItems;
     /**
      * @private
-     * @type {Parameters<import('./TypedCollection.js').TypedCollection['observeCollection']>[0]}
-     * @param {Set<import('./TypedData.js').TypedData>} removed
+     * @type {import('./TypedCollection.js').TypedCollectionObserverHandler<typeof uploadEntrySchema>}
      */
     private _handleCollectionUpdate;
     /**
      * @private
-     * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntry, Set<string>>} changeMap
+     * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntryData, Set<string>>} changeMap
      */
     private _handleCollectionPropertiesUpdate;
     /** @private */
@@ -68,9 +67,9 @@ export class UploaderBlock extends ActivityBlock {
      * @returns {Promise<import('@uploadcare/upload-client').FileFromOptions>}
      * @protected
      */
-    protected getUploadClientOptions(): Promise<import('@uploadcare/upload-client').FileFromOptions>;
+    protected getUploadClientOptions(): Promise<import("@uploadcare/upload-client").FileFromOptions>;
     /** @returns {import('../types/exported.js').OutputFileEntry[]} */
-    getOutputData(): import('../types/exported.js').OutputFileEntry[];
+    getOutputData(): import("../types/exported.js").OutputFileEntry[];
 }
 export namespace UploaderBlock {
     type extSrcList = string;
@@ -114,4 +113,5 @@ import { SecureUploadsManager } from './SecureUploadsManager.js';
 import { ValidationManager } from './ValidationManager.js';
 import { UploaderPublicApi } from './UploaderPublicApi.js';
 import { TypedCollection } from './TypedCollection.js';
+import { uploadEntrySchema } from './uploadEntrySchema.js';
 //# sourceMappingURL=UploaderBlock.d.ts.map

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,qDAKC;IAED,mCAAmC;IACnC,6BAKC;IAED,4BAEC;IAED,iCAAiC;IACjC,wCAKC;IAYD,eAAe;IACf,qBAkBC;IAfC,eAAe;IACf,6BAAiG;IAEjG,eAAe;IACf,uCAEC;IAWH;;;OAGG;IACH,qBAkBC;IAED,eAAe;IACf,0BAYQ;IAER;;;;OAIG;IACH,gCAiCE;IAEF;;;OAGG;IACH,0CA6FE;IAEF,eAAe;IACf,mCAoBE;IAEF,6BAiBC;IAED,eAAe;IACf,uBAwCC;IAED;;;OAGG;IACH,kCAHW,MAAM,qEAWhB;IAED;;;OAGG;IACH,oCAHa,QAAQ,OAAO,2BAA2B,EAAE,eAAe,CAAC,CA2BxE;IAED,kEAAkE;IAClE,iBADc,OAAO,sBAAsB,EAAE,eAAe,EAAE,CAK7D;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BArb6B,oBAAoB;qCAWb,2BAA2B;kCAG9B,wBAAwB;kCADxB,wBAAwB;gCAD1B,sBAAsB"}
+{"version":3,"file":"UploaderBlock.d.ts","sourceRoot":"","sources":["UploaderBlock.js"],"names":[],"mappings":"AAmBA;IACE,iBAAiB;IACjB,mCAAwB;IAExB,eAAe;IACf,mBAAmB;IAEnB;;;;+CAdA,UAAU;mCACa,UAAS;6BAEjC,2BAA2B;;wCAEW,2BAA2B;;;;;;MASjC;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;IAYD,eAAe;IACf,qBAkBC;IAfC,eAAe;IACf,6BAAiG;IAEjG,eAAe;IACf,uCAEC;IAWH;;;OAGG;IACH,qBAkBC;IAED,eAAe;IACf,0BAYQ;IAER;;;OAGG;IACH,gCAkCE;IAEF;;;OAGG;IACH,0CA6FE;IAEF,eAAe;IACf,mCAsBE;IAEF,6BAiBC;IAED,eAAe;IACf,uBAkDC;IAED;;;OAGG;IACH,kCAHW,MAAM,qEAWhB;IAED;;;OAGG;IACH,oCAHa,OAAO,CAAC,OAAO,2BAA2B,EAAE,eAAe,CAAC,CA2BxE;IAED,kEAAkE;IAClE,iBADc,OAAO,sBAAsB,EAAE,eAAe,EAAE,CAK7D;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAjc6B,oBAAoB;qCAWb,2BAA2B;kCAG9B,wBAAwB;kCADxB,wBAAwB;gCAD1B,sBAAsB;kCAGpB,wBAAwB"}

package/abstract/UploaderBlock.js

@@ -84,7 +84,7 @@ export class UploaderBlock extends ActivityBlock {
     return this.api;
   }
 
-  /** @returns {TypedCollection} */
+  /** @returns {TypedCollection<typeof uploadEntrySchema>} */
   get uploadCollection() {
     if (!this.has('*uploadCollection')) {
       throw new Error('Unexpected error: TypedCollection is not initialized');
@@ -164,8 +164,7 @@ export class UploaderBlock extends ActivityBlock {
 
   /**
    * @private
-   * @type {Parameters<import('./TypedCollection.js').TypedCollection['observeCollection']>[0]}
-   * @param {Set<import('./TypedData.js').TypedData>} removed
+   * @type {import('./TypedCollection.js').TypedCollectionObserverHandler<typeof uploadEntrySchema>}
    */
   _handleCollectionUpdate = (entries, added, removed) => {
     if (added.size || removed.size) {
@@ -190,7 +189,8 @@ export class UploaderBlock extends ActivityBlock {
         isUploading: false,
         uploadProgress: 0,
       });
-      URL.revokeObjectURL(entry?.getValue('thumbUrl'));
+      const thumbUrl = entry?.getValue('thumbUrl');
+      thumbUrl && URL.revokeObjectURL(thumbUrl);
       this.emit(EventType.FILE_REMOVED, this.api.getOutputItem(entry.uid));
     }
 
@@ -204,7 +204,7 @@ export class UploaderBlock extends ActivityBlock {
 
   /**
    * @private
-   * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntry, Set<string>>} changeMap
+   * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntryData, Set<string>>} changeMap
    */
   _handleCollectionPropertiesUpdate = (changeMap) => {
     this._flushOutputItems();
@@ -309,7 +309,9 @@ export class UploaderBlock extends ActivityBlock {
     const items = [...uploadTrigger].filter((id) => !!this.uploadCollection.read(id));
     items.forEach((id) => {
       const uploadProgress = this.uploadCollection.readProp(id, 'uploadProgress');
-      commonProgress += uploadProgress;
+      if (typeof uploadProgress === 'number') {
+        commonProgress += uploadProgress;
+      }
     });
     const progress = items.length ? Math.round(commonProgress / items.length) : 0;
 
@@ -326,7 +328,7 @@ export class UploaderBlock extends ActivityBlock {
 
   openCloudImageEditor() {
     const [entry] = this.uploadCollection
-      .findItems((entry) => entry.getValue('fileInfo') && entry.getValue('isImage'))
+      .findItems((entry) => !!entry.getValue('fileInfo') && entry.getValue('isImage'))
       .map((id) => this.uploadCollection.read(id));
 
     if (
@@ -352,14 +354,19 @@ export class UploaderBlock extends ActivityBlock {
       const entries = this.uploadCollection
         .findItems(
           (entry) =>
-            entry.getValue('fileInfo') &&
+            !!entry.getValue('fileInfo') &&
             entry.getValue('isImage') &&
             !entry.getValue('cdnUrlModifiers')?.includes('/crop/'),
         )
-        .map((id) => this.uploadCollection.read(id));
+        .map((id) => this.uploadCollection.read(id))
+        .filter(Boolean);
 
       for (const entry of entries) {
         const fileInfo = entry.getValue('fileInfo');
+        if (!fileInfo || !fileInfo.imageInfo) {
+          console.warn('Failed to get image info for entry', entry.uid);
+          continue;
+        }
         const { width, height } = fileInfo.imageInfo;
         const expectedAspectRatio = aspectRatioPreset.width / aspectRatioPreset.height;
         const crop = calculateMaxCenteredCropFrame(width, height, expectedAspectRatio);
@@ -367,9 +374,14 @@ export class UploaderBlock extends ActivityBlock {
           `crop/${crop.width}x${crop.height}/${crop.x},${crop.y}`,
           'preview',
         );
+        const cdnUrl = entry.getValue('cdnUrl');
+        if (!cdnUrl) {
+          console.warn('Failed to get cdnUrl for entry', entry.uid);
+          continue;
+        }
         entry.setMultipleValues({
           cdnUrlModifiers,
-          cdnUrl: createCdnUrl(entry.getValue('cdnUrl'), cdnUrlModifiers),
+          cdnUrl: createCdnUrl(cdnUrl, cdnUrlModifiers),
         });
         if (
           this.uploadCollection.size === 1 &&