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

package/abstract/ActivityBlock.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @typedef {{
+ *   'cloud-image-edit': import('../blocks/CloudImageEditorActivity/CloudImageEditorActivity.js').ActivityParams;
+ *   external: import('../blocks/ExternalSource/ExternalSource.js').ActivityParams;
+ * }} ActivityParamsMap
+ */
+export class ActivityBlock extends Block {
+    /**
+     * @private
+     * @type {Map<
+     *   ActivityBlock,
+     *   { activateCallback: (() => void) | undefined; deactivateCallback: (() => void) | undefined }
+     * >}
+     */
+    private static _activityCallbacks;
+    /** @protected */
+    protected historyTracked: boolean;
+    init$: {
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    _debouncedHistoryFlush: (() => void) & {
+        cancel: () => void;
+    };
+    /** @private */
+    private _deactivate;
+    /** @private */
+    private _activate;
+    /** @private */
+    private _historyFlush;
+    /** @private */
+    private _isActivityRegistered;
+    get isActivityActive(): boolean | undefined;
+    get couldOpenActivity(): boolean;
+    /**
+     * TODO: remove name argument
+     *
+     * @param {String} name
+     * @param {Object} [options]
+     * @param {() => void} [options.onActivate]
+     * @param {() => void} [options.onDeactivate]
+     */
+    registerActivity(name: string, options?: {
+        onActivate?: (() => void) | undefined;
+        onDeactivate?: (() => void) | undefined;
+    }): void;
+    unregisterActivity(): void;
+    get activityKey(): string;
+    /** @type {ActivityParamsMap[keyof ActivityParamsMap]} */
+    get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
+    /** @type {String} */
+    get initActivity(): string;
+    /** @type {String} */
+    get doneActivity(): string;
+    historyBack(): void;
+    ___ACTIVITY_IS_ACTIVE___: boolean | undefined;
+}
+export namespace ActivityBlock {
+    let activities: Readonly<{
+        START_FROM: "start-from";
+        CAMERA: "camera";
+        DRAW: "draw";
+        UPLOAD_LIST: "upload-list";
+        URL: "url";
+        CLOUD_IMG_EDIT: "cloud-image-edit";
+        EXTERNAL: "external";
+    }>;
+}
+export type ActivityParamsMap = {
+    "cloud-image-edit": import("../blocks/CloudImageEditorActivity/CloudImageEditorActivity.js").ActivityParams;
+    external: import("../blocks/ExternalSource/ExternalSource.js").ActivityParams;
+};
+export type RegisteredActivityType = (typeof ActivityBlock)["activities"][keyof (typeof ActivityBlock)["activities"]];
+export type ActivityType = RegisteredActivityType | (string & {}) | null;
+import { Block } from './Block.js';
+//# sourceMappingURL=ActivityBlock.d.ts.map

package/abstract/ActivityBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityBlock.d.ts","sourceRoot":"","sources":["ActivityBlock.js"],"names":[],"mappings":"AASA;;;;;GAKG;AAEH;IA+EE;;;;;;OAMG;IACH,kCAAsC;IArFtC,iBAAiB;IACjB,kCAAuB;IAEvB;;;;;;MAA+B;IAE/B;;MAAqE;IAErE,eAAe;IACf,oBAKC;IAED,eAAe;IACf,kBAaC;IA8BD,eAAe;IACf,sBAWC;IAED,eAAe;IACf,8BAEC;IAWD,4CAEC;IAED,iCAEC;IAED;;;;;;;OAOG;IACH,yCAHG;QAA6B,UAAU,UAAzB,IAAI;QACW,YAAY,UAA3B,IAAI;KAAwB,QAQ5C;IAED,2BAKC;IAoBD,0BAEC;IAED,yDAAyD;IACzD,sBADW,iBAAiB,CAAC,MAAM,iBAAiB,CAAC,CAGpD;IAED,qBAAqB;IACrB,2BAEC;IAED,qBAAqB;IACrB,2BAEC;IAED,oBA4BC;IA7KC,8CAAyB;CA8K5B;;;;;;;;;;;;gCA/LY;IACZ,kBAAsB,EAAE,OAAO,gEAAgE,EAAE,cAAc,CAAC;IAC5G,QAAQ,EAAE,OAAO,4CAA4C,EAAE,cAAc,CAAC;CAC/E;qCAwMU,CAAC,OAAO,aAAa,EAAE,YAAY,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,EAAE,YAAY,CAAC,CAAC;2BAChF,sBAAsB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI;sBAnNrC,YAAY"}

package/abstract/Block.d.ts

@@ -0,0 +1,102 @@
+export class Block extends BaseComponent<any> {
+    /** @type {string | null} */
+    static StateConsumerScope: string | null;
+    /** @type {string[]} */
+    static styleAttrs: string[];
+    /** @param {String} [name] */
+    static reg(name?: string): void;
+    constructor();
+    /** @protected */
+    protected requireCtxName: boolean;
+    /** @type {import('./ActivityBlock.js').ActivityType} */
+    activityType: import("./ActivityBlock.js").ActivityType;
+    init$: {};
+    /**
+     * @param {String} str
+     * @param {{ [key: string]: string | number }} variables
+     * @returns {String}
+     */
+    l10n(str: string, variables?: {
+        [key: string]: string | number;
+    }): string;
+    /**
+     * @private
+     * @param {string} key
+     * @param {number} count
+     * @returns {string}
+     */
+    private pluralize;
+    /**
+     * @param {string} key
+     * @param {() => void} resolver
+     * @protected
+     */
+    protected bindL10n(key: string, resolver: () => void): void;
+    /** @type {Map<string, Set<{ remove: () => void }>>} */
+    l10nProcessorSubs: Map<string, Set<{
+        remove: () => void;
+    }>>;
+    /**
+     * @param {Parameters<import('../blocks/UploadCtxProvider/EventEmitter.js').EventEmitter['emit']>[0]} type
+     * @param {Parameters<import('../blocks/UploadCtxProvider/EventEmitter.js').EventEmitter['emit']>[1]} [payload]
+     * @param {Parameters<import('../blocks/UploadCtxProvider/EventEmitter.js').EventEmitter['emit']>[2]} [options]
+     */
+    emit(type: Parameters<import("../blocks/UploadCtxProvider/EventEmitter.js").EventEmitter["emit"]>[0], payload?: Parameters<import("../blocks/UploadCtxProvider/EventEmitter.js").EventEmitter["emit"]>[1], options?: Parameters<import("../blocks/UploadCtxProvider/EventEmitter.js").EventEmitter["emit"]>[2]): void;
+    /**
+     * @param {(block: Block) => boolean} callback
+     * @returns {Boolean}
+     */
+    hasBlockInCtx(callback: (block: Block) => boolean): boolean;
+    /**
+     * @param {String} prop
+     * @param {any} newVal
+     */
+    setOrAddState(prop: string, newVal: any): void;
+    get testId(): string | null;
+    /**
+     * @returns {ModalManager}
+     * @public
+     */
+    public get modalManager(): ModalManager;
+    /**
+     * @private
+     * @returns {LocaleManager | null}
+     */
+    private get localeManager();
+    /**
+     * @returns {A11y | null}
+     * @protected
+     */
+    protected get a11y(): A11y | null;
+    /** @type {Set<Block>} */
+    get blocksRegistry(): Set<Block>;
+    /**
+     * Called when the last block is removed from the context. Note that inheritors must run their callback before that.
+     *
+     * @protected
+     */
+    protected destroyCtxCallback(): void;
+    /**
+     * @param {String} url
+     * @returns {Promise<String>}
+     * @protected
+     */
+    protected proxyUrl(url: string): Promise<string>;
+    /** @returns {import('../types').ConfigType} } */
+    get cfg(): import("../types").ConfigType;
+    /** @private */
+    private __cfgProxy;
+    /**
+     * @template {keyof import('../types').ConfigType} T
+     * @param {T} key
+     * @param {(value: import('../types').ConfigType[T]) => void} callback
+     */
+    subConfigValue<T extends keyof import("../types").ConfigType>(key: T, callback: (value: import("../types").ConfigType[T]) => void): void;
+    /** @param {unknown[]} args */
+    debugPrint(...args: unknown[]): void;
+}
+export { BaseComponent };
+import { BaseComponent } from '@symbiotejs/symbiote';
+import { ModalManager } from './ModalManager.js';
+import { A11y } from './a11y.js';
+//# sourceMappingURL=Block.d.ts.map

package/abstract/Block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["Block.js"],"names":[],"mappings":"AAqBA;IACE,4BAA4B;IAC5B,2BADW,MAAM,GAAG,IAAI,CACS;IAEjC,uBAAuB;IACvB,mBADW,MAAM,EAAE,CACI;IAmVvB,6BAA6B;IAC7B,gCAQC;IAxSD,cAQC;IA1DD,iBAAiB;IACjB,kCAAuB;IAEvB,wDAAwD;IACxD,cADW,OAAO,oBAAoB,EAAE,YAAY,CAChC;IAEpB,UAAmB;IAEnB;;;;OAIG;IACH,8BAHW;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;KAAE,UAiB5C;IAED;;;;;OAKG;IACH,kBAIC;IAED;;;;OAIG;IACH,wBAJW,MAAM,YACN,MAAM,IAAI,QAKpB;IAIC,uDAAuD;IACvD,mBADW,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC;QAAE,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC,CAAC,CACjB;IAOpC;;;;OAIG;IACH,WAJW,UAAU,CAAC,OAAO,6CAA6C,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,YACzF,UAAU,CAAC,OAAO,6CAA6C,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,YACzF,UAAU,CAAC,OAAO,6CAA6C,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QASnG;IAED;;;OAGG;IACH,wBAHW,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,WAUnC;IAED;;;OAGG;IACH,oCAFW,GAAG,QASb;IA8ED,4BAGC;IAED;;;OAGG;IACH,2BAHa,YAAY,CAKxB;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,sBAHa,IAAI,GAAG,IAAI,CAKvB;IAED,yBAAyB;IACzB,sBADW,GAAG,CAAC,KAAK,CAAC,CAGpB;IAwBD;;;;OAIG;IACH,qCAMC;IAED;;;;OAIG;IACH,iCAHa,OAAO,QAAQ,CA6B3B;IAED,iDAAiD;IACjD,WADc,OAAO,UAAU,EAAE,UAAU,CA+B1C;IA3BG,eAAe;IACf,mBAuBE;IAKN;;;;OAIG;IACH,eAJmD,CAAC,SAAvC,MAAO,OAAO,UAAU,EAAE,UAAW,OACvC,CAAC,YACD,CAAC,KAAK,EAAE,OAAO,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,QAQ3D;IAED,8BAA8B;IAC9B,oBADY,OAAO,EAAE,QAWpB;CAYF;;8BAtXmC,sBAAsB;6BAc7B,mBAAmB;qBAD3B,WAAW"}

