VaKeR CYBER ARMY
Logo of a company Server : Apache/2.4.41 (Ubuntu)
System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64
User : www-data ( 33)
PHP Version : 7.4.33
Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare,
Directory :  /var/www/html/libs/absol-full/dist/js/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : /var/www/html/libs/absol-full/dist/js/mdls__absol-vchart__src__helper.js
/*** module: node_modules/absol-vchart/src/helper.js ***/
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.circle = circle;
exports.text = text;
exports.vline = vline;
exports.moveVLine = moveVLine;
exports.hline = hline;
exports.moveHLine = moveHLine;
exports.rect = rect;
exports.line = line;
exports.calBeautySegment = calBeautySegment;
exports.autoCurve = autoCurve;
exports.generateBackgroundColors = generateBackgroundColors;
exports.isNumber = isNumber;
exports.toLocalString = toLocalString;
exports.map = map;
exports.getSubNumberArray = getSubNumberArray;
exports.wrapChartInWHResizer = wrapChartInWHResizer;
exports.paddingLeft = paddingLeft;
exports.pathTokenize = pathTokenize;
exports.getMinWidthBox = getMinWidthBox;
exports.getMinHeightBox = getMinHeightBox;
exports.getMaxWidthBox = getMaxWidthBox;
exports.getMaxHeightBox = getMaxHeightBox;
exports.lighterColor = lighterColor;
exports.fresherColor = fresherColor;
exports.wrapToLines = wrapToLines;
exports.addDevContextMenu = addDevContextMenu;
exports.measureArial14TextWidth = measureArial14TextWidth;
exports.getGlobalBBox = getGlobalBBox;
exports.beautyStep = void 0;

var _VCore = _interopRequireDefault(require("./VCore"));

var _Color = _interopRequireDefault(require("absol/src/Color/Color"));

var _Vec = _interopRequireDefault(require("absol/src/Math/Vec2"));

var _AComp = _interopRequireDefault(require("absol-acomp/AComp"));

require("./vchart.resizablediv");

var _TextMeasure = _interopRequireDefault(require("absol-acomp/js/TextMeasure"));

var _BContextCapture = _interopRequireDefault(require("absol-acomp/js/BContextCapture"));

var _Rectangle = _interopRequireDefault(require("absol/src/Math/Rectangle"));


var _ = _VCore.default._;
var beautyStep = [0.001, 0.002, 0.0025, 0.005, 0.01, 0.02, 0.025, 0.05, 0.1, 0.2, 0.25, 0.5, 1, 2, 5].concat(function () {
  var res = [];
  var h = 1;

  while (h < 10000000000) {
    res.push(10 * h);
    res.push(20 * h);
    res.push(25 * h);
    res.push(50 * h);
    h *= 10;
  }

  return res;
}());
exports.beautyStep = beautyStep;

function circle(x, y, r, eClss) {
  return _({
    tag: 'circle',
    class: eClss,
    attr: {
      cx: x,
      cy: y,
      r: r
    }
  });
}

;
/**
 * @param {String} text
 * @param {Number} x
 * @param {Number} y
 * @param {String=} eClss
 * @returns {SVGTextElement}
 */

function text(text, x, y, eClss) {
  if (eClss instanceof Array) eClss = eClss.join(' ');
  return _('<text x="' + x + '" y="' + y + '" ' + (eClss ? 'class="' + eClss + '"' : '') + '>' + text + '</text>');
}

function vline(x, y, length, eClss) {
  return _({
    tag: 'path',
    class: eClss,
    attr: {
      d: 'm' + x + ' ' + y + 'v' + length
    }
  });
}

function moveVLine(e, x, y, length) {
  return e.attr('d', 'm' + x + ' ' + y + 'v' + length);
}

function hline(x, y, length, eClss) {
  return _({
    tag: 'path',
    class: eClss,
    attr: {
      d: 'm' + x + ' ' + y + 'h' + length
    }
  });
}

function moveHLine(e, x, y, length) {
  return e.attr('d', 'm' + x + ' ' + y + 'h' + length);
}
/**
 *
 * @param {Number} x
 * @param {Number} y
 * @param {Number} width
 * @param {Number} height
 * @param {Number} eClss
 * @returns {SVGRect}
 */


