ps-toolkit-ui 0.0.213 → 0.0.217

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/WGLShader.js

@@ -1,470 +0,0 @@
-/* *
- *
- *  Copyright (c) 2019-2021 Highsoft AS
- *
- *  Boost module: stripped-down renderer for higher performance
- *
- *  License: highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-import U from '../../Core/Utilities.js';
-var clamp = U.clamp, error = U.error, pick = U.pick;
-/* eslint-disable valid-jsdoc */
-/**
- * A static shader mimicing axis translation functions found in Core/Axis
- *
- * @private
- * @function GLShader
- *
- * @param {WebGLContext} gl
- * the context in which the shader is active
- */
-function GLShader(gl) {
-    var vertShade = [
-        /* eslint-disable max-len, @typescript-eslint/indent */
-        '#version 100',
-        '#define LN10 2.302585092994046',
-        'precision highp float;',
-        'attribute vec4 aVertexPosition;',
-        'attribute vec4 aColor;',
-        'varying highp vec2 position;',
-        'varying highp vec4 vColor;',
-        'uniform mat4 uPMatrix;',
-        'uniform float pSize;',
-        'uniform float translatedThreshold;',
-        'uniform bool hasThreshold;',
-        'uniform bool skipTranslation;',
-        'uniform float xAxisTrans;',
-        'uniform float xAxisMin;',
-        'uniform float xAxisMinPad;',
-        'uniform float xAxisPointRange;',
-        'uniform float xAxisLen;',
-        'uniform bool  xAxisPostTranslate;',
-        'uniform float xAxisOrdinalSlope;',
-        'uniform float xAxisOrdinalOffset;',
-        'uniform float xAxisPos;',
-        'uniform bool  xAxisCVSCoord;',
-        'uniform bool  xAxisIsLog;',
-        'uniform bool  xAxisReversed;',
-        'uniform float yAxisTrans;',
-        'uniform float yAxisMin;',
-        'uniform float yAxisMinPad;',
-        'uniform float yAxisPointRange;',
-        'uniform float yAxisLen;',
-        'uniform bool  yAxisPostTranslate;',
-        'uniform float yAxisOrdinalSlope;',
-        'uniform float yAxisOrdinalOffset;',
-        'uniform float yAxisPos;',
-        'uniform bool  yAxisCVSCoord;',
-        'uniform bool  yAxisIsLog;',
-        'uniform bool  yAxisReversed;',
-        'uniform bool  isBubble;',
-        'uniform bool  bubbleSizeByArea;',
-        'uniform float bubbleZMin;',
-        'uniform float bubbleZMax;',
-        'uniform float bubbleZThreshold;',
-        'uniform float bubbleMinSize;',
-        'uniform float bubbleMaxSize;',
-        'uniform bool  bubbleSizeAbs;',
-        'uniform bool  isInverted;',
-        'float bubbleRadius(){',
-        'float value = aVertexPosition.w;',
-        'float zMax = bubbleZMax;',
-        'float zMin = bubbleZMin;',
-        'float radius = 0.0;',
-        'float pos = 0.0;',
-        'float zRange = zMax - zMin;',
-        'if (bubbleSizeAbs){',
-        'value = value - bubbleZThreshold;',
-        'zMax = max(zMax - bubbleZThreshold, zMin - bubbleZThreshold);',
-        'zMin = 0.0;',
-        '}',
-        'if (value < zMin){',
-        'radius = bubbleZMin / 2.0 - 1.0;',
-        '} else {',
-        'pos = zRange > 0.0 ? (value - zMin) / zRange : 0.5;',
-        'if (bubbleSizeByArea && pos > 0.0){',
-        'pos = sqrt(pos);',
-        '}',
-        'radius = ceil(bubbleMinSize + pos * (bubbleMaxSize - bubbleMinSize)) / 2.0;',
-        '}',
-        'return radius * 2.0;',
-        '}',
-        'float translate(float val,',
-        'float pointPlacement,',
-        'float localA,',
-        'float localMin,',
-        'float minPixelPadding,',
-        'float pointRange,',
-        'float len,',
-        'bool  cvsCoord,',
-        'bool  isLog,',
-        'bool  reversed',
-        '){',
-        'float sign = 1.0;',
-        'float cvsOffset = 0.0;',
-        'if (cvsCoord) {',
-        'sign *= -1.0;',
-        'cvsOffset = len;',
-        '}',
-        'if (isLog) {',
-        'val = log(val) / LN10;',
-        '}',
-        'if (reversed) {',
-        'sign *= -1.0;',
-        'cvsOffset -= sign * len;',
-        '}',
-        'return sign * (val - localMin) * localA + cvsOffset + ',
-        '(sign * minPixelPadding);',
-        '}',
-        'float xToPixels(float value) {',
-        'if (skipTranslation){',
-        'return value;// + xAxisPos;',
-        '}',
-        'return translate(value, 0.0, xAxisTrans, xAxisMin, xAxisMinPad, xAxisPointRange, xAxisLen, xAxisCVSCoord, xAxisIsLog, xAxisReversed);// + xAxisPos;',
-        '}',
-        'float yToPixels(float value, float checkTreshold) {',
-        'float v;',
-        'if (skipTranslation){',
-        'v = value;// + yAxisPos;',
-        '} else {',
-        'v = translate(value, 0.0, yAxisTrans, yAxisMin, yAxisMinPad, yAxisPointRange, yAxisLen, yAxisCVSCoord, yAxisIsLog, yAxisReversed);// + yAxisPos;',
-        'if (v > yAxisLen) {',
-        'v = yAxisLen;',
-        '}',
-        '}',
-        'if (checkTreshold > 0.0 && hasThreshold) {',
-        'v = min(v, translatedThreshold);',
-        '}',
-        'return v;',
-        '}',
-        'void main(void) {',
-        'if (isBubble){',
-        'gl_PointSize = bubbleRadius();',
-        '} else {',
-        'gl_PointSize = pSize;',
-        '}',
-        // 'gl_PointSize = 10.0;',
-        'vColor = aColor;',
-        'if (skipTranslation && isInverted) {',
-        // If we get translated values from JS, just swap them (x, y)
-        'gl_Position = uPMatrix * vec4(aVertexPosition.y + yAxisPos, aVertexPosition.x + xAxisPos, 0.0, 1.0);',
-        '} else if (isInverted) {',
-        // But when calculating pixel positions directly,
-        // swap axes and values (x, y)
-        'gl_Position = uPMatrix * vec4(yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, xToPixels(aVertexPosition.x) + xAxisPos, 0.0, 1.0);',
-        '} else {',
-        'gl_Position = uPMatrix * vec4(xToPixels(aVertexPosition.x) + xAxisPos, yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, 0.0, 1.0);',
-        '}',
-        // 'gl_Position = uPMatrix * vec4(aVertexPosition.x, aVertexPosition.y, 0.0, 1.0);',
-        '}'
-        /* eslint-enable max-len, @typescript-eslint/indent */
-    ].join('\n'), 
-    // Fragment shader source
-    fragShade = [
-        /* eslint-disable max-len, @typescript-eslint/indent */
-        'precision highp float;',
-        'uniform vec4 fillColor;',
-        'varying highp vec2 position;',
-        'varying highp vec4 vColor;',
-        'uniform sampler2D uSampler;',
-        'uniform bool isCircle;',
-        'uniform bool hasColor;',
-        // 'vec4 toColor(float value, vec2 point) {',
-        //     'return vec4(0.0, 0.0, 0.0, 0.0);',
-        // '}',
-        'void main(void) {',
-        'vec4 col = fillColor;',
-        'vec4 tcol = texture2D(uSampler, gl_PointCoord.st);',
-        'if (hasColor) {',
-        'col = vColor;',
-        '}',
-        'if (isCircle) {',
-        'col *= tcol;',
-        'if (tcol.r < 0.0) {',
-        'discard;',
-        '} else {',
-        'gl_FragColor = col;',
-        '}',
-        '} else {',
-        'gl_FragColor = col;',
-        '}',
-        '}'
-        /* eslint-enable max-len, @typescript-eslint/indent */
-    ].join('\n'), uLocations = {}, 
-    // The shader program
-    shaderProgram, 
-    // Uniform handle to the perspective matrix
-    pUniform, 
-    // Uniform for point size
-    psUniform, 
-    // Uniform for fill color
-    fillColorUniform, 
-    // Uniform for isBubble
-    isBubbleUniform, 
-    // Uniform for bubble abs sizing
-    bubbleSizeAbsUniform, bubbleSizeAreaUniform, 
-    // Skip translation uniform
-    skipTranslationUniform, 
-    // Set to 1 if circle
-    isCircleUniform, 
-    // Uniform for invertion
-    isInverted, 
-    // Error stack
-    errors = [], 
-    // Texture uniform
-    uSamplerUniform;
-    /**
-     * Handle errors accumulated in errors stack
-     * @private
-     */
-    function handleErrors() {
-        if (errors.length) {
-            error('[highcharts boost] shader error - ' + errors.join('\n'));
-        }
-    }
-    /**
-     * String to shader program
-     * @private
-     * @param {string} str
-     * the program source
-     * @param {string} type
-     * the program type: either `vertex` or `fragment`
-     */
-    function stringToProgram(str, type) {
-        var t = type === 'vertex' ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER, shader = gl.createShader(t);
-        gl.shaderSource(shader, str);
-        gl.compileShader(shader);
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            errors.push('when compiling ' +
-                type +
-                ' shader:\n' +
-                gl.getShaderInfoLog(shader));
-            return false;
-        }
-        return shader;
-    }
-    /**
-     * Create the shader.
-     * Loads the shader program statically defined above
-     * @private
-     */
-    function createShader() {
-        var v = stringToProgram(vertShade, 'vertex'), f = stringToProgram(fragShade, 'fragment');
-        if (!v || !f) {
-            shaderProgram = false;
-            handleErrors();
-            return false;
-        }
-        /**
-         * @private
-         */
-        function uloc(n) {
-            return gl.getUniformLocation(shaderProgram, n);
-        }
-        shaderProgram = gl.createProgram();
-        gl.attachShader(shaderProgram, v);
-        gl.attachShader(shaderProgram, f);
-        gl.linkProgram(shaderProgram);
-        if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
-            errors.push(gl.getProgramInfoLog(shaderProgram));
-            handleErrors();
-            shaderProgram = false;
-            return false;
-        }
-        gl.useProgram(shaderProgram);
-        gl.bindAttribLocation(shaderProgram, 0, 'aVertexPosition');
-        pUniform = uloc('uPMatrix');
-        psUniform = uloc('pSize');
-        fillColorUniform = uloc('fillColor');
-        isBubbleUniform = uloc('isBubble');
-        bubbleSizeAbsUniform = uloc('bubbleSizeAbs');
-        bubbleSizeAreaUniform = uloc('bubbleSizeByArea');
-        uSamplerUniform = uloc('uSampler');
-        skipTranslationUniform = uloc('skipTranslation');
-        isCircleUniform = uloc('isCircle');
-        isInverted = uloc('isInverted');
-        return true;
-    }
-    /**
-     * Destroy the shader
-     * @private
-     */
-    function destroy() {
-        if (gl && shaderProgram) {
-            gl.deleteProgram(shaderProgram);
-            shaderProgram = false;
-        }
-    }
-    /**
-     * Bind the shader.
-     * This makes the shader the active one until another one is bound,
-     * or until 0 is bound.
-     * @private
-     */
-    function bind() {
-        if (gl && shaderProgram) {
-            gl.useProgram(shaderProgram);
-        }
-    }
-    /**
-     * Set a uniform value.
-     * This uses a hash map to cache uniform locations.
-     * @private
-     * @param name {string} - the name of the uniform to set
-     * @param val {float} - the value to set
-     */
-    function setUniform(name, val) {
-        if (gl && shaderProgram) {
-            var u = uLocations[name] = (uLocations[name] ||
-                gl.getUniformLocation(shaderProgram, name));
-            gl.uniform1f(u, val);
-        }
-    }
-    /**
-     * Set the active texture
-     * @private
-     * @param texture
-     * the texture
-     */
-    function setTexture(texture) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(uSamplerUniform, texture);
-        }
-    }
-    /**
-     * Set if inversion state
-     * @private
-     * @param {number} flag
-     * is the state
-     */
-    function setInverted(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isInverted, flag);
-        }
-    }
-    /**
-     * Enable/disable circle drawing
-     * @private
-     */
-    function setDrawAsCircle(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isCircleUniform, flag ? 1 : 0);
-        }
-    }
-    /**
-     * Flush
-     * @private
-     */
-    function reset() {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isBubbleUniform, 0);
-            gl.uniform1i(isCircleUniform, 0);
-        }
-    }
-    /**
-     * Set bubble uniforms
-     * @private
-     * @param series {Highcharts.Series} - the series to use
-     */
-    function setBubbleUniforms(series, zCalcMin, zCalcMax) {
-        var seriesOptions = series.options, zMin = Number.MAX_VALUE, zMax = -Number.MAX_VALUE;
-        if (gl && shaderProgram && series.is('bubble')) {
-            var pxSizes = series.getPxExtremes();
-            zMin = pick(seriesOptions.zMin, clamp(zCalcMin, seriesOptions.displayNegative === false ?
-                seriesOptions.zThreshold : -Number.MAX_VALUE, zMin));
-            zMax = pick(seriesOptions.zMax, Math.max(zMax, zCalcMax));
-            gl.uniform1i(isBubbleUniform, 1);
-            gl.uniform1i(isCircleUniform, 1);
-            gl.uniform1i(bubbleSizeAreaUniform, (series.options.sizeBy !== 'width'));
-            gl.uniform1i(bubbleSizeAbsUniform, series.options
-                .sizeByAbsoluteValue);
-            setUniform('bubbleZMin', zMin);
-            setUniform('bubbleZMax', zMax);
-            setUniform('bubbleZThreshold', series.options.zThreshold);
-            setUniform('bubbleMinSize', pxSizes.minPxSize);
-            setUniform('bubbleMaxSize', pxSizes.maxPxSize);
-        }
-    }
-    /**
-     * Set the Color uniform.
-     * @private
-     * @param color {Array<float>} - an array with RGBA values
-     */
-    function setColor(color) {
-        if (gl && shaderProgram) {
-            gl.uniform4f(fillColorUniform, color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3]);
-        }
-    }
-    /**
-     * Set skip translation
-     * @private
-     */
-    function setSkipTranslation(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
-        }
-    }
-    /**
-     * Set the perspective matrix
-     * @private
-     * @param m {Matrix4x4} - the matrix
-     */
-    function setPMatrix(m) {
-        if (gl && shaderProgram) {
-            gl.uniformMatrix4fv(pUniform, false, m);
-        }
-    }
-    /**
-     * Set the point size.
-     * @private
-     * @param p {float} - point size
-     */
-    function setPointSize(p) {
-        if (gl && shaderProgram) {
-            gl.uniform1f(psUniform, p);
-        }
-    }
-    /**
-     * Get the shader program handle
-     * @private
-     * @return {GLInt} - the handle for the program
-     */
-    function getProgram() {
-        return shaderProgram;
-    }
-    if (gl) {
-        if (!createShader()) {
-            return false;
-        }
-    }
-    return {
-        psUniform: function () {
-            return psUniform;
-        },
-        pUniform: function () {
-            return pUniform;
-        },
-        fillColorUniform: function () {
-            return fillColorUniform;
-        },
-        setBubbleUniforms: setBubbleUniforms,
-        bind: bind,
-        program: getProgram,
-        create: createShader,
-        setUniform: setUniform,
-        setPMatrix: setPMatrix,
-        setColor: setColor,
-        setPointSize: setPointSize,
-        setSkipTranslation: setSkipTranslation,
-        setTexture: setTexture,
-        setDrawAsCircle: setDrawAsCircle,
-        reset: reset,
-        setInverted: setInverted,
-        destroy: destroy
-    };
-}
-export default GLShader;

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Boost/WGLVBuffer.js