package/abstract/CTX.d.ts

@@ -0,0 +1,30 @@
+export function blockCtx(): {};
+export function activityBlockCtx(fnCtx: import("./Block").Block): {
+    '*currentActivity': null;
+    '*currentActivityParams': {};
+    '*history': never[];
+    '*historyBack': null;
+    '*closeModal': () => void;
+};
+export function uploaderBlockCtx(fnCtx: import("./Block").Block): {
+    '*commonProgress': number;
+    '*uploadList': never[];
+    '*uploadQueue': Queue;
+    /** @type {ReturnType<import('../types').OutputErrorCollection>[]} */
+    '*collectionErrors': ReturnType<import("../types").OutputErrorCollection>[];
+    /** @type {import('../types').OutputCollectionState | null} */
+    '*collectionState': import("../types").OutputCollectionState | null;
+    /** @type {import('@uploadcare/upload-client').UploadcareGroup | null} */
+    '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
+    /** @type {Set<string>} */
+    '*uploadTrigger': Set<string>;
+    /** @type {import('./SecureUploadsManager.js').SecureUploadsManager | null} */
+    '*secureUploadsManager': import("./SecureUploadsManager.js").SecureUploadsManager | null;
+    '*currentActivity': null;
+    '*currentActivityParams': {};
+    '*history': never[];
+    '*historyBack': null;
+    '*closeModal': () => void;
+};
+import { Queue } from '@uploadcare/upload-client';
+//# sourceMappingURL=CTX.d.ts.map

