@aurigma/design-atoms/Services/Selection/Constraints/Resize/MinDpiResizeConstraint.js

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

import { flatten } from "@aurigma/design-atoms-model";
import { extractGroupContent, getPlaceholderContent, isNonVectorImageHandler } from "../../../../ItemHandlers/HandlerUtils";
import { getResizedImageAxisDpi, minByAbs } from "../../../../Utils/Math";
import { getSelectionAreaToImageSizeRatio, isIncreasingResize } from "./Utils";
import { Section } from "./Section";
import { AxisResizeData } from "./AxisResizeData";
import { ItemUtils } from "../../../../Utils/ItemUtils";
export class MinDpiResizeConstraint {
    applyTo(selection, resizeData, minDpi) {
        let result = selection.clone();
        if (resizeData.rectangleItemHandlers == null || !isIncreasingResize(selection, resizeData)) {
            return result;
        }
        const imageHandlers = this._getHandlersToConstrain(resizeData.rectangleItemHandlers);
        if (imageHandlers.length == 0) {
            return result;
        }
        result = this._applyToX(selection, resizeData, imageHandlers, minDpi);
        result = this._applyToY(result, resizeData, imageHandlers, minDpi);
        return result;
    }
    _applyToX(selection, resizeData, imageHandlers, minDpi) {
        return this._applyToAxis(selection, resizeData, imageHandlers, minDpi, size => size.width, resolution => resolution.dpiX, AxisResizeData.fromAxisX, Section.fromAxisX, (rectangle, section) => {
            rectangle.width = section.length;
            rectangle.centerX = section.center;
        });
    }
    _applyToY(selection, resizeData, imageHandlers, minDpi) {
        return this._applyToAxis(selection, resizeData, imageHandlers, minDpi, size => size.height, resolution => resolution.dpiY, AxisResizeData.fromAxisY, Section.fromAxisY, (rectangle, section) => {
            rectangle.height = section.length;
            rectangle.centerY = section.center;
        });
    }
    _applyToAxis(selection, resizeData, imageHandlers, minDpi, axisSize, axisDpi, axisResizeData, axisSection, applySection) {
        const result = selection.clone();
        const { handler, dpi, sizeRatioToSelection } = this._getMinDpiAfterResizeImageInfo(imageHandlers, axisSize(selection), resizeData, axisSize, axisDpi);
        if (handler.startRectangle == null)
            return result;
        const source = handler.item.source;
        const sourceSize = axisSize(ItemUtils.getImageSizeInPoints(source));
        const startLeastDpi = getResizedImageAxisDpi(sourceSize, axisDpi(source), axisSize(resizeData.startRectangle) / sizeRatioToSelection);
        if (dpi < minDpi) {
            const constrained = this._constrainAxis(axisResizeData(resizeData, selection), axisSection(handler.startRectangle), { length: sourceSize, dpi: axisDpi(source), lengthRatioToSelection: sizeRatioToSelection }, startLeastDpi, minDpi);
            applySection(result, constrained);
        }
        return result;
    }
    _constrainAxis(resizeData, startAxis, imageInfo, startDpi, minDpi) {
        let result = resizeData.target;
        const isWithinStartSize = Math.abs(resizeData.target.length) < Math.abs(resizeData.start.length);
        if (startDpi < minDpi) {
            if (!isWithinStartSize) {
                result = new Section(resizeData.start.length * Math.sign(resizeData.target.length), resizeData.start.center * Math.sign(resizeData.target.length));
            }
            return result;
        }
        const minDpiLength = imageInfo.length * imageInfo.lengthRatioToSelection * Math.sign(resizeData.target.length) * imageInfo.dpi / minDpi;
        const resizeDirection = Math.sign(resizeData.target.center - startAxis.center);
        result = new Section(minByAbs(minDpiLength, resizeData.target.length), startAxis.center + (minDpiLength - startAxis.length) / 2 * resizeDirection);
        return result;
    }
    _getMinDpiAfterResizeImageInfo(imageHandlers, selectionSize, resizeData, axisSize, sourceDpi) {
        let result = {
            handler: imageHandlers[0],
            dpi: Infinity,
            sizeRatioToSelection: 0
        };
        for (let handler of imageHandlers) {
            const sizeRatioToSelection = axisSize(getSelectionAreaToImageSizeRatio(resizeData, handler));
            const afterResizeHeight = selectionSize / sizeRatioToSelection;
            const source = handler.item.source;
            const sourceSize = axisSize(ItemUtils.getImageSizeInPoints(source));
            const dpi = getResizedImageAxisDpi(sourceSize, sourceDpi(source), afterResizeHeight);
            if (dpi < result.dpi) {
                result.handler = handler;
                result.dpi = dpi;
                result.sizeRatioToSelection = sizeRatioToSelection;
            }
        }
        return result;
    }
    _getHandlersToConstrain(handlers) {
        return flatten(handlers.map(extractGroupContent))
            .map(getPlaceholderContent)
            .filter(isNonVectorImageHandler)
            .map(handler => handler);
    }
}
//# sourceMappingURL=MinDpiResizeConstraint.js.map