function rect(x, y, width, height, eClss) {
  var option = {
    tag: 'rect',
    attr: {
      x: x,
      y: y,
      width: width,
      height: height
    },
    class: eClss
  };
  return _(option);
}

function line(x0, y0, x1, y1) {
  return _({
    tag: 'path',
    class: eClss,
    attr: {
      d: 'M' + x0 + ' ' + y0 + 'L' + x1 + ' ' + y1
    }
  });
}

function calBeautySegment(maxSegment, minValue, maxValue, integerOnly) {
  var i = 0;
  var res = {
    step: 1,
    segmentCount: maxValue - minValue,
    maxValue: maxValue,
    minValue: minValue
  };

  while (i < beautyStep.length) {
    var step = beautyStep[i];

    if (!integerOnly || step >= 1) {
      var bot = Math.floor(minValue / step);
      var top = Math.ceil(maxValue / step);

      if (top - bot <= maxSegment) {
        res.step = step;
        res.segmentCount = top - bot;
        res.maxValue = top * step;
        res.minValue = bot * step;
        break;
      }
    }

    ++i;
  }

  return res;
} //x[i] < x[i+1]


function autoCurve(points, strong, free) {
  if (!(strong > 0)) strong = 0.5;

  if (points.length == 0) {
    return '';
  }

  var paddingLeft = points[0].slice();
  var paddingRight = points[points.length - 1].slice();

  if (typeof free == "number") {
    paddingLeft[0] -= (points[1][0] - points[0][0]) * free;
    paddingLeft[1] -= (points[1][1] - points[0][1]) * free;
    paddingRight[0] += (points[points.length - 1][0] - points[points.length - 2][0]) * free;
    paddingRight[1] += (points[points.length - 1][1] - points[points.length - 2][1]) * free;
  } else if (free instanceof Array) {
    paddingLeft[0] -= free[0][0];
    paddingLeft[1] -= free[0][1];
    paddingRight[0] += free[1][0];
    paddingRight[1] += free[1][1];
  }

  points = [paddingLeft].concat(points).concat([paddingRight]);
  var Cs = [];
  Cs.push('M' + points[1].join(' '));

  for (var i = 1; i < points.length - 2; ++i) {
    var A = _Vec.default.make(points[i - 1]);

    var B = _Vec.default.make(points[i]);

    var C = _Vec.default.make(points[i + 1]);

    var D = _Vec.default.make(points[i + 2]);

    var AB = B.sub(A);
    var BC = C.sub(B);
    var CB = BC.inv();
    var DC = C.sub(D);
    var lAB = AB.abs();
    var lBC = BC.abs();
    var lDC = DC.abs();
    var lCB = lBC;
    var h1 = Math.sqrt(lAB * lBC);
    var h2 = Math.sqrt(lBC * lDC);
    if (h1 == 0) h1 = 1;
    if (h2 == 0) h2 = 1;
    var N1 = AB.normalized().add(BC.normalized()).normalized();
    var N2 = CB.normalized().add(DC.normalized()).normalized();
    var lN1 = lBC == 0 ? 0 : lBC * (N1.dot(BC) / (N1.abs() * BC.abs())) * h1 / (h1 + h2) * strong;
    var lN2 = lCB == 0 ? 0 : lCB * (N2.dot(CB) / (N2.abs() * CB.abs())) * h2 / (h1 + h2) * strong;
    N1 = N1.mult(lN1);
    N2 = N2.mult(lN2);
    var P1 = B.add(N1);
    var P2 = C.add(N2);
    var x1 = P1.x;
    var y1 = P1.y;
    var x2 = P2.x;
    var y2 = P2.y;
    var x = C.x;
    var y = C.y;
    Cs.push('C ' + x1 + ' ' + y1 + ', ' + x2 + ' ' + y2 + ', ' + x + ' ' + y);
  }

  return Cs.join('');
}

;