package/abstract/CTX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CTX.d.ts","sourceRoot":"","sources":["CTX.js"],"names":[],"mappings":"AAGO,+BAA2B;AAG3B,wCADK,OAAO,SAAS,EAAE,KAAK;;;;;;EAejC;AAGK,wCADK,OAAO,SAAS,EAAE,KAAK;;;;IAMjC,qEAAqE;yBAA1D,UAAU,CAAC,OAAO,UAAU,EAAE,qBAAqB,CAAC,EAAE;IAEjE,8DAA8D;wBAAnD,OAAO,UAAU,EAAE,qBAAqB,GAAG,IAAI;IAE1D,yEAAyE;kBAA9D,OAAO,2BAA2B,EAAE,eAAe,GAAG,IAAI;IAErE,0BAA0B;sBAAf,GAAG,CAAC,MAAM,CAAC;IAEtB,8EAA8E;6BAAnE,OAAO,2BAA2B,EAAE,oBAAoB,GAAG,IAAI;;;;;;EAE1E;sBArCoB,2BAA2B"}

package/abstract/LocaleManager.d.ts

@@ -0,0 +1,38 @@
+export function localeStateKey(key: string): string;
+export const DEFAULT_LOCALE: "en";
+export class LocaleManager {
+    /** @param {import('./Block.js').Block} blockInstance */
+    constructor(blockInstance: import("./Block.js").Block);
+    /**
+     * @private
+     * @type {import('./Block.js').Block | null}
+     */
+    private _blockInstance;
+    /** @private */
+    private _localeName;
+    /**
+     * @private
+     * @type {Set<() => void>}
+     */
+    private _callbacks;
+    /**
+     * @private
+     * @type {Map<import('./Block.js').Block, Map<string, () => void>>}
+     */
+    private _boundBlocks;
+    /**
+     * @param {() => void} callback
+     * @returns {() => void}
+     */
+    onLocaleChange(callback: () => void): () => void;
+    /**
+     * @param {import('./Block.js').Block} block
+     * @param {string} key
+     * @param {() => void} resolver
+     */
+    bindL10n(block: import("./Block.js").Block, key: string, resolver: () => void): void;
+    /** @param {import('./Block.js').Block} block */
+    destroyL10nBindings(block: import("./Block.js").Block): void;
+    destroy(): void;
+}
+//# sourceMappingURL=LocaleManager.d.ts.map

