@uploadcare/file-uploader 0.50.1-alpha.2

package/abstract/UploaderBlock.d.ts

@@ -0,0 +1,114 @@
+export class UploaderBlock extends ActivityBlock {
+    /** @protected */
+    protected couldBeCtxOwner: boolean;
+    /** @private */
+    private isCtxOwner;
+    init$: {
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*focusedEntry': null;
+        '*uploadQueue': import("@uploadcare/upload-client").Queue;
+        '*collectionErrors': any[];
+        '*collectionState': import("../types").OutputCollectionState<import("../types").OutputCollectionStatus, "maybe-has-group"> | null;
+        '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
+        '*uploadTrigger': Set<string>;
+        '*secureUploadsManager': SecureUploadsManager | null;
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    /** @private */
+    private get hasCtxOwner();
+    /**
+     * @returns {ValidationManager}
+     * @protected
+     */
+    protected get validationManager(): ValidationManager;
+    /** @returns {UploaderPublicApi} */
+    get api(): UploaderPublicApi;
+    getAPI(): UploaderPublicApi;
+    /** @returns {TypedCollection} */
+    get uploadCollection(): TypedCollection;
+    /** @private */
+    private initCtxOwner;
+    /** @private */
+    private _unobserveCollection;
+    /** @private */
+    private _unobserveCollectionProperties;
+    /**
+     * @private
+     * @param {import('../types').OutputCollectionState} collectionState
+     */
+    private _createGroup;
+    /** @private */
+    private _flushOutputItems;
+    /**
+     * @private
+     * @type {Parameters<import('./TypedCollection.js').TypedCollection['observeCollection']>[0]}
+     * @param {Set<import('./TypedData.js').TypedData>} removed
+     */
+    private _handleCollectionUpdate;
+    /**
+     * @private
+     * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntry, Set<string>>} changeMap
+     */
+    private _handleCollectionPropertiesUpdate;
+    /** @private */
+    private _flushCommonUploadProgress;
+    /** @private */
+    private setInitialCrop;
+    /**
+     * @param {string} entryId
+     * @protected
+     */
+    protected getMetadataFor(entryId: string): Promise<import("@uploadcare/upload-client").Metadata | undefined>;
+    /**
+     * @returns {Promise<import('@uploadcare/upload-client').FileFromOptions>}
+     * @protected
+     */
+    protected getUploadClientOptions(): Promise<import('@uploadcare/upload-client').FileFromOptions>;
+    /** @returns {import('../types/exported.js').OutputFileEntry[]} */
+    getOutputData(): import('../types/exported.js').OutputFileEntry[];
+}
+export namespace UploaderBlock {
+    type extSrcList = string;
+    let extSrcList: Readonly<{
+        FACEBOOK: "facebook";
+        DROPBOX: "dropbox";
+        GDRIVE: "gdrive";
+        GPHOTOS: "gphotos";
+        INSTAGRAM: "instagram";
+        FLICKR: "flickr";
+        VK: "vk";
+        EVERNOTE: "evernote";
+        BOX: "box";
+        ONEDRIVE: "onedrive";
+        HUDDLE: "huddle";
+    }>;
+    type sourceTypes = string;
+    let sourceTypes: Readonly<{
+        FACEBOOK: "facebook";
+        DROPBOX: "dropbox";
+        GDRIVE: "gdrive";
+        GPHOTOS: "gphotos";
+        INSTAGRAM: "instagram";
+        FLICKR: "flickr";
+        VK: "vk";
+        EVERNOTE: "evernote";
+        BOX: "box";
+        ONEDRIVE: "onedrive";
+        HUDDLE: "huddle";
+        LOCAL: "local";
+        URL: "url";
+        CAMERA: "camera";
+        DRAW: "draw";
+    }>;
+}
+import { ActivityBlock } from './ActivityBlock.js';
+import { SecureUploadsManager } from './SecureUploadsManager.js';
+import { ValidationManager } from './ValidationManager.js';
+import { UploaderPublicApi } from './UploaderPublicApi.js';
+import { TypedCollection } from './TypedCollection.js';
+//# sourceMappingURL=UploaderBlock.d.ts.map

package/abstract/UploaderBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploaderBlock.d.ts","sourceRoot":"","sources":["UploaderBlock.js"],"names":[],"mappings":"AAkBA;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,qBA0BC;IAvBC,eAAe;IACf,6BAAiG;IAEjG,eAAe;IACf,uCAEC;IAmBH;;;OAGG;IACH,qBAkBC;IAED,eAAe;IACf,0BAYQ;IAER;;;;OAIG;IACH,gCAiCE;IAEF;;;OAGG;IACH,0CAyFE;IAEF,eAAe;IACf,mCAoBE;IAEF,eAAe;IACf,uBAqCC;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAla6B,oBAAoB;qCAWb,2BAA2B;kCAG9B,wBAAwB;kCADxB,wBAAwB;gCAD1B,sBAAsB"}

package/abstract/UploaderBlock.js

@@ -0,0 +1,444 @@
+// @ts-check
+import { ActivityBlock } from './ActivityBlock.js';
+
+import { Data } from '@symbiotejs/symbiote';
+import { uploadFileGroup } from '@uploadcare/upload-client';
+import { calculateMaxCenteredCropFrame } from '../blocks/CloudImageEditor/src/crop-utils.js';
+import { parseCropPreset } from '../blocks/CloudImageEditor/src/lib/parseCropPreset.js';
+import { EventType } from '../blocks/UploadCtxProvider/EventEmitter.js';
+import { debounce } from '../blocks/utils/debounce.js';
+import { customUserAgent } from '../blocks/utils/userAgent.js';
+import { createCdnUrl, createCdnUrlModifiers } from '../utils/cdn-utils.js';
+import { uploaderBlockCtx } from './CTX.js';
+import { SecureUploadsManager } from './SecureUploadsManager.js';
+import { TypedCollection } from './TypedCollection.js';
+import { UploaderPublicApi } from './UploaderPublicApi.js';
+import { ValidationManager } from './ValidationManager.js';
+import { uploadEntrySchema } from './uploadEntrySchema.js';
+
+export class UploaderBlock extends ActivityBlock {
+  /** @protected */
+  couldBeCtxOwner = false;
+
+  /** @private */
+  isCtxOwner = false;
+
+  init$ = uploaderBlockCtx(this);
+
+  /** @private */
+  get hasCtxOwner() {
+    return this.hasBlockInCtx((block) => {
+      if (block instanceof UploaderBlock) {
+        return block.isCtxOwner && block.isConnected && block !== this;
+      }
+      return false;
+    });
+  }
+
+  /** @protected */
+  initCallback() {
+    super.initCallback();
+
+    if (!this.has('*uploadCollection')) {
+      let uploadCollection = new TypedCollection({
+        typedSchema: uploadEntrySchema,
+        watchList: ['uploadProgress', 'uploadError', 'fileInfo', 'errors', 'cdnUrl', 'isUploading'],
+      });
+      this.add('*uploadCollection', uploadCollection);
+    }
+
+    if (!this.has('*publicApi')) {
+      this.add('*publicApi', new UploaderPublicApi(this));
+    }
+
+    if (!this.has('*validationManager')) {
+      this.add('*validationManager', new ValidationManager(this));
+    }
+
+    if (!this.hasCtxOwner && this.couldBeCtxOwner) {
+      this.initCtxOwner();
+    }
+  }
+
+  /**
+   * @returns {ValidationManager}
+   * @protected
+   */
+  get validationManager() {
+    if (!this.has('*validationManager')) {
+      throw new Error('Unexpected error: ValidationManager is not initialized');
+    }
+    return this.$['*validationManager'];
+  }
+
+  /** @returns {UploaderPublicApi} */
+  get api() {
+    if (!this.has('*publicApi')) {
+      throw new Error('Unexpected error: UploaderPublicApi is not initialized');
+    }
+    return this.$['*publicApi'];
+  }
+
+  getAPI() {
+    return this.api;
+  }
+
+  /** @returns {TypedCollection} */
+  get uploadCollection() {
+    if (!this.has('*uploadCollection')) {
+      throw new Error('Unexpected error: TypedCollection is not initialized');
+    }
+    return this.$['*uploadCollection'];
+  }
+
+  /** @protected */
+  destroyCtxCallback() {
+    this._unobserveCollectionProperties?.();
+    this._unobserveCollection?.();
+    this.uploadCollection.destroy();
+    this.$['*uploadCollection'] = null;
+
+    super.destroyCtxCallback();
+  }
+
+  /** @private */
+  initCtxOwner() {
+    this.isCtxOwner = true;
+
+    /** @private */
+    this._unobserveCollection = this.uploadCollection.observeCollection(this._handleCollectionUpdate);
+
+    /** @private */
+    this._unobserveCollectionProperties = this.uploadCollection.observeProperties(
+      this._handleCollectionPropertiesUpdate,
+    );
+
+    this.subConfigValue('maxConcurrentRequests', (value) => {
+      this.$['*uploadQueue'].concurrency = Number(value) || 1;
+    });
+
+    if (!this.$['*secureUploadsManager']) {
+      this.$['*secureUploadsManager'] = new SecureUploadsManager(this);
+    }
+
+    if (this.has('*modalActive')) {
+      this.sub('*modalActive', (modalActive) => {
+        if (modalActive && !this.$['*currentActivity']) {
+          this.$['*modalActive'] = false;
+        }
+      });
+    }
+  }
+
+  /**
+   * @private
+   * @param {import('../types').OutputCollectionState} collectionState
+   */
+  async _createGroup(collectionState) {
+    const uploadClientOptions = await this.getUploadClientOptions();
+    const uuidList = collectionState.allEntries.map((entry) => {
+      return entry.uuid + (entry.cdnUrlModifiers ? `/${entry.cdnUrlModifiers}` : '');
+    });
+    const abortController = new AbortController();
+    const resp = await uploadFileGroup(uuidList, { ...uploadClientOptions, signal: abortController.signal });
+    if (this.$['*collectionState'] !== collectionState) {
+      abortController.abort();
+      return;
+    }
+    this.$['*groupInfo'] = resp;
+    const collectionStateWithGroup = /** @type {import('../types').OutputCollectionState<'success', 'has-group'>} */ (
+      this.api.getOutputCollectionState()
+    );
+    this.emit(EventType.GROUP_CREATED, collectionStateWithGroup);
+    this.emit(EventType.CHANGE, () => this.api.getOutputCollectionState(), { debounce: true });
+    this.$['*collectionState'] = collectionStateWithGroup;
+  }
+
+  /** @private */
+  _flushOutputItems = debounce(async () => {
+    const data = this.getOutputData();
+    if (data.length !== this.uploadCollection.size) {
+      return;
+    }
+    const collectionState = this.api.getOutputCollectionState();
+    this.$['*collectionState'] = collectionState;
+    this.emit(EventType.CHANGE, () => this.api.getOutputCollectionState(), { debounce: true });
+
+    if (this.cfg.groupOutput && collectionState.totalCount > 0 && collectionState.status === 'success') {
+      this._createGroup(collectionState);
+    }
+  }, 300);
+
+  /**
+   * @private
+   * @type {Parameters<import('./TypedCollection.js').TypedCollection['observeCollection']>[0]}
+   * @param {Set<import('./TypedData.js').TypedData>} removed
+   */
+  _handleCollectionUpdate = (entries, added, removed) => {
+    if (added.size || removed.size) {
+      this.$['*groupInfo'] = null;
+    }
+    this.validationManager.runFileValidators();
+    this.validationManager.runCollectionValidators();
+
+    for (const entry of added) {
+      if (!entry.getValue('silent')) {
+        this.emit(EventType.FILE_ADDED, this.api.getOutputItem(entry.uid));
+      }
+    }
+
+    for (const entry of removed) {
+      /** @type {Set<string>} */ (this.$['*uploadTrigger']).delete(entry.uid);
+
+      entry.getValue('abortController')?.abort();
+      entry.setMultipleValues({
+        isRemoved: true,
+        abortController: null,
+        isUploading: false,
+        uploadProgress: 0,
+      });
+      URL.revokeObjectURL(entry?.getValue('thumbUrl'));
+      this.emit(EventType.FILE_REMOVED, this.api.getOutputItem(entry.uid));
+    }
+
+    this.$['*uploadList'] = entries.map((uid) => {
+      return { uid };
+    });
+
+    this._flushCommonUploadProgress();
+    this._flushOutputItems();
+  };
+
+  /**
+   * @private
+   * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntry, Set<string>>} changeMap
+   */
+  _handleCollectionPropertiesUpdate = (changeMap) => {
+    this._flushOutputItems();
+
+    const uploadCollection = this.uploadCollection;
+    const entriesToRunValidation = [
+      ...new Set(
+        Object.entries(changeMap)
+          .filter(([key]) => ['uploadError', 'fileInfo'].includes(key))
+          .map(([, ids]) => [...ids])
+          .flat(),
+      ),
+    ];
+
+    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);
+      });
+
+    if (changeMap.uploadProgress) {
+      for (const entryId of changeMap.uploadProgress) {
+        const { isUploading, silent } = Data.getCtx(entryId).store;
+        if (isUploading && !silent) {
+          this.emit(EventType.FILE_UPLOAD_PROGRESS, this.api.getOutputItem(entryId));
+        }
+      }
+
+      this._flushCommonUploadProgress();
+    }
+    if (changeMap.isUploading) {
+      for (const entryId of changeMap.isUploading) {
+        const { isUploading, silent } = Data.getCtx(entryId).store;
+        if (isUploading && !silent) {
+          this.emit(EventType.FILE_UPLOAD_START, this.api.getOutputItem(entryId));
+        }
+      }
+    }
+    if (changeMap.fileInfo) {
+      for (const entryId of changeMap.fileInfo) {
+        const { fileInfo, silent } = Data.getCtx(entryId).store;
+        if (fileInfo && !silent) {
+          this.emit(EventType.FILE_UPLOAD_SUCCESS, this.api.getOutputItem(entryId));
+        }
+      }
+      if (this.cfg.cropPreset) {
+        this.setInitialCrop();
+      }
+    }
+    if (changeMap.errors) {
+      for (const entryId of changeMap.errors) {
+        const { errors } = Data.getCtx(entryId).store;
+        if (errors.length > 0) {
+          this.emit(EventType.FILE_UPLOAD_FAILED, this.api.getOutputItem(entryId));
+          this.emit(
+            EventType.COMMON_UPLOAD_FAILED,
+            () =>
+              /** @type {import('../types').OutputCollectionState<'failed'>} */ (this.api.getOutputCollectionState()),
+            { debounce: true },
+          );
+        }
+      }
+      const loadedItems = uploadCollection.findItems((entry) => {
+        return !!entry.getValue('fileInfo');
+      });
+      const errorItems = uploadCollection.findItems((entry) => {
+        return entry.getValue('errors').length > 0;
+      });
+      if (
+          uploadCollection.size > 0 &&
+          errorItems.length === 0 &&
+          uploadCollection.size === loadedItems.length &&
+          this.$['*collectionErrors'].length === 0
+      ) {
+        this.emit(
+          EventType.COMMON_UPLOAD_SUCCESS,
+          /** @type {import('../types').OutputCollectionState<'success'>} */ (this.api.getOutputCollectionState()),
+        );
+      }
+    }
+    if (changeMap.cdnUrl) {
+      const uids = [...changeMap.cdnUrl].filter((uid) => {
+        return !!this.uploadCollection.read(uid)?.getValue('cdnUrl');
+      });
+      uids.forEach((uid) => {
+        this.emit(EventType.FILE_URL_CHANGED, this.api.getOutputItem(uid));
+      });
+
+      this.$['*groupInfo'] = null;
+    }
+  };
+
+  /** @private */
+  _flushCommonUploadProgress = () => {
+    let commonProgress = 0;
+    /** @type {Set<string>} */
+    const uploadTrigger = this.$['*uploadTrigger'];
+    const items = [...uploadTrigger].filter((id) => !!this.uploadCollection.read(id));
+    items.forEach((id) => {
+      const uploadProgress = this.uploadCollection.readProp(id, 'uploadProgress');
+      commonProgress += uploadProgress;
+    });
+    const progress = items.length ? Math.round(commonProgress / items.length) : 0;
+
+    if (this.$['*commonProgress'] === progress) {
+      return;
+    }
+
+    this.$['*commonProgress'] = progress;
+    this.emit(
+      EventType.COMMON_UPLOAD_PROGRESS,
+      /** @type {import('../types').OutputCollectionState<'uploading'>} */ (this.api.getOutputCollectionState()),
+    );
+  };
+
+  /** @private */
+  setInitialCrop() {
+    const cropPreset = parseCropPreset(this.cfg.cropPreset);
+    if (cropPreset) {
+      const [aspectRatioPreset] = cropPreset;
+
+      const entries = this.uploadCollection
+        .findItems(
+          (entry) =>
+            entry.getValue('fileInfo') &&
+            entry.getValue('isImage') &&
+            !entry.getValue('cdnUrlModifiers')?.includes('/crop/'),
+        )
+        .map((id) => this.uploadCollection.read(id));
+
+      for (const entry of entries) {
+        const fileInfo = entry.getValue('fileInfo');
+        const { width, height } = fileInfo.imageInfo;
+        const expectedAspectRatio = aspectRatioPreset.width / aspectRatioPreset.height;
+        const crop = calculateMaxCenteredCropFrame(width, height, expectedAspectRatio);
+        const cdnUrlModifiers = createCdnUrlModifiers(
+          `crop/${crop.width}x${crop.height}/${crop.x},${crop.y}`,
+          'preview',
+        );
+        entry.setMultipleValues({
+          cdnUrlModifiers,
+          cdnUrl: createCdnUrl(entry.getValue('cdnUrl'), cdnUrlModifiers),
+        });
+        if (
+          this.uploadCollection.size === 1 &&
+          this.cfg.useCloudImageEditor &&
+          this.hasBlockInCtx((block) => block.activityType === ActivityBlock.activities.CLOUD_IMG_EDIT)
+        ) {
+          this.$['*focusedEntry'] = entry;
+          this.$['*currentActivity'] = ActivityBlock.activities.CLOUD_IMG_EDIT;
+        }
+      }
+    }
+  }
+
+  /**
+   * @param {string} entryId
+   * @protected
+   */
+  async getMetadataFor(entryId) {
+    const configValue = this.cfg.metadata || undefined;
+    if (typeof configValue === 'function') {
+      const outputFileEntry = this.api.getOutputItem(entryId);
+      const metadata = await configValue(outputFileEntry);
+      return metadata;
+    }
+    return configValue;
+  }
+
+  /**
+   * @returns {Promise<import('@uploadcare/upload-client').FileFromOptions>}
+   * @protected
+   */
+  async getUploadClientOptions() {
+    /** @type {SecureUploadsManager} */
+    const secureUploadsManager = this.$['*secureUploadsManager'];
+    const secureToken = await secureUploadsManager.getSecureToken().catch(() => null);
+
+    let options = {
+      store: this.cfg.store,
+      publicKey: this.cfg.pubkey,
+      baseCDN: this.cfg.cdnCname,
+      baseURL: this.cfg.baseUrl,
+      userAgent: customUserAgent,
+      integration: this.cfg.userAgentIntegration,
+      secureSignature: secureToken?.secureSignature,
+      secureExpire: secureToken?.secureExpire,
+      retryThrottledRequestMaxTimes: this.cfg.retryThrottledRequestMaxTimes,
+      multipartMinFileSize: this.cfg.multipartMinFileSize,
+      multipartChunkSize: this.cfg.multipartChunkSize,
+      maxConcurrentRequests: this.cfg.multipartMaxConcurrentRequests,
+      multipartMaxAttempts: this.cfg.multipartMaxAttempts,
+      checkForUrlDuplicates: !!this.cfg.checkForUrlDuplicates,
+      saveUrlForRecurrentUploads: !!this.cfg.saveUrlForRecurrentUploads,
+    };
+
+    return options;
+  }
+
+  /** @returns {import('../types/exported.js').OutputFileEntry[]} */
+  getOutputData() {
+    const entriesIds = this.uploadCollection.items();
+    const data = entriesIds.map((itemId) => this.api.getOutputItem(itemId));
+    return data;
+  }
+}
+
+/** @enum {String} */
+UploaderBlock.extSrcList = Object.freeze({
+  FACEBOOK: 'facebook',
+  DROPBOX: 'dropbox',
+  GDRIVE: 'gdrive',
+  GPHOTOS: 'gphotos',
+  INSTAGRAM: 'instagram',
+  FLICKR: 'flickr',
+  VK: 'vk',
+  EVERNOTE: 'evernote',
+  BOX: 'box',
+  ONEDRIVE: 'onedrive',
+  HUDDLE: 'huddle',
+});
+
+/** @enum {String} */
+UploaderBlock.sourceTypes = Object.freeze({
+  LOCAL: 'local',
+  URL: 'url',
+  CAMERA: 'camera',
+  DRAW: 'draw',
+  ...UploaderBlock.extSrcList,
+});