function generateBackgroundColors(n) {
  var l = Math.ceil(Math.sqrt(n));
  var arrs = Array(n).fill(null).reduce(function (ac, cr, i) {
    var tail = ac[ac.length - 1];

    if (tail.length >= l) {
      tail = [];
      ac.push(tail);
    }

    var color = _Color.default.fromHSL(i / n, 0.5, 0.5);

    tail.push(color);
    return ac;
  }, [[]]);
  var res = [];
  var i = 0;

  while (res.length < n) {
    if (arrs[i].length > 0) {
      res.push(arrs[i].shift());
    }

    i = (i + 1) % arrs.length;
  }

  return res;
}

function isNumber(x) {
  return -Infinity < x && x < Infinity && typeof x == 'number';
}

function toLocalString(fixedRight) {
  var separatorReal = 1.5.toLocaleString().replace(/[0-9]/g, '');
  var separatorInt = 10000 .toLocaleString().replace(/[0-9]/g, '');
  return function (value) {
    var x = Math.abs(value);
    if (fixedRight !== undefined) x = x.toFixed(fixedRight);
    var s = x.toString().split('.');
    var int = s[0] || '';
    var realText = s[1] || '';
    int = int.split('').reduce(function (ac, cr, i, arr) {
      if (i == 0 || (arr.length - i) % 3 == 0) {
        ac.push(cr);
      } else {
        ac[ac.length - 1] += cr;
      }

      return ac;
    }, []).join(separatorInt);
    return (value < 0 ? '-' : '') + int + (realText.length > 0 ? separatorReal + realText : '');
  };
}

;

function map(x, l, h, L, H) {
  return L + (x - l) * (H - L) / (h - l);
}

function getSubNumberArray(arr) {
  return arr.reduce(function (ac, value, j) {
    if (isNumber(value)) {
      var cr;

      if (ac.last + 1 < j) {
        cr = {
          start: j,
          values: []
        };
        ac.currentSubArea = cr;
        ac.result.push(cr);
      } else {
        cr = ac.currentSubArea;
      }

      ac.last = j;
      cr.values.push(value);
    }

    return ac;
  }, {
    last: -100,
    result: [],
    currentSubArea: null
  }).result;
}

function wrapChartInWHResizer(chartElt, outerParam) {
  outerParam = outerParam || {};
  var newVersion = chartElt.containsClass('ag-canvas');

  if (newVersion) {
    outerParam.style = outerParam.style || {};
    outerParam.style.width = outerParam.width || chartElt.style.width;
    outerParam.style.height = outerParam.width || chartElt.style.height;

    if (chartElt._isAutoWidth) {
      outerParam.style.width = 'auto';
      chartElt.addStyle({
        height: '100%'
      });
      setTimeout(function () {
        res.addStyle('width', chartElt.getBoundingClientRect().width + 'px');
        chartElt.addStyle({
          width: '100%',
          height: '100%'
        });
      }, 1000);
    } else {
      chartElt.addStyle({
        width: '100%',
        height: '100%'
      });
    }
  }

  var res = _AComp.default._({
    tag: 'resizablediv',
    style: {
      display: 'inline-block',
      verticalAlign: 'top'
    },
    child: chartElt,
    on: {
      sizechange: function (event) {
        if (chartElt.update) {
          if (event.width) {
            chartElt.canvasWidth = event.width;
          }

          if (event.height) {
            chartElt.canvasHeight = event.height;
          }

          chartElt.update();
        } else if (newVersion) {
          chartElt.updateSize();
        }
      }
    }
  }, false, true).addStyle(outerParam.style || {});

  return res;
}

function paddingLeft(text, char, length) {
  while (text.length < length) text = char + '' + text;

  return text;
}
/**
 *
 * @param {String} text
 */


function pathTokenize(text) {
  return text.match(/[a-zA-Z]+|(\-?[0-9\.]+(e\-?[0-9]+)?)/g);
}
/**
 * @argument {Array<SVGElement>}
 * @returns {Number}
 */


function getMinWidthBox() {
  return Array.prototype.reduce.call(arguments, function (ac, elt) {
    return Math.min(ac, elt.getBBox().width);
  }, 100000000);
}
/**
 * @argument {Array<SVGElement>}
 * @returns {Number}
 */