package/abstract/LocaleManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocaleManager.d.ts","sourceRoot":"","sources":["LocaleManager.js"],"names":[],"mappings":"AAMO,oCADK,MAAM,UACmC;AACrD,6BAA8B,IAAI,CAAC;AAEnC;IAsBE,wDAAwD;IACxD,2BADY,OAAO,YAAY,EAAE,KAAK,EAgDrC;IArED;;;OAGG;IACH,uBAAsB;IAEtB,eAAe;IACf,oBAAiB;IAEjB;;;OAGG;IACH,mBAAuB;IAEvB;;;OAGG;IACH,qBAAyB;IAoDzB;;;OAGG;IACH,yBAHW,MAAM,IAAI,GACR,MAAM,IAAI,CAQtB;IAED;;;;OAIG;IACH,gBAJW,OAAO,YAAY,EAAE,KAAK,OAC1B,MAAM,YACN,MAAM,IAAI,QAgBpB;IAED,gDAAgD;IAChD,2BADY,OAAO,YAAY,EAAE,KAAK,QAUrC;IAED,gBAEC;CACF"}

package/abstract/ModalManager.d.ts

@@ -0,0 +1,122 @@
+export const ModalEvents: Readonly<{
+    ADD: "modal:add";
+    DELETE: "modal:delete";
+    OPEN: "modal:open";
+    CLOSE: "modal:close";
+    CLOSE_ALL: "modal:closeAll";
+    DESTROY: "modal:destroy";
+}>;
+/** @typedef {import('../abstract/ActivityBlock').ActivityType} ModalId */
+/** @typedef {import('../blocks/Modal/Modal.js').Modal} ModalNode */
+/** @typedef {(data: { id: ModalId; modal: ModalNode }) => void} ModalCb */
+/** @typedef {(typeof ModalEvents)[keyof ModalEvents]} ModalEventType */
+export class ModalManager {
+    /** @param {import('./Block.js').Block} block */
+    constructor(block: import("./Block.js").Block);
+    /**
+     * @private
+     * @type {Map<ModalId, ModalNode>}
+     */
+    private _modals;
+    /**
+     * @private
+     * @type {Set<ModalId>}
+     */
+    private _activeModals;
+    /**
+     * @private
+     * @type {Map<ModalEventType, Set<ModalCb>>}
+     */
+    private _subscribers;
+    _block: import("./Block.js").Block;
+    /**
+     * @private
+     * @param {unknown[]} args
+     */
+    private _debugPrint;
+    /**
+     * Register a modal with the manager
+     *
+     * @param {ModalId} id - Unique identifier for the modal
+     * @param {ModalNode} modal - Modal component instance
+     */
+    registerModal(id: ModalId, modal: ModalNode): void;
+    /** @param {ModalId} id - Unique identifier for the modal */
+    deleteModal(id: ModalId): boolean;
+    /**
+     * Open a modal by its ID
+     *
+     * @param {ModalId} id - The ID of the modal to open
+     * @returns {boolean} - Success status
+     */
+    open(id: ModalId): boolean;
+    /**
+     * Close a specific modal by ID
+     *
+     * @param {ModalId} id - The ID of the modal to close
+     * @returns {boolean} - Success status
+     */
+    close(id: ModalId): boolean;
+    /**
+     * Toggle a modal - open if closed, close if open
+     *
+     * @param {ModalId} id - The ID of the modal to toggle
+     * @returns {boolean} - Success status
+     */
+    toggle(id: ModalId): boolean;
+    /**
+     * Check if any modals are currently active/open
+     *
+     * @returns {boolean} - True if there are any active modals
+     */
+    get hasActiveModals(): boolean;
+    /**
+     * Close the most recently opened modal and return to the previous one
+     *
+     * @returns {boolean} - Success status
+     */
+    back(): boolean;
+    /**
+     * Close all open modals
+     *
+     * @returns {number} - Number of modals closed
+     */
+    closeAll(): number;
+    /**
+     * Subscribe to modal events
+     *
+     * @param {ModalEventType} event
+     * @param {ModalCb} callback
+     * @returns {() => void}
+     */
+    subscribe(event: ModalEventType, callback: ModalCb): () => void;
+    /**
+     * Unsubscribe from modal events
+     *
+     * @param {ModalEventType} event
+     * @param {ModalCb | undefined} callback
+     */
+    unsubscribe(event: ModalEventType, callback: ModalCb | undefined): void;
+    /**
+     * Notify all subscribers of a modal event
+     *
+     * @private
+     * @param {ModalEventType} event - Event name
+     * @param {{
+     *       id: ModalId;
+     *       modal: ModalNode;
+     *     }
+     *   | object} data
+     */
+    private _notify;
+    /** Destroy the modal manager, clean up resources */
+    destroy(): void;
+}
+export type ModalId = import("../abstract/ActivityBlock").ActivityType;
+export type ModalNode = import("../blocks/Modal/Modal.js").Modal;
+export type ModalCb = (data: {
+    id: ModalId;
+    modal: ModalNode;
+}) => void;
+export type ModalEventType = (typeof ModalEvents)["ADD" | "DELETE" | "OPEN" | "CLOSE" | "CLOSE_ALL" | "DESTROY"];
+//# sourceMappingURL=ModalManager.d.ts.map

