advanced-cropper
Version:
The core of the advanced cropper libraries family
133 lines (130 loc) • 6.57 kB
JavaScript
import { __assign } from 'tslib';
import { isGreater } from '../../utils/index.js';
import { ratio } from '../../service/utils.js';
import { mergeSizeRestrictions } from '../../service/sizeRestrictions.js';
import { isInitializedState, getSizeRestrictions, getAreaSizeRestrictions, getTransformedImageSize } from '../../service/helpers.js';
import '../../types/index.js';
import '../../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 = __assign(__assign({}, settings), { minWidth: Math.max(1, settings.minWidth || 0), minHeight: Math.max(1, settings.minHeight || 0) });
// Prepare size restrictions
var sizeRestrictions = getSizeRestrictions(state, settings);
// Calculate the maximum visible area image size
var basicAreaSizeRestrictions = getAreaSizeRestrictions(state, settings);
// Calculate maximum allowed visible area
var minimumCoordinatesScale = isGreater(sizeRestrictions.minWidth / sizeRestrictions.minHeight, ratio(coordinates))
? sizeRestrictions.minWidth / coordinates.width
: sizeRestrictions.minHeight / coordinates.height;
var minimumAllowedVisibleArea = {
minHeight: visibleArea.height * minimumCoordinatesScale,
minWidth: visibleArea.width * minimumCoordinatesScale,
};
var minimumVisibleArea;
if (adjustStencil) {
var coordinatesBox = isGreater(ratio(visibleArea), ratio(state.coordinates))
? {
minHeight: state.coordinates.height,
minWidth: state.coordinates.height * ratio(visibleArea),
}
: {
minWidth: state.coordinates.width,
minHeight: state.coordinates.width / ratio(visibleArea),
};
minimumVisibleArea = mergeSizeRestrictions(basicAreaSizeRestrictions, {
minWidth: Math.min(minimumAllowedVisibleArea.minWidth, coordinatesBox.minWidth),
minHeight: Math.min(minimumAllowedVisibleArea.minHeight, coordinatesBox.minHeight),
});
}
else {
minimumVisibleArea = mergeSizeRestrictions(basicAreaSizeRestrictions, minimumAllowedVisibleArea);
}
return isGreater(minimumVisibleArea.minWidth / minimumVisibleArea.minHeight, ratio(visibleArea))
? minimumVisibleArea.minHeight * 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 = ratio(coordinates);
var sizeRestrictions = getSizeRestrictions(state, settings);
var transformedImageSize = getTransformedImageSize(state);
// Adapt size restrictions:
if (sizeRestrictions.maxWidth === Infinity) {
sizeRestrictions.maxWidth = transformedImageSize.width;
}
if (sizeRestrictions.maxHeight === Infinity) {
sizeRestrictions.maxHeight = transformedImageSize.height;
}
if (isGreater(sizeRestrictions.maxWidth / sizeRestrictions.maxHeight, aspectRatio)) {
sizeRestrictions.maxWidth = sizeRestrictions.maxHeight * aspectRatio;
}
else {
sizeRestrictions.maxHeight = sizeRestrictions.maxWidth / aspectRatio;
}
var basicAreaSizeRestrictions = getAreaSizeRestrictions(state, settings);
var maximumCoordinatesScale = isGreater(sizeRestrictions.maxWidth / sizeRestrictions.maxHeight, ratio(coordinates))
? sizeRestrictions.maxWidth / coordinates.width
: sizeRestrictions.maxHeight / coordinates.height;
var maximumAllowedVisibleArea = {
maxHeight: visibleArea.height * maximumCoordinatesScale,
maxWidth: visibleArea.width * maximumCoordinatesScale,
};
var maximumVisibleArea;
if (adjustStencil) {
var imageBox = isGreater(ratio(visibleArea), ratio(transformedImageSize))
? {
maxHeight: transformedImageSize.height,
maxWidth: transformedImageSize.height * ratio(visibleArea),
}
: {
maxWidth: transformedImageSize.width,
maxHeight: transformedImageSize.height * ratio(visibleArea),
};
maximumVisibleArea = mergeSizeRestrictions(basicAreaSizeRestrictions, {
maxWidth: Math.max(maximumAllowedVisibleArea.maxWidth, imageBox.maxWidth),
maxHeight: Math.max(maximumAllowedVisibleArea.maxHeight, imageBox.maxHeight),
});
}
else {
maximumVisibleArea = mergeSizeRestrictions(basicAreaSizeRestrictions, maximumAllowedVisibleArea);
}
return isGreater(maximumVisibleArea.maxWidth / maximumVisibleArea.maxHeight, ratio(visibleArea))
? maximumVisibleArea.maxHeight * 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 (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 (isInitializedState(state)) {
var currentAbsoluteZoom = getAbsoluteZoom(state, settings, false);
return (getVisibleAreaSize(state, settings, currentAbsoluteZoom) / getVisibleAreaSize(state, settings, absoluteZoom));
}
else {
return 1;
}
}
export { getAbsoluteZoom, getZoomFactor };