@aurigma/design-atoms/Services/ItemHandlerImageLoaderService.js

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

import { ImageContainer } from "../ItemHandlers/ImageContainer";
import { RectangleF } from "@aurigma/design-atoms-model/Math/RectangleF";
import { EventWithSenderArg } from "@aurigma/design-atoms-model/EventObject";
export class ItemHandlerImageLoaderService {
    constructor(_serviceEndpoint) {
        this._serviceEndpoint = _serviceEndpoint;
        this._imageContainers = new Map();
        this._fileCacheIdToCombined = {};
        this._locks = new Map();
        this._rectangles = {};
        this._imageContainerLoadedEvent = new EventWithSenderArg();
    }
    loadCombinedImage(combinedImageDescription) {
        var _a;
        if (combinedImageDescription == null)
            return;
        if (combinedImageDescription.fileCacheId) {
            var imageContainer = new ImageContainer(() => this._raiseImageLoadedEvent());
            this._imageContainers.set(combinedImageDescription.fileCacheId, imageContainer);
            imageContainer.updateUrl(this._getImageUrl(combinedImageDescription.fileCacheId));
            for (let key in combinedImageDescription.itemsRectangles) {
                this._fileCacheIdToCombined[key] = combinedImageDescription.fileCacheId;
                this._rectangles[key] = RectangleF.fromString(combinedImageDescription.itemsRectangles[key]);
            }
        }
        if (((_a = combinedImageDescription.largeImagesIds) === null || _a === void 0 ? void 0 : _a.length) > 0) {
            combinedImageDescription.largeImagesIds.forEach(largeImageId => {
                const imageContainer = new ImageContainer(() => this._raiseImageLoadedEvent());
                this._imageContainers.set(largeImageId, imageContainer);
                imageContainer.updateUrl(this._getImageUrl(largeImageId));
                this._fileCacheIdToCombined[largeImageId] = largeImageId;
            });
        }
    }
    getImageContainerFor(cacheFileId) {
        if (!this.hasImageContainerFor(cacheFileId))
            return null;
        const combinedCacheId = this._fileCacheIdToCombined[cacheFileId];
        return this._imageContainers.get(combinedCacheId);
    }
    hasImageContainerFor(cacheFileId) {
        if (cacheFileId == null || cacheFileId === undefined || cacheFileId.length === 0)
            return false;
        return cacheFileId in this._fileCacheIdToCombined;
    }
    lockImageContainerFor(cacheFileId, lockObjectId) {
        if (!this._fileCacheIdToCombined[cacheFileId])
            return;
        if (!this._locks.has(cacheFileId))
            this._locks.set(cacheFileId, []);
        const lockArray = this._locks.get(cacheFileId);
        if (!lockArray.includes(lockObjectId))
            lockArray.push(lockObjectId);
    }
    releaseImageContainerFor(cacheFileId, lockObjectId) {
        if (!this._locks.has(cacheFileId))
            return;
        const lockArray = this._locks.get(cacheFileId);
        if (!lockArray.includes(lockObjectId)) {
            console.error(`no lock found for cacheFileId ${cacheFileId} and lockObjectId ${lockObjectId}`);
            return;
        }
        const index = lockArray.indexOf(lockObjectId);
        lockArray.splice(index, 1);
        if (lockArray.length == 0) {
            this._locks.delete(cacheFileId);
            this._releaseCacheId(cacheFileId);
        }
    }
    _releaseCacheId(cacheFileId) {
        const combinedCacheId = this._fileCacheIdToCombined[cacheFileId];
        if (!combinedCacheId) {
            console.error(`_releaseCacheId combined not found for ${cacheFileId}`);
            return;
        }
        delete this._fileCacheIdToCombined[cacheFileId];
        let found = false;
        for (let id in this._fileCacheIdToCombined) {
            let combined = this._fileCacheIdToCombined[id];
            if (combinedCacheId === combined) {
                found = true;
                break;
            }
        }
        if (!found)
            this._imageContainers.delete(combinedCacheId);
    }
    getImageContainerRectangleFor(cacheFileId) {
        return this._rectangles[cacheFileId];
    }
    addImageContainerLoaded(handler) {
        this._imageContainerLoadedEvent.add(handler);
    }
    removeImageContainerLoaded(handler) {
        this._imageContainerLoadedEvent.remove(handler);
    }
    _getImageUrl(fileCacheId) {
        return this._serviceEndpoint + "/txt?" + "f=" + encodeURIComponent(fileCacheId);
    }
    _raiseImageLoadedEvent() {
        this._imageContainerLoadedEvent.notify(this);
    }
}
//# sourceMappingURL=ItemHandlerImageLoaderService.js.map