package/abstract/ModalManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalManager.d.ts","sourceRoot":"","sources":["ModalManager.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,0EAA0E;AAE1E,oEAAoE;AAEpE,2EAA2E;AAE3E,wEAAwE;AAExE;IAmBE,gDAAgD;IAChD,mBADY,OAAO,YAAY,EAAE,KAAK,EAGrC;IArBD;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,sBAA0B;IAE1B;;;OAGG;IACH,qBAAyB;IAIvB,mCAAmB;IAGrB;;;OAGG;IACH,oBAEC;IAED;;;;;OAKG;IACH,kBAHW,OAAO,SACP,SAAS,QAKnB;IAED,4DAA4D;IAC5D,gBADY,OAAO,WASlB;IAED;;;;;OAKG;IACH,SAHW,OAAO,GACL,OAAO,CAanB;IAED;;;;;OAKG;IACH,UAHW,OAAO,GACL,OAAO,CAanB;IAED;;;;;OAKG;IACH,WAHW,OAAO,GACL,OAAO,CAanB;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,QAFa,OAAO,CAWnB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,iBAJW,cAAc,YACd,OAAO,GACL,MAAM,IAAI,CAStB;IAED;;;;;OAKG;IACH,mBAHW,cAAc,YACd,OAAO,GAAG,SAAS,QAM7B;IAED;;;;;;;;;;OAUG;IACH,gBAiBC;IAED,oDAAoD;IACpD,gBAKC;CACF;sBA9Na,OAAO,2BAA2B,EAAE,YAAY;wBAEhD,OAAO,0BAA0B,EAAE,KAAK;sBAExC,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,KAAK,IAAI;6BAEjD,CAAC,OAAO,WAAW,gEAAoB"}

