@uploadcare/file-uploader 1.21.0-alpha.3 → 1.21.0

package/abstract/{ModalManager.js → managers/ModalManager.js}

@@ -9,9 +9,9 @@ export const ModalEvents = Object.freeze({
   DESTROY: 'modal:destroy',
 });
 
-/** @typedef {import('../abstract/ActivityBlock').ActivityType} ModalId */
+/** @typedef {import('../ActivityBlock').ActivityType} ModalId */
 
-/** @typedef {import('../blocks/Modal/Modal.js').Modal} ModalNode */
+/** @typedef {import('../../blocks/Modal/Modal.js').Modal} ModalNode */
 
 /** @typedef {(data: { id: ModalId; modal: ModalNode }) => void} ModalCb */
 
@@ -36,7 +36,7 @@ export class ModalManager {
    */
   _subscribers = new Map();
 
-  /** @param {import('./Block.js').Block} block */
+  /** @param {import('../Block.js').Block} block */
   constructor(block) {
     this._block = block;
   }
@@ -218,6 +218,7 @@ export class ModalManager {
              */ (data),
           );
         } catch (error) {
+          this._block.telemetryManager.sendEventError(error, 'modal subscriber');
           this._debugPrint('Error in modal subscriber:', error);
         }
       }

package/abstract/managers/SecureUploadsManager.d.ts

@@ -0,0 +1,22 @@
+export class SecureUploadsManager {
+    /** @param {import('../UploaderBlock.js').UploaderBlock} block */
+    constructor(block: import("../UploaderBlock.js").UploaderBlock);
+    /**
+     * @private
+     * @type {import('../UploaderBlock.js').UploaderBlock}
+     */
+    private _block;
+    /**
+     * @private
+     * @type {import('../../types/index.js').SecureUploadsSignatureAndExpire | null}
+     */
+    private _secureToken;
+    /**
+     * @private
+     * @param {unknown[]} args
+     */
+    private _debugPrint;
+    /** @returns {Promise<import('../../types/index.js').SecureUploadsSignatureAndExpire | null>} */
+    getSecureToken(): Promise<import("../../types/index.js").SecureUploadsSignatureAndExpire | null>;
+}
+//# sourceMappingURL=SecureUploadsManager.d.ts.map

package/abstract/{SecureUploadsManager.d.ts.map → managers/SecureUploadsManager.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"SecureUploadsManager.d.ts","sourceRoot":"","sources":["SecureUploadsManager.js"],"names":[],"mappings":"AAIA;IAYE,gEAAgE;IAChE,mBADY,OAAO,oBAAoB,EAAE,aAAa,EAGrD;IAdD;;;OAGG;IACH,eAAO;IACP;;;OAGG;IACH,qBAAoB;IAOpB;;;OAGG;IACH,oBAEC;IAED,oFAAoF;IACpF,kBADc,OAAO,CAAC,OAAO,UAAU,EAAE,+BAA+B,GAAG,IAAI,CAAC,CAwD/E;CACF"}
+{"version":3,"file":"SecureUploadsManager.d.ts","sourceRoot":"","sources":["SecureUploadsManager.js"],"names":[],"mappings":"AAIA;IAYE,iEAAiE;IACjE,mBADY,OAAO,qBAAqB,EAAE,aAAa,EAGtD;IAdD;;;OAGG;IACH,eAAO;IACP;;;OAGG;IACH,qBAAoB;IAOpB;;;OAGG;IACH,oBAEC;IAED,gGAAgG;IAChG,kBADc,OAAO,CAAC,OAAO,sBAAsB,EAAE,+BAA+B,GAAG,IAAI,CAAC,CA4D3F;CACF"}

package/abstract/{SecureUploadsManager.js → managers/SecureUploadsManager.js}

@@ -1,20 +1,20 @@
 // @ts-check
 
