advanced-cropper/node/extensions/absolute-zoom/index.js

The core of the advanced cropper libraries family

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var tslib = require('tslib');
var index = require('../../utils/index.js');
var utils = require('../../service/utils.js');
var sizeRestrictions = require('../../service/sizeRestrictions.js');
var helpers = require('../../service/helpers.js');
require('../../types/index.js');
require('../../state/setCoordinates.js');

function getMinimumVisibleAreaWidth(state, settings) {
    var _a;
    var coordinates = state.coordinates, visibleArea = state.visibleArea;
    var adjustStencil = ((_a = settings === null || settings === void 0 ? void 0 : settings.transformImage) === null || _a === void 0 ? void 0 : _a.adjustStencil) && (settings.minWidth || settings.minHeight);
    // Extend the basic settings
    settings = tslib.__assign(tslib.__assign({}, settings), { minWidth: Math.max(1, settings.minWidth || 0), minHeight: Math.max(1, settings.minHeight || 0) });
    // Prepare size restrictions
    var sizeRestrictions$1 = helpers.getSizeRestrictions(state, settings);
    // Calculate the maximum visible area image size
    var basicAreaSizeRestrictions = helpers.getAreaSizeRestrictions(state, settings);
    // Calculate maximum allowed visible area
    var minimumCoordinatesScale = index.isGreater(sizeRestrictions$1.minWidth / sizeRestrictions$1.minHeight, utils.ratio(coordinates))
        ? sizeRestrictions$1.minWidth / coordinates.width
        : sizeRestrictions$1.minHeight / coordinates.height;
    var minimumAllowedVisibleArea = {
        minHeight: visibleArea.height * minimumCoordinatesScale,
        minWidth: visibleArea.width * minimumCoordinatesScale,
    };
    var minimumVisibleArea;
    if (adjustStencil) {
        var coordinatesBox = index.isGreater(utils.ratio(visibleArea), utils.ratio(state.coordinates))
            ? {
                minHeight: state.coordinates.height,
                minWidth: state.coordinates.height * utils.ratio(visibleArea),
            }
            : {
                minWidth: state.coordinates.width,
                minHeight: state.coordinates.width / utils.ratio(visibleArea),
            };
        minimumVisibleArea = sizeRestrictions.mergeSizeRestrictions(basicAreaSizeRestrictions, {
            minWidth: Math.min(minimumAllowedVisibleArea.minWidth, coordinatesBox.minWidth),
            minHeight: Math.min(minimumAllowedVisibleArea.minHeight, coordinatesBox.minHeight),
        });
    }
    else {
        minimumVisibleArea = sizeRestrictions.mergeSizeRestrictions(basicAreaSizeRestrictions, minimumAllowedVisibleArea);
    }
    return index.isGreater(minimumVisibleArea.minWidth / minimumVisibleArea.minHeight, utils.ratio(visibleArea))
        ? minimumVisibleArea.minHeight * utils.ratio(visibleArea)
        : minimumVisibleArea.minWidth;
}
function getMaximumVisibleAreaWidth(state, settings) {
    var _a;
    var coordinates = state.coordinates, visibleArea = state.visibleArea;
    var adjustStencil = (_a = settings === null || settings === void 0 ? void 0 : settings.transformImage) === null || _a === void 0 ? void 0 : _a.adjustStencil;
    var aspectRatio = utils.ratio(coordinates);
    var sizeRestrictions$1 = helpers.getSizeRestrictions(state, settings);
    var transformedImageSize = helpers.getTransformedImageSize(state);
    // Adapt size restrictions:
    if (sizeRestrictions$1.maxWidth === Infinity) {
        sizeRestrictions$1.maxWidth = transformedImageSize.width;
    }
    if (sizeRestrictions$1.maxHeight === Infinity) {
        sizeRestrictions$1.maxHeight = transformedImageSize.height;
    }
    if (index.isGreater(sizeRestrictions$1.maxWidth / sizeRestrictions$1.maxHeight, aspectRatio)) {
        sizeRestrictions$1.maxWidth = sizeRestrictions$1.maxHeight * aspectRatio;
    }
    else {
        sizeRestrictions$1.maxHeight = sizeRestrictions$1.maxWidth / aspectRatio;
    }
    var basicAreaSizeRestrictions = helpers.getAreaSizeRestrictions(state, settings);
    var maximumCoordinatesScale = index.isGreater(sizeRestrictions$1.maxWidth / sizeRestrictions$1.maxHeight, utils.ratio(coordinates))
        ? sizeRestrictions$1.maxWidth / coordinates.width
        : sizeRestrictions$1.maxHeight / coordinates.height;
    var maximumAllowedVisibleArea = {
        maxHeight: visibleArea.height * maximumCoordinatesScale,
        maxWidth: visibleArea.width * maximumCoordinatesScale,
    };
    var maximumVisibleArea;
    if (adjustStencil) {
        var imageBox = index.isGreater(utils.ratio(visibleArea), utils.ratio(transformedImageSize))
            ? {
                maxHeight: transformedImageSize.height,
                maxWidth: transformedImageSize.height * utils.ratio(visibleArea),
            }
            : {
                maxWidth: transformedImageSize.width,
                maxHeight: transformedImageSize.height * utils.ratio(visibleArea),
            };
        maximumVisibleArea = sizeRestrictions.mergeSizeRestrictions(basicAreaSizeRestrictions, {
            maxWidth: Math.max(maximumAllowedVisibleArea.maxWidth, imageBox.maxWidth),
            maxHeight: Math.max(maximumAllowedVisibleArea.maxHeight, imageBox.maxHeight),
        });
    }
    else {
        maximumVisibleArea = sizeRestrictions.mergeSizeRestrictions(basicAreaSizeRestrictions, maximumAllowedVisibleArea);
    }
    return index.isGreater(maximumVisibleArea.maxWidth / maximumVisibleArea.maxHeight, utils.ratio(visibleArea))
        ? maximumVisibleArea.maxHeight * utils.ratio(visibleArea)
        : maximumVisibleArea.maxWidth;
}
function getVisibleAreaSize(state, settings, absoluteZoom) {
    var minSize = getMinimumVisibleAreaWidth(state, settings);
    var maxSize = getMaximumVisibleAreaWidth(state, settings);
    return maxSize - absoluteZoom * (maxSize - minSize);
}
function getAbsoluteZoom(state, settings, normalized) {
    if (normalized === void 0) { normalized = true; }
    if (helpers.isInitializedState(state)) {
        var visibleArea = state.visibleArea;
        var minSize = getMinimumVisibleAreaWidth(state, settings);
        var maxSize = getMaximumVisibleAreaWidth(state, settings);
        // This simple linear formula defines that absolute zoom is equal:
        // - 0 when `size` is equal to `maxSize`
        // - 1 when `size` is equal to `minSize`
        var value = 1 - (visibleArea.width - minSize) / (maxSize - minSize);
        return normalized ? Math.min(1, Math.max(0, value)) : value;
    }
    else {
        return 0;
    }
}
function getZoomFactor(state, settings, absoluteZoom) {
    if (helpers.isInitializedState(state)) {
        var currentAbsoluteZoom = getAbsoluteZoom(state, settings, false);
        return (getVisibleAreaSize(state, settings, currentAbsoluteZoom) / getVisibleAreaSize(state, settings, absoluteZoom));
    }
    else {
        return 1;
    }
}

exports.getAbsoluteZoom = getAbsoluteZoom;
exports.getZoomFactor = getZoomFactor;