package/abstract/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').SecureUploadsSignatureAndExpire | null}
+     */
+    private _secureToken;
+    /**
+     * @private
+     * @param {unknown[]} args
+     */
+    private _debugPrint;
+    /** @returns {Promise<import('../types').SecureUploadsSignatureAndExpire | null>} */
+    getSecureToken(): Promise<import("../types").SecureUploadsSignatureAndExpire | null>;
+}
+//# sourceMappingURL=SecureUploadsManager.d.ts.map

package/abstract/SecureUploadsManager.d.ts.map

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

package/abstract/SolutionBlock.d.ts

@@ -0,0 +1,22 @@
+export class SolutionBlock extends Block {
+    static set template(value: any);
+    static get template(): any;
+    init$: {
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*uploadQueue': import("@uploadcare/upload-client").Queue;
+        '*collectionErrors': ReturnType<import("../index.js").OutputErrorCollection>[];
+        '*collectionState': import("../index.js").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;
+    };
+    _template: null;
+}
+import { Block } from './Block.js';
+//# sourceMappingURL=SolutionBlock.d.ts.map

package/abstract/SolutionBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolutionBlock.d.ts","sourceRoot":"","sources":["SolutionBlock.js"],"names":[],"mappings":"AAIA;IAWE,gCAEC;IAED,2BAEC;IAdD;;;;;;;;;;;;;;MAA+B;IAC/B,gBAAiB;CAclB;sBArBqB,YAAY"}