-import { isSecureTokenExpired } from '../utils/isSecureTokenExpired.js';
+import { isSecureTokenExpired } from '../../utils/isSecureTokenExpired.js';
 
 export class SecureUploadsManager {
   /**
    * @private
-   * @type {import('./UploaderBlock.js').UploaderBlock}
+   * @type {import('../UploaderBlock.js').UploaderBlock}
    */
   _block;
   /**
    * @private
-   * @type {import('../types').SecureUploadsSignatureAndExpire | null}
+   * @type {import('../../types/index.js').SecureUploadsSignatureAndExpire | null}
    */
   _secureToken = null;
 
-  /** @param {import('./UploaderBlock.js').UploaderBlock} block */
+  /** @param {import('../UploaderBlock.js').UploaderBlock} block */
   constructor(block) {
     this._block = block;
   }
@@ -27,7 +27,7 @@ export class SecureUploadsManager {
     this._block.debugPrint('[secure-uploads]', ...args);
   }
 
-  /** @returns {Promise<import('../types').SecureUploadsSignatureAndExpire | null>} */
+  /** @returns {Promise<import('../../types/index.js').SecureUploadsSignatureAndExpire | null>} */
   async getSecureToken() {
     const { secureSignature, secureExpire, secureUploadsSignatureResolver } = this._block.cfg;
 
@@ -64,6 +64,10 @@ export class SecureUploadsManager {
           }
         } catch (err) {
           console.error('Secure signature resolving failed. Falling back to the previous one.', err);
+          this._block.telemetryManager.sendEventError(
+            err,
+            'secureUploadsSignatureResolver. Secure signature resolving failed. Falling back to the previous one.',
+          );
         }
       }
 

package/abstract/managers/TelemetryManager.d.ts

@@ -0,0 +1,71 @@
+/** @typedef {import('@uploadcare/quality-insights').TelemetryRequest & { eventTimestamp: number }} TelemetryState */
+export class TelemetryManager {
+    /** @param {import('../Block.js').Block} block */
+    constructor(block: import("../Block.js").Block);
+    /** @type {ReturnType<Crypto['randomUUID']>} */
+    _sessionId: ReturnType<Crypto["randomUUID"]>;
+    /** @type {TelemetryAPIService | null} */
+    _telemetryInstance: TelemetryAPIService | null;
+    /** @type {import('../Block.js').Block | null} */
+    _block: import("../Block.js").Block | null;
+    _config: import("../../types").ConfigType;
+    /** @type {boolean} */
+    _initialized: boolean;
+    /** @type {TelemetryState | null} */
+    _lastPayload: TelemetryState | null;
+    /** @type {import('@uploadcare/upload-client').Queue | null} */
+    _queue: import("@uploadcare/upload-client").Queue | null;
+    /** @param {keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload | undefined} type */
+    _init(type: keyof import("../../blocks/UploadCtxProvider/EventEmitter.js").EventPayload | undefined): void;
+    /**
+     * @template {keyof import('../../types').ConfigType} T
+     * @param {T} key
+     * @param {import('../../types').ConfigType[T]} value
+     */
+    _setConfig<T extends keyof import("../../types").ConfigType>(key: T, value: import("../../types").ConfigType[T]): void;
+    /**
+     * @param {Pick<TelemetryState, 'eventType' | 'payload' | 'config'>} body
+     * @returns {TelemetryState}
+     */
+    _formattingPayload(body: Pick<TelemetryState, "eventType" | "payload" | "config">): TelemetryState;
+    /** @param {keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload | undefined} type */
+    _excludedEvents(type: keyof import("../../blocks/UploadCtxProvider/EventEmitter.js").EventPayload | undefined): boolean;
+    /**
+     * @param {Partial<Pick<TelemetryState, 'eventType' | 'payload'>> & {
+     *   modalId?: string;
+     *   eventType?: keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload;
+     * }} body
+     */
+    sendEvent(body: Partial<Pick<TelemetryState, "eventType" | "payload">> & {
+        modalId?: string;
+        eventType?: keyof import("../../blocks/UploadCtxProvider/EventEmitter.js").EventPayload;
+    }): null | undefined;
+    /**
+     * @param {Error | unknown} error
+     * @param {string} context
+     */
+    sendEventError(error: Error | unknown, context?: string): void;
+    /**
+     * Method to send telemetry event for Cloud Image Editor.
+     *
+     * @param {MouseEvent} e
+     * @param {string} tabId
+     * @param {Record<string, unknown>} options
+     */
+    sendEventCloudImageEditor(e: MouseEvent, tabId: string, options?: Record<string, unknown>): void;
+    /**
+     * Deeply compares two objects and returns true if they are equal, false otherwise.
+     *
+     * @param {any} last
+     * @param {any} current
+     */
+    _checkObj(last: any, current: any): boolean;
+    get _timestamp(): number;
+    get _solution(): any;
+    get _activity(): any;
+}
+export type TelemetryState = import("@uploadcare/quality-insights").TelemetryRequest & {
+    eventTimestamp: number;
+};
+import { TelemetryAPIService } from '@uploadcare/quality-insights';
+//# sourceMappingURL=TelemetryManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryManager.d.ts","sourceRoot":"","sources":["TelemetryManager.js"],"names":[],"mappings":"AAQA,qHAAqH;AAErH;IAqBE,iDAAiD;IACjD,mBADY,OAAO,aAAa,EAAE,KAAK,EAiBtC;IArCD,+CAA+C;IAC/C,YADW,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CACV;IAEjC,yCAAyC;IACzC,oBADW,mBAAmB,GAAG,IAAI,CACX;IAE1B,iDAAiD;IACjD,QADW,OAAO,aAAa,EAAE,KAAK,GAAG,IAAI,CAC/B;IAEd,0CAAyC;IAEzC,sBAAsB;IACtB,cADW,OAAO,CACG;IAErB,oCAAoC;IACpC,cADW,cAAc,GAAG,IAAI,CACZ;IAEpB,+DAA+D;IAC/D,QADW,OAAO,2BAA2B,EAAE,KAAK,GAAG,IAAI,CAC7C;IAqBd,4GAA4G;IAC5G,YADY,MAAM,OAAO,gDAAgD,EAAE,YAAY,GAAG,SAAS,QAKlG;IAED;;;;OAIG;IACH,WAJsD,CAAC,SAA1C,MAAO,OAAO,aAAa,EAAE,UAAW,OAC1C,CAAC,SACD,OAAO,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,QAQ7C;IAED;;;OAGG;IACH,yBAHW,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC,GACtD,cAAc,CA4B1B;IAED,4GAA4G;IAC5G,sBADY,MAAM,OAAO,gDAAgD,EAAE,YAAY,GAAG,SAAS,WAqBlG;IAED;;;;;OAKG;IACH,gBALW,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,SAAS,CAAC,CAAC,GAAG;QAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,OAAO,gDAAgD,EAAE,YAAY,CAAC;KACzF,oBAmBH;IAED;;;OAGG;IACH,sBAHW,KAAK,GAAG,OAAO,YACf,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,6BAJW,UAAU,SACV,MAAM,YACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAajC;IAED;;;;;OAKG;IACH,gBAHW,GAAG,WACH,GAAG,WAcb;IAED,yBAEC;IAED,qBAEC;IAED,qBAEC;CACF;6BAjNa,OAAO,8BAA8B,EAAE,gBAAgB,GAAG;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE;oCAP9D,8BAA8B"}

