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

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

import { EventObject, EquatableKeyDictionary } from "@aurigma/design-atoms-model";
import { ColorPreviewLoadAwaiter } from "./ColorPreviewLoadAwaiter";
export class ColorPreviewService {
    constructor(apiClient, renderingConfigProvider) {
        this._apiClient = apiClient;
        this._previews = new EquatableKeyDictionary();
        this._previewLoadedEvents = new EquatableKeyDictionary();
        this._renderingConfigProvider = renderingConfigProvider;
    }
    get _colorSettings() {
        return {
            rgbColorProfileName: this._renderingConfigProvider.getRgbColorProfileName(),
            cmykColorProfileName: this._renderingConfigProvider.getCmykColorProfileName(),
            grayscaleColorProfileName: this._renderingConfigProvider.getGrayscaleColorProfileName(),
            hiResDestinationColorProfileName: this._renderingConfigProvider.getHiResDestinationColorProfileName()
        };
    }
    getPreviews(colors) {
        if (colors == null)
            return null;
        const response = [];
        for (let i = 0; i < colors.length; i++) {
            if (colors[i] == null)
                response[i] = null;
            else
                response[i] = this._getPreview(colors[i]);
        }
        return response;
    }
    async getPreviewsAsync(colors) {
        if (colors == null)
            return null;
        const colorsToRequest = [];
        const remap = [];
        const response = [];
        const previewAwaiter = new ColorPreviewLoadAwaiter();
        const previewAwaiterIndexes = [];
        for (let i = 0; i < colors.length; i++) {
            let color = colors[i];
            if (color == null) {
                response[i] = null;
                continue;
            }
            let { hasValue: hasPreview, value: previewValue } = this._previews.tryGetValueOf(color);
            if (hasPreview) {
                response[i] = previewValue.clone();
                continue;
            }
            let { hasValue: hasRequest, value: requestValue } = this._previewLoadedEvents.tryGetValueOf(color);
            if (hasRequest) {
                previewAwaiterIndexes.push(i);
                previewAwaiter.appendColor(color);
                requestValue.add(previewAwaiter.listener);
                continue;
            }
            remap.push(i);
            colorsToRequest.push(color);
        }
        if (colorsToRequest.length > 0) {
            for (let requestColor of colorsToRequest) {
                this._previewLoadedEvents.set(requestColor, new EventObject());
            }
            const apiResult = await this._apiClient.getColorPreviews(colorsToRequest, this._colorSettings);
            if (apiResult == null || apiResult.length != colorsToRequest.length)
                throw new Error("Unexpected getColorPreviews respose");
            for (let i = 0; i < apiResult.length; i++) {
                let responseIndex = remap[i];
                let preview = apiResult[i];
                let color = colorsToRequest[i];
                this._previews.set(color, preview);
                this._notifyPreviewLoaded(color);
                response[responseIndex] = apiResult[i];
            }
        }
        if (previewAwaiterIndexes.length > 0) {
            await previewAwaiter.waitForLoad();
            for (var i of previewAwaiterIndexes) {
                let color = colors[i];
                let { hasValue: hasPreview, value: previewValue } = this._previews.tryGetValueOf(color);
                if (hasPreview) {
                    response[i] = previewValue.clone();
                }
                else {
                    console.error("Expected color to be present in previews array, but it was not.", color);
                }
            }
        }
        return response;
    }
    getPreview(color) {
        if (color == null) {
            return null;
        }
        return this._getPreview(color);
    }
    async getPreviewAsync(color) {
        const result = await this.getPreviewsAsync([color]);
        if (result == null)
            return null;
        return result[0];
    }
    subscribeToPreviewLoaded(color, listener) {
        let { hasValue, value } = this._previewLoadedEvents.tryGetValueOf(color);
        if (hasValue) {
            value.add(listener);
        }
    }
    unsubscribeFromPreviewLoaded(color, listener) {
        let { hasValue, value } = this._previewLoadedEvents.tryGetValueOf(color);
        if (hasValue) {
            value.remove(listener);
        }
    }
    _getPreview(color) {
        let { hasValue, value } = this._previews.tryGetValueOf(color);
        if (hasValue) {
            return value.clone();
        }
        if (this._previewLoadedEvents.hasEqual(color)) {
            return null;
        }
        this._previewLoadedEvents.set(color, new EventObject());
        this._requestPreviewFromServer(color);
        return null;
    }
    _notifyPreviewLoaded(color) {
        let { hasKey, key } = this._previewLoadedEvents.tryGetKeyEqualTo(color);
        if (hasKey) {
            const event = this._previewLoadedEvents.get(key);
            event.notify({ color: color });
            if (event.listenersCount() === 0) {
                this._previewLoadedEvents.delete(key);
            }
        }
    }
    _requestPreviewFromServer(color) {
        this._apiClient.getColorPreview(color, this._colorSettings)
            .then((preview) => {
            this._previews.set(color, preview);
            this._notifyPreviewLoaded(color);
        });
    }
}
//# sourceMappingURL=ColorPreviewService.js.map