@uploadcare/file-uploader 1.17.0-alpha.2 → 1.17.0-alpha.3

package/abstract/TypedData.d.ts.map

@@ -0,0 +1 @@
+{"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/UploaderBlock.d.ts

@@ -0,0 +1,117 @@
+export class UploaderBlock extends ActivityBlock {
+    /** @protected */
+    protected couldBeCtxOwner: boolean;
+    /** @private */
+    private isCtxOwner;
+    init$: {
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*uploadQueue': import("@uploadcare/upload-client").Queue;
+        '*collectionErrors': ReturnType<import("../types").OutputErrorCollection>[];
+        '*collectionState': import("../types").OutputCollectionState | null;
+        '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
+        '*uploadTrigger': Set<string>;
+        '*secureUploadsManager': import("./SecureUploadsManager.js").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<typeof uploadEntrySchema>} */
+    get uploadCollection(): TypedCollection<typeof uploadEntrySchema>;
+    /** @private */
+    private initCtxOwner;
+    /** @private */
+    private _unobserveCollection;
+    /** @private */
+    private _unobserveCollectionProperties;
+    /**
+     * @private
+     * @param {import('../types').OutputCollectionState} collectionState
+     */
+    private _createGroup;
+    /** @private */
+    private _flushOutputItems;
+    /**
+     * @private
+     * @type {import('./TypedCollection.js').TypedCollectionObserverHandler<typeof uploadEntrySchema>}
+     */
+    private _handleCollectionUpdate;
+    /**
+     * @private
+     * @param {Record<keyof import('./uploadEntrySchema.js').UploadEntryData, Set<string>>} changeMap
+     */
+    private _handleCollectionPropertiesUpdate;
+    /** @private */
+    private _flushCommonUploadProgress;
+    openCloudImageEditor(): void;
+    /** @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: "ngdrive";
+        GPHOTOS: "gphotos";
+        FLICKR: "flickr";
+        VK: "vk";
+        EVERNOTE: "evernote";
+        BOX: "box";
+        ONEDRIVE: "onedrive";
+        HUDDLE: "huddle";
+    }>;
+    type sourceTypes = string;
+    let sourceTypes: Readonly<{
+        FACEBOOK: "facebook";
+        DROPBOX: "dropbox";
+        GDRIVE: "ngdrive";
+        GPHOTOS: "gphotos";
+        FLICKR: "flickr";
+        VK: "vk";
+        EVERNOTE: "evernote";
+        BOX: "box";
+        ONEDRIVE: "onedrive";
+        HUDDLE: "huddle";
+        MOBILE_VIDEO_CAMERA: "mobile-video-camera";
+        MOBILE_PHOTO_CAMERA: "mobile-photo-camera";
+        LOCAL: "local";
+        DROP_AREA: "drop-area";
+        CAMERA: "camera";
+        EXTERNAL: "external";
+        API: "js-api";
+        URL: "url";
+        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';
+import { uploadEntrySchema } from './uploadEntrySchema.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":"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;IAkBD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAvc6B,oBAAoB;qCAWb,2BAA2B;kCAG9B,wBAAwB;kCADxB,wBAAwB;gCAD1B,sBAAsB;kCAGpB,wBAAwB"}

package/abstract/UploaderPublicApi.d.ts

@@ -0,0 +1,100 @@
+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;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
+    /**
+     * @param {string} uuid
+     * @param {{ silent?: boolean; fileName?: string; source?: string }} [options]
+     * @returns {import('../types').OutputFileEntry<'idle'>}
+     */
+    addFileFromUuid: (uuid: string, { silent, fileName, source }?: {
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
+    /**
+     * @param {string} cdnUrl
+     * @param {{ silent?: boolean; fileName?: string; source?: string }} [options]
+     * @returns {import('../types').OutputFileEntry<'idle'>}
+     */
+    addFileFromCdnUrl: (cdnUrl: string, { silent, fileName, source }?: {
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
+    /**
+     * @param {File} file
+     * @param {{ silent?: boolean; fileName?: string; source?: string; fullPath?: string }} [options]
+     * @returns {import('../types').OutputFileEntry<'idle'>}
+     */
+    addFileFromObject: (file: File, { silent, fileName, source, fullPath }?: {
+        silent?: boolean;
+        fileName?: string;
+        source?: string;
+        fullPath?: string;
+    }) => import("../types").OutputFileEntry<"idle">;
+    /** @param {string} internalId */
+    removeFileByInternalId: (internalId: string) => void;
+    removeAllFiles(): void;
+    uploadAll: () => void;
+    /** @param {{ captureCamera?: boolean; modeCamera?: import('../blocks/CameraSource/constants.js').ModeCameraType }} options */
+    openSystemDialog: (options?: {
+        captureCamera?: boolean;
+        modeCamera?: import("../blocks/CameraSource/constants.js").ModeCameraType;
+    }) => void;
+    /**
+     * @template {import('../types').OutputFileStatus} TStatus
+     * @param {string} entryId
+     * @returns {import('../types/exported.js').OutputFileEntry<TStatus>}
+     */
+    getOutputItem: (entryId: string) => import("../types/exported.js").OutputFileEntry<TStatus>;
+    /** @template {import('../types').OutputCollectionStatus} TStatus */
+    getOutputCollectionState: () => ReturnType<typeof buildOutputCollectionState<TStatus>>;
+    /** @param {Boolean} [force] */
+    initFlow: (force?: boolean) => void;
+    doneFlow: () => void;
+    /**
+     * @type {<T extends import('./ActivityBlock.js').ActivityType>(
+     *   activityType: T,
+     *   ...params: T extends keyof import('./ActivityBlock.js').ActivityParamsMap
+     *     ? [import('./ActivityBlock.js').ActivityParamsMap[T]]
+     *     : T extends import('./ActivityBlock.js').RegisteredActivityType
+     *       ? [undefined?]
+     *       : [any?]
+     * ) => void}
+     */
+    setCurrentActivity: <T extends import("./ActivityBlock.js").ActivityType>(activityType: T, ...params: T extends keyof import("./ActivityBlock.js").ActivityParamsMap ? [import("./ActivityBlock.js").ActivityParamsMap[T]] : T extends import("./ActivityBlock.js").RegisteredActivityType ? [undefined?] : [any?]) => void;
+    /** @returns {import('./ActivityBlock.js').ActivityType} */
+    getCurrentActivity: () => import("./ActivityBlock.js").ActivityType;
+    /** @param {boolean} opened */
+    setModalState: (opened: boolean) => void;
+    /**
+     * @private
+     * @type {string[]}
+     */
+    private get _sourceList();
+}
+import { buildOutputCollectionState } from './buildOutputCollectionState.js';
+//# 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":"AAqBA;IAOE,8DAA8D;IAC9D,iBADY,OAAO,oBAAoB,EAAE,aAAa,EAGrD;IATD;;;OAGG;IACH,aAAK;IAOL,eAAe;IACf,gCAEC;IAED,yCAEC;IAED;;iBAEC;IAED;;;;;;OAMG;IACH,iBAAkB,KAJP,MAIU,EAAE,+BAHZ;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGT,KAF3C,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,kBAAmB,MAJR,MAIY,EAAE,+BAHd;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGP,KAF7C,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAUrD;IAEF;;;;OAIG;IACH,oBAAqB,QAJV,MAIgB,EAAE,+BAHlB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAGH,KAFjD,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAgBrD;IAEF;;;;OAIG;IACH,oBAAqB,MAJV,IAIc,EAAE,yCAHhB;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAGd,KAFzD,OAAO,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAcrD;IAEF,iCAAiC;IACjC,yBAA0B,YADd,MACwB,UAKlC;IAEF,uBAEC;IAED,sBAgBE;IAEF,8HAA8H;IAC9H,mBAAoB,UADR;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,qCAAqC,EAAE,cAAc,CAAA;KAChF,UA0D9B;IAEF;;;;OAIG;IACH,gBAAiB,SAHN,MAGa,KAFX,OAAO,sBAAsB,EAAE,eAAe,CAAC,OAAO,CAAC,CA+ClE;IAEF,oEAAoE;IACpE,gCACoB,UAAU,CAAC,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAGxE;IAEF,+BAA+B;IAC/B,WAAY,eAAa,UA6DvB;IAEF,qBAQE;IAEF;;;;;;;;;OASG;IACH,oBATU,CAAC,CAAC,SAAS,OAAO,oBAAoB,EAAE,YAAY,EACzD,YAAY,EAAE,CAAC,EACnB,GAAO,MAAM,EAAE,CAAC,SAAS,MAAM,OAAO,oBAAoB,EAAE,iBAAiB,GACrE,CAAC,OAAO,oBAAoB,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACnD,CAAC,SAAS,OAAO,oBAAoB,EAAE,sBAAsB,GAC3D,CAAC,SAAS,CAAC,CAAC,GACZ,CAAC,GAAG,CAAC,CAAC,KACT,IAAI,CAWV;IAEF,2DAA2D;IAC3D,0BADc,OAAO,oBAAoB,EAAE,YAAY,CAGrD;IAEF,8BAA8B;IAC9B,gBAAiB,QADL,OACW,UAYrB;IAEF;;;OAGG;IACH,0BAOC;CACF;2CAxX0C,iCAAiC"}

package/abstract/ValidationManager.d.ts

@@ -0,0 +1,150 @@
+export class ValidationManager {
+    /** @param {import('./UploaderBlock.js').UploaderBlock} blockInstance */
+    constructor(blockInstance: import("./UploaderBlock.js").UploaderBlock);
+    /**
+     * @private
+     * @type {import('./UploaderBlock.js').UploaderBlock}
+     */
+    private _blockInstance;
+    /** @type {FuncFileValidator[]} */
+    _fileValidators: FuncFileValidator[];
+    /** @type {FuncCollectionValidator[]} */
+    _collectionValidators: FuncCollectionValidator[];
+    _uploadCollection: import("./TypedCollection.js").TypedCollection<Readonly<{
+        file: Readonly<{
+            type: {
+                new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+                prototype: File;
+            };
+            value: null;
+            nullable: true;
+        }>;
+        externalUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileName: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileSize: Readonly<{
+            type: NumberConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        lastModified: Readonly<{
+            type: NumberConstructor;
+            value: number;
+        }>;
+        uploadProgress: Readonly<{
+            type: NumberConstructor;
+            value: 0;
+        }>;
+        uuid: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        isImage: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        mimeType: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        ctxName: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        cdnUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        cdnUrlModifiers: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fileInfo: Readonly<{
+            type: typeof import("@uploadcare/upload-client").UploadcareFile;
+            value: null;
+            nullable: true;
+        }>;
+        isUploading: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        abortController: Readonly<{
+            type: {
+                new (): AbortController;
+                prototype: AbortController;
+            };
+            value: null;
+            nullable: true;
+        }>;
+        thumbUrl: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        silent: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        source: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        fullPath: Readonly<{
+            type: StringConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        metadata: Readonly<{
+            type: ObjectConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        errors: Readonly<{
+            type: ArrayConstructor;
+            value: Error[];
+        }>;
+        uploadError: Readonly<{
+            type: ErrorConstructor;
+            value: null;
+            nullable: true;
+        }>;
+        isRemoved: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+        isQueued: Readonly<{
+            type: BooleanConstructor;
+            value: false;
+        }>;
+    }>>;
+    /** @param {string[]} [entryIds] */
+    runFileValidators(entryIds?: string[]): void;
+    runCollectionValidators(): void;
+    /**
+     * @private
+     * @param {import('./TypedData.js').TypedData<typeof import('./uploadEntrySchema.js').uploadEntrySchema>} entry
+     */
+    private _runFileValidatorsForEntry;
+    /**
+     * @template T
+     * @param {T[]} validators
+     * @returns {T[]}
+     */
+    _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;
+//# sourceMappingURL=ValidationManager.d.ts.map

package/abstract/ValidationManager.d.ts.map

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

package/abstract/a11y.d.ts

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

package/abstract/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,gDAAgD;IAChD,qBADY,OAAO,YAAY,EAAE,KAAK,QAGrC;IAED,gBAGC;CACF;;;;4BA/GY,UAAU,CAAC,OAAO,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC"}

package/abstract/buildOutputCollectionState.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @template {import('../index.js').OutputCollectionStatus} TCollectionStatus
+ * @template {import('../index.js').GroupFlag} [TGroupFlag='maybe-has-group'] Default is `'maybe-has-group'`
+ * @param {import('./UploaderBlock.js').UploaderBlock} uploaderBlock
+ * @returns {import('../index.js').OutputCollectionState<TCollectionStatus, TGroupFlag>}
+ */
+export function buildOutputCollectionState<TCollectionStatus extends import("../index.js").OutputCollectionStatus, TGroupFlag extends import("../index.js").GroupFlag = "maybe-has-group">(uploaderBlock: import("./UploaderBlock.js").UploaderBlock): import("../index.js").OutputCollectionState<TCollectionStatus, TGroupFlag>;
+//# sourceMappingURL=buildOutputCollectionState.d.ts.map

package/abstract/buildOutputCollectionState.d.ts.map

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

package/abstract/defineComponents.d.ts

@@ -0,0 +1,5 @@
+/** @param {Object<string, any>} blockExports */
+export function defineComponents(blockExports: {
+    [x: string]: any;
+}): void;
+//# sourceMappingURL=defineComponents.d.ts.map

package/abstract/defineComponents.d.ts.map

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

package/abstract/l10nProcessor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @template {import('./Block.js').Block} T
+ * @param {DocumentFragment} fr
+ * @param {T} fnCtx
+ */
+export function l10nProcessor<T extends import("./Block.js").Block>(fr: DocumentFragment, fnCtx: T): void;
+//# sourceMappingURL=l10nProcessor.d.ts.map

package/abstract/l10nProcessor.d.ts.map

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

package/abstract/loadFileUploaderFrom.d.ts

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

package/abstract/loadFileUploaderFrom.d.ts.map

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

package/abstract/localeRegistry.d.ts

@@ -0,0 +1,5 @@
+export function defineLocale(localeName: string, definitionOrResolver: LocaleDefinition | LocaleDefinitionResolver): void;
+export function resolveLocaleDefinition(localeName: string): Promise<LocaleDefinition>;
+export type LocaleDefinition = Record<string, string>;
+export type LocaleDefinitionResolver = () => Promise<LocaleDefinition>;
+//# sourceMappingURL=localeRegistry.d.ts.map

package/abstract/localeRegistry.d.ts.map

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

package/abstract/sharedConfigKey.d.ts

@@ -0,0 +1,2 @@
+export function sharedConfigKey<T extends keyof import("../types").ConfigType>(key: T): `*cfg/${T}`;
+//# sourceMappingURL=sharedConfigKey.d.ts.map

package/abstract/sharedConfigKey.d.ts.map

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

package/abstract/testModeProcessor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @template {import('./Block.js').Block} T
+ * @param {DocumentFragment} fr
+ * @param {T} fnCtx
+ */
+export function testModeProcessor<T extends import("./Block.js").Block>(fr: DocumentFragment, fnCtx: T): void;
+//# sourceMappingURL=testModeProcessor.d.ts.map

package/abstract/testModeProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testModeProcessor.d.ts","sourceRoot":"","sources":["testModeProcessor.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,kCAJ0C,CAAC,SAA9B,OAAQ,YAAY,EAAE,KAAM,MAC9B,gBAAgB,SAChB,CAAC,QAiCX"}

package/abstract/uploadEntrySchema.d.ts

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

package/abstract/uploadEntrySchema.d.ts.map

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

package/blocks/ActivityHeader/ActivityHeader.d.ts

@@ -0,0 +1,4 @@
+export class ActivityHeader extends ActivityBlock {
+}
+import { ActivityBlock } from '../../abstract/ActivityBlock.js';
+//# sourceMappingURL=ActivityHeader.d.ts.map

package/blocks/ActivityHeader/ActivityHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityHeader.d.ts","sourceRoot":"","sources":["ActivityHeader.js"],"names":[],"mappings":"AAEA;CAAoD;8BAFtB,iCAAiC"}