package/abstract/managers/TelemetryManager.js

@@ -0,0 +1,218 @@
+// @ts-check
+import { TelemetryAPIService } from '@uploadcare/quality-insights';
+
+import { Queue } from '@uploadcare/upload-client';
+import { PACKAGE_VERSION, PACKAGE_NAME } from '../../env.js';
+import { initialConfig } from '../../blocks/Config/initialConfig.js';
+import { EventType } from '../../blocks/UploadCtxProvider/EventEmitter.js';
+
+/** @typedef {import('@uploadcare/quality-insights').TelemetryRequest & { eventTimestamp: number }} TelemetryState */
+
+export class TelemetryManager {
+  /** @type {ReturnType<Crypto['randomUUID']>} */
+  _sessionId = crypto.randomUUID();
+
+  /** @type {TelemetryAPIService | null} */
+  _telemetryInstance = null;
+
+  /** @type {import('../Block.js').Block | null} */
+  _block = null;
+
+  _config = structuredClone(initialConfig);
+
+  /** @type {boolean} */
+  _initialized = false;
+
+  /** @type {TelemetryState | null} */
+  _lastPayload = null;
+
+  /** @type {import('@uploadcare/upload-client').Queue | null} */
+  _queue = null;
+
+  /** @param {import('../Block.js').Block} block */
+  constructor(block) {
+    this._block = block;
+
+    this._telemetryInstance = new TelemetryAPIService();
+
+    this._queue = new Queue(10);
+
+    for (const key of /** @type {(keyof import('../../types/exported').ConfigType)[]} */ (Object.keys(this._config))) {
+      this._block.subConfigValue(key, (value) => {
+        if (this._initialized && this._config[key] !== value) {
+          this._block?.emit(EventType.CHANGE_CONFIG, undefined);
+        }
+
+        this._setConfig(key, value);
+      });
+    }
+  }
+
+  /** @param {keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload | undefined} type */
+  _init(type) {
+    if (type === EventType.INIT_SOLUTION && !this._initialized) {
+      this._initialized = true;
+    }
+  }
+
+  /**
+   * @template {keyof import('../../types').ConfigType} T
+   * @param {T} key
+   * @param {import('../../types').ConfigType[T]} value
+   */
+  _setConfig(key, value) {
+    if (this._config[key] === value) {
+      return;
+    }
+
+    this._config[key] = value;
+  }
+
+  /**
+   * @param {Pick<TelemetryState, 'eventType' | 'payload' | 'config'>} body
+   * @returns {TelemetryState}
+   */
+  _formattingPayload(body) {
+    const payload = body.payload ? { ...body.payload } : {};
+    if (payload.activity) payload.activity = undefined;
+
+    const result = { ...body };
+    if (body.eventType === EventType.INIT_SOLUTION || body.eventType === EventType.CHANGE_CONFIG) {
+      result.config = this._config;
+    }
+
+    return {
+      ...result,
+
+      appVersion: PACKAGE_VERSION,
+      appName: PACKAGE_NAME,
+      sessionId: this._sessionId,
+      component: this._solution,
+      activity: this._activity,
+      projectPubkey: this._config?.pubkey,
+      userAgent: navigator.userAgent,
+      eventType: result.eventType ?? '',
+      eventTimestamp: this._timestamp,
+
+      payload: {
+        ...payload,
+      },
+    };
+  }
+
+  /** @param {keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload | undefined} type */
+  _excludedEvents(type) {
+    if (
+      type &&
+      [
+        EventType.CHANGE,
+        EventType.COMMON_UPLOAD_PROGRESS,
+        EventType.FILE_ADDED,
+        EventType.FILE_REMOVED,
+        EventType.FILE_UPLOAD_START,
+        EventType.FILE_UPLOAD_PROGRESS,
+        EventType.FILE_UPLOAD_SUCCESS,
+        EventType.FILE_UPLOAD_FAILED,
+        EventType.FILE_URL_CHANGED,
+        EventType.GROUP_CREATED,
+      ].includes(type)
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {Partial<Pick<TelemetryState, 'eventType' | 'payload'>> & {
+   *   modalId?: string;
+   *   eventType?: keyof import('../../blocks/UploadCtxProvider/EventEmitter.js').EventPayload;
+   * }} body
+   */
+  sendEvent(body) {
+    const payload = this._formattingPayload(
+      /** @type {Pick<TelemetryState, 'eventType' | 'payload' | 'config'>} */ (body),
+    );
+
+    this._init(body.eventType);
+
+    const hasExcludedEvents = this._excludedEvents(body.eventType);
+    if (hasExcludedEvents) return null;
+
+    const hasDataSame = this._lastPayload && this._checkObj(this._lastPayload, payload);
+    if (hasDataSame) return null;
+
+    this._queue?.add(async () => {
+      this._lastPayload = payload;
+      await this._telemetryInstance?.sendEvent(/** @type {TelemetryState} */ (payload));
+    });
+  }
+
+  /**
+   * @param {Error | unknown} error
+   * @param {string} context
+   */
+  sendEventError(error, context = 'unknown') {
+    this.sendEvent({
+      payload: {
+        metadata: {
+          event: 'error',
+          text: `Error in ${context}`,
+          error: /** @type {Error} */ (error).message,
+        },
+      },
+    });
+  }
+
+  /**
+   * Method to send telemetry event for Cloud Image Editor.
+   *
+   * @param {MouseEvent} e
+   * @param {string} tabId
+   * @param {Record<string, unknown>} options
+   */
+  sendEventCloudImageEditor(e, tabId, options = {}) {
+    this.sendEvent({
+      payload: {
+        metadata: {
+          tabId,
+          node: /** @type {HTMLElement} */ (e.currentTarget)?.tagName,
+          event: e.type,
+          ...options,
+        },
+      },
+    });
+  }
+
+  /**
+   * Deeply compares two objects and returns true if they are equal, false otherwise.
+   *
+   * @param {any} last
+   * @param {any} current
+   */
+  _checkObj(last, current) {
+    if (JSON.stringify(last) === JSON.stringify(current)) return true;
+    if (typeof last !== 'object' || typeof current !== 'object' || last == null || current == null) return false;
+    const lastKeys = Object.keys(last);
+    const currentKeys = Object.keys(current);
+    if (lastKeys.length !== currentKeys.length) return false;
+    for (const key of lastKeys) {
+      if (!Object.prototype.hasOwnProperty.call(current, key)) return false;
+      if (!this._checkObj(last[key], current[key])) return false;
+    }
+
+    return true;
+  }
+
+  get _timestamp() {
+    return Date.now();
+  }
+
+  get _solution() {
+    return this._block?.has('*solution') ? this._block?.$['*solution'].toLowerCase() : null;
+  }
+
+  get _activity() {
+    return this._block?.has('*currentActivity') ? this._block?.$['*currentActivity'] : null;
+  }
+}

package/abstract/{ValidationManager.d.ts → managers/ValidationManager.d.ts}

@@ -1,16 +1,16 @@
 export class ValidationManager {
-    /** @param {import('./UploaderBlock.js').UploaderBlock} blockInstance */
-    constructor(blockInstance: import("./UploaderBlock.js").UploaderBlock);
+    /** @param {import('../UploaderBlock.js').UploaderBlock} blockInstance */
+    constructor(blockInstance: import("../UploaderBlock.js").UploaderBlock);
     /**
      * @private
-     * @type {import('./UploaderBlock.js').UploaderBlock}
+     * @type {import('../UploaderBlock.js').UploaderBlock}
      */
     private _blockInstance;
     /** @type {FuncFileValidator[]} */
     _fileValidators: FuncFileValidator[];
     /** @type {FuncCollectionValidator[]} */
     _collectionValidators: FuncCollectionValidator[];
-    _uploadCollection: import("./TypedCollection.js").TypedCollection<Readonly<{
+    _uploadCollection: import("../TypedCollection.js").TypedCollection<Readonly<{
         file: Readonly<{
             type: {
                 new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
@@ -135,7 +135,7 @@ export class ValidationManager {
     runCollectionValidators(): void;
     /**
      * @private
-     * @param {import('./TypedData.js').TypedData<typeof import('./uploadEntrySchema.js').uploadEntrySchema>} entry
+     * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
      */
     private _runFileValidatorsForEntry;
     /**
@@ -145,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/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;
 //# sourceMappingURL=ValidationManager.d.ts.map

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

@@ -0,0 +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"}

package/abstract/{ValidationManager.js → managers/ValidationManager.js}

@@ -1,29 +1,29 @@
 // @ts-check
-import { EventType } from '../blocks/UploadCtxProvider/EventEmitter.js';
+import { EventType } from '../../blocks/UploadCtxProvider/EventEmitter.js';
 import {
   validateIsImage,
   validateFileType,
   validateMaxSizeLimit,
   validateUploadError,
-} from '../utils/validators/file/index.js';
-import { validateMultiple, validateCollectionUploadError } from '../utils/validators/collection/index.js';
+} from '../../utils/validators/file/index.js';
+import { validateMultiple, validateCollectionUploadError } from '../../utils/validators/collection/index.js';
 
 /**
  * @typedef {(
- *   outputEntry: import('../types').OutputFileEntry,
- *   api: import('./UploaderPublicApi.js').UploaderPublicApi,
- * ) => undefined | import('../types').OutputErrorFile} FuncFileValidator
+ *   outputEntry: import('../../types/index.js').OutputFileEntry,
+ *   api: import('../UploaderPublicApi.js').UploaderPublicApi,
+ * ) => undefined | import('../../types/index.js').OutputErrorFile} FuncFileValidator
  */
 
 /**
  * @typedef {(
  *   collection: ReturnType<
- *     typeof import('./buildOutputCollectionState.js').buildOutputCollectionState<
- *       import('../types').OutputCollectionStatus
+ *     typeof import('../buildOutputCollectionState.js').buildOutputCollectionState<
+ *       import('../../types/index.js').OutputCollectionStatus
  *     >
  *   >,
- *   api: import('./UploaderPublicApi.js').UploaderPublicApi,
- * ) => undefined | import('../types').OutputErrorCollection} FuncCollectionValidator
+ *   api: import('../UploaderPublicApi.js').UploaderPublicApi,
+ * ) => undefined | import('../../types/index.js').OutputErrorCollection} FuncCollectionValidator
  */
 
 const LOGGER = {
@@ -35,7 +35,7 @@ const LOGGER = {
 export class ValidationManager {
   /**
    * @private
-   * @type {import('./UploaderBlock.js').UploaderBlock}
+   * @type {import('../UploaderBlock.js').UploaderBlock}
    */
   _blockInstance;
 
@@ -45,7 +45,7 @@ export class ValidationManager {
   /** @type {FuncCollectionValidator[]} */
   _collectionValidators = [validateMultiple, validateCollectionUploadError];
 
-  /** @param {import('./UploaderBlock.js').UploaderBlock} blockInstance */
+  /** @param {import('../UploaderBlock.js').UploaderBlock} blockInstance */
   constructor(blockInstance) {
     this._blockInstance = blockInstance;
 
@@ -97,6 +97,7 @@ export class ValidationManager {
         }
       } catch (error) {
         console.warn(LOGGER.collection, error);
+        this._blockInstance.telemetryManager.sendEventError(error, `collection validator. ${LOGGER.collection}`);
       }
     }
 
@@ -106,7 +107,7 @@ export class ValidationManager {
       this._blockInstance.emit(
         EventType.COMMON_UPLOAD_FAILED,
         () =>
-          /** @type {import('../types').OutputCollectionState<'failed'>} */ (
+          /** @type {import('../../types/index.js').OutputCollectionState<'failed'>} */ (
             this._blockInstance.api.getOutputCollectionState()
           ),
         { debounce: true },
@@ -116,7 +117,7 @@ export class ValidationManager {
 
   /**
    * @private
-   * @param {import('./TypedData.js').TypedData<typeof import('./uploadEntrySchema.js').uploadEntrySchema>} entry
+   * @param {import('../TypedData.js').TypedData<typeof import('../uploadEntrySchema.js').uploadEntrySchema>} entry
    */
   _runFileValidatorsForEntry(entry) {
     const outputEntry = this._blockInstance.api.getOutputItem(entry.uid);
@@ -140,6 +141,7 @@ export class ValidationManager {
         }
       } catch (error) {
         console.warn(LOGGER.file, error);
+        this._blockInstance.telemetryManager.sendEventError(error, `file validator. ${LOGGER.file}`);
       }
     }
     entry.setValue('errors', errors);

package/abstract/{a11y.d.ts → managers/a11y.d.ts}

@@ -9,8 +9,8 @@ export class A11y {
      * @type {ScopedMinimalWindow}
      */
     private _scopedWindow;
-    /** @param {import('./Block.js').Block} scope */
-    registerBlock(scope: import("./Block.js").Block): void;
+    /** @param {import('../Block.js').Block} scope */
+    registerBlock(scope: import("../Block.js").Block): void;
     destroy(): void;
 }
 /**

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

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

package/abstract/{a11y.js → managers/a11y.js}

@@ -106,7 +106,7 @@ export class A11y {
     ]);
   }
 
-  /** @param {import('./Block.js').Block} scope */
+  /** @param {import('../Block.js').Block} scope */
   registerBlock(scope) {
     this._scopedWindow.registerScope(scope);
   }

package/blocks/CameraSource/CameraSource.d.ts

@@ -64,11 +64,11 @@ export class CameraSource extends UploaderBlock {
         '*commonProgress': number;
         '*uploadList': never[];
         '*uploadQueue': import("@uploadcare/upload-client").Queue;
-        '*collectionErrors': ReturnType<import("../../index.js").OutputErrorCollection>[];
+        '*collectionErrors': 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;
+        '*secureUploadsManager': import("../../abstract/managers/SecureUploadsManager.js").SecureUploadsManager | null;
         '*currentActivity': null;
         '*currentActivityParams': {};
         '*history': never[];

package/blocks/CameraSource/CameraSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraSource.d.ts","sourceRoot":"","sources":["CameraSource.js"],"names":[],"mappings":"AAmCA,8CAA8C;AAE9C,kGAAkG;AAElG;IAEE,uBAA+C;IAE/C,eAAe;IACf,0BAAyB;IAEzB,yBAAyB;IACzB,SADW,QAAQ,EAAE,CACR;IAEb,mCAAmC;IACnC,gBADW,aAAa,GAAG,IAAI,CACT;IAEtB,iCAAiC;IACjC,SADW,WAAW,GAAG,IAAI,CACd;IAEf,4BAA4B;IAC5B,kBADW,MAAM,GAAG,IAAI,CACA;IAExB,4BAA4B;IAC5B,mBADW,MAAM,GAAG,IAAI,CACC;IAKvB;;;;;;;;;;;;;;;;;;;;;;;;QAiCE,qBAAqB;;QAErB,qBAAqB;;;;QAMrB,uBAAuB;kCAAX,KAAK;QAMjB,uBAAuB;iCAAX,KAAK;;;;QAcjB,iDAAiD;;;;;;;;QAejD,4BAA4B;wBAAhB,UAAU;;;;;;;;;;;;;;MAKvB;IAGH,oCAaE;IAEF,yBAkBE;IADA,sCAAiE;IAGnE,wBAKE;IAEF,uBAEE;IAEF,2BAOE;IAEF,0BAEE;IAEF,4BAiCE;IA9BE;;;;;kBAEC;IA8BL,eAAe;IACf,uBAWE;IAEF,2DAA2D;IAC3D,6BAQE;IAEF,+BAOE;IAEF;;;;OAIG;IACH,sBA6BE;IAEF,oBAUE;IAEF,oBAoBE;IAEF,mCAAmC;IACnC,eAAgB,QADJ,YACU,UAoBpB;IAEF,mCAAmC;IACnC,eAAgB,QADJ,YACU,UAuCpB;IAEF;;;OAGG;IACH,wBAmBE;IAEF,eAAe;IACf,cAoBC;IAjBC,uCAA+C;IAC/C,kDAAyC;IAkB3C;;;OAGG;IACH,yBAwBE;IADA,mCAAuB;IAGzB;;;;;OAKG;IACH,cAAe,MALJ,QAAQ,GAAG,OAKH,EAAE,KAJV,MAAM,GAAG,MAII,EAAE,cAAM,EAAE,MAFvB,IAE2B,UAUpC;IAEF,uCAAuC;IACvC,4BADY,SAAS,SAAS,OAmC7B;IAED;;;;OAIG;IACH,UAAW,MAFA,IAEI,UAMb;IAEF,eAAe;IACf,2BAEC;IAED;;;OAGG;IACH,6BA+CQ;IAER,6CAQE;IAEF,yBAWE;IAFE,gCAAuB;IAI3B,8BAyCE;IAEF,qCAEE;IAEF,uCAYE;IAEF,2BAA0B;IAE1B,0CASE;IAEF,iCAsCE;IAlCE;;;oBAKK;IAEL;;;oBAOO;IAsBX,iCAME;IAEF,mCAYE;IAEF,wCAAwC;IACxC,qBAAsB,aADV,UAAU,EACW,UAQ/B;IAyBF,iBAMC;IAED,iCAIC;CACF;;;;yBAlxBa,OAAO,GAAG,OAAO;2BAEjB,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ;8BAnCnD,iCAAiC"}
+{"version":3,"file":"CameraSource.d.ts","sourceRoot":"","sources":["CameraSource.js"],"names":[],"mappings":"AAyCA,8CAA8C;AAE9C,kGAAkG;AAElG;IAEE,uBAA+C;IAE/C,eAAe;IACf,0BAAyB;IAEzB,yBAAyB;IACzB,SADW,QAAQ,EAAE,CACR;IAEb,mCAAmC;IACnC,gBADW,aAAa,GAAG,IAAI,CACT;IAEtB,iCAAiC;IACjC,SADW,WAAW,GAAG,IAAI,CACd;IAEf,4BAA4B;IAC5B,kBADW,MAAM,GAAG,IAAI,CACA;IAExB,4BAA4B;IAC5B,mBADW,MAAM,GAAG,IAAI,CACC;IAKvB;;;;;;;;;;;;;;;;;;;;;;;;QAiCE,qBAAqB;;QAErB,qBAAqB;;;;QAMrB,uBAAuB;kCAAX,KAAK;QAMjB,uBAAuB;iCAAX,KAAK;;;;QAcjB,iDAAiD;;;;;;;;QAejD,4BAA4B;wBAAhB,UAAU;;;;;;;;;;;;;;MAKvB;IAGH,oCAaE;IAEF,yBAkBE;IADA,sCAAiE;IAGnE,wBAKE;IAEF,uBAEE;IAEF,2BAOE;IAEF,0BAEE;IAEF,4BAkCE;IA/BE;;;;;kBAEC;IA+BL,eAAe;IACf,uBAWE;IAEF,2DAA2D;IAC3D,6BAQE;IAEF,+BAOE;IAEF;;;;OAIG;IACH,sBA8BE;IAEF,oBAUE;IAEF,oBAoBE;IAEF,mCAAmC;IACnC,eAAgB,QADJ,YACU,UAoBpB;IAEF,mCAAmC;IACnC,eAAgB,QADJ,YACU,UAuCpB;IAEF;;;OAGG;IACH,wBAmBE;IAEF,eAAe;IACf,cAoBC;IAjBC,uCAA+C;IAC/C,kDAAyC;IAkB3C;;;OAGG;IACH,yBAwBE;IADA,mCAAuB;IAGzB;;;;;OAKG;IACH,cAAe,MALJ,QAAQ,GAAG,OAKH,EAAE,KAJV,MAAM,GAAG,MAII,EAAE,cAAM,EAAE,MAFvB,IAE2B,UAUpC;IAEF,uCAAuC;IACvC,4BADY,SAAS,SAAS,OAmC7B;IAED;;;;OAIG;IACH,UAAW,MAFA,IAEI,UAMb;IAEF,eAAe;IACf,2BAEC;IAED;;;OAGG;IACH,6BA+CQ;IAER,6CAQE;IAEF,yBAWE;IAFE,gCAAuB;IAI3B,8BA0CE;IAEF,qCAEE;IAEF,uCAaE;IAEF,2BAA0B;IAE1B,0CAUE;IAEF,iCAuCE;IAnCE;;;oBAKK;IAEL;;;oBAOO;IAuBX,iCAME;IAEF,mCAYE;IAEF,wCAAwC;IACxC,qBAAsB,aADV,UAAU,EACW,UAQ/B;IAyBF,iBAMC;IAED,iCAIC;CACF;;;;yBAxxBa,OAAO,GAAG,OAAO;2BAEjB,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ;8BAzCnD,iCAAiC"}

package/blocks/CameraSource/CameraSource.js

@@ -9,9 +9,15 @@ import { UploadSource } from '../utils/UploadSource.js';
 import { CameraSourceEvents, CameraSourceTypes } from './constants.js';
 
 const DEFAULT_VIDEO_CONFIG = {
-  width: { ideal: 4096 },
-  height: { ideal: 2160 },
-  frameRate: { ideal: 60 },
+  width: {
+    ideal: 1920,
+  },
+  height: {
+    ideal: 1080,
+  },
+  frameRate: {
+    ideal: 30,
+  },
 };
 
 const DEFAULT_PERMISSIONS = ['camera', 'microphone'];
@@ -237,6 +243,7 @@ export class CameraSource extends UploaderBlock {
       }
     } catch (error) {
       console.error('Failed to start recording', error);
+      this.telemetryManager.sendEventError(error, 'camera recording. Failed to start recording');
     }
   };
 
@@ -307,6 +314,7 @@ export class CameraSource extends UploaderBlock {
       });
     } catch (error) {
       console.error('Failed to preview video', error);
+      this.telemetryManager.sendEventError(error, 'camera previewing. Failed to preview video');
     }
   };
 
@@ -676,6 +684,7 @@ export class CameraSource extends UploaderBlock {
     } catch (error) {
       this._setPermissionsState('denied');
       console.log('Failed to capture camera', error);
+      this.telemetryManager.sendEventError(error, 'camera capturing. Failed to capture camera');
     }
   };
 
@@ -693,6 +702,7 @@ export class CameraSource extends UploaderBlock {
       }
     } catch (error) {
       console.log('Failed to use permissions API. Fallback to manual request mode.', error);
+      this.telemetryManager.sendEventError(error, 'camera permissions. Failed to use permissions API');
       this._capture();
     }
   };
@@ -706,6 +716,7 @@ export class CameraSource extends UploaderBlock {
 
       navigator.mediaDevices.addEventListener('devicechange', this._getDevices);
     } catch (error) {
+      this.telemetryManager.sendEventError(error, 'camera devices. Failed to get user media');
       console.log('Failed to get user media', error);
     }
   };
@@ -746,6 +757,7 @@ export class CameraSource extends UploaderBlock {
       }
       this._selectedAudioId = this._audioDevices[0]?.value;
     } catch (error) {
+      this.telemetryManager.sendEventError(error, 'camera devices. Failed to get devices');
       console.log('Failed to get devices', error);
     }
   };

package/blocks/CloudImageEditor/src/CloudImageEditorBlock.d.ts

@@ -9,7 +9,8 @@ export class CloudImageEditorBlock extends Block {
         '*imageSize': null;
         '*editorTransformations': import("./types.js").Transformations;
         '*cropPresetList': import("./types.js").CropPresetList;
-        '*tabList': ("crop" | "tuning" | "filters" | "ai")[];
+        '*currentAspectRatio': null;
+        '*tabList': ("crop" | "tuning" | "filters")[];
         '*tabId': "crop";
         entry: null;
         extension: null;