function getMinHeightBox() {
  return Array.prototype.reduce.call(arguments, function (ac, elt) {
    return Math.min(ac, elt.getBBox().height);
  }, 100000000);
}
/**
 * @argument {Array<SVGElement>}
 * @returns {Number}
 */


function getMaxWidthBox() {
  return Array.prototype.reduce.call(arguments, function (ac, elt) {
    return Math.max(ac, elt.getBBox().width);
  }, -100000000);
}
/**
 * @argument {Array<SVGElement>}
 * @returns {Number}
 */


function getMaxHeightBox() {
  return Array.prototype.reduce.call(arguments, function (ac, elt) {
    return Math.max(ac, elt.getBBox().height);
  }, -100000000);
}
/**
 *
 * @param {import ('absol/src/Color/Color').default} color
 * @returns {import ('absol/src/Color/Color').default}
 */


function lighterColor(color, delta) {
  delta = delta || 0;
  var hsla = color.toHSLA();
  hsla[2] = Math.max(0, Math.min(1, hsla[2] + delta));
  return _Color.default.fromHSLA.apply(_Color.default, hsla);
}

function fresherColor(color, delta) {
  delta = delta || 0.2;
  var hsla = color.toHSLA();
  hsla[1] = Math.max(0, Math.min(1, hsla[1] + delta));
  return _Color.default.fromHSLA.apply(_Color.default, hsla);
}
/***
 * Default font size: Arial
 * @param {string} text
 * @param {number} fontSize
 * @param {number} width
 */


function wrapToLines(text, fontSize, width) {
  var words = text.split(' ');
  var line = [words.shift()];
  var lines = [line];
  var newText;

  for (var i = 0; i < words.length; ++i) {
    newText = line.concat([words[i]]).join(' ');

    if (_TextMeasure.default.measureWidth(newText, 'Arial', 14) <= width) {
      line.push(words[i]);
    } else {
      line = [words[i]];
      lines.push(line);
    }
  }

  for (var i = 0; i < lines.length; ++i) {
    lines[i] = lines[i].join(' ');
  }

  return lines;
}

function addDevContextMenu(svg) {
  _BContextCapture.default.auto();

  svg.defineEvent('contextmenu');
  svg.on({
    contextmenu: function (event) {
      var img = this;
      event.showContextMenu({
        items: [{
          icon: 'span.mdi.mdi-download-outline',
          text: 'Download as SVG',
          cmd: 'download'
        }]
      }, function (ev) {
        var menuItem = ev.menuItem;

        if (menuItem.cmd === 'download') {
          var url = absol.Svg.svgToSvgUrl(img);

          var a = absol._({
            tag: 'a',
            style: {
              display: 'none'
            },
            attr: {
              href: url,
              download: 'export.svg'
            }
          }).addTo(document.body);

          a.click();
          a.remove();
        }
      });
    }
  });
}

function measureArial14TextWidth(text) {
  return _TextMeasure.default.measureWidth(text, 'Arial', 14);
}

function getGlobalBBox(svgElement) {
  var bbox = svgElement.getBBox();
  var matrix = svgElement.getCTM();
  var points = [svgElement.ownerSVGElement.createSVGPoint(), svgElement.ownerSVGElement.createSVGPoint(), svgElement.ownerSVGElement.createSVGPoint(), svgElement.ownerSVGElement.createSVGPoint()];
  points[0].x = bbox.x;
  points[0].y = bbox.y;
  points[1].x = bbox.x + bbox.width;
  points[1].y = bbox.y;
  points[2].x = bbox.x;
  points[2].y = bbox.y + bbox.height;
  points[3].x = bbox.x + bbox.width;
  points[3].y = bbox.y + bbox.height;
  points = points.map(function (point) {
    return point.matrixTransform(matrix);
  });
  var minX = Math.min(points[0].x, points[1].x, points[2].x, points[3].x);
  var minY = Math.min(points[0].y, points[1].y, points[2].y, points[3].y);
  var maxX = Math.max(points[0].x, points[1].x, points[2].x, points[3].x);
  var maxY = Math.max(points[0].y, points[1].y, points[2].y, points[3].y);
  return new _Rectangle.default(minX, minY, maxX - minX, maxY - minY);
}

VaKeR 2022