@@ -1,153 +0,0 @@
-/* *
- *
- *  Copyright (c) 2019-2021 Highsoft AS
- *
- *  Boost module: stripped-down renderer for higher performance
- *
- *  License: highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-/* eslint-disable valid-jsdoc */
-/**
- * Vertex Buffer abstraction.
- * A vertex buffer is a set of vertices which are passed to the GPU
- * in a single call.
- *
- * @private
- * @function GLVertexBuffer
- * @param {WebGLContext} gl
- * the context in which to create the buffer
- * @param {GLShader} shader
- * the shader to use
- */
-function GLVertexBuffer(gl, shader, dataComponents
-/* , type */
-) {
-    var buffer = false, vertAttribute = false, components = dataComponents || 2, preAllocated = false, iterator = 0, 
-    // farray = false,
-    data;
-    // type = type || 'float';
-    /**
-     * @private
-     */
-    function destroy() {
-        if (buffer) {
-            gl.deleteBuffer(buffer);
-            buffer = false;
-            vertAttribute = false;
-        }
-        iterator = 0;
-        components = dataComponents || 2;
-        data = [];
-    }
-    /**
-     * Build the buffer
-     * @private
-     * @param dataIn {Array<float>} - a 0 padded array of indices
-     * @param attrib {String} - the name of the Attribute to bind the buffer to
-     * @param dataComponents {Integer} - the number of components per. indice
-     */
-    function build(dataIn, attrib, dataComponents) {
-        var farray;
-        data = dataIn || [];
-        if ((!data || data.length === 0) && !preAllocated) {
-            // console.error('trying to render empty vbuffer');
-            destroy();
-            return false;
-        }
-        components = dataComponents || components;
-        if (buffer) {
-            gl.deleteBuffer(buffer);
-        }
-        if (!preAllocated) {
-            farray = new Float32Array(data);
-        }
-        buffer = gl.createBuffer();
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, preAllocated || farray, gl.STATIC_DRAW);
-        // gl.bindAttribLocation(shader.program(), 0, 'aVertexPosition');
-        vertAttribute = gl.getAttribLocation(shader.program(), attrib);
-        gl.enableVertexAttribArray(vertAttribute);
-        // Trigger cleanup
-        farray = false;
-        return true;
-    }
-    /**
-     * Bind the buffer
-     * @private
-     */
-    function bind() {
-        if (!buffer) {
-            return false;
-        }
-        // gl.bindAttribLocation(shader.program(), 0, 'aVertexPosition');
-        // gl.enableVertexAttribArray(vertAttribute);
-        // gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.vertexAttribPointer(vertAttribute, components, gl.FLOAT, false, 0, 0);
-        // gl.enableVertexAttribArray(vertAttribute);
-    }
-    /**
-     * Render the buffer
-     * @private
-     * @param from {Integer} - the start indice
-     * @param to {Integer} - the end indice
-     * @param drawMode {String} - the draw mode
-     */
-    function render(from, to, drawMode) {
-        var length = preAllocated ?
-            preAllocated.length : data.length;
-        if (!buffer) {
-            return false;
-        }
-        if (!length) {
-            return false;
-        }
-        if (!from || from > length || from < 0) {
-            from = 0;
-        }
-        if (!to || to > length) {
-            to = length;
-        }
-        if (from >= to) {
-            return false;
-        }
-        drawMode = drawMode || 'points';
-        gl.drawArrays(gl[drawMode.toUpperCase()], from / components, (to - from) / components);
-        return true;
-    }
-    /**
-     * @private
-     */
-    function push(x, y, a, b) {
-        if (preAllocated) { // && iterator <= preAllocated.length - 4) {
-            preAllocated[++iterator] = x;
-            preAllocated[++iterator] = y;
-            preAllocated[++iterator] = a;
-            preAllocated[++iterator] = b;
-        }
-    }
-    /**
-     * Note about pre-allocated buffers:
-     *     - This is slower for charts with many series
-     * @private
-     */
-    function allocate(size) {
-        size *= 4;
-        iterator = -1;
-        preAllocated = new Float32Array(size);
-    }
-    // /////////////////////////////////////////////////////////////////////////
-    return {
-        destroy: destroy,
-        bind: bind,
-        data: data,
-        build: build,
-        render: render,
-        allocate: allocate,
-        push: push
-    };
-}
-export default GLVertexBuffer;