204 lines
9.0 KiB
JavaScript
204 lines
9.0 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
var _typeof = require("@babel/runtime/helpers/typeof");
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = useOffset;
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
var React = _interopRequireWildcard(require("react"));
|
|
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
function useOffset(min, max, step, markList, allowCross, pushable) {
|
|
var formatRangeValue = React.useCallback(function (val) {
|
|
var formatNextValue = isFinite(val) ? val : min;
|
|
formatNextValue = Math.min(max, val);
|
|
formatNextValue = Math.max(min, formatNextValue);
|
|
return formatNextValue;
|
|
}, [min, max]);
|
|
var formatStepValue = React.useCallback(function (val) {
|
|
if (step !== null) {
|
|
var stepValue = min + Math.round((formatRangeValue(val) - min) / step) * step;
|
|
// Cut number in case to be like 0.30000000000000004
|
|
var getDecimal = function getDecimal(num) {
|
|
return (String(num).split('.')[1] || '').length;
|
|
};
|
|
var maxDecimal = Math.max(getDecimal(step), getDecimal(max), getDecimal(min));
|
|
var fixedValue = Number(stepValue.toFixed(maxDecimal));
|
|
return min <= fixedValue && fixedValue <= max ? fixedValue : null;
|
|
}
|
|
return null;
|
|
}, [step, min, max, formatRangeValue]);
|
|
var formatValue = React.useCallback(function (val) {
|
|
var formatNextValue = formatRangeValue(val);
|
|
// List align values
|
|
var alignValues = markList.map(function (mark) {
|
|
return mark.value;
|
|
});
|
|
if (step !== null) {
|
|
alignValues.push(formatStepValue(val));
|
|
}
|
|
// min & max
|
|
alignValues.push(min, max);
|
|
// Align with marks
|
|
var closeValue = alignValues[0];
|
|
var closeDist = max - min;
|
|
alignValues.forEach(function (alignValue) {
|
|
var dist = Math.abs(formatNextValue - alignValue);
|
|
if (dist <= closeDist) {
|
|
closeValue = alignValue;
|
|
closeDist = dist;
|
|
}
|
|
});
|
|
return closeValue;
|
|
}, [min, max, markList, step, formatRangeValue, formatStepValue]);
|
|
// ========================== Offset ==========================
|
|
// Single Value
|
|
var offsetValue = function offsetValue(values, offset, valueIndex) {
|
|
var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
|
|
if (typeof offset === 'number') {
|
|
var nextValue;
|
|
var originValue = values[valueIndex];
|
|
// Only used for `dist` mode
|
|
var targetDistValue = originValue + offset;
|
|
// Compare next step value & mark value which is best match
|
|
var potentialValues = [];
|
|
markList.forEach(function (mark) {
|
|
potentialValues.push(mark.value);
|
|
});
|
|
// Min & Max
|
|
potentialValues.push(min, max);
|
|
// In case origin value is align with mark but not with step
|
|
potentialValues.push(formatStepValue(originValue));
|
|
// Put offset step value also
|
|
var sign = offset > 0 ? 1 : -1;
|
|
if (mode === 'unit') {
|
|
potentialValues.push(formatStepValue(originValue + sign * step));
|
|
} else {
|
|
potentialValues.push(formatStepValue(targetDistValue));
|
|
}
|
|
// Find close one
|
|
potentialValues = potentialValues.filter(function (val) {
|
|
return val !== null;
|
|
})
|
|
// Remove reverse value
|
|
.filter(function (val) {
|
|
return offset < 0 ? val <= originValue : val >= originValue;
|
|
});
|
|
if (mode === 'unit') {
|
|
// `unit` mode can not contain itself
|
|
potentialValues = potentialValues.filter(function (val) {
|
|
return val !== originValue;
|
|
});
|
|
}
|
|
var compareValue = mode === 'unit' ? originValue : targetDistValue;
|
|
nextValue = potentialValues[0];
|
|
var valueDist = Math.abs(nextValue - compareValue);
|
|
potentialValues.forEach(function (potentialValue) {
|
|
var dist = Math.abs(potentialValue - compareValue);
|
|
if (dist < valueDist) {
|
|
nextValue = potentialValue;
|
|
valueDist = dist;
|
|
}
|
|
});
|
|
// Out of range will back to range
|
|
if (nextValue === undefined) {
|
|
return offset < 0 ? min : max;
|
|
}
|
|
// `dist` mode
|
|
if (mode === 'dist') {
|
|
return nextValue;
|
|
}
|
|
// `unit` mode may need another round
|
|
if (Math.abs(offset) > 1) {
|
|
var cloneValues = (0, _toConsumableArray2.default)(values);
|
|
cloneValues[valueIndex] = nextValue;
|
|
return offsetValue(cloneValues, offset - sign, valueIndex, mode);
|
|
}
|
|
return nextValue;
|
|
} else if (offset === 'min') {
|
|
return min;
|
|
} else if (offset === 'max') {
|
|
return max;
|
|
}
|
|
};
|
|
/** Same as `offsetValue` but return `changed` mark to tell value changed */
|
|
var offsetChangedValue = function offsetChangedValue(values, offset, valueIndex) {
|
|
var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
|
|
var originValue = values[valueIndex];
|
|
var nextValue = offsetValue(values, offset, valueIndex, mode);
|
|
return {
|
|
value: nextValue,
|
|
changed: nextValue !== originValue
|
|
};
|
|
};
|
|
var needPush = function needPush(dist) {
|
|
return pushable === null && dist === 0 || typeof pushable === 'number' && dist < pushable;
|
|
};
|
|
// Values
|
|
var offsetValues = function offsetValues(values, offset, valueIndex) {
|
|
var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
|
|
var nextValues = values.map(formatValue);
|
|
var originValue = nextValues[valueIndex];
|
|
var nextValue = offsetValue(nextValues, offset, valueIndex, mode);
|
|
nextValues[valueIndex] = nextValue;
|
|
if (allowCross === false) {
|
|
// >>>>> Allow Cross
|
|
var pushNum = pushable || 0;
|
|
// ============ AllowCross ===============
|
|
if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) {
|
|
nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
|
|
}
|
|
if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) {
|
|
nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
|
|
}
|
|
} else if (typeof pushable === 'number' || pushable === null) {
|
|
// >>>>> Pushable
|
|
// =============== Push ==================
|
|
// >>>>>> Basic push
|
|
// End values
|
|
for (var i = valueIndex + 1; i < nextValues.length; i += 1) {
|
|
var changed = true;
|
|
while (needPush(nextValues[i] - nextValues[i - 1]) && changed) {
|
|
var _offsetChangedValue = offsetChangedValue(nextValues, 1, i);
|
|
nextValues[i] = _offsetChangedValue.value;
|
|
changed = _offsetChangedValue.changed;
|
|
}
|
|
}
|
|
// Start values
|
|
for (var _i = valueIndex; _i > 0; _i -= 1) {
|
|
var _changed = true;
|
|
while (needPush(nextValues[_i] - nextValues[_i - 1]) && _changed) {
|
|
var _offsetChangedValue2 = offsetChangedValue(nextValues, -1, _i - 1);
|
|
nextValues[_i - 1] = _offsetChangedValue2.value;
|
|
_changed = _offsetChangedValue2.changed;
|
|
}
|
|
}
|
|
// >>>>> Revert back to safe push range
|
|
// End to Start
|
|
for (var _i2 = nextValues.length - 1; _i2 > 0; _i2 -= 1) {
|
|
var _changed2 = true;
|
|
while (needPush(nextValues[_i2] - nextValues[_i2 - 1]) && _changed2) {
|
|
var _offsetChangedValue3 = offsetChangedValue(nextValues, -1, _i2 - 1);
|
|
nextValues[_i2 - 1] = _offsetChangedValue3.value;
|
|
_changed2 = _offsetChangedValue3.changed;
|
|
}
|
|
}
|
|
// Start to End
|
|
for (var _i3 = 0; _i3 < nextValues.length - 1; _i3 += 1) {
|
|
var _changed3 = true;
|
|
while (needPush(nextValues[_i3 + 1] - nextValues[_i3]) && _changed3) {
|
|
var _offsetChangedValue4 = offsetChangedValue(nextValues, 1, _i3 + 1);
|
|
nextValues[_i3 + 1] = _offsetChangedValue4.value;
|
|
_changed3 = _offsetChangedValue4.changed;
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
value: nextValues[valueIndex],
|
|
values: nextValues
|
|
};
|
|
};
|
|
return [formatValue, offsetValues];
|
|
} |