@privjs/gradients/bin/lib/utils.js

Javascript utility to generate beautiful gradient backgrounds. Built by the team behind [privjs.com](https://privjs.com)

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRandomCurve = exports.seededPick = exports.seededRandom = exports.normalize = exports.getYValueForBezier = void 0;
const seedrandom_1 = __importDefault(require("seedrandom"));
const presets_1 = require("./presets");
const getValuesForBezierCurve = ({ startPoint, endPoint, controlPoint1, controlPoint2 }, t) => {
    let x, y;
    if (controlPoint2) {
        // Cubic Bezier curve
        x =
            (1 - t) ** 3 * startPoint[0] +
                3 * (1 - t) ** 2 * t * controlPoint1[0] +
                3 * (1 - t) * t ** 2 * controlPoint2[0] +
                t ** 3 * endPoint[0];
        y =
            (1 - t) ** 3 * startPoint[1] +
                3 * (1 - t) ** 2 * t * controlPoint1[1] +
                3 * (1 - t) * t ** 2 * controlPoint2[1] +
                t ** 3 * endPoint[1];
    }
    else {
        // Quadratic Bezier curve
        x =
            (1 - t) * (1 - t) * startPoint[0] +
                2 * (1 - t) * t * controlPoint1[0] +
                t * t * endPoint[0];
        y =
            (1 - t) * (1 - t) * startPoint[1] +
                2 * (1 - t) * t * controlPoint1[1] +
                t * t * endPoint[1];
    }
    return [x, y];
};
const getYValueForBezier = function (xTarget, x1, y1, x2, y2) {
    var xTolerance = 0.0001;
    var myBezier = function (t) {
        return getValuesForBezierCurve({
            startPoint: [0, 0],
            controlPoint1: [x1, y1],
            controlPoint2: [x2, y2],
            endPoint: [1, 1],
        }, t);
    };
    // Binary search to find an approximation for `X`
    //establish bounds
    var lower = 0;
    var upper = 1;
    var percent = (upper + lower) / 2;
    var x = myBezier(percent)[0];
    while (Math.abs(xTarget - x) > xTolerance) {
        if (xTarget > x)
            lower = percent;
        else
            upper = percent;
        percent = (upper + lower) / 2;
        x = myBezier(percent)[0];
    }
    return myBezier(percent)[1];
};
exports.getYValueForBezier = getYValueForBezier;
const normalize = (number, currentScaleMin, currentScaleMax, newScaleMin = 0, newScaleMax = 1) => {
    // FIrst, normalize the value between 0 and 1.
    const standardNormalization = (number - currentScaleMin) / (currentScaleMax - currentScaleMin);
    // Next, transpose that value to our desired scale.
    return (newScaleMax - newScaleMin) * standardNormalization + newScaleMin;
};
exports.normalize = normalize;
(0, seedrandom_1.default)('UNIQUE_SALT', { global: true });
const seededRandom = (seed, range = [0, 1]) => {
    return Math.floor((0, seedrandom_1.default)(seed)() * (range[1] - range[0]) + range[0]);
};
exports.seededRandom = seededRandom;
const seededPick = (seed, arr) => {
    const indx = (0, exports.seededRandom)(seed, [0, arr.length - 1]);
    return arr[indx];
};
exports.seededPick = seededPick;
function getRandomCurve(seed = '') {
    const presets = presets_1.CURVE_PRESETS.map((preset) => preset.curve);
    return (0, exports.seededPick)(seed, [...presets]);
}
exports.getRandomCurve = getRandomCurve;