package/abstract/UploaderPublicApi.d.ts

@@ -0,0 +1,90 @@
+export class UploaderPublicApi {
+    /** @param {import('./UploaderBlock.js').UploaderBlock} ctx */
+    constructor(ctx: import('./UploaderBlock.js').UploaderBlock);
+    /**
+     * @private
+     * @type {import('./UploaderBlock.js').UploaderBlock}
+     */
+    private _ctx;
+    /** @private */
+    private get _uploadCollection();
+    get cfg(): import("../types").ConfigType;
+    get l10n(): (str: string, variables?: {
+        [key: string]: string | number;
+    }) => string;
+    /**
+     * TODO: Probably we should not allow user to override `source` property
+     *
+     * @param {string} url
+     * @param {{ silent?: boolean; fileName?: string; source?: string }} [options]
+     * @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'>;
+    /**
+     * @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'>;
+    /**
+     * @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'>;
+    /**
+     * @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'>;
+    /** @param {string} internalId */
+    removeFileByInternalId: (internalId: string) => void;
+    removeAllFiles(): void;
+    uploadAll: () => void;
+    /** @param {{ captureCamera?: boolean }} options */
+    openSystemDialog: (options?: {
+        captureCamera?: boolean;
+    }) => 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>;
+    /** @template {import('../types').OutputCollectionStatus} TStatus */
+    getOutputCollectionState: <TStatus_1 extends import("../types").OutputCollectionStatus>() => import("../types").OutputCollectionState<TStatus_1, "maybe-has-group">;
+    /** @param {Boolean} [force] */
+    initFlow: (force?: boolean | undefined) => void;
+    doneFlow: () => void;
+    /**
+     * @param {import('./ActivityBlock.js').ActivityType} activityType
+     * @param {import('../blocks/ExternalSource/ExternalSource.js').ActivityParams | {}} [params]
+     */
+    setCurrentActivity: (activityType: import('./ActivityBlock.js').ActivityType, params?: {} | import("../blocks/ExternalSource/ExternalSource.js").ActivityParams | undefined) => void;
+    /** @param {boolean} opened */
+    setModalState: (opened: boolean) => void;
+    /**
+     * @private
+     * @type {string[]}
+     */
+    private get _sourceList();
+}
+//# sourceMappingURL=UploaderPublicApi.d.ts.map

package/abstract/UploaderPublicApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploaderPublicApi.d.ts","sourceRoot":"","sources":["UploaderPublicApi.js"],"names":[],"mappings":"AAYA;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,mDAAmD;IACnD,6BADY;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,UAgCrC;IAEF;;;;OAIG;IACH,8EAHW,MAAM,iDA6Cf;IAEF,oEAAoE;IACpE,oKAIE;IAEF,+BAA+B;IAC/B,gDAsCE;IAEF,qBAQE;IAEF;;;OAGG;IACH,mCAHW,OAAO,oBAAoB,EAAE,YAAY,yGAYlD;IAEF,8BAA8B;IAC9B,wBADY,OAAO,UAOjB;IAEF;;;OAGG;IACH,0BAOC;CACF"}