package/abstract/TypedCollection.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @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<T extends import("./TypedData.js").TypedSchema> {
+    /**
+     * @param {Object} options
+     * @param {T} options.typedSchema
+     * @param {import('./TypedData.js').ExtractKeysFromSchema<T>[]} [options.watchList]
+     * @param {TypedCollectionObserverHandler<T>} [options.handler]
+     * @param {string} [options.ctxName]
+     */
+    constructor(options: {
+        typedSchema: T;
+        watchList?: Extract<keyof T, string>[] | undefined;
+        handler?: TypedCollectionObserverHandler<T> | undefined;
+        ctxName?: string | undefined;
+    });
+    /**
+     * @private
+     * @type {T}
+     */
+    private __typedSchema;
+    /**
+     * @private
+     * @type {string}
+     */
+    private __ctxId;
+    /**
+     * @private
+     * @type {Data}
+     */
+    private __data;
+    /**
+     * @private
+     * @type {import('./TypedData.js').ExtractKeysFromSchema<T>[]}
+     */
+    private __watchList;
+    /**
+     * @private
+     * @type {Object<string, ReturnType<TypedData<T>['subscribe']>[]>}
+     */
+    private __subsMap;
+    /**
+     * @private
+     * @type {Set<Function>}
+     */
+    private __propertyObservers;
+    /**
+     * @private
+     * @type {Set<TypedCollectionObserverHandler<T>>}
+     */
+    private __collectionObservers;
+    /**
+     * @private
+     * @type {Set<string>}
+     */
+    private __items;
+    /**
+     * @private
+     * @type {Set<import('./TypedData.js').TypedData<T>>}
+     */
+    private __removed;
+    /**
+     * @private
+     * @type {Set<import('./TypedData.js').TypedData<T>>}
+     */
+    private __added;
+    /**
+     * @private
+     * @param {String} propName
+     * @param {String} ctxId
+     */
+    private __notifyObservers;
+    /** @private */
+    private __observeTimeout;
+    notify(): void;
+    /** @private */
+    private __notifyTimeout;
+    /** @param {TypedCollectionObserverHandler<T>} handler */
+    observeCollection(handler: TypedCollectionObserverHandler<T>): () => void;
+    /** @param {TypedCollectionObserverHandler<T>} handler */
+    unobserveCollection(handler: TypedCollectionObserverHandler<T>): void;
+    /**
+     * @param {Partial<import('./TypedData.js').ExtractDataFromSchema<T>>} init
+     * @returns {string}
+     */
+    add(init: Partial<import("./TypedData.js").ExtractDataFromSchema<T>>): string;
+    /**
+     * @param {string} id
+     * @returns {TypedData<T> | null}
+     */
+    read(id: string): TypedData<T> | null;
+    /**
+     * @template {import('./TypedData.js').ExtractKeysFromSchema<T>} K
+     * @param {string} id
+     * @param {K} propName
+     * @returns {import('./TypedData.js').ExtractDataFromSchema<T>[propName] | null}
+     */
+    readProp<K extends import("./TypedData.js").ExtractKeysFromSchema<T>>(id: string, propName: K): import("./TypedData.js").ExtractDataFromSchema<T>[K] | null;
+    /**
+     * @template {import('./TypedData.js').ExtractKeysFromSchema<T>} K
+     * @param {string} id
+     * @param {K} propName
+     * @param {import('./TypedData.js').ExtractDataFromSchema<T>[K]} value
+     */
+    publishProp<K extends import("./TypedData.js").ExtractKeysFromSchema<T>>(id: string, propName: K, value: import("./TypedData.js").ExtractDataFromSchema<T>[K]): void;
+    /** @param {string} id */
+    remove(id: string): void;
+    clearAll(): void;
+    /** @param {Function} handler */
+    observeProperties(handler: Function): () => void;
+    /** @param {Function} handler */
+    unobserveProperties(handler: Function): void;
+    /**
+     * @param {(item: TypedData<T>) => Boolean} checkFn
+     * @returns {string[]}
+     */
+    findItems(checkFn: (item: TypedData<T>) => boolean): string[];
+    items(): string[];
+    get size(): number;
+    destroy(): void;
+}
+export type TypedCollectionObserverHandler<T extends import("./TypedData.js").TypedSchema> = (list: string[], added: Set<import("./TypedData.js").TypedData<T>>, removed: Set<TypedData<T>>) => void;
+import { TypedData } from './TypedData.js';
+//# sourceMappingURL=TypedCollection.d.ts.map

