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

package/blocks/CameraSource/CameraSource.d.ts

@@ -0,0 +1,176 @@
+/** @typedef {'photo' | 'video'} CameraMode */
+/** @typedef {'shot' | 'retake' | 'accept' | 'play' | 'stop' | 'pause' | 'resume'} CameraStatus */
+export class CameraSource extends UploaderBlock {
+    activityType: "camera";
+    /** @private */
+    private _unsubPermissions;
+    /** @type {BlobPart[]} */
+    _chunks: BlobPart[];
+    /** @type {MediaRecorder | null} */
+    _mediaRecorder: MediaRecorder | null;
+    /** @type {MediaStream | null} */
+    _stream: MediaStream | null;
+    /** @type {string | null} */
+    _selectedAudioId: string | null;
+    /** @type {string | null} */
+    _selectedCameraId: string | null;
+    init$: {
+        video: null;
+        videoTransformCss: null;
+        videoHidden: boolean;
+        messageHidden: boolean;
+        requestBtnHidden: boolean;
+        cameraSelectOptions: null;
+        cameraSelectHidden: boolean;
+        l10nMessage: string;
+        switcher: null;
+        panels: null;
+        timer: null;
+        timerHidden: boolean;
+        cameraHidden: boolean;
+        cameraActionsHidden: boolean;
+        audioSelectOptions: null;
+        audioSelectHidden: boolean;
+        audioSelectDisabled: boolean;
+        audioToggleMicrophoneHidden: boolean;
+        tabCameraHidden: boolean;
+        tabVideoHidden: boolean;
+        currentIcon: string;
+        currentTimelineIcon: string;
+        toggleMicrophoneIcon: string;
+        /** @type {Number} */
+        _startTime: number;
+        /** @type {Number} */
+        _elapsedTime: number;
+        _animationFrameId: null;
+        mutableClassButton: string;
+        /** @param {Event} e */
+        onCameraSelectChange: (e: Event) => void;
+        /** @param {Event} e */
+        onAudioSelectChange: (e: Event) => void;
+        onCancel: () => void;
+        onShot: () => void;
+        onRequestPermissions: () => Promise<void>;
+        /** General method for photo and video capture */
+        onStartCamera: () => void;
+        onStartRecording: () => void;
+        onStopRecording: () => void;
+        onToggleRecording: () => void;
+        onToggleAudio: () => void;
+        onRetake: () => void;
+        onAccept: () => void;
+        /** @param {MouseEvent} e */
+        onClickTab: (e: MouseEvent) => void;
+        '*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("../../abstract/SecureUploadsManager.js").SecureUploadsManager | null;
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    _chooseActionWithCamera: () => void;
+    _updateTimer: () => void;
+    _animationFrameId: number | undefined;
+    _startTimer: () => void;
+    _stopTimer: () => void;
+    _startTimeline: () => void;
+    _stopTimeline: () => void;
+    _startRecording: () => void;
+    _options: {
+        audioBitsPerSecond?: number;
+        bitsPerSecond?: number;
+        mimeType?: string;
+        videoBitsPerSecond?: number;
+    } | undefined;
+    /** @private */
+    private _stopRecording;
+    /** This method is used to toggle recording pause/resume */
+    _toggleRecording: () => void;
+    _toggleEnableAudio: () => void;
+    /**
+     * Previewing the video that was recorded on the camera
+     *
+     * @private
+     */
+    private _previewVideo;
+    _retake: () => void;
+    _accept: () => void;
+    /** @param {CameraStatus} status */
+    _handlePhoto: (status: CameraStatus) => void;
+    /** @param {CameraStatus} status */
+    _handleVideo: (status: CameraStatus) => void;
+    /**
+     * @private
+     * @param {CameraStatus} status
+     */
+    private _setCameraState;
+    /** @private */
+    private _shot;
+    _canvas: HTMLCanvasElement | undefined;
+    _ctx: CanvasRenderingContext2D | null | undefined;
+    /**
+     * @private
+     * @param {CameraMode} tabId
+     */
+    private _handleActiveTab;
+    _activeTab: CameraMode | undefined;
+    /**
+     * @param {'camera' | 'video'} type
+     * @param {'jpeg' | 'webm'} ext
+     * @param {String} format
+     * @param {Blob} blob
+     */
+    _createFile: (type: "camera" | "video", ext: "jpeg" | "webm", format: string, blob: Blob) => File;
+    /** @param {String | undefined} mime */
+    _guessExtensionByMime(mime: string | undefined): any;
+    /**
+     * The send file to the server
+     *
+     * @param {File} file
+     */
+    _toSend: (file: File) => void;
+    /** @private */
+    private get _cameraModes();
+    /**
+     * @private
+     * @param {'granted' | 'denied' | 'prompt'} state
+     */
+    private _setPermissionsState;
+    _makeStreamInactive: () => false | undefined;
+    _stopCapture: () => void;
+    _capturing: boolean | undefined;
+    _capture: () => Promise<void>;
+    _handlePermissionsChange: () => void;
+    _permissionAccess: () => Promise<void>;
+    _getPermission: () => void;
+    _requestDeviceAccess: () => Promise<void>;
+    _getDevices: () => Promise<void>;
+    _cameraDevices: {
+        text: string;
+        value: string;
+    }[] | undefined;
+    _audioDevices: false | {
+        text: string;
+        value: string;
+    }[] | undefined;
+    _onActivate: () => Promise<void>;
+    _onDeactivate: () => Promise<void>;
+    /** @param {CameraMode[]} cameraModes */
+    _handleCameraModes: (cameraModes: CameraMode[]) => void;
+    _destroy(): void;
+    destroyCallback(): Promise<void>;
+}
+export namespace CameraSource {
+    let template: string;
+}
+export type CameraMode = "photo" | "video";
+export type CameraStatus = "shot" | "retake" | "accept" | "play" | "stop" | "pause" | "resume";
+import { UploaderBlock } from '../../abstract/UploaderBlock.js';
+//# sourceMappingURL=CameraSource.d.ts.map

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

@@ -0,0 +1 @@
+{"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,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;8BAzCnD,iCAAiC"}

package/blocks/CameraSource/calcCameraModes.d.ts

@@ -0,0 +1,5 @@
+export function calcCameraModes(cfg: import("../../types").ConfigType): {
+    isVideoRecordingEnabled: boolean;
+    isPhotoEnabled: boolean;
+};
+//# sourceMappingURL=calcCameraModes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calcCameraModes.d.ts","sourceRoot":"","sources":["calcCameraModes.js"],"names":[],"mappings":"AAKO,qCAAoC,OAAO,aAAa,EAAE,UAAU;;;EAK1E"}

package/blocks/CameraSource/constants.d.ts

@@ -0,0 +1,16 @@
+export const CameraSourceTypes: Readonly<{
+    PHOTO: "photo";
+    VIDEO: "video";
+}>;
+export const CameraSourceEvents: Readonly<{
+    IDLE: "idle";
+    SHOT: "shot";
+    PLAY: "play";
+    PAUSE: "pause";
+    RESUME: "resume";
+    STOP: "stop";
+    RETAKE: "retake";
+    ACCEPT: "accept";
+}>;
+export type ModeCameraType = (typeof CameraSourceTypes)[keyof typeof CameraSourceTypes];
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GAWG;6BAEW,CAAC,OAAO,iBAAiB,EAAE,MAAM,OAAO,iBAAiB,CAAC"}

package/blocks/CloudImageEditor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/index.js";
+//# sourceMappingURL=index.d.ts.map

package/blocks/CloudImageEditor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,58 @@
+export class CloudImageEditorBlock extends Block {
+    init$: {
+        '*originalUrl': null;
+        '*faderEl': null;
+        '*cropperEl': null;
+        '*imgEl': null;
+        '*imgContainerEl': null;
+        '*networkProblems': boolean;
+        '*imageSize': null;
+        '*editorTransformations': import("./types.js").Transformations;
+        '*cropPresetList': import("./types.js").CropPresetList;
+        '*tabList': ("crop" | "tuning" | "filters")[];
+        '*tabId': "crop";
+        entry: null;
+        extension: null;
+        editorMode: boolean;
+        modalCaption: string;
+        isImage: boolean;
+        msg: string;
+        src: string;
+        fileType: string;
+        showLoader: boolean;
+        uuid: null;
+        cdnUrl: null;
+        cropPreset: string;
+        tabs: string;
+        'presence.networkProblems': boolean;
+        'presence.modalCaption': boolean;
+        'presence.editorToolbar': boolean;
+        'presence.viewerToolbar': boolean;
+        '*on.retryNetwork': () => void;
+        '*on.apply': (transformations: import("./types.js").Transformations) => void;
+        '*on.cancel': () => void;
+    };
+    /** @private */
+    private _debouncedShowLoader;
+    /**
+     * @private
+     * @param {boolean} show
+     */
+    private _showLoader;
+    /**
+     * To proper work, we need non-zero size the element. So, we'll wait for it.
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private _waitForSize;
+    updateImage(): Promise<void>;
+    initEditor(): Promise<void>;
+    _imgLoading: boolean | undefined;
+}
+export namespace CloudImageEditorBlock {
+    export { TEMPLATE as template };
+}
+import { Block } from '../../../abstract/Block.js';
+import { TEMPLATE } from './template.js';
+//# sourceMappingURL=CloudImageEditorBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudImageEditorBlock.d.ts","sourceRoot":"","sources":["CloudImageEditorBlock.js"],"names":[],"mappings":"AAmBA;IAOI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGC;IAGH,eAAe;IACf,6BAAkE;IAElE;;;OAGG;IACH,oBAEC;IAED;;;;;OAKG;IACH,qBAeC;IAYD,6BAkDC;IAED,4BA0FC;IA9EG,iCAAwB;CA+E7B;;;;sBA1NqB,4BAA4B;yBAezB,eAAe"}

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

@@ -0,0 +1,158 @@
+export class CropFrame extends Block {
+    init$: {
+        dragging: boolean;
+    };
+    /** @private */
+    private _handlePointerUp;
+    /** @private */
+    private _handlePointerMove;
+    /** @private */
+    private _handleSvgPointerMove;
+    /**
+     * @private
+     * @param {import('./types.js').Direction} direction
+     */
+    private _shouldThumbBeDisabled;
+    /** @private */
+    private _createBackdrop;
+    _backdropMask: SVGElement | undefined;
+    _backdropMaskInner: SVGElement | undefined;
+    /**
+     * @private Super Tricky workaround for the chromium bug See
+     *   https://bugs.chromium.org/p/chromium/issues/detail?id=330815
+     */
+    private _resizeBackdrop;
+    /** @private */
+    private _updateBackdrop;
+    /** @private */
+    private _updateFrame;
+    /**
+     * @param {import('./types.js').FrameThumbs} frameThumbs
+     * @param {import('./types.js').Direction} direction
+     */
+    _createThumb(frameThumbs: import("./types.js").FrameThumbs, direction: import("./types.js").Direction): void;
+    /** @private */
+    private _createThumbs;
+    /** @private */
+    private _createGuides;
+    /** @private */
+    private _createFrame;
+    _frameThumbs: Partial<{
+        "": {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        n: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        s: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        e: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        w: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        ne: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        nw: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        se: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+        sw: {
+            direction: import("./types.js").Direction;
+            pathNode: SVGElement;
+            interactionNode: SVGElement;
+            groupNode: SVGElement;
+        };
+    }> | undefined;
+    _frameGuides: SVGElement | undefined;
+    /**
+     * @private
+     * @param {import('./types.js').Direction} direction
+     * @param {PointerEvent} e
+     */
+    private _handlePointerDown;
+    _draggingThumb: {
+        direction: import("./types.js").Direction;
+        pathNode: SVGElement;
+        interactionNode: SVGElement;
+        groupNode: SVGElement;
+    } | undefined;
+    _dragStartPoint: number[] | undefined;
+    /** @type {import('./types.js').Rectangle} */
+    _dragStartCrop: import("./types.js").Rectangle | undefined;
+    /**
+     * @private
+     * @param {PointerEvent} e
+     */
+    private _handlePointerUp_;
+    /**
+     * @private
+     * @param {PointerEvent} e
+     */
+    private _handlePointerMove_;
+    /**
+     * @private
+     * @param {import('./types.js').Direction} direction
+     * @param {[Number, Number]} delta
+     */
+    private _calcCropBox;
+    /**
+     * @private
+     * @param {PointerEvent} e
+     */
+    private _handleSvgPointerMove_;
+    _hoverThumb: {
+        direction: import("./types.js").Direction;
+        pathNode: SVGElement;
+        interactionNode: SVGElement;
+        groupNode: SVGElement;
+    } | undefined;
+    /** @private */
+    private _updateCursor;
+    /**
+     * @private
+     * @param {String} href
+     */
+    private _createMask;
+    _frameImage: SVGElement | undefined;
+    _updateMask(): void;
+    /** @private */
+    private _render;
+    /** @param {boolean} visible */
+    toggleThumbs(visible: boolean): void;
+    _guidesHidden: boolean | undefined;
+}
+export namespace CropFrame {
+    let template: string;
+}
+import { Block } from '../../../abstract/Block.js';
+//# sourceMappingURL=CropFrame.d.ts.map

package/blocks/CloudImageEditor/src/CropFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CropFrame.d.ts","sourceRoot":"","sources":["CropFrame.js"],"names":[],"mappings":"AA2BA;IAII;;MAGC;IAED,eAAe;IACf,yBAAyD;IAEzD,eAAe;IACf,2BAA6D;IAE7D,eAAe;IACf,8BAAmE;IAGrE;;;OAGG;IACH,+BAaC;IAED,eAAe;IACf,wBAyCC;IAFC,sCAAyB;IACzB,2CAAuC;IAGzC;;;OAGG;IACH,wBAUC;IAED,eAAe;IACf,wBASC;IAED,eAAe;IACf,qBAgEC;IAED;;;OAGG;IACH,0BAHW,OAAO,YAAY,EAAE,WAAW,aAChC,OAAO,YAAY,EAAE,SAAS,QA4BxC;IAED,eAAe;IACf,sBAiBC;IAED,eAAe;IACf,sBA4CC;IAED,eAAe;IACf,qBAeC;IAFC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA+B;IAC/B,qCAA+B;IAGjC;;;;OAIG;IACH,2BAiBC;IAJC;;;;;kBAA2B;IAC3B,sCAA6B;IAC7B,6CAA6C;IAC7C,2DAAoC;IAGtC;;;OAGG;IACH,0BAUC;IAED;;;OAGG;IACH,4BAmBC;IAED;;;;OAIG;IACH,qBAsBC;IAED;;;OAGG;IACH,+BAqBC;IAFC;;;;;kBAA6B;IAI/B,eAAe;IACf,sBAGC;IAED;;;OAGG;IACH,oBAoBC;IADC,oCAA4B;IAG9B,oBAeC;IAED,eAAe;IACf,gBAIC;IAED,+BAA+B;IAC/B,sBADY,OAAO,QAclB;IAmBG,mCAAsF;CAmC3F;;;;sBArjBqB,4BAA4B"}

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

@@ -0,0 +1,10 @@
+export class EditorButtonControl extends Block {
+    init$: any;
+    _titleEl: any;
+    _iconEl: any;
+}
+export namespace EditorButtonControl {
+    let template: string;
+}
+import { Block } from '../../../abstract/Block.js';
+//# sourceMappingURL=EditorButtonControl.d.ts.map

package/blocks/CloudImageEditor/src/EditorButtonControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorButtonControl.d.ts","sourceRoot":"","sources":["EditorButtonControl.js"],"names":[],"mappings":"AAGA;IACE,WAOE;IAKA,cAAoC;IACpC,aAAkC;CAoBrC;;;;sBApCqB,4BAA4B"}

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

@@ -0,0 +1,6 @@
+export class EditorCropButtonControl extends EditorButtonControl {
+    /** @private */
+    private _operation;
+}
+import { EditorButtonControl } from './EditorButtonControl.js';
+//# sourceMappingURL=EditorCropButtonControl.d.ts.map

package/blocks/CloudImageEditor/src/EditorCropButtonControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorCropButtonControl.d.ts","sourceRoot":"","sources":["EditorCropButtonControl.js"],"names":[],"mappings":"AAkBA;IASM,eAAe;IACf,mBAA2B;CAehC;oCA3CmC,0BAA0B"}

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

@@ -0,0 +1,18 @@
+export class EditorFilterControl extends EditorButtonControl {
+    _previewSrc(): string;
+    /**
+     * @param {IntersectionObserverEntry[]} entries
+     * @param {IntersectionObserver} observer
+     */
+    _observerCallback(entries: IntersectionObserverEntry[], observer: IntersectionObserver): Promise<void>;
+    _cancelPreload: (() => void) | undefined;
+    _operation: string | undefined;
+    _filter: string | undefined;
+    _observer: IntersectionObserver | undefined;
+    _originalUrl: any;
+}
+export namespace EditorFilterControl {
+    let template: string;
+}
+import { EditorButtonControl } from './EditorButtonControl.js';
+//# sourceMappingURL=EditorFilterControl.d.ts.map

package/blocks/CloudImageEditor/src/EditorFilterControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorFilterControl.d.ts","sourceRoot":"","sources":["EditorFilterControl.js"],"names":[],"mappings":"AAOA;IAeE,sBA2BC;IAED;;;OAGG;IACH,2BAHW,yBAAyB,EAAE,YAC3B,oBAAoB,iBAuB9B;IAfG,yCAA4B;IAoC1B,+BAA0B;IAC1B,4BAAqB;IAYzB,4CAEE;IAGF,kBAA+B;CAgDlC;;;;oCAjKmC,0BAA0B"}

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

@@ -0,0 +1,106 @@
+export class EditorImageCropper extends Block {
+    init$: {
+        image: null;
+        '*padding': number;
+        /** @type {Operations} */
+        '*operations': Operations;
+        /** @type {import('./types.js').Rectangle} */
+        '*imageBox': import("./types.js").Rectangle;
+        /** @type {import('./types.js').Rectangle} */
+        '*cropBox': import("./types.js").Rectangle;
+    };
+    /** @private */
+    private _commitDebounced;
+    /** @private */
+    private _handleResizeThrottled;
+    _imageSize: {
+        width: number;
+        height: number;
+    };
+    /** @private */
+    private _handleResize;
+    /** @private */
+    private _syncTransformations;
+    /** @private */
+    private _initCanvas;
+    _canvas: HTMLCanvasElement | undefined;
+    _ctx: CanvasRenderingContext2D | null | undefined;
+    /** @private */
+    private _alignImage;
+    /** @private */
+    private _alignCrop;
+    /** @private */
+    private _drawImage;
+    /** @private */
+    private _draw;
+    /**
+     * @private
+     * @param {{ fromViewer?: boolean }} options
+     */
+    private _animateIn;
+    /**
+     * @private
+     * @returns {NonNullable<import('./types.js').Transformations['crop']>['dimensions']}
+     */
+    private _getCropDimensions;
+    /**
+     * @private
+     * @returns {import('./types.js').Transformations['crop']}
+     */
+    private _getCropTransformation;
+    /** @private */
+    private _commit;
+    /**
+     * @param {String} operation
+     * @param {Number} value
+     * @returns {void}
+     */
+    setValue(operation: string, value: number): void;
+    /**
+     * @param {keyof Operations} operation
+     * @returns {Number | boolean}
+     */
+    getValue(operation: keyof Operations): number | boolean;
+    /**
+     * @param {import('./types.js').ImageSize} imageSize
+     * @param {{ fromViewer?: boolean }} options
+     */
+    activate(imageSize: import("./types.js").ImageSize, { fromViewer }?: {
+        fromViewer?: boolean;
+    }): Promise<void>;
+    _isActive: boolean | undefined;
+    _observer: ResizeObserver | undefined;
+    deactivate({ reset }?: {
+        reset?: boolean | undefined;
+    }): void;
+    /** @private */
+    private _transitionToCrop;
+    /** @private */
+    private _transitionToImage;
+    /** @private */
+    private _reset;
+    /**
+     * @private
+     * @param {String} originalUrl
+     * @param {import('./types.js').Transformations} transformations
+     * @returns {Promise<HTMLImageElement>}
+     */
+    private _waitForImage;
+    _cancelPreload: (() => void) | undefined;
+    /**
+     * @private
+     * @param {String} src
+     * @returns {() => void} Destructor
+     */
+    private _handleImageLoading;
+}
+export namespace EditorImageCropper {
+    let template: string;
+}
+export type Operations = {
+    flip: boolean;
+    mirror: boolean;
+    rotate: number;
+};
+import { Block } from '../../../abstract/Block.js';
+//# sourceMappingURL=EditorImageCropper.d.ts.map

package/blocks/CloudImageEditor/src/EditorImageCropper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorImageCropper.d.ts","sourceRoot":"","sources":["EditorImageCropper.js"],"names":[],"mappings":"AA2CA;IAKI;;;QAIE,yBAAyB;uBAAd,UAAU;QAMrB,6CAA6C;qBAAlC,OAAO,YAAY,EAAE,SAAS;QAOzC,6CAA6C;oBAAlC,OAAO,YAAY,EAAE,SAAS;MAO1C;IAED,eAAe;IACf,yBAA8D;IAE9D,eAAe;IACf,+BAA0E;IAE1E;;;MAAyC;IAG3C,eAAe;IACf,sBASC;IAED,eAAe;IACf,6BAKC;IAED,eAAe;IACf,oBAgBC;IAFC,uCAAqB;IACrB,kDAAe;IAGjB,eAAe;IACf,oBAuCC;IAED,eAAe;IACf,mBAqDC;IAED,eAAe;IACf,mBAcC;IAED,eAAe;IACf,cAUC;IAED;;;OAGG;IACH,mBAYC;IAED;;;OAGG;IACH,2BAkBC;IAED;;;OAGG;IACH,+BA8BC;IAED,eAAe;IACf,gBAkBC;IAED;;;;OAIG;IACH,4CAFa,IAAI,CAehB;IAED;;;OAGG;IACH,oBAHW,MAAM,UAAU,GACd,SAAS,OAAO,CAI5B;IAED;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,SAAS,mBAC9B;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,iBAyBlC;IAnBC,+BAAqB;IAYrB,sCAKE;IAGJ;;aAkBC;IAED,eAAe;IACf,0BAYC;IAED,eAAe;IACf,2BAMC;IAED,eAAe;IACf,eAKC;IAED;;;;;OAKG;IACH,sBAyBC;IATC,yCAA4B;IAW9B;;;;OAIG;IACH,4BAkBC;CAgCF;;;;;UA5gBa,OAAO;YACP,OAAO;;;sBApBC,4BAA4B"}