package/abstract/TypedCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCollection.d.ts","sourceRoot":"","sources":["TypedCollection.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH,yDAAyD;AACzD,6BADqD,CAAC,SAAxC,OAAQ,gBAAgB,EAAE,WAAY;IAElD;;;;;;OAMG;IACH,qBALG;QAAmB,WAAW,EAAtB,CAAC;QAC6D,SAAS;QAC3B,OAAO;QAClC,OAAO;KAAC,EAgFnC;IA7EC;;;OAGG;IACH,sBAAwC;IACxC;;;OAGG;IACH,gBAAgD;IAChD;;;OAGG;IACH,eAAgD;IAChD;;;OAGG;IACH,oBAA0C;IAC1C;;;OAGG;IACH,kBAAoC;IACpC;;;OAGG;IACH,4BAAoC;IACpC;;;OAGG;IACH,8BAAsC;IACtC;;;OAGG;IACH,gBAAwB;IACxB;;;OAGG;IACH,kBAA0B;IAC1B;;;OAGG;IACH,gBAAwB;IAIxB;;;;OAIG;IACH,0BAkBC;IAVC,eAAe;IACf,yBAQE;IAIN,eAcC;IAVC,eAAe;IACf,wBAQE;IAGJ,yDAAyD;IACzD,2BADY,8BAA8B,CAAC,CAAC,CAAC,cAW5C;IAED,yDAAyD;IACzD,6BADY,8BAA8B,CAAC,CAAC,CAAC,QAG5C;IAED;;;OAGG;IACH,UAHW,OAAO,CAAC,OAAO,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,GACxD,MAAM,CAuBlB;IAED;;;OAGG;IACH,SAHW,MAAM,GACJ,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAI/B;IAED;;;;;OAKG;IACH,SALiE,CAAC,SAArD,OAAQ,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAE,MACrD,MAAM,YACN,CAAC,GACC,OAAO,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAU,GAAG,IAAI,CAS9E;IAED;;;;;OAKG;IACH,YALiE,CAAC,SAArD,OAAQ,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAE,MACrD,MAAM,YACN,CAAC,SACD,OAAO,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAS9D;IAED,yBAAyB;IACzB,WADY,MAAM,QAUjB;IAED,iBAIC;IAED,gCAAgC;IAChC,iDAMC;IAED,gCAAgC;IAChC,6CAEC;IAED;;;OAGG;IACH,mBAHW,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,YAAY,GAC7B,MAAM,EAAE,CAYpB;IAED,kBAEC;IAED,mBAEC;IAED,gBAUC;CACF;2CAnQmD,CAAC,SAAxC,OAAQ,gBAAgB,EAAE,WAAY,IACtC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;0BAJ1F,gBAAgB"}

package/abstract/TypedData.d.ts

@@ -0,0 +1,93 @@
+/** @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 {T} typedSchema
+     * @param {String} [ctxName]
+     */
+    constructor(typedSchema: T, ctxName?: string);
+    /**
+     * @private
+     * @type {T}
+     */
+    private __typedSchema;
+    /**
+     * @private
+     * @type {string}
+     */
+    private __ctxId;
+    /**
+     * @private
+     * @type {ExtractDataFromSchema<T>}
+     */
+    private __schema;
+    /**
+     * @private
+     * @type {Data}
+     */
+    private __data;
+    /** @returns {string} */
+    get uid(): string;
+    /**
+     * @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]}
+     */
+    getValue<K extends ExtractKeysFromSchema<T>>(prop: K): ExtractDataFromSchema<T>[K];
+    /**
+     * @template {ExtractKeysFromSchema<T>} K
+     * @param {K} prop
+     * @param {(newVal: ExtractDataFromSchema<T>[K]) => void} handler
+     */
+    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