+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Traffic Overview
+
+
+
+
+
+
+
+
+
+
+
+
+
Productivity Tips!
+
Duis at orci justo nulla in libero id leo
+ molestie sodales phasellus justo.
+
View All Tips
+
+
+
+
+
+
+
View by page title and screen class
+
+
+
+
+ Page Title
+ Link
+ Pageviews
+ Page Value
+
+
+
+
+
+ Welcome to our
+ website
+
+
+ /index.html
+
+ 18,456
+ $2.40
+
+
+
+ Modern Admin
+ Dashboard Template
+
+
+ /dashboard
+
+ 17,452
+ $0.97
+
+
+
+ Explore our
+ product catalog
+
+
+ /product-checkout
+
+ 12,180
+ $7,50
+
+
+
+ Comprehensive
+ User Guide
+
+
+ /docs
+
+ 800
+ $5,50
+
+
+
+ Check out our
+ services
+
+
+ /services
+
+ 1300
+ $2,15
+
+
+
+
+
+
+
+
+
+
+
Sessions by
+ device
+
+
+ Computers
+
87%
+
+
+ Smartphone
+
9.2%
+
+
+ Tablets
+
3.1%
+
+
+
+
+
+
+ Computers
+
87%
+
+
+
+
+
+
+ Smartphones
+
9.2%
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2
+ min Read
+
+
+
+
+
+
+
+
+
+
+
2
+ min Read
+
+
+
+
+
+
+
+
+
+
+
2
+ min Read
+
+
+
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/sample-page.html b/cao_sunyata/static/html-SEODash/sample-page.html
new file mode 100644
index 0000000..fb74cbb
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/sample-page.html
@@ -0,0 +1,222 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Sample Page
+
This is a sample page
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/ui-alerts.html b/cao_sunyata/static/html-SEODash/ui-alerts.html
new file mode 100644
index 0000000..3628dba
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/ui-alerts.html
@@ -0,0 +1,249 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Alerts
+
+
+
+ A simple primary alert—check it out!
+
+
+ A simple secondary alert—check it out!
+
+
+ A simple success alert—check it out!
+
+
+ A simple danger alert—check it out!
+
+
+ A simple warning alert—check it out!
+
+
+ A simple info alert—check it out!
+
+
+ A simple light alert—check it out!
+
+
+ A simple dark alert—check it out!
+
+
+
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/ui-buttons.html b/cao_sunyata/static/html-SEODash/ui-buttons.html
new file mode 100644
index 0000000..335f8d2
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/ui-buttons.html
@@ -0,0 +1,248 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Buttons
+
+
+ Primary
+ Secondary
+ Success
+ Danger
+ Warning
+ Info
+ Light
+ Dark
+ Link
+
+
+
Outline buttons
+
+
+ Primary
+ Secondary
+ Success
+ Danger
+ Warning
+ Info
+ Light
+ Dark
+ Link
+
+
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/ui-card.html b/cao_sunyata/static/html-SEODash/ui-card.html
new file mode 100644
index 0000000..a5cf7ae
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/ui-card.html
@@ -0,0 +1,262 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Card
+
+
+
+
Card title
+
Some quick example text to build on the card title and make up the bulk of
+ the
+ card's content.
+
Go somewhere
+
+
+
+
+
Header and footer
+
+
+
+
Special title treatment
+
With supporting text below as a natural lead-in to additional content.
+
Go somewhere
+
+
+
+
+
Titles, text, and links
+
+
+
Card title
+
Card subtitle
+
Some quick example text to build on the card title and make up the bulk of
+ the
+ card's content.
+
Card link
+
Another link
+
+
+
+
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/ui-forms.html b/cao_sunyata/static/html-SEODash/ui-forms.html
new file mode 100644
index 0000000..64227e8
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/ui-forms.html
@@ -0,0 +1,270 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/html-SEODash/ui-typography.html b/cao_sunyata/static/html-SEODash/ui-typography.html
new file mode 100644
index 0000000..c47c4e8
--- /dev/null
+++ b/cao_sunyata/static/html-SEODash/ui-typography.html
@@ -0,0 +1,244 @@
+
+
+
+
+
+
+
SeoDash Free Bootstrap Admin Template by Adminmart
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Headings
+
+
+
h1. Bootstrap heading
+ h2. Bootstrap heading
+ h3. Bootstrap heading
+ h4. Bootstrap heading
+ h5. Bootstrap heading
+ h6. Bootstrap heading
+
+
+
Inline text elements
+
+
+
You can use the mark tag to highlight text.
+
This line of text is meant to be treated as deleted text.
+
This line of text is meant to be treated as no longer accurate.
+
This line of text is meant to be treated as an addition to the document.
+
This line of text will render as underlined.
+
This line of text is meant to be treated as fine print.
+
This line rendered as bold text.
+
This line rendered as italicized text.
+
+
+
+
+
+
Design and Developed by AdminMart.com Distributed by ThemeWagon
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/images/backgrounds/product-tip.png b/cao_sunyata/static/images/backgrounds/product-tip.png
new file mode 100644
index 0000000..c39565f
Binary files /dev/null and b/cao_sunyata/static/images/backgrounds/product-tip.png differ
diff --git a/cao_sunyata/static/images/backgrounds/rocket.png b/cao_sunyata/static/images/backgrounds/rocket.png
new file mode 100644
index 0000000..5ee44a9
Binary files /dev/null and b/cao_sunyata/static/images/backgrounds/rocket.png differ
diff --git a/cao_sunyata/static/images/blog/blog-img1.jpg b/cao_sunyata/static/images/blog/blog-img1.jpg
new file mode 100644
index 0000000..94204af
Binary files /dev/null and b/cao_sunyata/static/images/blog/blog-img1.jpg differ
diff --git a/cao_sunyata/static/images/blog/blog-img2.jpg b/cao_sunyata/static/images/blog/blog-img2.jpg
new file mode 100644
index 0000000..1595772
Binary files /dev/null and b/cao_sunyata/static/images/blog/blog-img2.jpg differ
diff --git a/cao_sunyata/static/images/blog/blog-img3.jpg b/cao_sunyata/static/images/blog/blog-img3.jpg
new file mode 100644
index 0000000..b065626
Binary files /dev/null and b/cao_sunyata/static/images/blog/blog-img3.jpg differ
diff --git a/cao_sunyata/static/images/logos/logo-light.svg b/cao_sunyata/static/images/logos/logo-light.svg
new file mode 100644
index 0000000..229b5d6
--- /dev/null
+++ b/cao_sunyata/static/images/logos/logo-light.svg
@@ -0,0 +1,12 @@
+
+
diff --git a/cao_sunyata/static/images/logos/seodashlogo.png b/cao_sunyata/static/images/logos/seodashlogo.png
new file mode 100644
index 0000000..40a6a8a
Binary files /dev/null and b/cao_sunyata/static/images/logos/seodashlogo.png differ
diff --git a/cao_sunyata/static/images/products/s1.jpg b/cao_sunyata/static/images/products/s1.jpg
new file mode 100644
index 0000000..144d0e8
Binary files /dev/null and b/cao_sunyata/static/images/products/s1.jpg differ
diff --git a/cao_sunyata/static/images/products/s11.jpg b/cao_sunyata/static/images/products/s11.jpg
new file mode 100644
index 0000000..8980089
Binary files /dev/null and b/cao_sunyata/static/images/products/s11.jpg differ
diff --git a/cao_sunyata/static/images/products/s4.jpg b/cao_sunyata/static/images/products/s4.jpg
new file mode 100644
index 0000000..803e397
Binary files /dev/null and b/cao_sunyata/static/images/products/s4.jpg differ
diff --git a/cao_sunyata/static/images/products/s5.jpg b/cao_sunyata/static/images/products/s5.jpg
new file mode 100644
index 0000000..c40751b
Binary files /dev/null and b/cao_sunyata/static/images/products/s5.jpg differ
diff --git a/cao_sunyata/static/images/products/s7.jpg b/cao_sunyata/static/images/products/s7.jpg
new file mode 100644
index 0000000..d819743
Binary files /dev/null and b/cao_sunyata/static/images/products/s7.jpg differ
diff --git a/cao_sunyata/static/images/profile/user-1.jpg b/cao_sunyata/static/images/profile/user-1.jpg
new file mode 100644
index 0000000..2a541d7
Binary files /dev/null and b/cao_sunyata/static/images/profile/user-1.jpg differ
diff --git a/cao_sunyata/static/images/profile/user-2.jpg b/cao_sunyata/static/images/profile/user-2.jpg
new file mode 100644
index 0000000..e60f75e
Binary files /dev/null and b/cao_sunyata/static/images/profile/user-2.jpg differ
diff --git a/cao_sunyata/static/images/profile/user-3 (1).jpg b/cao_sunyata/static/images/profile/user-3 (1).jpg
new file mode 100644
index 0000000..55cbe1e
Binary files /dev/null and b/cao_sunyata/static/images/profile/user-3 (1).jpg differ
diff --git a/cao_sunyata/static/images/profile/user-3.jpg b/cao_sunyata/static/images/profile/user-3.jpg
new file mode 100644
index 0000000..55cbe1e
Binary files /dev/null and b/cao_sunyata/static/images/profile/user-3.jpg differ
diff --git a/cao_sunyata/static/img/IMG_0029.jpeg b/cao_sunyata/static/img/IMG_0029.jpeg
new file mode 100644
index 0000000..f99ccf2
Binary files /dev/null and b/cao_sunyata/static/img/IMG_0029.jpeg differ
diff --git a/cao_sunyata/static/js/app.min.js b/cao_sunyata/static/js/app.min.js
new file mode 100644
index 0000000..e6a27a6
--- /dev/null
+++ b/cao_sunyata/static/js/app.min.js
@@ -0,0 +1,37 @@
+
+$(function () {
+ // Admin Panel settings
+
+ //****************************
+ /* This is for the mini-sidebar if width is less then 1170*/
+ //****************************
+ var setsidebartype = function () {
+ var width =
+ window.innerWidth > 0 ? window.innerWidth : this.screen.width;
+ if (width < 1199) {
+ $("#main-wrapper").attr("data-sidebartype", "mini-sidebar");
+ $("#main-wrapper").addClass("mini-sidebar");
+ } else {
+ $("#main-wrapper").attr("data-sidebartype", "full");
+ $("#main-wrapper").removeClass("mini-sidebar");
+ }
+ };
+ $(window).ready(setsidebartype);
+ $(window).on("resize", setsidebartype);
+ //****************************
+ /* This is for sidebartoggler*/
+ //****************************
+ $(".sidebartoggler").on("click", function () {
+ $("#main-wrapper").toggleClass("mini-sidebar");
+ if ($("#main-wrapper").hasClass("mini-sidebar")) {
+ $(".sidebartoggler").prop("checked", !0);
+ $("#main-wrapper").attr("data-sidebartype", "mini-sidebar");
+ } else {
+ $(".sidebartoggler").prop("checked", !1);
+ $("#main-wrapper").attr("data-sidebartype", "full");
+ }
+ });
+ $(".sidebartoggler").on("click", function () {
+ $("#main-wrapper").toggleClass("show-sidebar");
+ });
+})
\ No newline at end of file
diff --git a/cao_sunyata/static/js/dashboard.js b/cao_sunyata/static/js/dashboard.js
new file mode 100644
index 0000000..3a443ec
--- /dev/null
+++ b/cao_sunyata/static/js/dashboard.js
@@ -0,0 +1,82 @@
+$(function () {
+// -----------------------------------------------------------------------
+ // Traffic Overview
+ // -----------------------------------------------------------------------
+
+ var chart = {
+ series: [
+ {
+ name: "New Users",
+ data: [5, 1, 17, 6, 15, 9, 6],
+ },
+ {
+ name: "Users",
+ data: [7, 11, 4, 16, 10, 14, 10],
+ },
+ ],
+ chart: {
+ toolbar: {
+ show: false,
+ },
+ type: "line",
+ fontFamily: "inherit",
+ foreColor: "#adb0bb",
+ height: 320,
+ stacked: false,
+ },
+ colors: ["var(--bs-gray-300)", "var(--bs-primary)"],
+ plotOptions: {},
+ dataLabels: {
+ enabled: false,
+ },
+ legend: {
+ show: false,
+ },
+ stroke: {
+ width: 2,
+ curve: "smooth",
+ dashArray: [8, 0],
+ },
+ grid: {
+ borderColor: "rgba(0,0,0,0.1)",
+ strokeDashArray: 3,
+ xaxis: {
+ lines: {
+ show: false,
+ },
+ },
+ },
+ yaxis: {
+ title: {
+ // text: 'Age',
+ },
+ },
+ xaxis: {
+ axisBorder: {
+ show: false,
+ },
+ axisTicks: {
+ show: false,
+ },
+ categories: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
+ },
+ yaxis: {
+ tickAmount: 4,
+ },
+ markers: {
+ strokeColor: ["var(--bs-gray-300)", "var(--bs-primary)"],
+ strokeWidth: 2,
+ },
+ tooltip: {
+ theme: "dark",
+ },
+ };
+
+ var chart = new ApexCharts(
+ document.querySelector("#traffic-overview"),
+ chart
+ );
+ chart.render();
+
+
+})
\ No newline at end of file
diff --git a/cao_sunyata/static/js/sidebarmenu.js b/cao_sunyata/static/js/sidebarmenu.js
new file mode 100644
index 0000000..101dd1e
--- /dev/null
+++ b/cao_sunyata/static/js/sidebarmenu.js
@@ -0,0 +1,52 @@
+/*
+Template Name: Admin Template
+Author: Wrappixel
+
+File: js
+*/
+// ==============================================================
+// Auto select left navbar
+// ==============================================================
+$(function () {
+ "use strict";
+ var url = window.location + "";
+ var path = url.replace(
+ window.location.protocol + "//" + window.location.host + "/",
+ ""
+ );
+ var element = $("ul#sidebarnav a").filter(function () {
+ return this.href === url || this.href === path; // || url.href.indexOf(this.href) === 0;
+ });
+ element.parentsUntil(".sidebar-nav").each(function (index) {
+ if ($(this).is("li") && $(this).children("a").length !== 0) {
+ $(this).children("a").addClass("active");
+ $(this).parent("ul#sidebarnav").length === 0
+ ? $(this).addClass("active")
+ : $(this).addClass("selected");
+ } else if (!$(this).is("ul") && $(this).children("a").length === 0) {
+ $(this).addClass("selected");
+ } else if ($(this).is("ul")) {
+ $(this).addClass("in");
+ }
+ });
+
+ element.addClass("active");
+ $("#sidebarnav a").on("click", function (e) {
+ if (!$(this).hasClass("active")) {
+ // hide any open menus and remove all other classes
+ $("ul", $(this).parents("ul:first")).removeClass("in");
+ $("a", $(this).parents("ul:first")).removeClass("active");
+
+ // open our new menu and add the open class
+ $(this).next("ul").addClass("in");
+ $(this).addClass("active");
+ } else if ($(this).hasClass("active")) {
+ $(this).removeClass("active");
+ $(this).parents("ul:first").removeClass("active");
+ $(this).next("ul").removeClass("in");
+ }
+ });
+ $("#sidebarnav >li >a.has-arrow").on("click", function (e) {
+ e.preventDefault();
+ });
+ });
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/LICENSE b/cao_sunyata/static/libs/apexcharts/LICENSE
new file mode 100644
index 0000000..1702793
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 ApexCharts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/README.md b/cao_sunyata/static/libs/apexcharts/README.md
new file mode 100644
index 0000000..2aee7df
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/README.md
@@ -0,0 +1,228 @@
+
+
+
+
+
+
+
+
+
A modern JavaScript charting library that allows you to build interactive data visualizations with simple API and 100+ ready-to-use samples. Packed with the features that you expect, ApexCharts includes over a dozen chart types that deliver beautiful, responsive visualizations in your apps and dashboards. ApexCharts is an MIT licensed open-source project that can be used in commercial and non-commercial projects.
+
+
+
+
+
+## Browsers support
+
+| [
](http://godban.github.io/browsers-support-badges/)
Firefox | [
](http://godban.github.io/browsers-support-badges/)
Chrome | [
](http://godban.github.io/browsers-support-badges/)
Safari | [
](http://godban.github.io/browsers-support-badges/)
Edge | [
](http://godban.github.io/browsers-support-badges/)
IE11 |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 31+ ✔ | 35+ ✔ | 6+ ✔ | Edge ✔ | [(IE11)](#using-it-with-ie11) ✔ |
+
+## Download and Installation
+
+##### Installing via npm
+
+```bash
+npm install apexcharts --save
+```
+
+##### Direct <script> include
+
+```html
+
+```
+
+## Wrappers for Vue/React/Angular/Stencil
+
+Integrate easily with 3rd party frameworks
+
+- [vue-apexcharts](https://github.com/apexcharts/vue-apexcharts)
+- [react-apexcharts](https://github.com/apexcharts/react-apexcharts)
+- [ng-apexcharts](https://github.com/apexcharts/ng-apexcharts) - Plugin by [Morris Janatzek](https://morrisj.net/)
+- [stencil-apexcharts](https://github.com/apexcharts/stencil-apexcharts)
+
+### Unofficial Wrappers
+
+Useful links to wrappers other than the popular frameworks mentioned above
+
+- [apexcharter](https://github.com/dreamRs/apexcharter) - Htmlwidget for ApexCharts
+- [apexcharts.rb](https://github.com/styd/apexcharts.rb) - Ruby wrapper for ApexCharts
+- [larapex-charts](https://github.com/ArielMejiaDev/larapex-charts) - Laravel wrapper for ApexCharts
+- [blazor-apexcharts](https://github.com/apexcharts/Blazor-ApexCharts) - Blazor wrapper for ApexCharts [demo](https://apexcharts.github.io/Blazor-ApexCharts/)
+- [svelte-apexcharts](https://github.com/galkatz373/svelte-apexcharts) - Svelte wrapper for ApexCharts
+
+
+## Usage
+
+```js
+import ApexCharts from 'apexcharts'
+```
+
+To create a basic bar chart with minimal configuration, write as follows:
+
+```js
+var options = {
+ chart: {
+ type: 'bar'
+ },
+ series: [
+ {
+ name: 'sales',
+ data: [30, 40, 35, 50, 49, 60, 70, 91, 125]
+ }
+ ],
+ xaxis: {
+ categories: [1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999]
+ }
+}
+
+var chart = new ApexCharts(document.querySelector('#chart'), options)
+chart.render()
+```
+
+This will render the following chart
+
+
+
+### A little more than the basic
+
+You can create a combination of different charts, sync them and give your desired look with unlimited possibilities.
+Below is an example of synchronized charts with github style.
+
+
+
+## Interactivity
+
+Zoom, Pan, Scroll through data. Make selections and load other charts using those selections.
+An example showing some interactivity
+
+
+
+## Dynamic Series Update
+
+Another approach to Drill down charts where one selection updates the data of other charts.
+An example of loading dynamic series into charts is shown below
+
+
+
+## Annotations
+
+Annotations allows you to write custom text on specific values or on axes values. Valuable to expand the visual appeal of your chart and make it more informative.
+
+
+
+## Mixed Charts
+
+You can combine more than one chart type to create a combo/mixed chart. Possible combinations can be line/area/column together in a single chart. Each chart-type can have it's own y-axis.
+
+
+
+## Candlestick
+
+Use a candlestick chart (a common financial chart) to describe price changes of a security, derivative, or currency. Below image show how you can use another chart as a brush/preview-pane which acts as a handle to browse the main candlestick chart.
+
+
+
+## Heatmaps
+
+Use Heatmaps to represent data through colors and shades. Frequently used with bigger data collections, they are valuable for recognizing patterns and area of focus.
+
+
+
+## Gauges
+
+The tiny gauges are an important part of a dashboard and are useful in displaying single series data. A demo of these gauges:
+
+
+
+## Sparklines
+
+Utilize sparklines to indicate trends in data, for example, occasional increments or declines, monetary cycles, or to feature most extreme and least values:
+
+
+
+
+## Need Advanced Data Grid for your next project?
+We partnered with Infragistics, creators of the fastest data grids on the planet! Ignite UI Grids can handle unlimited rows and columns of data, while providing access to custom templates and real-time data updates.
+
+
+
+Featuring an intuitive API for easy theming and branding, you can quickly bind to data with minimal hand-on coding. The grid is available in most of your favorite frameworks:
+
+
Angular Data Grid |
React Data Grid |
Blazor Data Grid |
Web Components DataGrid |
jQuery Data Grid
+
+## What's included
+
+The download bundle includes the following files and directories providing a minified single file in the dist folder. Every asset including icon/css is bundled in the js itself to avoid loading multiple files.
+
+```
+apexcharts/
+├── dist/
+│ └── apexcharts.min.js
+├── src/
+│ ├── assets/
+│ ├── charts/
+│ ├── modules/
+│ ├── utils/
+│ └── apexcharts.js
+└── samples/
+```
+
+## Using it with IE11
+
+If you need to make it work with IE11, you need to include these polyfills before including ApexCharts
+
+- [promise-polyfill](https://cdn.jsdelivr.net/npm/promise-polyfill@8/dist/polyfill.min.js)
+- [classlist.js](https://cdn.jsdelivr.net/npm/eligrey-classlist-js-polyfill)
+- [ResizeObserver polyfill](https://cdn.jsdelivr.net/npm/@juggle/resize-observer)
+- [findIndex](https://cdn.jsdelivr.net/npm/findindex_polyfill_mdn) - You will need this only if you require timeline/rangebar charts
+- [canvg](https://unpkg.com/canvg@3.0.4/lib/umd.js) - You will need this only if you require PNG download of your charts
+
+## Development
+
+#### Install dependencies and run project
+
+```bash
+npm install
+npm run dev
+```
+
+This will start the webpack watch and any changes you make to `src` folder will auto-compile and output will be produced in the `dist` folder.
+
+#### Minifying the src
+
+```bash
+npm run build
+```
+
+## Where do I go next?
+
+Head over to the
documentation section to read more about how to use different kinds of charts and explore all options.
+
+## Contacts
+
+Email:
info@apexcharts.com
+
+Twitter:
@apexcharts
+
+Facebook:
fb.com/apexcharts
+
+## Dependency
+
+ApexCharts uses
SVG.js for drawing shapes, animations, applying svg filters and a lot more under the hood. The library is bundled in the final build file, so you don't need to include it.
+
+## License
+
+ApexCharts is released under MIT license. You are free to use, modify and distribute this software, as long as the copyright header is left intact.
diff --git a/cao_sunyata/static/libs/apexcharts/package.json b/cao_sunyata/static/libs/apexcharts/package.json
new file mode 100644
index 0000000..bf2c65a
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/package.json
@@ -0,0 +1,106 @@
+{
+ "name": "apexcharts",
+ "version": "3.35.2",
+ "description": "A JavaScript Chart Library",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/apexcharts/apexcharts.js.git"
+ },
+ "main": "dist/apexcharts.common.js",
+ "unpkg": "dist/apexcharts.js",
+ "jsdelivr": "dist/apexcharts.js",
+ "typings": "types/apexcharts.d.ts",
+ "files": [
+ "src",
+ "dist/*.js",
+ "dist/*.css",
+ "dist/locales/*.json",
+ "types/*.d.ts"
+ ],
+ "scripts": {
+ "dev": "rollup -w -c build/config.js --environment TARGET:web-umd-dev",
+ "dev:cjs": "rollup -w -c build/config.js --environment TARGET:web-cjs",
+ "bundle": "node build/build.js",
+ "build": "npm run bundle && webpack",
+ "build:umd": "rollup -w -c build/config.js --environment TARGET:web-umd-dev",
+ "build:amd": "webpack",
+ "lint": "eslint .",
+ "lint:fix": "eslint . --fix",
+ "test": "npm run e2e && npm run unit",
+ "unit": "jest tests/unit/",
+ "e2e": "node tests/e2e/samples.js test",
+ "e2e:update": "node tests/e2e/samples.js update",
+ "build:samples": "node samples/source/index.js generate"
+ },
+ "dependencies": {
+ "svg.draggable.js": "^2.2.2",
+ "svg.easing.js": "^2.0.0",
+ "svg.filter.js": "^2.0.2",
+ "svg.pathmorphing.js": "^0.1.3",
+ "svg.resize.js": "^1.4.3",
+ "svg.select.js": "^3.0.1"
+ },
+ "devDependencies": {
+ "@babel/core": "^7.8.7",
+ "@babel/plugin-proposal-class-properties": "^7.8.3",
+ "@babel/preset-env": "^7.8.7",
+ "@rollup/plugin-babel": "^5.2.1",
+ "@rollup/plugin-json": "4.0.1",
+ "@rollup/plugin-node-resolve": "6.0.0",
+ "@rollup/plugin-replace": "2.3.0",
+ "@rollup/plugin-strip": "1.3.1",
+ "babel-eslint": "10.0.3",
+ "babel-jest": "27.3.1",
+ "babel-loader": "8.0.6",
+ "babel-plugin-istanbul": "6.0.0",
+ "chalk": "3.0.0",
+ "css-loader": "3.4.1",
+ "eslint": "8.2.0",
+ "eslint-config-prettier": "6.9.0",
+ "eslint-loader": "3.0.3",
+ "eslint-plugin-import": "2.19.1",
+ "eslint-plugin-prettier": "3.1.2",
+ "eslint-plugin-promise": "4.2.1",
+ "fs-extra": "8.1.0",
+ "jest": "27.3.1",
+ "nunjucks": "3.2.1",
+ "nyc": "15.0.0",
+ "pixelmatch": "5.1.0",
+ "pngjs": "3.4.0",
+ "postcss": "^8.3.11",
+ "prettier": "1.19.1",
+ "puppeteer": "2.0.0",
+ "puppeteer-cluster": "0.18.0",
+ "rollup": "2.56.0",
+ "rollup-plugin-babel": "4.4.0",
+ "rollup-plugin-copy-glob": "0.3.2",
+ "rollup-plugin-postcss": "4.0.1",
+ "rollup-plugin-svgo": "1.1.0",
+ "rollup-plugin-terser": "7.0.2",
+ "style-loader": "1.1.2",
+ "svg-inline-loader": "0.8.0",
+ "terser": "5.3.8",
+ "tslint": "5.12.1",
+ "typescript": "3.2.2",
+ "webpack": "5.3.2",
+ "webpack-bundle-analyzer": "3.9.0",
+ "webpack-cli": "4.9.1"
+ },
+ "bugs": {
+ "url": "https://github.com/apexcharts/apexcharts.js/issues"
+ },
+ "license": "MIT",
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "http://www.opensource.org/licenses/mit-license.php"
+ }
+ ],
+ "homepage": "https://apexcharts.com",
+ "keywords": [
+ "charts",
+ "graphs",
+ "visualizations",
+ "data"
+ ]
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/apexcharts.js b/cao_sunyata/static/libs/apexcharts/src/apexcharts.js
new file mode 100644
index 0000000..d44ae14
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/apexcharts.js
@@ -0,0 +1,762 @@
+import Annotations from './modules/annotations/Annotations'
+import Base from './modules/Base'
+import CoreUtils from './modules/CoreUtils'
+import DataLabels from './modules/DataLabels'
+import Defaults from './modules/settings/Defaults'
+import Exports from './modules/Exports'
+import Grid from './modules/axes/Grid'
+import Markers from './modules/Markers'
+import Range from './modules/Range'
+import Utils from './utils/Utils'
+import XAxis from './modules/axes/XAxis'
+import YAxis from './modules/axes/YAxis'
+import InitCtxVariables from './modules/helpers/InitCtxVariables'
+import Destroy from './modules/helpers/Destroy'
+import { addResizeListener, removeResizeListener } from './utils/Resize'
+import apexCSS from './assets/apexcharts.css'
+
+/**
+ *
+ * @module ApexCharts
+ **/
+
+export default class ApexCharts {
+ constructor(el, opts) {
+ this.opts = opts
+ this.ctx = this
+
+ // Pass the user supplied options to the Base Class where these options will be extended with defaults. The returned object from Base Class will become the config object in the entire codebase.
+ this.w = new Base(opts).init()
+
+ this.el = el
+
+ this.w.globals.cuid = Utils.randomId()
+ this.w.globals.chartID = this.w.config.chart.id
+ ? Utils.escapeString(this.w.config.chart.id)
+ : this.w.globals.cuid
+
+ const initCtx = new InitCtxVariables(this)
+ initCtx.initModules()
+
+ this.create = Utils.bind(this.create, this)
+ this.windowResizeHandler = this._windowResizeHandler.bind(this)
+ this.parentResizeHandler = this._parentResizeCallback.bind(this)
+ }
+
+ /**
+ * The primary method user will call to render the chart.
+ */
+ render() {
+ // main method
+ return new Promise((resolve, reject) => {
+ // only draw chart, if element found
+ if (this.el !== null) {
+ if (typeof Apex._chartInstances === 'undefined') {
+ Apex._chartInstances = []
+ }
+ if (this.w.config.chart.id) {
+ Apex._chartInstances.push({
+ id: this.w.globals.chartID,
+ group: this.w.config.chart.group,
+ chart: this
+ })
+ }
+
+ // set the locale here
+ this.setLocale(this.w.config.chart.defaultLocale)
+ const beforeMount = this.w.config.chart.events.beforeMount
+ if (typeof beforeMount === 'function') {
+ beforeMount(this, this.w)
+ }
+
+ this.events.fireEvent('beforeMount', [this, this.w])
+ window.addEventListener('resize', this.windowResizeHandler)
+ addResizeListener(this.el.parentNode, this.parentResizeHandler)
+
+ // Add CSS if not already added
+ if (!this.css) {
+ let rootNode = this.el.getRootNode && this.el.getRootNode()
+ let inShadowRoot = Utils.is('ShadowRoot', rootNode)
+ let doc = this.el.ownerDocument
+ let globalCSS = doc.getElementById('apexcharts-css')
+
+ if (inShadowRoot || !globalCSS) {
+ this.css = document.createElement('style')
+ this.css.id = 'apexcharts-css'
+ this.css.textContent = apexCSS
+
+ if (inShadowRoot) {
+ // We are in Shadow DOM, add to shadow root
+ rootNode.prepend(this.css)
+ } else {
+ // Add to of element's document
+ doc.head.appendChild(this.css)
+ }
+ }
+ }
+
+ let graphData = this.create(this.w.config.series, {})
+ if (!graphData) return resolve(this)
+ this.mount(graphData)
+ .then(() => {
+ if (typeof this.w.config.chart.events.mounted === 'function') {
+ this.w.config.chart.events.mounted(this, this.w)
+ }
+
+ this.events.fireEvent('mounted', [this, this.w])
+ resolve(graphData)
+ })
+ .catch((e) => {
+ reject(e)
+ // handle error in case no data or element not found
+ })
+ } else {
+ reject(new Error('Element not found'))
+ }
+ })
+ }
+
+ create(ser, opts) {
+ let w = this.w
+
+ const initCtx = new InitCtxVariables(this)
+ initCtx.initModules()
+ let gl = this.w.globals
+
+ gl.noData = false
+ gl.animationEnded = false
+
+ this.responsive.checkResponsiveConfig(opts)
+
+ if (w.config.xaxis.convertedCatToNumeric) {
+ const defaults = new Defaults(w.config)
+ defaults.convertCatToNumericXaxis(w.config, this.ctx)
+ }
+
+ if (this.el === null) {
+ gl.animationEnded = true
+ return null
+ }
+
+ this.core.setupElements()
+
+ if (w.config.chart.type === 'treemap') {
+ w.config.grid.show = false
+ w.config.yaxis[0].show = false
+ }
+
+ if (gl.svgWidth === 0) {
+ // if the element is hidden, skip drawing
+ gl.animationEnded = true
+ return null
+ }
+
+ const combo = CoreUtils.checkComboSeries(ser)
+ gl.comboCharts = combo.comboCharts
+ gl.comboBarCount = combo.comboBarCount
+
+ const allSeriesAreEmpty = ser.every((s) => s.data && s.data.length === 0)
+
+ if (ser.length === 0 || allSeriesAreEmpty) {
+ this.series.handleNoData()
+ }
+
+ this.events.setupEventHandlers()
+
+ // Handle the data inputted by user and set some of the global variables (for eg, if data is datetime / numeric / category). Don't calculate the range / min / max at this time
+ this.data.parseData(ser)
+
+ // this is a good time to set theme colors first
+ this.theme.init()
+
+ // as markers accepts array, we need to setup global markers for easier access
+ const markers = new Markers(this)
+ markers.setGlobalMarkerSize()
+
+ // labelFormatters should be called before dimensions as in dimensions we need text labels width
+ this.formatters.setLabelFormatters()
+ this.titleSubtitle.draw()
+
+ // legend is calculated here before coreCalculations because it affects the plottable area
+ // if there is some data to show or user collapsed all series, then proceed drawing legend
+ if (
+ !gl.noData ||
+ gl.collapsedSeries.length === gl.series.length ||
+ w.config.legend.showForSingleSeries
+ ) {
+ this.legend.init()
+ }
+
+ // check whether in multiple series, all series share the same X
+ this.series.hasAllSeriesEqualX()
+
+ // coreCalculations will give the min/max range and yaxis/axis values. It should be called here to set series variable from config to globals
+ if (gl.axisCharts) {
+ this.core.coreCalculations()
+ if (w.config.xaxis.type !== 'category') {
+ // as we have minX and maxX values, determine the default DateTimeFormat for time series
+ this.formatters.setLabelFormatters()
+ }
+ this.ctx.toolbar.minX = w.globals.minX
+ this.ctx.toolbar.maxX = w.globals.maxX
+ }
+
+ // we need to generate yaxis for heatmap separately as we are not showing numerics there, but seriesNames. There are some tweaks which are required for heatmap to align labels correctly which are done in below function
+ // Also we need to do this before calculating Dimensions plotCoords() method of Dimensions
+ this.formatters.heatmapLabelFormatters()
+
+ // get the largest marker size which will be needed in dimensions calc
+ const coreUtils = new CoreUtils(this)
+ coreUtils.getLargestMarkerSize()
+
+ // We got plottable area here, next task would be to calculate axis areas
+ this.dimensions.plotCoords()
+
+ const xyRatios = this.core.xySettings()
+
+ this.grid.createGridMask()
+
+ const elGraph = this.core.plotChartType(ser, xyRatios)
+
+ const dataLabels = new DataLabels(this)
+ dataLabels.bringForward()
+ if (w.config.dataLabels.background.enabled) {
+ dataLabels.dataLabelsBackground()
+ }
+
+ // after all the drawing calculations, shift the graphical area (actual charts/bars) excluding legends
+ this.core.shiftGraphPosition()
+
+ const dim = {
+ plot: {
+ left: w.globals.translateX,
+ top: w.globals.translateY,
+ width: w.globals.gridWidth,
+ height: w.globals.gridHeight
+ }
+ }
+
+ return {
+ elGraph,
+ xyRatios,
+ elInner: w.globals.dom.elGraphical,
+ dimensions: dim
+ }
+ }
+
+ mount(graphData = null) {
+ let me = this
+ let w = me.w
+
+ return new Promise((resolve, reject) => {
+ // no data to display
+ if (me.el === null) {
+ return reject(
+ new Error('Not enough data to display or target element not found')
+ )
+ } else if (graphData === null || w.globals.allSeriesCollapsed) {
+ me.series.handleNoData()
+ }
+ if (w.config.chart.type !== 'treemap') {
+ me.axes.drawAxis(w.config.chart.type, graphData.xyRatios)
+ }
+
+ me.grid = new Grid(me)
+ let elgrid = me.grid.drawGrid()
+
+ me.annotations = new Annotations(me)
+ me.annotations.drawImageAnnos()
+ me.annotations.drawTextAnnos()
+
+ if (w.config.grid.position === 'back' && elgrid) {
+ w.globals.dom.elGraphical.add(elgrid.el)
+ }
+
+ let xAxis = new XAxis(this.ctx)
+ let yaxis = new YAxis(this.ctx)
+ if (elgrid !== null) {
+ xAxis.xAxisLabelCorrections(elgrid.xAxisTickWidth)
+ yaxis.setYAxisTextAlignments()
+
+ w.config.yaxis.map((yaxe, index) => {
+ if (w.globals.ignoreYAxisIndexes.indexOf(index) === -1) {
+ yaxis.yAxisTitleRotate(index, yaxe.opposite)
+ }
+ })
+ }
+
+ if (w.config.annotations.position === 'back') {
+ w.globals.dom.Paper.add(w.globals.dom.elAnnotations)
+ me.annotations.drawAxesAnnotations()
+ }
+
+ if (Array.isArray(graphData.elGraph)) {
+ for (let g = 0; g < graphData.elGraph.length; g++) {
+ w.globals.dom.elGraphical.add(graphData.elGraph[g])
+ }
+ } else {
+ w.globals.dom.elGraphical.add(graphData.elGraph)
+ }
+
+ if (w.config.grid.position === 'front' && elgrid) {
+ w.globals.dom.elGraphical.add(elgrid.el)
+ }
+
+ if (w.config.xaxis.crosshairs.position === 'front') {
+ me.crosshairs.drawXCrosshairs()
+ }
+
+ if (w.config.yaxis[0].crosshairs.position === 'front') {
+ me.crosshairs.drawYCrosshairs()
+ }
+
+ if (w.config.annotations.position === 'front') {
+ w.globals.dom.Paper.add(w.globals.dom.elAnnotations)
+ me.annotations.drawAxesAnnotations()
+ }
+
+ if (!w.globals.noData) {
+ // draw tooltips at the end
+ if (w.config.tooltip.enabled && !w.globals.noData) {
+ me.w.globals.tooltip.drawTooltip(graphData.xyRatios)
+ }
+
+ if (
+ w.globals.axisCharts &&
+ (w.globals.isXNumeric ||
+ w.config.xaxis.convertedCatToNumeric ||
+ w.globals.isRangeBar)
+ ) {
+ if (
+ w.config.chart.zoom.enabled ||
+ (w.config.chart.selection && w.config.chart.selection.enabled) ||
+ (w.config.chart.pan && w.config.chart.pan.enabled)
+ ) {
+ me.zoomPanSelection.init({
+ xyRatios: graphData.xyRatios
+ })
+ }
+ } else {
+ const tools = w.config.chart.toolbar.tools
+ let toolsArr = [
+ 'zoom',
+ 'zoomin',
+ 'zoomout',
+ 'selection',
+ 'pan',
+ 'reset'
+ ]
+ toolsArr.forEach((t) => {
+ tools[t] = false
+ })
+ }
+
+ if (w.config.chart.toolbar.show && !w.globals.allSeriesCollapsed) {
+ me.toolbar.createToolbar()
+ }
+ }
+
+ if (w.globals.memory.methodsToExec.length > 0) {
+ w.globals.memory.methodsToExec.forEach((fn) => {
+ fn.method(fn.params, false, fn.context)
+ })
+ }
+
+ if (!w.globals.axisCharts && !w.globals.noData) {
+ me.core.resizeNonAxisCharts()
+ }
+ resolve(me)
+ })
+ }
+
+ /**
+ * Destroy the chart instance by removing all elements which also clean up event listeners on those elements.
+ */
+ destroy() {
+ window.removeEventListener('resize', this.windowResizeHandler)
+
+ removeResizeListener(this.el.parentNode, this.parentResizeHandler)
+ // remove the chart's instance from the global Apex._chartInstances
+ const chartID = this.w.config.chart.id
+ if (chartID) {
+ Apex._chartInstances.forEach((c, i) => {
+ if (c.id === Utils.escapeString(chartID)) {
+ Apex._chartInstances.splice(i, 1)
+ }
+ })
+ }
+ new Destroy(this.ctx).clear({ isUpdating: false })
+ }
+
+ /**
+ * Allows users to update Options after the chart has rendered.
+ *
+ * @param {object} options - A new config object can be passed which will be merged with the existing config object
+ * @param {boolean} redraw - should redraw from beginning or should use existing paths and redraw from there
+ * @param {boolean} animate - should animate or not on updating Options
+ */
+ updateOptions(
+ options,
+ redraw = false,
+ animate = true,
+ updateSyncedCharts = true,
+ overwriteInitialConfig = true
+ ) {
+ const w = this.w
+
+ // when called externally, clear some global variables
+ // fixes apexcharts.js#1488
+ w.globals.selection = undefined
+
+ if (options.series) {
+ this.series.resetSeries(false, true, false)
+ if (options.series.length && options.series[0].data) {
+ options.series = options.series.map((s, i) => {
+ return this.updateHelpers._extendSeries(s, i)
+ })
+ }
+
+ // user updated the series via updateOptions() function.
+ // Hence, we need to reset axis min/max to avoid zooming issues
+ this.updateHelpers.revertDefaultAxisMinMax()
+ }
+ // user has set x-axis min/max externally - hence we need to forcefully set the xaxis min/max
+ if (options.xaxis) {
+ options = this.updateHelpers.forceXAxisUpdate(options)
+ }
+ if (options.yaxis) {
+ options = this.updateHelpers.forceYAxisUpdate(options)
+ }
+ if (w.globals.collapsedSeriesIndices.length > 0) {
+ this.series.clearPreviousPaths()
+ }
+ /* update theme mode#459 */
+ if (options.theme) {
+ options = this.theme.updateThemeOptions(options)
+ }
+ return this.updateHelpers._updateOptions(
+ options,
+ redraw,
+ animate,
+ updateSyncedCharts,
+ overwriteInitialConfig
+ )
+ }
+
+ /**
+ * Allows users to update Series after the chart has rendered.
+ *
+ * @param {array} series - New series which will override the existing
+ */
+ updateSeries(newSeries = [], animate = true, overwriteInitialSeries = true) {
+ this.series.resetSeries(false)
+ this.updateHelpers.revertDefaultAxisMinMax()
+ return this.updateHelpers._updateSeries(
+ newSeries,
+ animate,
+ overwriteInitialSeries
+ )
+ }
+
+ /**
+ * Allows users to append a new series after the chart has rendered.
+ *
+ * @param {array} newSerie - New serie which will be appended to the existing series
+ */
+ appendSeries(newSerie, animate = true, overwriteInitialSeries = true) {
+ const newSeries = this.w.config.series.slice()
+ newSeries.push(newSerie)
+ this.series.resetSeries(false)
+ this.updateHelpers.revertDefaultAxisMinMax()
+ return this.updateHelpers._updateSeries(
+ newSeries,
+ animate,
+ overwriteInitialSeries
+ )
+ }
+
+ /**
+ * Allows users to append Data to series.
+ *
+ * @param {array} newData - New data in the same format as series
+ */
+ appendData(newData, overwriteInitialSeries = true) {
+ let me = this
+
+ me.w.globals.dataChanged = true
+
+ me.series.getPreviousPaths()
+
+ let newSeries = me.w.config.series.slice()
+
+ for (let i = 0; i < newSeries.length; i++) {
+ if (newData[i] !== null && typeof newData[i] !== 'undefined') {
+ for (let j = 0; j < newData[i].data.length; j++) {
+ newSeries[i].data.push(newData[i].data[j])
+ }
+ }
+ }
+ me.w.config.series = newSeries
+ if (overwriteInitialSeries) {
+ me.w.globals.initialSeries = Utils.clone(me.w.config.series)
+ }
+
+ return this.update()
+ }
+
+ update(options) {
+ return new Promise((resolve, reject) => {
+ new Destroy(this.ctx).clear({ isUpdating: true })
+
+ const graphData = this.create(this.w.config.series, options)
+ if (!graphData) return resolve(this)
+ this.mount(graphData)
+ .then(() => {
+ if (typeof this.w.config.chart.events.updated === 'function') {
+ this.w.config.chart.events.updated(this, this.w)
+ }
+ this.events.fireEvent('updated', [this, this.w])
+
+ this.w.globals.isDirty = true
+
+ resolve(this)
+ })
+ .catch((e) => {
+ reject(e)
+ })
+ })
+ }
+
+ /**
+ * Get all charts in the same "group" (including the instance which is called upon) to sync them when user zooms in/out or pan.
+ */
+ getSyncedCharts() {
+ const chartGroups = this.getGroupedCharts()
+ let allCharts = [this]
+ if (chartGroups.length) {
+ allCharts = []
+ chartGroups.forEach((ch) => {
+ allCharts.push(ch)
+ })
+ }
+
+ return allCharts
+ }
+
+ /**
+ * Get charts in the same "group" (excluding the instance which is called upon) to perform operations on the other charts of the same group (eg., tooltip hovering)
+ */
+ getGroupedCharts() {
+ return Apex._chartInstances
+ .filter((ch) => {
+ if (ch.group) {
+ return true
+ }
+ })
+ .map((ch) => (this.w.config.chart.group === ch.group ? ch.chart : this))
+ }
+
+ static getChartByID(id) {
+ const chartId = Utils.escapeString(id)
+ const c = Apex._chartInstances.filter((ch) => ch.id === chartId)[0]
+ return c && c.chart
+ }
+
+ /**
+ * Allows the user to provide data attrs in the element and the chart will render automatically when this method is called by searching for the elements containing 'data-apexcharts' attribute
+ */
+ static initOnLoad() {
+ const els = document.querySelectorAll('[data-apexcharts]')
+
+ for (let i = 0; i < els.length; i++) {
+ const el = els[i]
+ const options = JSON.parse(els[i].getAttribute('data-options'))
+ const apexChart = new ApexCharts(el, options)
+ apexChart.render()
+ }
+ }
+
+ /**
+ * This static method allows users to call chart methods without necessarily from the
+ * instance of the chart in case user has assigned chartID to the targeted chart.
+ * The chartID is used for mapping the instance stored in Apex._chartInstances global variable
+ *
+ * This is helpful in cases when you don't have reference of the chart instance
+ * easily and need to call the method from anywhere.
+ * For eg, in React/Vue applications when you have many parent/child components,
+ * and need easy reference to other charts for performing dynamic operations
+ *
+ * @param {string} chartID - The unique identifier which will be used to call methods
+ * on that chart instance
+ * @param {function} fn - The method name to call
+ * @param {object} opts - The parameters which are accepted in the original method will be passed here in the same order.
+ */
+ static exec(chartID, fn, ...opts) {
+ const chart = this.getChartByID(chartID)
+ if (!chart) return
+
+ // turn on the global exec flag to indicate this method was called
+ chart.w.globals.isExecCalled = true
+
+ let ret = null
+ if (chart.publicMethods.indexOf(fn) !== -1) {
+ ret = chart[fn](...opts)
+ }
+ return ret
+ }
+
+ static merge(target, source) {
+ return Utils.extend(target, source)
+ }
+
+ toggleSeries(seriesName) {
+ return this.series.toggleSeries(seriesName)
+ }
+
+ highlightSeriesOnLegendHover(e, targetElement) {
+ return this.series.toggleSeriesOnHover(e, targetElement)
+ }
+
+ showSeries(seriesName) {
+ this.series.showSeries(seriesName)
+ }
+
+ hideSeries(seriesName) {
+ this.series.hideSeries(seriesName)
+ }
+
+ resetSeries(shouldUpdateChart = true, shouldResetZoom = true) {
+ this.series.resetSeries(shouldUpdateChart, shouldResetZoom)
+ }
+
+ // Public method to add event listener on chart context
+ addEventListener(name, handler) {
+ this.events.addEventListener(name, handler)
+ }
+
+ // Public method to remove event listener on chart context
+ removeEventListener(name, handler) {
+ this.events.removeEventListener(name, handler)
+ }
+
+ addXaxisAnnotation(opts, pushToMemory = true, context = undefined) {
+ let me = this
+ if (context) {
+ me = context
+ }
+ me.annotations.addXaxisAnnotationExternal(opts, pushToMemory, me)
+ }
+
+ addYaxisAnnotation(opts, pushToMemory = true, context = undefined) {
+ let me = this
+ if (context) {
+ me = context
+ }
+ me.annotations.addYaxisAnnotationExternal(opts, pushToMemory, me)
+ }
+
+ addPointAnnotation(opts, pushToMemory = true, context = undefined) {
+ let me = this
+ if (context) {
+ me = context
+ }
+ me.annotations.addPointAnnotationExternal(opts, pushToMemory, me)
+ }
+
+ clearAnnotations(context = undefined) {
+ let me = this
+ if (context) {
+ me = context
+ }
+ me.annotations.clearAnnotations(me)
+ }
+
+ removeAnnotation(id, context = undefined) {
+ let me = this
+ if (context) {
+ me = context
+ }
+ me.annotations.removeAnnotation(me, id)
+ }
+
+ getChartArea() {
+ const el = this.w.globals.dom.baseEl.querySelector('.apexcharts-inner')
+
+ return el
+ }
+
+ getSeriesTotalXRange(minX, maxX) {
+ return this.coreUtils.getSeriesTotalsXRange(minX, maxX)
+ }
+
+ getHighestValueInSeries(seriesIndex = 0) {
+ const range = new Range(this.ctx)
+ return range.getMinYMaxY(seriesIndex).highestY
+ }
+
+ getLowestValueInSeries(seriesIndex = 0) {
+ const range = new Range(this.ctx)
+ return range.getMinYMaxY(seriesIndex).lowestY
+ }
+
+ getSeriesTotal() {
+ return this.w.globals.seriesTotals
+ }
+
+ toggleDataPointSelection(seriesIndex, dataPointIndex) {
+ return this.updateHelpers.toggleDataPointSelection(
+ seriesIndex,
+ dataPointIndex
+ )
+ }
+
+ zoomX(min, max) {
+ this.ctx.toolbar.zoomUpdateOptions(min, max)
+ }
+
+ setLocale(localeName) {
+ this.localization.setCurrentLocaleValues(localeName)
+ }
+
+ dataURI(options) {
+ const exp = new Exports(this.ctx)
+ return exp.dataURI(options)
+ }
+
+ paper() {
+ return this.w.globals.dom.Paper
+ }
+
+ _parentResizeCallback() {
+ if (
+ this.w.globals.animationEnded &&
+ this.w.config.chart.redrawOnParentResize
+ ) {
+ this._windowResize()
+ }
+ }
+
+ /**
+ * Handle window resize and re-draw the whole chart.
+ */
+ _windowResize() {
+ clearTimeout(this.w.globals.resizeTimer)
+ this.w.globals.resizeTimer = window.setTimeout(() => {
+ this.w.globals.resized = true
+ this.w.globals.dataChanged = false
+
+ // we need to redraw the whole chart on window resize (with a small delay).
+ this.ctx.update()
+ }, 150)
+ }
+
+ _windowResizeHandler() {
+ let { redrawOnWindowResize: redraw } = this.w.config.chart
+
+ if (typeof redraw === 'function') {
+ redraw = redraw()
+ }
+
+ redraw && this._windowResize()
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/apexcharts.css b/cao_sunyata/static/libs/apexcharts/src/assets/apexcharts.css
new file mode 100644
index 0000000..27ada7b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/apexcharts.css
@@ -0,0 +1,688 @@
+.apexcharts-canvas {
+ position: relative;
+ user-select: none;
+ /* cannot give overflow: hidden as it will crop tooltips which overflow outside chart area */
+}
+
+
+/* scrollbar is not visible by default for legend, hence forcing the visibility */
+.apexcharts-canvas ::-webkit-scrollbar {
+ -webkit-appearance: none;
+ width: 6px;
+}
+
+.apexcharts-canvas ::-webkit-scrollbar-thumb {
+ border-radius: 4px;
+ background-color: rgba(0, 0, 0, .5);
+ box-shadow: 0 0 1px rgba(255, 255, 255, .5);
+ -webkit-box-shadow: 0 0 1px rgba(255, 255, 255, .5);
+}
+
+
+.apexcharts-inner {
+ position: relative;
+}
+
+.apexcharts-text tspan {
+ font-family: inherit;
+}
+
+.legend-mouseover-inactive {
+ transition: 0.15s ease all;
+ opacity: 0.20;
+}
+
+.apexcharts-series-collapsed {
+ opacity: 0;
+}
+
+.apexcharts-tooltip {
+ border-radius: 5px;
+ box-shadow: 2px 2px 6px -4px #999;
+ cursor: default;
+ font-size: 14px;
+ left: 62px;
+ opacity: 0;
+ pointer-events: none;
+ position: absolute;
+ top: 20px;
+ display: flex;
+ flex-direction: column;
+ overflow: hidden;
+ white-space: nowrap;
+ z-index: 12;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-tooltip.apexcharts-active {
+ opacity: 1;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-tooltip.apexcharts-theme-light {
+ border: 1px solid #e3e3e3;
+ background: rgba(255, 255, 255, 0.96);
+}
+
+.apexcharts-tooltip.apexcharts-theme-dark {
+ color: #fff;
+ background: rgba(30, 30, 30, 0.8);
+}
+
+.apexcharts-tooltip * {
+ font-family: inherit;
+}
+
+
+.apexcharts-tooltip-title {
+ padding: 6px;
+ font-size: 15px;
+ margin-bottom: 4px;
+}
+
+.apexcharts-tooltip.apexcharts-theme-light .apexcharts-tooltip-title {
+ background: #ECEFF1;
+ border-bottom: 1px solid #ddd;
+}
+
+.apexcharts-tooltip.apexcharts-theme-dark .apexcharts-tooltip-title {
+ background: rgba(0, 0, 0, 0.7);
+ border-bottom: 1px solid #333;
+}
+
+.apexcharts-tooltip-text-y-value,
+.apexcharts-tooltip-text-goals-value,
+.apexcharts-tooltip-text-z-value {
+ display: inline-block;
+ font-weight: 600;
+ margin-left: 5px;
+}
+
+.apexcharts-tooltip-title:empty,
+.apexcharts-tooltip-text-y-label:empty,
+.apexcharts-tooltip-text-y-value:empty,
+.apexcharts-tooltip-text-goals-label:empty,
+.apexcharts-tooltip-text-goals-value:empty,
+.apexcharts-tooltip-text-z-value:empty {
+ display: none;
+}
+
+.apexcharts-tooltip-text-y-value,
+.apexcharts-tooltip-text-goals-value,
+.apexcharts-tooltip-text-z-value {
+ font-weight: 600;
+}
+
+.apexcharts-tooltip-text-goals-label,
+.apexcharts-tooltip-text-goals-value {
+ padding: 6px 0 5px;
+}
+
+.apexcharts-tooltip-goals-group,
+.apexcharts-tooltip-text-goals-label,
+.apexcharts-tooltip-text-goals-value {
+ display: flex;
+}
+.apexcharts-tooltip-text-goals-label:not(:empty),
+.apexcharts-tooltip-text-goals-value:not(:empty) {
+ margin-top: -6px;
+}
+
+.apexcharts-tooltip-marker {
+ width: 12px;
+ height: 12px;
+ position: relative;
+ top: 0px;
+ margin-right: 10px;
+ border-radius: 50%;
+}
+
+.apexcharts-tooltip-series-group {
+ padding: 0 10px;
+ display: none;
+ text-align: left;
+ justify-content: left;
+ align-items: center;
+}
+
+.apexcharts-tooltip-series-group.apexcharts-active .apexcharts-tooltip-marker {
+ opacity: 1;
+}
+
+.apexcharts-tooltip-series-group.apexcharts-active,
+.apexcharts-tooltip-series-group:last-child {
+ padding-bottom: 4px;
+}
+
+.apexcharts-tooltip-series-group-hidden {
+ opacity: 0;
+ height: 0;
+ line-height: 0;
+ padding: 0 !important;
+}
+
+.apexcharts-tooltip-y-group {
+ padding: 6px 0 5px;
+}
+
+.apexcharts-tooltip-box, .apexcharts-custom-tooltip {
+ padding: 4px 8px;
+}
+
+.apexcharts-tooltip-boxPlot {
+ display: flex;
+ flex-direction: column-reverse;
+}
+
+.apexcharts-tooltip-box>div {
+ margin: 4px 0;
+}
+
+.apexcharts-tooltip-box span.value {
+ font-weight: bold;
+}
+
+.apexcharts-tooltip-rangebar {
+ padding: 5px 8px;
+}
+
+.apexcharts-tooltip-rangebar .category {
+ font-weight: 600;
+ color: #777;
+}
+
+.apexcharts-tooltip-rangebar .series-name {
+ font-weight: bold;
+ display: block;
+ margin-bottom: 5px;
+}
+
+.apexcharts-xaxistooltip {
+ opacity: 0;
+ padding: 9px 10px;
+ pointer-events: none;
+ color: #373d3f;
+ font-size: 13px;
+ text-align: center;
+ border-radius: 2px;
+ position: absolute;
+ z-index: 10;
+ background: #ECEFF1;
+ border: 1px solid #90A4AE;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-xaxistooltip.apexcharts-theme-dark {
+ background: rgba(0, 0, 0, 0.7);
+ border: 1px solid rgba(0, 0, 0, 0.5);
+ color: #fff;
+}
+
+.apexcharts-xaxistooltip:after,
+.apexcharts-xaxistooltip:before {
+ left: 50%;
+ border: solid transparent;
+ content: " ";
+ height: 0;
+ width: 0;
+ position: absolute;
+ pointer-events: none;
+}
+
+.apexcharts-xaxistooltip:after {
+ border-color: rgba(236, 239, 241, 0);
+ border-width: 6px;
+ margin-left: -6px;
+}
+
+.apexcharts-xaxistooltip:before {
+ border-color: rgba(144, 164, 174, 0);
+ border-width: 7px;
+ margin-left: -7px;
+}
+
+.apexcharts-xaxistooltip-bottom:after,
+.apexcharts-xaxistooltip-bottom:before {
+ bottom: 100%;
+}
+
+.apexcharts-xaxistooltip-top:after,
+.apexcharts-xaxistooltip-top:before {
+ top: 100%;
+}
+
+.apexcharts-xaxistooltip-bottom:after {
+ border-bottom-color: #ECEFF1;
+}
+
+.apexcharts-xaxistooltip-bottom:before {
+ border-bottom-color: #90A4AE;
+}
+
+.apexcharts-xaxistooltip-bottom.apexcharts-theme-dark:after {
+ border-bottom-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-xaxistooltip-bottom.apexcharts-theme-dark:before {
+ border-bottom-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-xaxistooltip-top:after {
+ border-top-color: #ECEFF1
+}
+
+.apexcharts-xaxistooltip-top:before {
+ border-top-color: #90A4AE;
+}
+
+.apexcharts-xaxistooltip-top.apexcharts-theme-dark:after {
+ border-top-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-xaxistooltip-top.apexcharts-theme-dark:before {
+ border-top-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-xaxistooltip.apexcharts-active {
+ opacity: 1;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-yaxistooltip {
+ opacity: 0;
+ padding: 4px 10px;
+ pointer-events: none;
+ color: #373d3f;
+ font-size: 13px;
+ text-align: center;
+ border-radius: 2px;
+ position: absolute;
+ z-index: 10;
+ background: #ECEFF1;
+ border: 1px solid #90A4AE;
+}
+
+.apexcharts-yaxistooltip.apexcharts-theme-dark {
+ background: rgba(0, 0, 0, 0.7);
+ border: 1px solid rgba(0, 0, 0, 0.5);
+ color: #fff;
+}
+
+.apexcharts-yaxistooltip:after,
+.apexcharts-yaxistooltip:before {
+ top: 50%;
+ border: solid transparent;
+ content: " ";
+ height: 0;
+ width: 0;
+ position: absolute;
+ pointer-events: none;
+}
+
+.apexcharts-yaxistooltip:after {
+ border-color: rgba(236, 239, 241, 0);
+ border-width: 6px;
+ margin-top: -6px;
+}
+
+.apexcharts-yaxistooltip:before {
+ border-color: rgba(144, 164, 174, 0);
+ border-width: 7px;
+ margin-top: -7px;
+}
+
+.apexcharts-yaxistooltip-left:after,
+.apexcharts-yaxistooltip-left:before {
+ left: 100%;
+}
+
+.apexcharts-yaxistooltip-right:after,
+.apexcharts-yaxistooltip-right:before {
+ right: 100%;
+}
+
+.apexcharts-yaxistooltip-left:after {
+ border-left-color: #ECEFF1;
+}
+
+.apexcharts-yaxistooltip-left:before {
+ border-left-color: #90A4AE;
+}
+
+.apexcharts-yaxistooltip-left.apexcharts-theme-dark:after {
+ border-left-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-yaxistooltip-left.apexcharts-theme-dark:before {
+ border-left-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-yaxistooltip-right:after {
+ border-right-color: #ECEFF1;
+}
+
+.apexcharts-yaxistooltip-right:before {
+ border-right-color: #90A4AE;
+}
+
+.apexcharts-yaxistooltip-right.apexcharts-theme-dark:after {
+ border-right-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-yaxistooltip-right.apexcharts-theme-dark:before {
+ border-right-color: rgba(0, 0, 0, 0.5);
+}
+
+.apexcharts-yaxistooltip.apexcharts-active {
+ opacity: 1;
+}
+
+.apexcharts-yaxistooltip-hidden {
+ display: none;
+}
+
+.apexcharts-xcrosshairs,
+.apexcharts-ycrosshairs {
+ pointer-events: none;
+ opacity: 0;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-xcrosshairs.apexcharts-active,
+.apexcharts-ycrosshairs.apexcharts-active {
+ opacity: 1;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-ycrosshairs-hidden {
+ opacity: 0;
+}
+
+.apexcharts-selection-rect {
+ cursor: move;
+}
+
+.svg_select_boundingRect, .svg_select_points_rot {
+ pointer-events: none;
+ opacity: 0;
+ visibility: hidden;
+}
+.apexcharts-selection-rect + g .svg_select_boundingRect,
+.apexcharts-selection-rect + g .svg_select_points_rot {
+ opacity: 0;
+ visibility: hidden;
+}
+
+.apexcharts-selection-rect + g .svg_select_points_l,
+.apexcharts-selection-rect + g .svg_select_points_r {
+ cursor: ew-resize;
+ opacity: 1;
+ visibility: visible;
+}
+
+.svg_select_points {
+ fill: #efefef;
+ stroke: #333;
+ rx: 2;
+}
+
+.apexcharts-svg.apexcharts-zoomable.hovering-zoom {
+ cursor: crosshair
+}
+
+.apexcharts-svg.apexcharts-zoomable.hovering-pan {
+ cursor: move
+}
+
+.apexcharts-zoom-icon,
+.apexcharts-zoomin-icon,
+.apexcharts-zoomout-icon,
+.apexcharts-reset-icon,
+.apexcharts-pan-icon,
+.apexcharts-selection-icon,
+.apexcharts-menu-icon,
+.apexcharts-toolbar-custom-icon {
+ cursor: pointer;
+ width: 20px;
+ height: 20px;
+ line-height: 24px;
+ color: #6E8192;
+ text-align: center;
+}
+
+.apexcharts-zoom-icon svg,
+.apexcharts-zoomin-icon svg,
+.apexcharts-zoomout-icon svg,
+.apexcharts-reset-icon svg,
+.apexcharts-menu-icon svg {
+ fill: #6E8192;
+}
+
+.apexcharts-selection-icon svg {
+ fill: #444;
+ transform: scale(0.76)
+}
+
+.apexcharts-theme-dark .apexcharts-zoom-icon svg,
+.apexcharts-theme-dark .apexcharts-zoomin-icon svg,
+.apexcharts-theme-dark .apexcharts-zoomout-icon svg,
+.apexcharts-theme-dark .apexcharts-reset-icon svg,
+.apexcharts-theme-dark .apexcharts-pan-icon svg,
+.apexcharts-theme-dark .apexcharts-selection-icon svg,
+.apexcharts-theme-dark .apexcharts-menu-icon svg,
+.apexcharts-theme-dark .apexcharts-toolbar-custom-icon svg {
+ fill: #f3f4f5;
+}
+
+.apexcharts-canvas .apexcharts-zoom-icon.apexcharts-selected svg,
+.apexcharts-canvas .apexcharts-selection-icon.apexcharts-selected svg,
+.apexcharts-canvas .apexcharts-reset-zoom-icon.apexcharts-selected svg {
+ fill: #008FFB;
+}
+
+.apexcharts-theme-light .apexcharts-selection-icon:not(.apexcharts-selected):hover svg,
+.apexcharts-theme-light .apexcharts-zoom-icon:not(.apexcharts-selected):hover svg,
+.apexcharts-theme-light .apexcharts-zoomin-icon:hover svg,
+.apexcharts-theme-light .apexcharts-zoomout-icon:hover svg,
+.apexcharts-theme-light .apexcharts-reset-icon:hover svg,
+.apexcharts-theme-light .apexcharts-menu-icon:hover svg {
+ fill: #333;
+}
+
+.apexcharts-selection-icon,
+.apexcharts-menu-icon {
+ position: relative;
+}
+
+.apexcharts-reset-icon {
+ margin-left: 5px;
+}
+
+.apexcharts-zoom-icon,
+.apexcharts-reset-icon,
+.apexcharts-menu-icon {
+ transform: scale(0.85);
+}
+
+.apexcharts-zoomin-icon,
+.apexcharts-zoomout-icon {
+ transform: scale(0.7)
+}
+
+.apexcharts-zoomout-icon {
+ margin-right: 3px;
+}
+
+.apexcharts-pan-icon {
+ transform: scale(0.62);
+ position: relative;
+ left: 1px;
+ top: 0px;
+}
+
+.apexcharts-pan-icon svg {
+ fill: #fff;
+ stroke: #6E8192;
+ stroke-width: 2;
+}
+
+.apexcharts-pan-icon.apexcharts-selected svg {
+ stroke: #008FFB;
+}
+
+.apexcharts-pan-icon:not(.apexcharts-selected):hover svg {
+ stroke: #333;
+}
+
+.apexcharts-toolbar {
+ position: absolute;
+ z-index: 11;
+ max-width: 176px;
+ text-align: right;
+ border-radius: 3px;
+ padding: 0px 6px 2px 6px;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+}
+
+.apexcharts-menu {
+ background: #fff;
+ position: absolute;
+ top: 100%;
+ border: 1px solid #ddd;
+ border-radius: 3px;
+ padding: 3px;
+ right: 10px;
+ opacity: 0;
+ min-width: 110px;
+ transition: 0.15s ease all;
+ pointer-events: none;
+}
+
+.apexcharts-menu.apexcharts-menu-open {
+ opacity: 1;
+ pointer-events: all;
+ transition: 0.15s ease all;
+}
+
+.apexcharts-menu-item {
+ padding: 6px 7px;
+ font-size: 12px;
+ cursor: pointer;
+}
+
+.apexcharts-theme-light .apexcharts-menu-item:hover {
+ background: #eee;
+}
+
+.apexcharts-theme-dark .apexcharts-menu {
+ background: rgba(0, 0, 0, 0.7);
+ color: #fff;
+}
+
+@media screen and (min-width: 768px) {
+ .apexcharts-canvas:hover .apexcharts-toolbar {
+ opacity: 1;
+ }
+}
+
+.apexcharts-datalabel.apexcharts-element-hidden {
+ opacity: 0;
+}
+
+.apexcharts-pie-label,
+.apexcharts-datalabels,
+.apexcharts-datalabel,
+.apexcharts-datalabel-label,
+.apexcharts-datalabel-value {
+ cursor: default;
+ pointer-events: none;
+}
+
+.apexcharts-pie-label-delay {
+ opacity: 0;
+ animation-name: opaque;
+ animation-duration: 0.3s;
+ animation-fill-mode: forwards;
+ animation-timing-function: ease;
+}
+
+.apexcharts-canvas .apexcharts-element-hidden {
+ opacity: 0;
+}
+
+.apexcharts-hide .apexcharts-series-points {
+ opacity: 0;
+}
+
+.apexcharts-gridline,
+.apexcharts-annotation-rect,
+.apexcharts-tooltip .apexcharts-marker,
+.apexcharts-area-series .apexcharts-area,
+.apexcharts-line,
+.apexcharts-zoom-rect,
+.apexcharts-toolbar svg,
+.apexcharts-area-series .apexcharts-series-markers .apexcharts-marker.no-pointer-events,
+.apexcharts-line-series .apexcharts-series-markers .apexcharts-marker.no-pointer-events,
+.apexcharts-radar-series path,
+.apexcharts-radar-series polygon {
+ pointer-events: none;
+}
+
+
+/* markers */
+
+.apexcharts-marker {
+ transition: 0.15s ease all;
+}
+
+@keyframes opaque {
+ 0% {
+ opacity: 0;
+ }
+ 100% {
+ opacity: 1;
+ }
+}
+
+
+/* Resize generated styles */
+
+@keyframes resizeanim {
+ from {
+ opacity: 0;
+ }
+ to {
+ opacity: 0;
+ }
+}
+
+.resize-triggers {
+ animation: 1ms resizeanim;
+ visibility: hidden;
+ opacity: 0;
+}
+
+.resize-triggers,
+.resize-triggers>div,
+.contract-trigger:before {
+ content: " ";
+ display: block;
+ position: absolute;
+ top: 0;
+ left: 0;
+ height: 100%;
+ width: 100%;
+ overflow: hidden;
+}
+
+.resize-triggers>div {
+ background: #eee;
+ overflow: auto;
+}
+
+.contract-trigger:before {
+ width: 200%;
+ height: 200%;
+}
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-camera.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-camera.svg
new file mode 100644
index 0000000..3f052f2
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-camera.svg
@@ -0,0 +1,5 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-home.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-home.svg
new file mode 100644
index 0000000..676d2d3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-home.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-menu.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-menu.svg
new file mode 100644
index 0000000..770b192
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-menu.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus-square.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus-square.svg
new file mode 100644
index 0000000..c4988e8
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus-square.svg
@@ -0,0 +1,9 @@
+
+
+
+
+
+
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus.svg
new file mode 100644
index 0000000..f0a7ec8
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-minus.svg
@@ -0,0 +1,4 @@
+
+
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan-hand.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan-hand.svg
new file mode 100644
index 0000000..1768e5e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan-hand.svg
@@ -0,0 +1,9 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan.svg
new file mode 100644
index 0000000..ae65a94
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-pan.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus-square.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus-square.svg
new file mode 100644
index 0000000..f1b885f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus-square.svg
@@ -0,0 +1,4 @@
+
+
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus.svg
new file mode 100644
index 0000000..b376ab5
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-plus.svg
@@ -0,0 +1,4 @@
+
+
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-refresh.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-refresh.svg
new file mode 100644
index 0000000..81c46c6
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-refresh.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-reset.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-reset.svg
new file mode 100644
index 0000000..2ee1dc3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-reset.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-select.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-select.svg
new file mode 100644
index 0000000..326ab03
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-select.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-select1.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-select1.svg
new file mode 100644
index 0000000..529a226
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-select1.svg
@@ -0,0 +1,3 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-in.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-in.svg
new file mode 100644
index 0000000..3d9355a
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-in.svg
@@ -0,0 +1,5 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-out.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-out.svg
new file mode 100644
index 0000000..74310b6
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom-out.svg
@@ -0,0 +1,10 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom.svg b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom.svg
new file mode 100644
index 0000000..346fdb4
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/assets/ico-zoom.svg
@@ -0,0 +1,4 @@
+
+
\ No newline at end of file
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Bar.js b/cao_sunyata/static/libs/apexcharts/src/charts/Bar.js
new file mode 100644
index 0000000..dd56c69
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Bar.js
@@ -0,0 +1,492 @@
+import BarDataLabels from './common/bar/DataLabels'
+import BarHelpers from './common/bar/Helpers'
+import CoreUtils from '../modules/CoreUtils'
+import Utils from '../utils/Utils'
+import Filters from '../modules/Filters'
+import Graphics from '../modules/Graphics'
+
+/**
+ * ApexCharts Bar Class responsible for drawing both Columns and Bars.
+ *
+ * @module Bar
+ **/
+
+class Bar {
+ constructor(ctx, xyRatios) {
+ this.ctx = ctx
+ this.w = ctx.w
+ const w = this.w
+ this.barOptions = w.config.plotOptions.bar
+
+ this.isHorizontal = this.barOptions.horizontal
+ this.strokeWidth = w.config.stroke.width
+ this.isNullValue = false
+
+ this.isRangeBar = w.globals.seriesRangeBar.length && this.isHorizontal
+
+ this.xyRatios = xyRatios
+
+ if (this.xyRatios !== null) {
+ this.xRatio = xyRatios.xRatio
+ this.initialXRatio = xyRatios.initialXRatio
+ this.yRatio = xyRatios.yRatio
+ this.invertedXRatio = xyRatios.invertedXRatio
+ this.invertedYRatio = xyRatios.invertedYRatio
+ this.baseLineY = xyRatios.baseLineY
+ this.baseLineInvertedY = xyRatios.baseLineInvertedY
+ }
+ this.yaxisIndex = 0
+ this.seriesLen = 0
+
+ this.barHelpers = new BarHelpers(this)
+ }
+
+ /** primary draw method which is called on bar object
+ * @memberof Bar
+ * @param {array} series - user supplied series values
+ * @param {int} seriesIndex - the index by which series will be drawn on the svg
+ * @return {node} element which is supplied to parent chart draw method for appending
+ **/
+ draw(series, seriesIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ const coreUtils = new CoreUtils(this.ctx, w)
+ series = coreUtils.getLogSeries(series)
+ this.series = series
+ this.yRatio = coreUtils.getLogYRatios(this.yRatio)
+
+ this.barHelpers.initVariables(series)
+
+ let ret = graphics.group({
+ class: 'apexcharts-bar-series apexcharts-plot-series'
+ })
+
+ if (w.config.dataLabels.enabled) {
+ if (this.totalItems > this.barOptions.dataLabels.maxItems) {
+ console.warn(
+ 'WARNING: DataLabels are enabled but there are too many to display. This may cause performance issue when rendering.'
+ )
+ }
+ }
+
+ for (let i = 0, bc = 0; i < series.length; i++, bc++) {
+ let x,
+ y,
+ xDivision, // xDivision is the GRIDWIDTH divided by number of datapoints (columns)
+ yDivision, // yDivision is the GRIDHEIGHT divided by number of datapoints (bars)
+ zeroH, // zeroH is the baseline where 0 meets y axis
+ zeroW // zeroW is the baseline where 0 meets x axis
+
+ let yArrj = [] // hold y values of current iterating series
+ let xArrj = [] // hold x values of current iterating series
+
+ let realIndex = w.globals.comboCharts ? seriesIndex[i] : i
+
+ // el to which series will be drawn
+ let elSeries = graphics.group({
+ class: `apexcharts-series`,
+ rel: i + 1,
+ seriesName: Utils.escapeString(w.globals.seriesNames[realIndex]),
+ 'data:realIndex': realIndex
+ })
+
+ this.ctx.series.addCollapsedClassToSeries(elSeries, realIndex)
+
+ if (series[i].length > 0) {
+ this.visibleI = this.visibleI + 1
+ }
+
+ let barHeight = 0
+ let barWidth = 0
+
+ if (this.yRatio.length > 1) {
+ this.yaxisIndex = realIndex
+ }
+
+ this.isReversed =
+ w.config.yaxis[this.yaxisIndex] &&
+ w.config.yaxis[this.yaxisIndex].reversed
+
+ let initPositions = this.barHelpers.initialPositions()
+
+ y = initPositions.y
+ barHeight = initPositions.barHeight
+ yDivision = initPositions.yDivision
+ zeroW = initPositions.zeroW
+
+ x = initPositions.x
+ barWidth = initPositions.barWidth
+ xDivision = initPositions.xDivision
+ zeroH = initPositions.zeroH
+
+ if (!this.horizontal) {
+ xArrj.push(x + barWidth / 2)
+ }
+
+ // eldatalabels
+ let elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-datalabels',
+ 'data:realIndex': realIndex
+ })
+
+ let elGoalsMarkers = graphics.group({
+ class: 'apexcharts-bar-goals-markers',
+ style: `pointer-events: none`
+ })
+
+ for (let j = 0; j < w.globals.dataPoints; j++) {
+ const strokeWidth = this.barHelpers.getStrokeWidth(i, j, realIndex)
+
+ let paths = null
+ const pathsParams = {
+ indexes: {
+ i,
+ j,
+ realIndex,
+ bc
+ },
+ x,
+ y,
+ strokeWidth,
+ elSeries
+ }
+ if (this.isHorizontal) {
+ paths = this.drawBarPaths({
+ ...pathsParams,
+ barHeight,
+ zeroW,
+ yDivision
+ })
+ barWidth = this.series[i][j] / this.invertedYRatio
+ } else {
+ paths = this.drawColumnPaths({
+ ...pathsParams,
+ xDivision,
+ barWidth,
+ zeroH
+ })
+ barHeight = this.series[i][j] / this.yRatio[this.yaxisIndex]
+ }
+
+ const barGoalLine = this.barHelpers.drawGoalLine({
+ barXPosition: paths.barXPosition,
+ barYPosition: paths.barYPosition,
+ goalX: paths.goalX,
+ goalY: paths.goalY,
+ barHeight,
+ barWidth
+ })
+
+ if (barGoalLine) {
+ elGoalsMarkers.add(barGoalLine)
+ }
+
+ y = paths.y
+ x = paths.x
+
+ // push current X
+ if (j > 0) {
+ xArrj.push(x + barWidth / 2)
+ }
+
+ yArrj.push(y)
+
+ let pathFill = this.barHelpers.getPathFillColor(series, i, j, realIndex)
+
+ this.renderSeries({
+ realIndex,
+ pathFill,
+ j,
+ i,
+ pathFrom: paths.pathFrom,
+ pathTo: paths.pathTo,
+ strokeWidth,
+ elSeries,
+ x,
+ y,
+ series,
+ barHeight,
+ barWidth,
+ elDataLabelsWrap,
+ elGoalsMarkers,
+ visibleSeries: this.visibleI,
+ type: 'bar'
+ })
+ }
+
+ // push all x val arrays into main xArr
+ w.globals.seriesXvalues[realIndex] = xArrj
+ w.globals.seriesYvalues[realIndex] = yArrj
+
+ ret.add(elSeries)
+ }
+
+ return ret
+ }
+
+ renderSeries({
+ realIndex,
+ pathFill,
+ lineFill,
+ j,
+ i,
+ pathFrom,
+ pathTo,
+ strokeWidth,
+ elSeries,
+ x,
+ y,
+ y1,
+ y2,
+ series,
+ barHeight,
+ barWidth,
+ barYPosition,
+ elDataLabelsWrap,
+ elGoalsMarkers,
+ visibleSeries,
+ type
+ }) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ if (!lineFill) {
+ /* fix apexcharts#341 */
+ lineFill = this.barOptions.distributed
+ ? w.globals.stroke.colors[j]
+ : w.globals.stroke.colors[realIndex]
+ }
+
+ if (w.config.series[i].data[j] && w.config.series[i].data[j].strokeColor) {
+ lineFill = w.config.series[i].data[j].strokeColor
+ }
+
+ if (this.isNullValue) {
+ pathFill = 'none'
+ }
+
+ let delay =
+ ((j / w.config.chart.animations.animateGradually.delay) *
+ (w.config.chart.animations.speed / w.globals.dataPoints)) /
+ 2.4
+
+ let renderedPath = graphics.renderPaths({
+ i,
+ j,
+ realIndex,
+ pathFrom,
+ pathTo,
+ stroke: lineFill,
+ strokeWidth,
+ strokeLineCap: w.config.stroke.lineCap,
+ fill: pathFill,
+ animationDelay: delay,
+ initialSpeed: w.config.chart.animations.speed,
+ dataChangeSpeed: w.config.chart.animations.dynamicAnimation.speed,
+ className: `apexcharts-${type}-area`
+ })
+
+ renderedPath.attr('clip-path', `url(#gridRectMask${w.globals.cuid})`)
+
+ const forecast = w.config.forecastDataPoints
+ if (forecast.count > 0) {
+ if (j >= w.globals.dataPoints - forecast.count) {
+ renderedPath.node.setAttribute('stroke-dasharray', forecast.dashArray)
+ renderedPath.node.setAttribute('stroke-width', forecast.strokeWidth)
+ renderedPath.node.setAttribute('fill-opacity', forecast.fillOpacity)
+ }
+ }
+
+ if (typeof y1 !== 'undefined' && typeof y2 !== 'undefined') {
+ renderedPath.attr('data-range-y1', y1)
+ renderedPath.attr('data-range-y2', y2)
+ }
+
+ const filters = new Filters(this.ctx)
+ filters.setSelectionFilter(renderedPath, realIndex, j)
+ elSeries.add(renderedPath)
+
+ let barDataLabels = new BarDataLabels(this)
+ let dataLabels = barDataLabels.handleBarDataLabels({
+ x,
+ y,
+ y1,
+ y2,
+ i,
+ j,
+ series,
+ realIndex,
+ barHeight,
+ barWidth,
+ barYPosition,
+ renderedPath,
+ visibleSeries
+ })
+ if (dataLabels !== null) {
+ elDataLabelsWrap.add(dataLabels)
+ }
+
+ elSeries.add(elDataLabelsWrap)
+
+ if (elGoalsMarkers) {
+ elSeries.add(elGoalsMarkers)
+ }
+ return elSeries
+ }
+
+ drawBarPaths({
+ indexes,
+ barHeight,
+ strokeWidth,
+ zeroW,
+ x,
+ y,
+ yDivision,
+ elSeries
+ }) {
+ let w = this.w
+
+ let i = indexes.i
+ let j = indexes.j
+
+ if (w.globals.isXNumeric) {
+ y =
+ (w.globals.seriesX[i][j] - w.globals.minX) / this.invertedXRatio -
+ barHeight
+ }
+
+ let barYPosition = y + barHeight * this.visibleI
+
+ x = this.barHelpers.getXForValue(this.series[i][j], zeroW)
+
+ const paths = this.barHelpers.getBarpaths({
+ barYPosition,
+ barHeight,
+ x1: zeroW,
+ x2: x,
+ strokeWidth,
+ series: this.series,
+ realIndex: indexes.realIndex,
+ i,
+ j,
+ w
+ })
+
+ if (!w.globals.isXNumeric) {
+ y = y + yDivision
+ }
+
+ this.barHelpers.barBackground({
+ j,
+ i,
+ y1: barYPosition - barHeight * this.visibleI,
+ y2: barHeight * this.seriesLen,
+ elSeries
+ })
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ x,
+ y,
+ goalX: this.barHelpers.getGoalValues('x', zeroW, null, i, j),
+ barYPosition
+ }
+ }
+
+ drawColumnPaths({
+ indexes,
+ x,
+ y,
+ xDivision,
+ barWidth,
+ zeroH,
+ strokeWidth,
+ elSeries
+ }) {
+ let w = this.w
+
+ let realIndex = indexes.realIndex
+ let i = indexes.i
+ let j = indexes.j
+ let bc = indexes.bc
+
+ if (w.globals.isXNumeric) {
+ let sxI = realIndex
+ if (!w.globals.seriesX[realIndex].length) {
+ sxI = w.globals.maxValsInArrayIndex
+ }
+
+ x =
+ (w.globals.seriesX[sxI][j] - w.globals.minX) / this.xRatio -
+ (barWidth * this.seriesLen) / 2
+ }
+
+ let barXPosition = x + barWidth * this.visibleI
+
+ y = this.barHelpers.getYForValue(this.series[i][j], zeroH)
+
+ const paths = this.barHelpers.getColumnPaths({
+ barXPosition,
+ barWidth,
+ y1: zeroH,
+ y2: y,
+ strokeWidth,
+ series: this.series,
+ realIndex: indexes.realIndex,
+ i,
+ j,
+ w
+ })
+
+ if (!w.globals.isXNumeric) {
+ x = x + xDivision
+ }
+
+ this.barHelpers.barBackground({
+ bc,
+ j,
+ i,
+ x1: barXPosition - strokeWidth / 2 - barWidth * this.visibleI,
+ x2: barWidth * this.seriesLen + strokeWidth / 2,
+ elSeries
+ })
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ x,
+ y,
+ goalY: this.barHelpers.getGoalValues('y', null, zeroH, i, j),
+ barXPosition
+ }
+ }
+
+ /** getPreviousPath is a common function for bars/columns which is used to get previous paths when data changes.
+ * @memberof Bar
+ * @param {int} realIndex - current iterating i
+ * @param {int} j - current iterating series's j index
+ * @return {string} pathFrom is the string which will be appended in animations
+ **/
+ getPreviousPath(realIndex, j) {
+ let w = this.w
+ let pathFrom
+ for (let pp = 0; pp < w.globals.previousPaths.length; pp++) {
+ let gpp = w.globals.previousPaths[pp]
+
+ if (
+ gpp.paths &&
+ gpp.paths.length > 0 &&
+ parseInt(gpp.realIndex, 10) === parseInt(realIndex, 10)
+ ) {
+ if (typeof w.globals.previousPaths[pp].paths[j] !== 'undefined') {
+ pathFrom = w.globals.previousPaths[pp].paths[j].d
+ }
+ }
+ }
+ return pathFrom
+ }
+}
+
+export default Bar
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/BarStacked.js b/cao_sunyata/static/libs/apexcharts/src/charts/BarStacked.js
new file mode 100644
index 0000000..345abde
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/BarStacked.js
@@ -0,0 +1,481 @@
+import CoreUtils from '../modules/CoreUtils'
+import Bar from './Bar'
+import Graphics from '../modules/Graphics'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts BarStacked Class responsible for drawing both Stacked Columns and Bars.
+ *
+ * @module BarStacked
+ * The whole calculation for stacked bar/column is different from normal bar/column,
+ * hence it makes sense to derive a new class for it extending most of the props of Parent Bar
+ **/
+
+class BarStacked extends Bar {
+ draw(series, seriesIndex) {
+ let w = this.w
+ this.graphics = new Graphics(this.ctx)
+ this.bar = new Bar(this.ctx, this.xyRatios)
+
+ const coreUtils = new CoreUtils(this.ctx, w)
+ series = coreUtils.getLogSeries(series)
+ this.yRatio = coreUtils.getLogYRatios(this.yRatio)
+
+ this.barHelpers.initVariables(series)
+
+ if (w.config.chart.stackType === '100%') {
+ series = w.globals.seriesPercent.slice()
+ }
+
+ this.series = series
+
+ this.totalItems = 0
+
+ this.prevY = [] // y position on chart
+ this.prevX = [] // x position on chart
+ this.prevYF = [] // y position including shapes on chart
+ this.prevXF = [] // x position including shapes on chart
+ this.prevYVal = [] // y values (series[i][j]) in columns
+ this.prevXVal = [] // x values (series[i][j]) in bars
+
+ this.xArrj = [] // xj indicates x position on graph in bars
+ this.xArrjF = [] // xjF indicates bar's x position + roundedShape's positions in bars
+ this.xArrjVal = [] // x val means the actual series's y values in horizontal/bars
+ this.yArrj = [] // yj indicates y position on graph in columns
+ this.yArrjF = [] // yjF indicates bar's y position + roundedShape's positions in columns
+ this.yArrjVal = [] // y val means the actual series's y values in columns
+
+ for (let sl = 0; sl < series.length; sl++) {
+ if (series[sl].length > 0) {
+ this.totalItems += series[sl].length
+ }
+ }
+
+ let ret = this.graphics.group({
+ class: 'apexcharts-bar-series apexcharts-plot-series'
+ })
+
+ let x = 0
+ let y = 0
+
+ for (let i = 0, bc = 0; i < series.length; i++, bc++) {
+ let xDivision // xDivision is the GRIDWIDTH divided by number of datapoints (columns)
+ let yDivision // yDivision is the GRIDHEIGHT divided by number of datapoints (bars)
+ let zeroH // zeroH is the baseline where 0 meets y axis
+ let zeroW // zeroW is the baseline where 0 meets x axis
+
+ let xArrValues = []
+ let yArrValues = []
+
+ let realIndex = w.globals.comboCharts ? seriesIndex[i] : i
+
+ if (this.yRatio.length > 1) {
+ this.yaxisIndex = realIndex
+ }
+
+ this.isReversed =
+ w.config.yaxis[this.yaxisIndex] &&
+ w.config.yaxis[this.yaxisIndex].reversed
+
+ // el to which series will be drawn
+ let elSeries = this.graphics.group({
+ class: `apexcharts-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[realIndex]),
+ rel: i + 1,
+ 'data:realIndex': realIndex
+ })
+ this.ctx.series.addCollapsedClassToSeries(elSeries, realIndex)
+
+ // eldatalabels
+ let elDataLabelsWrap = this.graphics.group({
+ class: 'apexcharts-datalabels',
+ 'data:realIndex': realIndex
+ })
+
+ let barHeight = 0
+ let barWidth = 0
+
+ let initPositions = this.initialPositions(
+ x,
+ y,
+ xDivision,
+ yDivision,
+ zeroH,
+ zeroW
+ )
+ y = initPositions.y
+ barHeight = initPositions.barHeight
+ yDivision = initPositions.yDivision
+ zeroW = initPositions.zeroW
+
+ x = initPositions.x
+ barWidth = initPositions.barWidth
+ xDivision = initPositions.xDivision
+ zeroH = initPositions.zeroH
+
+ this.yArrj = []
+ this.yArrjF = []
+ this.yArrjVal = []
+ this.xArrj = []
+ this.xArrjF = []
+ this.xArrjVal = []
+
+ // if (!this.horizontal) {
+ // this.xArrj.push(x + barWidth / 2)
+ // }
+
+ // fix issue #1215;
+ // where all stack bar disappear after collapsing the first series
+ // sol: if only 1 arr in this.prevY(this.prevY.length === 1) and all are NaN
+ if (this.prevY.length === 1 && this.prevY[0].every((val) => isNaN(val))) {
+ // make this.prevY[0] all zeroH
+ this.prevY[0] = this.prevY[0].map((val) => zeroH)
+ // make this.prevYF[0] all 0
+ this.prevYF[0] = this.prevYF[0].map((val) => 0)
+ }
+
+ for (let j = 0; j < w.globals.dataPoints; j++) {
+ const strokeWidth = this.barHelpers.getStrokeWidth(i, j, realIndex)
+ const commonPathOpts = {
+ indexes: { i, j, realIndex, bc },
+ strokeWidth,
+ x,
+ y,
+ elSeries
+ }
+ let paths = null
+ if (this.isHorizontal) {
+ paths = this.drawStackedBarPaths({
+ ...commonPathOpts,
+ zeroW,
+ barHeight,
+ yDivision
+ })
+ barWidth = this.series[i][j] / this.invertedYRatio
+ } else {
+ paths = this.drawStackedColumnPaths({
+ ...commonPathOpts,
+ xDivision,
+ barWidth,
+ zeroH
+ })
+ barHeight = this.series[i][j] / this.yRatio[this.yaxisIndex]
+ }
+
+ y = paths.y
+ x = paths.x
+
+ xArrValues.push(x)
+ yArrValues.push(y)
+
+ let pathFill = this.barHelpers.getPathFillColor(series, i, j, realIndex)
+
+ elSeries = this.renderSeries({
+ realIndex,
+ pathFill,
+ j,
+ i,
+ pathFrom: paths.pathFrom,
+ pathTo: paths.pathTo,
+ strokeWidth,
+ elSeries,
+ x,
+ y,
+ series,
+ barHeight,
+ barWidth,
+ elDataLabelsWrap,
+ type: 'bar',
+ visibleSeries: 0
+ })
+ }
+
+ // push all x val arrays into main xArr
+ w.globals.seriesXvalues[realIndex] = xArrValues
+ w.globals.seriesYvalues[realIndex] = yArrValues
+
+ // push all current y values array to main PrevY Array
+ this.prevY.push(this.yArrj)
+ this.prevYF.push(this.yArrjF)
+ this.prevYVal.push(this.yArrjVal)
+ this.prevX.push(this.xArrj)
+ this.prevXF.push(this.xArrjF)
+ this.prevXVal.push(this.xArrjVal)
+
+ ret.add(elSeries)
+ }
+
+ return ret
+ }
+
+ initialPositions(x, y, xDivision, yDivision, zeroH, zeroW) {
+ let w = this.w
+
+ let barHeight, barWidth
+ if (this.isHorizontal) {
+ // height divided into equal parts
+ yDivision = w.globals.gridHeight / w.globals.dataPoints
+ barHeight = yDivision
+
+ barHeight =
+ (barHeight * parseInt(w.config.plotOptions.bar.barHeight, 10)) / 100
+
+ zeroW =
+ this.baseLineInvertedY +
+ w.globals.padHorizontal +
+ (this.isReversed ? w.globals.gridWidth : 0) -
+ (this.isReversed ? this.baseLineInvertedY * 2 : 0)
+
+ // initial y position is half of barHeight * half of number of Bars
+ y = (yDivision - barHeight) / 2
+ } else {
+ // width divided into equal parts
+ xDivision = w.globals.gridWidth / w.globals.dataPoints
+
+ barWidth = xDivision
+
+ if (w.globals.isXNumeric && w.globals.dataPoints > 1) {
+ // the check (w.globals.dataPoints > 1) fixes apexcharts.js #1617
+ xDivision = w.globals.minXDiff / this.xRatio
+ barWidth = (xDivision * parseInt(this.barOptions.columnWidth, 10)) / 100
+ } else {
+ barWidth =
+ (barWidth * parseInt(w.config.plotOptions.bar.columnWidth, 10)) / 100
+ }
+
+ zeroH =
+ this.baseLineY[this.yaxisIndex] +
+ (this.isReversed ? w.globals.gridHeight : 0) -
+ (this.isReversed ? this.baseLineY[this.yaxisIndex] * 2 : 0)
+
+ // initial x position is one third of barWidth
+ x = w.globals.padHorizontal + (xDivision - barWidth) / 2
+ }
+ return {
+ x,
+ y,
+ yDivision,
+ xDivision,
+ barHeight,
+ barWidth,
+ zeroH,
+ zeroW
+ }
+ }
+
+ drawStackedBarPaths({
+ indexes,
+ barHeight,
+ strokeWidth,
+ zeroW,
+ x,
+ y,
+ yDivision,
+ elSeries
+ }) {
+ let w = this.w
+ let barYPosition = y
+ let barXPosition
+ let i = indexes.i
+ let j = indexes.j
+
+ let prevBarW = 0
+ for (let k = 0; k < this.prevXF.length; k++) {
+ prevBarW = prevBarW + this.prevXF[k][j]
+ }
+
+ if (i > 0) {
+ let bXP = zeroW
+
+ if (this.prevXVal[i - 1][j] < 0) {
+ bXP =
+ this.series[i][j] >= 0
+ ? this.prevX[i - 1][j] +
+ prevBarW -
+ (this.isReversed ? prevBarW : 0) * 2
+ : this.prevX[i - 1][j]
+ } else if (this.prevXVal[i - 1][j] >= 0) {
+ bXP =
+ this.series[i][j] >= 0
+ ? this.prevX[i - 1][j]
+ : this.prevX[i - 1][j] -
+ prevBarW +
+ (this.isReversed ? prevBarW : 0) * 2
+ }
+
+ barXPosition = bXP
+ } else {
+ // the first series will not have prevX values
+ barXPosition = zeroW
+ }
+
+ if (this.series[i][j] === null) {
+ x = barXPosition
+ } else {
+ x =
+ barXPosition +
+ this.series[i][j] / this.invertedYRatio -
+ (this.isReversed ? this.series[i][j] / this.invertedYRatio : 0) * 2
+ }
+
+ const paths = this.barHelpers.getBarpaths({
+ barYPosition,
+ barHeight,
+ x1: barXPosition,
+ x2: x,
+ strokeWidth,
+ series: this.series,
+ realIndex: indexes.realIndex,
+ i,
+ j,
+ w
+ })
+
+ this.barHelpers.barBackground({
+ j,
+ i,
+ y1: barYPosition,
+ y2: barHeight,
+ elSeries
+ })
+
+ y = y + yDivision
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ x,
+ y
+ }
+ }
+
+ drawStackedColumnPaths({
+ indexes,
+ x,
+ y,
+ xDivision,
+ barWidth,
+ zeroH,
+ strokeWidth,
+ elSeries
+ }) {
+ let w = this.w
+ let i = indexes.i
+ let j = indexes.j
+ let bc = indexes.bc
+
+ if (w.globals.isXNumeric) {
+ let seriesVal = w.globals.seriesX[i][j]
+ if (!seriesVal) seriesVal = 0
+ x = (seriesVal - w.globals.minX) / this.xRatio - barWidth / 2
+ }
+
+ let barXPosition = x
+ let barYPosition
+
+ let prevBarH = 0
+ for (let k = 0; k < this.prevYF.length; k++) {
+ // fix issue #1215
+ // in case where this.prevYF[k][j] is NaN, use 0 instead
+ prevBarH = prevBarH + (!isNaN(this.prevYF[k][j]) ? this.prevYF[k][j] : 0)
+ }
+
+ if (
+ (i > 0 && !w.globals.isXNumeric) ||
+ (i > 0 &&
+ w.globals.isXNumeric &&
+ w.globals.seriesX[i - 1][j] === w.globals.seriesX[i][j])
+ ) {
+ let bYP
+ let prevYValue
+ const p = Math.min(this.yRatio.length + 1, i + 1)
+ if (this.prevY[i - 1] !== undefined) {
+ for (let ii = 1; ii < p; ii++) {
+ if (!isNaN(this.prevY[i - ii][j])) {
+ // find the previous available value to give prevYValue
+ prevYValue = this.prevY[i - ii][j]
+ // if found it, break the loop
+ break
+ }
+ }
+ }
+
+ for (let ii = 1; ii < p; ii++) {
+ // find the previous available value(non-NaN) to give bYP
+ if (this.prevYVal[i - ii][j] < 0) {
+ bYP =
+ this.series[i][j] >= 0
+ ? prevYValue - prevBarH + (this.isReversed ? prevBarH : 0) * 2
+ : prevYValue
+ // found it? break the loop
+ break
+ } else if (this.prevYVal[i - ii][j] >= 0) {
+ bYP =
+ this.series[i][j] >= 0
+ ? prevYValue
+ : prevYValue + prevBarH - (this.isReversed ? prevBarH : 0) * 2
+ // found it? break the loop
+ break
+ }
+ }
+
+ if (typeof bYP === 'undefined') bYP = w.globals.gridHeight
+
+ // if this.prevYF[0] is all 0 resulted from line #486
+ // AND every arr starting from the second only contains NaN
+ if (
+ this.prevYF[0].every((val) => val === 0) &&
+ this.prevYF.slice(1, i).every((arr) => arr.every((val) => isNaN(val)))
+ ) {
+ // Use the same calc way as line #485
+ barYPosition = w.globals.gridHeight - zeroH
+ } else {
+ // Nothing special
+ barYPosition = bYP
+ }
+ } else {
+ // the first series will not have prevY values, also if the prev index's series X doesn't matches the current index's series X, then start from zero
+ barYPosition = w.globals.gridHeight - zeroH
+ }
+
+ y =
+ barYPosition -
+ this.series[i][j] / this.yRatio[this.yaxisIndex] +
+ (this.isReversed ? this.series[i][j] / this.yRatio[this.yaxisIndex] : 0) *
+ 2
+
+ const paths = this.barHelpers.getColumnPaths({
+ barXPosition,
+ barWidth,
+ y1: barYPosition,
+ y2: y,
+ yRatio: this.yRatio[this.yaxisIndex],
+ strokeWidth: this.strokeWidth,
+ series: this.series,
+ realIndex: indexes.realIndex,
+ i,
+ j,
+ w
+ })
+
+ this.barHelpers.barBackground({
+ bc,
+ j,
+ i,
+ x1: barXPosition,
+ x2: barWidth,
+ elSeries
+ })
+
+ x = x + xDivision
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ x: w.globals.isXNumeric ? x - xDivision : x,
+ y
+ }
+ }
+}
+
+export default BarStacked
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/BoxCandleStick.js b/cao_sunyata/static/libs/apexcharts/src/charts/BoxCandleStick.js
new file mode 100644
index 0000000..b2d121a
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/BoxCandleStick.js
@@ -0,0 +1,428 @@
+import CoreUtils from '../modules/CoreUtils'
+import Bar from './Bar'
+import Fill from '../modules/Fill'
+import Graphics from '../modules/Graphics'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts BoxCandleStick Class responsible for drawing both Stacked Columns and Bars.
+ *
+ * @module BoxCandleStick
+ **/
+
+class BoxCandleStick extends Bar {
+ draw(series, seriesIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+ let fill = new Fill(this.ctx)
+
+ this.candlestickOptions = this.w.config.plotOptions.candlestick
+ this.boxOptions = this.w.config.plotOptions.boxPlot
+ this.isHorizontal = w.config.plotOptions.bar.horizontal
+
+ const coreUtils = new CoreUtils(this.ctx, w)
+ series = coreUtils.getLogSeries(series)
+ this.series = series
+ this.yRatio = coreUtils.getLogYRatios(this.yRatio)
+
+ this.barHelpers.initVariables(series)
+
+ let ret = graphics.group({
+ class: `apexcharts-${w.config.chart.type}-series apexcharts-plot-series`
+ })
+
+ for (let i = 0; i < series.length; i++) {
+ this.isBoxPlot =
+ w.config.chart.type === 'boxPlot' ||
+ w.config.series[i].type === 'boxPlot'
+
+ let x,
+ y,
+ xDivision, // xDivision is the GRIDWIDTH divided by number of datapoints (columns)
+ yDivision, // yDivision is the GRIDHEIGHT divided by number of datapoints (bars)
+ zeroH, // zeroH is the baseline where 0 meets y axis
+ zeroW // zeroW is the baseline where 0 meets x axis
+
+ let yArrj = [] // hold y values of current iterating series
+ let xArrj = [] // hold x values of current iterating series
+
+ let realIndex = w.globals.comboCharts ? seriesIndex[i] : i
+
+ // el to which series will be drawn
+ let elSeries = graphics.group({
+ class: `apexcharts-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[realIndex]),
+ rel: i + 1,
+ 'data:realIndex': realIndex
+ })
+
+ this.ctx.series.addCollapsedClassToSeries(elSeries, realIndex)
+
+ if (series[i].length > 0) {
+ this.visibleI = this.visibleI + 1
+ }
+
+ let barHeight = 0
+ let barWidth = 0
+
+ if (this.yRatio.length > 1) {
+ this.yaxisIndex = realIndex
+ }
+
+ let initPositions = this.barHelpers.initialPositions()
+
+ y = initPositions.y
+ barHeight = initPositions.barHeight
+ yDivision = initPositions.yDivision
+ zeroW = initPositions.zeroW
+
+ x = initPositions.x
+ barWidth = initPositions.barWidth
+ xDivision = initPositions.xDivision
+ zeroH = initPositions.zeroH
+
+ xArrj.push(x + barWidth / 2)
+
+ // eldatalabels
+ let elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-datalabels',
+ 'data:realIndex': realIndex
+ })
+
+ for (let j = 0; j < w.globals.dataPoints; j++) {
+ const strokeWidth = this.barHelpers.getStrokeWidth(i, j, realIndex)
+
+ let paths = null
+ const pathsParams = {
+ indexes: {
+ i,
+ j,
+ realIndex
+ },
+ x,
+ y,
+ strokeWidth,
+ elSeries
+ }
+
+ if (this.isHorizontal) {
+ paths = this.drawHorizontalBoxPaths({
+ ...pathsParams,
+ yDivision,
+ barHeight,
+ zeroW
+ })
+ } else {
+ paths = this.drawVerticalBoxPaths({
+ ...pathsParams,
+ xDivision,
+ barWidth,
+ zeroH
+ })
+ }
+
+ y = paths.y
+ x = paths.x
+
+ // push current X
+ if (j > 0) {
+ xArrj.push(x + barWidth / 2)
+ }
+
+ yArrj.push(y)
+
+ paths.pathTo.forEach((pathTo, pi) => {
+ let lineFill =
+ !this.isBoxPlot && this.candlestickOptions.wick.useFillColor
+ ? paths.color[pi]
+ : w.globals.stroke.colors[i]
+
+ let pathFill = fill.fillPath({
+ seriesNumber: realIndex,
+ dataPointIndex: j,
+ color: paths.color[pi],
+ value: series[i][j]
+ })
+
+ this.renderSeries({
+ realIndex,
+ pathFill,
+ lineFill,
+ j,
+ i,
+ pathFrom: paths.pathFrom,
+ pathTo,
+ strokeWidth,
+ elSeries,
+ x,
+ y,
+ series,
+ barHeight,
+ barWidth,
+ elDataLabelsWrap,
+ visibleSeries: this.visibleI,
+ type: w.config.chart.type
+ })
+ })
+ }
+
+ // push all x val arrays into main xArr
+ w.globals.seriesXvalues[realIndex] = xArrj
+ w.globals.seriesYvalues[realIndex] = yArrj
+
+ ret.add(elSeries)
+ }
+
+ return ret
+ }
+
+ drawVerticalBoxPaths({
+ indexes,
+ x,
+ y,
+ xDivision,
+ barWidth,
+ zeroH,
+ strokeWidth
+ }) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let i = indexes.i
+ let j = indexes.j
+
+ let isPositive = true
+ let colorPos = w.config.plotOptions.candlestick.colors.upward
+ let colorNeg = w.config.plotOptions.candlestick.colors.downward
+ let color = ''
+
+ if (this.isBoxPlot) {
+ color = [this.boxOptions.colors.lower, this.boxOptions.colors.upper]
+ }
+
+ const yRatio = this.yRatio[this.yaxisIndex]
+ let realIndex = indexes.realIndex
+
+ const ohlc = this.getOHLCValue(realIndex, j)
+ let l1 = zeroH
+ let l2 = zeroH
+
+ if (ohlc.o > ohlc.c) {
+ isPositive = false
+ }
+
+ let y1 = Math.min(ohlc.o, ohlc.c)
+ let y2 = Math.max(ohlc.o, ohlc.c)
+ let m = ohlc.m
+
+ if (w.globals.isXNumeric) {
+ x =
+ (w.globals.seriesX[realIndex][j] - w.globals.minX) / this.xRatio -
+ barWidth / 2
+ }
+
+ let barXPosition = x + barWidth * this.visibleI
+
+ if (
+ typeof this.series[i][j] === 'undefined' ||
+ this.series[i][j] === null
+ ) {
+ y1 = zeroH
+ y2 = zeroH
+ } else {
+ y1 = zeroH - y1 / yRatio
+ y2 = zeroH - y2 / yRatio
+ l1 = zeroH - ohlc.h / yRatio
+ l2 = zeroH - ohlc.l / yRatio
+ m = zeroH - ohlc.m / yRatio
+ }
+
+ let pathTo = graphics.move(barXPosition, zeroH)
+ let pathFrom = graphics.move(barXPosition + barWidth / 2, y1)
+ if (w.globals.previousPaths.length > 0) {
+ pathFrom = this.getPreviousPath(realIndex, j, true)
+ }
+
+ if (this.isBoxPlot) {
+ pathTo = [
+ graphics.move(barXPosition, y1) +
+ graphics.line(barXPosition + barWidth / 2, y1) +
+ graphics.line(barXPosition + barWidth / 2, l1) +
+ graphics.line(barXPosition + barWidth / 4, l1) +
+ graphics.line(barXPosition + barWidth - barWidth / 4, l1) +
+ graphics.line(barXPosition + barWidth / 2, l1) +
+ graphics.line(barXPosition + barWidth / 2, y1) +
+ graphics.line(barXPosition + barWidth, y1) +
+ graphics.line(barXPosition + barWidth, m) +
+ graphics.line(barXPosition, m) +
+ graphics.line(barXPosition, y1 + strokeWidth / 2),
+ graphics.move(barXPosition, m) +
+ graphics.line(barXPosition + barWidth, m) +
+ graphics.line(barXPosition + barWidth, y2) +
+ graphics.line(barXPosition + barWidth / 2, y2) +
+ graphics.line(barXPosition + barWidth / 2, l2) +
+ graphics.line(barXPosition + barWidth - barWidth / 4, l2) +
+ graphics.line(barXPosition + barWidth / 4, l2) +
+ graphics.line(barXPosition + barWidth / 2, l2) +
+ graphics.line(barXPosition + barWidth / 2, y2) +
+ graphics.line(barXPosition, y2) +
+ graphics.line(barXPosition, m) +
+ 'z'
+ ]
+ } else {
+ // candlestick
+ pathTo = [
+ graphics.move(barXPosition, y2) +
+ graphics.line(barXPosition + barWidth / 2, y2) +
+ graphics.line(barXPosition + barWidth / 2, l1) +
+ graphics.line(barXPosition + barWidth / 2, y2) +
+ graphics.line(barXPosition + barWidth, y2) +
+ graphics.line(barXPosition + barWidth, y1) +
+ graphics.line(barXPosition + barWidth / 2, y1) +
+ graphics.line(barXPosition + barWidth / 2, l2) +
+ graphics.line(barXPosition + barWidth / 2, y1) +
+ graphics.line(barXPosition, y1) +
+ graphics.line(barXPosition, y2 - strokeWidth / 2)
+ ]
+ }
+
+ pathFrom = pathFrom + graphics.move(barXPosition, y1)
+
+ if (!w.globals.isXNumeric) {
+ x = x + xDivision
+ }
+
+ return {
+ pathTo,
+ pathFrom,
+ x,
+ y: y2,
+ barXPosition,
+ color: this.isBoxPlot ? color : isPositive ? [colorPos] : [colorNeg]
+ }
+ }
+
+ drawHorizontalBoxPaths({
+ indexes,
+ x,
+ y,
+ yDivision,
+ barHeight,
+ zeroW,
+ strokeWidth
+ }) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let i = indexes.i
+ let j = indexes.j
+
+ let color = this.boxOptions.colors.lower
+
+ if (this.isBoxPlot) {
+ color = [this.boxOptions.colors.lower, this.boxOptions.colors.upper]
+ }
+
+ const yRatio = this.invertedYRatio
+ let realIndex = indexes.realIndex
+
+ const ohlc = this.getOHLCValue(realIndex, j)
+ let l1 = zeroW
+ let l2 = zeroW
+
+ let x1 = Math.min(ohlc.o, ohlc.c)
+ let x2 = Math.max(ohlc.o, ohlc.c)
+ let m = ohlc.m
+
+ if (w.globals.isXNumeric) {
+ y =
+ (w.globals.seriesX[realIndex][j] - w.globals.minX) /
+ this.invertedXRatio -
+ barHeight / 2
+ }
+
+ let barYPosition = y + barHeight * this.visibleI
+
+ if (
+ typeof this.series[i][j] === 'undefined' ||
+ this.series[i][j] === null
+ ) {
+ x1 = zeroW
+ x2 = zeroW
+ } else {
+ x1 = zeroW + x1 / yRatio
+ x2 = zeroW + x2 / yRatio
+ l1 = zeroW + ohlc.h / yRatio
+ l2 = zeroW + ohlc.l / yRatio
+ m = zeroW + ohlc.m / yRatio
+ }
+
+ let pathTo = graphics.move(zeroW, barYPosition)
+ let pathFrom = graphics.move(x1, barYPosition + barHeight / 2)
+ if (w.globals.previousPaths.length > 0) {
+ pathFrom = this.getPreviousPath(realIndex, j, true)
+ }
+
+ pathTo = [
+ graphics.move(x1, barYPosition) +
+ graphics.line(x1, barYPosition + barHeight / 2) +
+ graphics.line(l1, barYPosition + barHeight / 2) +
+ graphics.line(l1, barYPosition + barHeight / 2 - barHeight / 4) +
+ graphics.line(l1, barYPosition + barHeight / 2 + barHeight / 4) +
+ graphics.line(l1, barYPosition + barHeight / 2) +
+ graphics.line(x1, barYPosition + barHeight / 2) +
+ graphics.line(x1, barYPosition + barHeight) +
+ graphics.line(m, barYPosition + barHeight) +
+ graphics.line(m, barYPosition) +
+ graphics.line(x1 + strokeWidth / 2, barYPosition),
+ graphics.move(m, barYPosition) +
+ graphics.line(m, barYPosition + barHeight) +
+ graphics.line(x2, barYPosition + barHeight) +
+ graphics.line(x2, barYPosition + barHeight / 2) +
+ graphics.line(l2, barYPosition + barHeight / 2) +
+ graphics.line(l2, barYPosition + barHeight - barHeight / 4) +
+ graphics.line(l2, barYPosition + barHeight / 4) +
+ graphics.line(l2, barYPosition + barHeight / 2) +
+ graphics.line(x2, barYPosition + barHeight / 2) +
+ graphics.line(x2, barYPosition) +
+ graphics.line(m, barYPosition) +
+ 'z'
+ ]
+
+ pathFrom = pathFrom + graphics.move(x1, barYPosition)
+
+ if (!w.globals.isXNumeric) {
+ y = y + yDivision
+ }
+
+ return {
+ pathTo,
+ pathFrom,
+ x: x2,
+ y,
+ barYPosition,
+ color
+ }
+ }
+ getOHLCValue(i, j) {
+ const w = this.w
+
+ return {
+ o: this.isBoxPlot
+ ? w.globals.seriesCandleH[i][j]
+ : w.globals.seriesCandleO[i][j],
+ h: this.isBoxPlot
+ ? w.globals.seriesCandleO[i][j]
+ : w.globals.seriesCandleH[i][j],
+ m: w.globals.seriesCandleM[i][j],
+ l: this.isBoxPlot
+ ? w.globals.seriesCandleC[i][j]
+ : w.globals.seriesCandleL[i][j],
+ c: this.isBoxPlot
+ ? w.globals.seriesCandleL[i][j]
+ : w.globals.seriesCandleC[i][j]
+ }
+ }
+}
+
+export default BoxCandleStick
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/HeatMap.js b/cao_sunyata/static/libs/apexcharts/src/charts/HeatMap.js
new file mode 100644
index 0000000..60e3a9b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/HeatMap.js
@@ -0,0 +1,241 @@
+import Animations from '../modules/Animations'
+import Graphics from '../modules/Graphics'
+import Fill from '../modules/Fill'
+import Utils from '../utils/Utils'
+import Helpers from './common/treemap/Helpers'
+import Filters from '../modules/Filters'
+
+/**
+ * ApexCharts HeatMap Class.
+ * @module HeatMap
+ **/
+
+export default class HeatMap {
+ constructor(ctx, xyRatios) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.xRatio = xyRatios.xRatio
+ this.yRatio = xyRatios.yRatio
+
+ this.dynamicAnim = this.w.config.chart.animations.dynamicAnimation
+
+ this.helpers = new Helpers(ctx)
+ this.rectRadius = this.w.config.plotOptions.heatmap.radius
+ this.strokeWidth = this.w.config.stroke.show
+ ? this.w.config.stroke.width
+ : 0
+ }
+
+ draw(series) {
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let ret = graphics.group({
+ class: 'apexcharts-heatmap'
+ })
+
+ ret.attr('clip-path', `url(#gridRectMask${w.globals.cuid})`)
+
+ // width divided into equal parts
+ let xDivision = w.globals.gridWidth / w.globals.dataPoints
+ let yDivision = w.globals.gridHeight / w.globals.series.length
+
+ let y1 = 0
+ let rev = false
+
+ this.negRange = this.helpers.checkColorRange()
+
+ let heatSeries = series.slice()
+ if (w.config.yaxis[0].reversed) {
+ rev = true
+ heatSeries.reverse()
+ }
+
+ for (
+ let i = rev ? 0 : heatSeries.length - 1;
+ rev ? i < heatSeries.length : i >= 0;
+ rev ? i++ : i--
+ ) {
+ // el to which series will be drawn
+ let elSeries = graphics.group({
+ class: `apexcharts-series apexcharts-heatmap-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[i]),
+ rel: i + 1,
+ 'data:realIndex': i
+ })
+ this.ctx.series.addCollapsedClassToSeries(elSeries, i)
+
+ if (w.config.chart.dropShadow.enabled) {
+ const shadow = w.config.chart.dropShadow
+ const filters = new Filters(this.ctx)
+ filters.dropShadow(elSeries, shadow, i)
+ }
+
+ let x1 = 0
+ let shadeIntensity = w.config.plotOptions.heatmap.shadeIntensity
+
+ for (let j = 0; j < heatSeries[i].length; j++) {
+ let heatColor = this.helpers.getShadeColor(
+ w.config.chart.type,
+ i,
+ j,
+ this.negRange
+ )
+ let color = heatColor.color
+ let heatColorProps = heatColor.colorProps
+
+ if (w.config.fill.type === 'image') {
+ const fill = new Fill(this.ctx)
+
+ color = fill.fillPath({
+ seriesNumber: i,
+ dataPointIndex: j,
+ opacity: w.globals.hasNegs
+ ? heatColorProps.percent < 0
+ ? 1 - (1 + heatColorProps.percent / 100)
+ : shadeIntensity + heatColorProps.percent / 100
+ : heatColorProps.percent / 100,
+ patternID: Utils.randomId(),
+ width: w.config.fill.image.width
+ ? w.config.fill.image.width
+ : xDivision,
+ height: w.config.fill.image.height
+ ? w.config.fill.image.height
+ : yDivision
+ })
+ }
+
+ let radius = this.rectRadius
+
+ let rect = graphics.drawRect(x1, y1, xDivision, yDivision, radius)
+ rect.attr({
+ cx: x1,
+ cy: y1
+ })
+
+ rect.node.classList.add('apexcharts-heatmap-rect')
+ elSeries.add(rect)
+
+ rect.attr({
+ fill: color,
+ i,
+ index: i,
+ j,
+ val: heatSeries[i][j],
+ 'stroke-width': this.strokeWidth,
+ stroke: w.config.plotOptions.heatmap.useFillColorAsStroke
+ ? color
+ : w.globals.stroke.colors[0],
+ color
+ })
+
+ this.helpers.addListeners(rect)
+
+ if (w.config.chart.animations.enabled && !w.globals.dataChanged) {
+ let speed = 1
+ if (!w.globals.resized) {
+ speed = w.config.chart.animations.speed
+ }
+ this.animateHeatMap(rect, x1, y1, xDivision, yDivision, speed)
+ }
+
+ if (w.globals.dataChanged) {
+ let speed = 1
+ if (this.dynamicAnim.enabled && w.globals.shouldAnimate) {
+ speed = this.dynamicAnim.speed
+
+ let colorFrom =
+ w.globals.previousPaths[i] &&
+ w.globals.previousPaths[i][j] &&
+ w.globals.previousPaths[i][j].color
+
+ if (!colorFrom) colorFrom = 'rgba(255, 255, 255, 0)'
+
+ this.animateHeatColor(
+ rect,
+ Utils.isColorHex(colorFrom)
+ ? colorFrom
+ : Utils.rgb2hex(colorFrom),
+ Utils.isColorHex(color) ? color : Utils.rgb2hex(color),
+ speed
+ )
+ }
+ }
+
+ let formatter = w.config.dataLabels.formatter
+ let formattedText = formatter(w.globals.series[i][j], {
+ value: w.globals.series[i][j],
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+
+ let dataLabels = this.helpers.calculateDataLabels({
+ text: formattedText,
+ x: x1 + xDivision / 2,
+ y: y1 + yDivision / 2,
+ i,
+ j,
+ colorProps: heatColorProps,
+ series: heatSeries
+ })
+ if (dataLabels !== null) {
+ elSeries.add(dataLabels)
+ }
+
+ x1 = x1 + xDivision
+ }
+
+ y1 = y1 + yDivision
+
+ ret.add(elSeries)
+ }
+
+ // adjust yaxis labels for heatmap
+ let yAxisScale = w.globals.yAxisScale[0].result.slice()
+ if (w.config.yaxis[0].reversed) {
+ yAxisScale.unshift('')
+ } else {
+ yAxisScale.push('')
+ }
+ w.globals.yAxisScale[0].result = yAxisScale
+ let divisor = w.globals.gridHeight / w.globals.series.length
+ w.config.yaxis[0].labels.offsetY = -(divisor / 2)
+
+ return ret
+ }
+
+ animateHeatMap(el, x, y, width, height, speed) {
+ const animations = new Animations(this.ctx)
+ animations.animateRect(
+ el,
+ {
+ x: x + width / 2,
+ y: y + height / 2,
+ width: 0,
+ height: 0
+ },
+ {
+ x,
+ y,
+ width,
+ height
+ },
+ speed,
+ () => {
+ animations.animationCompleted(el)
+ }
+ )
+ }
+
+ animateHeatColor(el, colorFrom, colorTo, speed) {
+ el.attr({
+ fill: colorFrom
+ })
+ .animate(speed)
+ .attr({
+ fill: colorTo
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Line.js b/cao_sunyata/static/libs/apexcharts/src/charts/Line.js
new file mode 100644
index 0000000..4b8e0e2
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Line.js
@@ -0,0 +1,728 @@
+import CoreUtils from '../modules/CoreUtils'
+import Graphics from '../modules/Graphics'
+import Fill from '../modules/Fill'
+import DataLabels from '../modules/DataLabels'
+import Markers from '../modules/Markers'
+import Scatter from './Scatter'
+import Utils from '../utils/Utils'
+import Helpers from './common/line/Helpers'
+
+/**
+ * ApexCharts Line Class responsible for drawing Line / Area Charts.
+ * This class is also responsible for generating values for Bubble/Scatter charts, so need to rename it to Axis Charts to avoid confusions
+ * @module Line
+ **/
+
+class Line {
+ constructor(ctx, xyRatios, isPointsChart) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.xyRatios = xyRatios
+
+ this.pointsChart =
+ !(
+ this.w.config.chart.type !== 'bubble' &&
+ this.w.config.chart.type !== 'scatter'
+ ) || isPointsChart
+
+ this.scatter = new Scatter(this.ctx)
+
+ this.noNegatives = this.w.globals.minX === Number.MAX_VALUE
+
+ this.lineHelpers = new Helpers(this)
+ this.markers = new Markers(this.ctx)
+
+ this.prevSeriesY = []
+ this.categoryAxisCorrection = 0
+ this.yaxisIndex = 0
+ }
+
+ draw(series, ptype, seriesIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+ let type = w.globals.comboCharts ? ptype : w.config.chart.type
+ let ret = graphics.group({
+ class: `apexcharts-${type}-series apexcharts-plot-series`
+ })
+
+ const coreUtils = new CoreUtils(this.ctx, w)
+ this.yRatio = this.xyRatios.yRatio
+ this.zRatio = this.xyRatios.zRatio
+ this.xRatio = this.xyRatios.xRatio
+ this.baseLineY = this.xyRatios.baseLineY
+
+ series = coreUtils.getLogSeries(series)
+ this.yRatio = coreUtils.getLogYRatios(this.yRatio)
+
+ // push all series in an array, so we can draw in reverse order (for stacked charts)
+ let allSeries = []
+
+ for (let i = 0; i < series.length; i++) {
+ series = this.lineHelpers.sameValueSeriesFix(i, series)
+
+ let realIndex = w.globals.comboCharts ? seriesIndex[i] : i
+
+ this._initSerieVariables(series, i, realIndex)
+
+ let yArrj = [] // hold y values of current iterating series
+ let xArrj = [] // hold x values of current iterating series
+
+ let x = w.globals.padHorizontal + this.categoryAxisCorrection
+ let y = 1
+
+ let linePaths = []
+ let areaPaths = []
+
+ this.ctx.series.addCollapsedClassToSeries(this.elSeries, realIndex)
+
+ if (w.globals.isXNumeric && w.globals.seriesX.length > 0) {
+ x = (w.globals.seriesX[realIndex][0] - w.globals.minX) / this.xRatio
+ }
+
+ xArrj.push(x)
+
+ let pX = x
+ let pY
+ let prevX = pX
+ let prevY = this.zeroY
+ let lineYPosition = 0
+
+ // the first value in the current series is not null or undefined
+ let firstPrevY = this.lineHelpers.determineFirstPrevY({
+ i,
+ series,
+ prevY,
+ lineYPosition
+ })
+ prevY = firstPrevY.prevY
+
+ yArrj.push(prevY)
+ pY = prevY
+
+ let pathsFrom = this._calculatePathsFrom({
+ series,
+ i,
+ realIndex,
+ prevX,
+ prevY
+ })
+
+ let paths = this._iterateOverDataPoints({
+ series,
+ realIndex,
+ i,
+ x,
+ y,
+ pX,
+ pY,
+ pathsFrom,
+ linePaths,
+ areaPaths,
+ seriesIndex,
+ lineYPosition,
+ xArrj,
+ yArrj
+ })
+
+ this._handlePaths({ type, realIndex, i, paths })
+
+ this.elSeries.add(this.elPointsMain)
+ this.elSeries.add(this.elDataLabelsWrap)
+
+ allSeries.push(this.elSeries)
+ }
+
+ if (w.config.chart.stacked) {
+ for (let s = allSeries.length; s > 0; s--) {
+ ret.add(allSeries[s - 1])
+ }
+ } else {
+ for (let s = 0; s < allSeries.length; s++) {
+ ret.add(allSeries[s])
+ }
+ }
+
+ return ret
+ }
+
+ _initSerieVariables(series, i, realIndex) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ // width divided into equal parts
+ this.xDivision =
+ w.globals.gridWidth /
+ (w.globals.dataPoints - (w.config.xaxis.tickPlacement === 'on' ? 1 : 0))
+
+ this.strokeWidth = Array.isArray(w.config.stroke.width)
+ ? w.config.stroke.width[realIndex]
+ : w.config.stroke.width
+
+ if (this.yRatio.length > 1) {
+ this.yaxisIndex = realIndex
+ }
+
+ this.isReversed =
+ w.config.yaxis[this.yaxisIndex] &&
+ w.config.yaxis[this.yaxisIndex].reversed
+
+ // zeroY is the 0 value in y series which can be used in negative charts
+ this.zeroY =
+ w.globals.gridHeight -
+ this.baseLineY[this.yaxisIndex] -
+ (this.isReversed ? w.globals.gridHeight : 0) +
+ (this.isReversed ? this.baseLineY[this.yaxisIndex] * 2 : 0)
+
+ this.areaBottomY = this.zeroY
+ if (
+ this.zeroY > w.globals.gridHeight ||
+ w.config.plotOptions.area.fillTo === 'end'
+ ) {
+ this.areaBottomY = w.globals.gridHeight
+ }
+
+ this.categoryAxisCorrection = this.xDivision / 2
+
+ // el to which series will be drawn
+ this.elSeries = graphics.group({
+ class: `apexcharts-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[realIndex])
+ })
+
+ // points
+ this.elPointsMain = graphics.group({
+ class: 'apexcharts-series-markers-wrap',
+ 'data:realIndex': realIndex
+ })
+
+ // eldatalabels
+ this.elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-datalabels',
+ 'data:realIndex': realIndex
+ })
+
+ let longestSeries = series[i].length === w.globals.dataPoints
+ this.elSeries.attr({
+ 'data:longestSeries': longestSeries,
+ rel: i + 1,
+ 'data:realIndex': realIndex
+ })
+
+ this.appendPathFrom = true
+ }
+
+ _calculatePathsFrom({ series, i, realIndex, prevX, prevY }) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+ let linePath, areaPath, pathFromLine, pathFromArea
+
+ if (series[i][0] === null) {
+ // when the first value itself is null, we need to move the pointer to a location where a null value is not found
+ for (let s = 0; s < series[i].length; s++) {
+ if (series[i][s] !== null) {
+ prevX = this.xDivision * s
+ prevY = this.zeroY - series[i][s] / this.yRatio[this.yaxisIndex]
+ linePath = graphics.move(prevX, prevY)
+ areaPath = graphics.move(prevX, this.areaBottomY)
+ break
+ }
+ }
+ } else {
+ linePath = graphics.move(prevX, prevY)
+ areaPath =
+ graphics.move(prevX, this.areaBottomY) + graphics.line(prevX, prevY)
+ }
+
+ pathFromLine = graphics.move(-1, this.zeroY) + graphics.line(-1, this.zeroY)
+ pathFromArea = graphics.move(-1, this.zeroY) + graphics.line(-1, this.zeroY)
+
+ if (w.globals.previousPaths.length > 0) {
+ const pathFrom = this.lineHelpers.checkPreviousPaths({
+ pathFromLine,
+ pathFromArea,
+ realIndex
+ })
+ pathFromLine = pathFrom.pathFromLine
+ pathFromArea = pathFrom.pathFromArea
+ }
+
+ return {
+ prevX,
+ prevY,
+ linePath,
+ areaPath,
+ pathFromLine,
+ pathFromArea
+ }
+ }
+
+ _handlePaths({ type, realIndex, i, paths }) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+ const fill = new Fill(this.ctx)
+
+ // push all current y values array to main PrevY Array
+ this.prevSeriesY.push(paths.yArrj)
+
+ // push all x val arrays into main xArr
+ w.globals.seriesXvalues[realIndex] = paths.xArrj
+ w.globals.seriesYvalues[realIndex] = paths.yArrj
+
+ const forecast = w.config.forecastDataPoints
+ if (forecast.count > 0) {
+ const forecastCutoff =
+ w.globals.seriesXvalues[realIndex][
+ w.globals.seriesXvalues[realIndex].length - forecast.count - 1
+ ]
+ const elForecastMask = graphics.drawRect(
+ forecastCutoff,
+ 0,
+ w.globals.gridWidth,
+ w.globals.gridHeight,
+ 0
+ )
+ w.globals.dom.elForecastMask.appendChild(elForecastMask.node)
+
+ const elNonForecastMask = graphics.drawRect(
+ 0,
+ 0,
+ forecastCutoff,
+ w.globals.gridHeight,
+ 0
+ )
+ w.globals.dom.elNonForecastMask.appendChild(elNonForecastMask.node)
+ }
+
+ // these elements will be shown after area path animation completes
+ if (!this.pointsChart) {
+ w.globals.delayedElements.push({
+ el: this.elPointsMain.node,
+ index: realIndex
+ })
+ }
+
+ const defaultRenderedPathOptions = {
+ i,
+ realIndex,
+ animationDelay: i,
+ initialSpeed: w.config.chart.animations.speed,
+ dataChangeSpeed: w.config.chart.animations.dynamicAnimation.speed,
+ className: `apexcharts-${type}`
+ }
+
+ if (type === 'area') {
+ let pathFill = fill.fillPath({
+ seriesNumber: realIndex
+ })
+
+ for (let p = 0; p < paths.areaPaths.length; p++) {
+ let renderedPath = graphics.renderPaths({
+ ...defaultRenderedPathOptions,
+ pathFrom: paths.pathFromArea,
+ pathTo: paths.areaPaths[p],
+ stroke: 'none',
+ strokeWidth: 0,
+ strokeLineCap: null,
+ fill: pathFill
+ })
+
+ this.elSeries.add(renderedPath)
+ }
+ }
+
+ if (w.config.stroke.show && !this.pointsChart) {
+ let lineFill = null
+ if (type === 'line') {
+ lineFill = fill.fillPath({
+ seriesNumber: realIndex,
+ i
+ })
+ } else {
+ if (w.config.stroke.fill.type === 'solid') {
+ lineFill = w.globals.stroke.colors[realIndex]
+ } else {
+ const prevFill = w.config.fill
+ w.config.fill = w.config.stroke.fill
+
+ lineFill = fill.fillPath({
+ seriesNumber: realIndex,
+ i
+ })
+ w.config.fill = prevFill
+ }
+ }
+
+ for (let p = 0; p < paths.linePaths.length; p++) {
+ const linePathCommonOpts = {
+ ...defaultRenderedPathOptions,
+ pathFrom: paths.pathFromLine,
+ pathTo: paths.linePaths[p],
+ stroke: lineFill,
+ strokeWidth: this.strokeWidth,
+ strokeLineCap: w.config.stroke.lineCap,
+ fill: 'none'
+ }
+ let renderedPath = graphics.renderPaths(linePathCommonOpts)
+ this.elSeries.add(renderedPath)
+
+ if (forecast.count > 0) {
+ let renderedForecastPath = graphics.renderPaths(linePathCommonOpts)
+
+ renderedForecastPath.node.setAttribute(
+ 'stroke-dasharray',
+ forecast.dashArray
+ )
+
+ if (forecast.strokeWidth) {
+ renderedForecastPath.node.setAttribute(
+ 'stroke-width',
+ forecast.strokeWidth
+ )
+ }
+
+ this.elSeries.add(renderedForecastPath)
+ renderedForecastPath.attr(
+ 'clip-path',
+ `url(#forecastMask${w.globals.cuid})`
+ )
+ renderedPath.attr(
+ 'clip-path',
+ `url(#nonForecastMask${w.globals.cuid})`
+ )
+ }
+ }
+ }
+ }
+
+ _iterateOverDataPoints({
+ series,
+ realIndex,
+ i,
+ x,
+ y,
+ pX,
+ pY,
+ pathsFrom,
+ linePaths,
+ areaPaths,
+ seriesIndex,
+ lineYPosition,
+ xArrj,
+ yArrj
+ }) {
+ const w = this.w
+ let graphics = new Graphics(this.ctx)
+ let yRatio = this.yRatio
+ let { prevY, linePath, areaPath, pathFromLine, pathFromArea } = pathsFrom
+
+ const minY = Utils.isNumber(w.globals.minYArr[realIndex])
+ ? w.globals.minYArr[realIndex]
+ : w.globals.minY
+
+ const iterations =
+ w.globals.dataPoints > 1 ? w.globals.dataPoints - 1 : w.globals.dataPoints
+
+ for (let j = 0; j < iterations; j++) {
+ const isNull =
+ typeof series[i][j + 1] === 'undefined' || series[i][j + 1] === null
+
+ if (w.globals.isXNumeric) {
+ let sX = w.globals.seriesX[realIndex][j + 1]
+ if (typeof w.globals.seriesX[realIndex][j + 1] === 'undefined') {
+ /* fix #374 */
+ sX = w.globals.seriesX[realIndex][iterations - 1]
+ }
+ x = (sX - w.globals.minX) / this.xRatio
+ } else {
+ x = x + this.xDivision
+ }
+
+ if (w.config.chart.stacked) {
+ if (
+ i > 0 &&
+ w.globals.collapsedSeries.length < w.config.series.length - 1
+ ) {
+ // a collapsed series in a stacked bar chart may provide wrong result for the next series, hence find the prevIndex of prev series which is not collapsed - fixes apexcharts.js#1372
+ const prevIndex = (pi) => {
+ let pii = pi
+ for (let cpi = 0; cpi < w.globals.series.length; cpi++) {
+ if (w.globals.collapsedSeriesIndices.indexOf(pi) > -1) {
+ pii--
+ break
+ }
+ }
+
+ return pii >= 0 ? pii : 0
+ }
+ lineYPosition = this.prevSeriesY[prevIndex(i - 1)][j + 1]
+ } else {
+ // the first series will not have prevY values
+ lineYPosition = this.zeroY
+ }
+ } else {
+ lineYPosition = this.zeroY
+ }
+
+ if (isNull) {
+ y =
+ lineYPosition -
+ minY / yRatio[this.yaxisIndex] +
+ (this.isReversed ? minY / yRatio[this.yaxisIndex] : 0) * 2
+ } else {
+ y =
+ lineYPosition -
+ series[i][j + 1] / yRatio[this.yaxisIndex] +
+ (this.isReversed ? series[i][j + 1] / yRatio[this.yaxisIndex] : 0) * 2
+ }
+
+ // push current X
+ xArrj.push(x)
+
+ // push current Y that will be used as next series's bottom position
+ yArrj.push(y)
+
+ let pointsPos = this.lineHelpers.calculatePoints({
+ series,
+ x,
+ y,
+ realIndex,
+ i,
+ j,
+ prevY
+ })
+
+ let calculatedPaths = this._createPaths({
+ series,
+ i,
+ realIndex,
+ j,
+ x,
+ y,
+ pX,
+ pY,
+ linePath,
+ areaPath,
+ linePaths,
+ areaPaths,
+ seriesIndex
+ })
+
+ areaPaths = calculatedPaths.areaPaths
+ linePaths = calculatedPaths.linePaths
+ pX = calculatedPaths.pX
+ pY = calculatedPaths.pY
+ areaPath = calculatedPaths.areaPath
+ linePath = calculatedPaths.linePath
+
+ if (this.appendPathFrom) {
+ pathFromLine = pathFromLine + graphics.line(x, this.zeroY)
+ pathFromArea = pathFromArea + graphics.line(x, this.zeroY)
+ }
+
+ this.handleNullDataPoints(series, pointsPos, i, j, realIndex)
+
+ this._handleMarkersAndLabels({
+ pointsPos,
+ series,
+ x,
+ y,
+ prevY,
+ i,
+ j,
+ realIndex
+ })
+ }
+
+ return {
+ yArrj,
+ xArrj,
+ pathFromArea,
+ areaPaths,
+ pathFromLine,
+ linePaths
+ }
+ }
+
+ _handleMarkersAndLabels({ pointsPos, series, x, y, prevY, i, j, realIndex }) {
+ const w = this.w
+ let dataLabels = new DataLabels(this.ctx)
+
+ if (!this.pointsChart) {
+ if (w.globals.series[i].length > 1) {
+ this.elPointsMain.node.classList.add('apexcharts-element-hidden')
+ }
+
+ let elPointsWrap = this.markers.plotChartMarkers(
+ pointsPos,
+ realIndex,
+ j + 1
+ )
+ if (elPointsWrap !== null) {
+ this.elPointsMain.add(elPointsWrap)
+ }
+ } else {
+ // scatter / bubble chart points creation
+ this.scatter.draw(this.elSeries, j, {
+ realIndex,
+ pointsPos,
+ zRatio: this.zRatio,
+ elParent: this.elPointsMain
+ })
+ }
+
+ let drawnLabels = dataLabels.drawDataLabel(
+ pointsPos,
+ realIndex,
+ j + 1,
+ null
+ )
+ if (drawnLabels !== null) {
+ this.elDataLabelsWrap.add(drawnLabels)
+ }
+ }
+
+ _createPaths({
+ series,
+ i,
+ realIndex,
+ j,
+ x,
+ y,
+ pX,
+ pY,
+ linePath,
+ areaPath,
+ linePaths,
+ areaPaths,
+ seriesIndex
+ }) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let curve = w.config.stroke.curve
+ const areaBottomY = this.areaBottomY
+
+ if (Array.isArray(w.config.stroke.curve)) {
+ if (Array.isArray(seriesIndex)) {
+ curve = w.config.stroke.curve[seriesIndex[i]]
+ } else {
+ curve = w.config.stroke.curve[i]
+ }
+ }
+
+ // logic of smooth curve derived from chartist
+ // CREDITS: https://gionkunz.github.io/chartist-js/
+ if (curve === 'smooth') {
+ let length = (x - pX) * 0.35
+ if (w.globals.hasNullValues) {
+ if (series[i][j] !== null) {
+ if (series[i][j + 1] !== null) {
+ linePath =
+ graphics.move(pX, pY) +
+ graphics.curve(pX + length, pY, x - length, y, x + 1, y)
+ areaPath =
+ graphics.move(pX + 1, pY) +
+ graphics.curve(pX + length, pY, x - length, y, x + 1, y) +
+ graphics.line(x, areaBottomY) +
+ graphics.line(pX, areaBottomY) +
+ 'z'
+ } else {
+ linePath = graphics.move(pX, pY)
+ areaPath = graphics.move(pX, pY) + 'z'
+ }
+ }
+
+ linePaths.push(linePath)
+ areaPaths.push(areaPath)
+ } else {
+ linePath =
+ linePath + graphics.curve(pX + length, pY, x - length, y, x, y)
+ areaPath =
+ areaPath + graphics.curve(pX + length, pY, x - length, y, x, y)
+ }
+
+ pX = x
+ pY = y
+
+ if (j === series[i].length - 2) {
+ // last loop, close path
+ areaPath =
+ areaPath +
+ graphics.curve(pX, pY, x, y, x, areaBottomY) +
+ graphics.move(x, y) +
+ 'z'
+ if (!w.globals.hasNullValues) {
+ linePaths.push(linePath)
+ areaPaths.push(areaPath)
+ }
+ }
+ } else {
+ if (series[i][j + 1] === null) {
+ linePath = linePath + graphics.move(x, y)
+
+ const numericOrCatX = w.globals.isXNumeric
+ ? (w.globals.seriesX[realIndex][j] - w.globals.minX) / this.xRatio
+ : x - this.xDivision
+ areaPath =
+ areaPath +
+ graphics.line(numericOrCatX, areaBottomY) +
+ graphics.move(x, y) +
+ 'z'
+ }
+ if (series[i][j] === null) {
+ linePath = linePath + graphics.move(x, y)
+ areaPath = areaPath + graphics.move(x, areaBottomY)
+ }
+
+ if (curve === 'stepline') {
+ linePath =
+ linePath + graphics.line(x, null, 'H') + graphics.line(null, y, 'V')
+ areaPath =
+ areaPath + graphics.line(x, null, 'H') + graphics.line(null, y, 'V')
+ } else if (curve === 'straight') {
+ linePath = linePath + graphics.line(x, y)
+ areaPath = areaPath + graphics.line(x, y)
+ }
+
+ if (j === series[i].length - 2) {
+ // last loop, close path
+ areaPath =
+ areaPath + graphics.line(x, areaBottomY) + graphics.move(x, y) + 'z'
+ linePaths.push(linePath)
+ areaPaths.push(areaPath)
+ }
+ }
+
+ return {
+ linePaths,
+ areaPaths,
+ pX,
+ pY,
+ linePath,
+ areaPath
+ }
+ }
+
+ handleNullDataPoints(series, pointsPos, i, j, realIndex) {
+ const w = this.w
+ if (
+ (series[i][j] === null && w.config.markers.showNullDataPoints) ||
+ series[i].length === 1
+ ) {
+ // fixes apexcharts.js#1282, #1252
+ let elPointsWrap = this.markers.plotChartMarkers(
+ pointsPos,
+ realIndex,
+ j + 1,
+ this.strokeWidth - w.config.markers.strokeWidth / 2,
+ true
+ )
+ if (elPointsWrap !== null) {
+ this.elPointsMain.add(elPointsWrap)
+ }
+ }
+ }
+}
+
+export default Line
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Pie.js b/cao_sunyata/static/libs/apexcharts/src/charts/Pie.js
new file mode 100644
index 0000000..8259e7f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Pie.js
@@ -0,0 +1,1057 @@
+import Animations from '../modules/Animations'
+import Fill from '../modules/Fill'
+import Utils from '../utils/Utils'
+import Graphics from '../modules/Graphics'
+import Filters from '../modules/Filters'
+import Scales from '../modules/Scales'
+import Helpers from './common/circle/Helpers'
+/**
+ * ApexCharts Pie Class for drawing Pie / Donut Charts.
+ * @module Pie
+ **/
+
+class Pie {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ const w = this.w
+
+ this.chartType = this.w.config.chart.type
+
+ this.initialAnim = this.w.config.chart.animations.enabled
+ this.dynamicAnim =
+ this.initialAnim &&
+ this.w.config.chart.animations.dynamicAnimation.enabled
+
+ this.animBeginArr = [0]
+ this.animDur = 0
+
+ this.donutDataLabels = this.w.config.plotOptions.pie.donut.labels
+
+ this.lineColorArr =
+ w.globals.stroke.colors !== undefined
+ ? w.globals.stroke.colors
+ : w.globals.colors
+
+ this.defaultSize = Math.min(w.globals.gridWidth, w.globals.gridHeight)
+
+ this.centerY = this.defaultSize / 2
+ this.centerX = w.globals.gridWidth / 2
+
+ if (w.config.chart.type === 'radialBar') {
+ this.fullAngle = 360
+ } else {
+ this.fullAngle = Math.abs(
+ w.config.plotOptions.pie.endAngle - w.config.plotOptions.pie.startAngle
+ )
+ }
+ this.initialAngle = w.config.plotOptions.pie.startAngle % this.fullAngle
+
+ w.globals.radialSize =
+ this.defaultSize / 2.05 -
+ w.config.stroke.width -
+ (!w.config.chart.sparkline.enabled ? w.config.chart.dropShadow.blur : 0)
+
+ this.donutSize =
+ (w.globals.radialSize *
+ parseInt(w.config.plotOptions.pie.donut.size, 10)) /
+ 100
+
+ this.maxY = 0
+ this.sliceLabels = []
+ this.sliceSizes = []
+
+ this.prevSectorAngleArr = [] // for dynamic animations
+ }
+
+ draw(series) {
+ let self = this
+ let w = this.w
+
+ const graphics = new Graphics(this.ctx)
+
+ this.ret = graphics.group({
+ class: 'apexcharts-pie'
+ })
+
+ if (w.globals.noData) return this.ret
+
+ let total = 0
+ for (let k = 0; k < series.length; k++) {
+ // CALCULATE THE TOTAL
+ total += Utils.negToZero(series[k])
+ }
+
+ let sectorAngleArr = []
+
+ // el to which series will be drawn
+ let elSeries = graphics.group()
+
+ // prevent division by zero error if there is no data
+ if (total === 0) {
+ total = 0.00001
+ }
+
+ series.forEach((m) => {
+ this.maxY = Math.max(this.maxY, m)
+ })
+
+ // override maxY if user provided in config
+ if (w.config.yaxis[0].max) {
+ this.maxY = w.config.yaxis[0].max
+ }
+
+ if (w.config.grid.position === 'back' && this.chartType === 'polarArea') {
+ this.drawPolarElements(this.ret)
+ }
+
+ for (let i = 0; i < series.length; i++) {
+ // CALCULATE THE ANGLES
+ let angle = (this.fullAngle * Utils.negToZero(series[i])) / total
+ sectorAngleArr.push(angle)
+
+ if (this.chartType === 'polarArea') {
+ sectorAngleArr[i] = this.fullAngle / series.length
+ this.sliceSizes.push((w.globals.radialSize * series[i]) / this.maxY)
+ } else {
+ this.sliceSizes.push(w.globals.radialSize)
+ }
+ }
+
+ if (w.globals.dataChanged) {
+ let prevTotal = 0
+ for (let k = 0; k < w.globals.previousPaths.length; k++) {
+ // CALCULATE THE PREV TOTAL
+ prevTotal += Utils.negToZero(w.globals.previousPaths[k])
+ }
+
+ let previousAngle
+
+ for (let i = 0; i < w.globals.previousPaths.length; i++) {
+ // CALCULATE THE PREVIOUS ANGLES
+ previousAngle =
+ (this.fullAngle * Utils.negToZero(w.globals.previousPaths[i])) /
+ prevTotal
+ this.prevSectorAngleArr.push(previousAngle)
+ }
+ }
+
+ // on small chart size after few count of resizes browser window donutSize can be negative
+ if (this.donutSize < 0) {
+ this.donutSize = 0
+ }
+
+ let scaleSize = w.config.plotOptions.pie.customScale
+ let halfW = w.globals.gridWidth / 2
+ let halfH = w.globals.gridHeight / 2
+ let translateX = halfW - (w.globals.gridWidth / 2) * scaleSize
+ let translateY = halfH - (w.globals.gridHeight / 2) * scaleSize
+
+ if (this.chartType === 'donut') {
+ // draw the inner circle and add some text to it
+ const circle = graphics.drawCircle(this.donutSize)
+
+ circle.attr({
+ cx: this.centerX,
+ cy: this.centerY,
+ fill: w.config.plotOptions.pie.donut.background
+ ? w.config.plotOptions.pie.donut.background
+ : 'transparent'
+ })
+
+ elSeries.add(circle)
+ }
+
+ let elG = self.drawArcs(sectorAngleArr, series)
+
+ // add slice dataLabels at the end
+ this.sliceLabels.forEach((s) => {
+ elG.add(s)
+ })
+
+ elSeries.attr({
+ transform: `translate(${translateX}, ${translateY}) scale(${scaleSize})`
+ })
+
+ elSeries.add(elG)
+
+ this.ret.add(elSeries)
+
+ if (this.donutDataLabels.show) {
+ let dataLabels = this.renderInnerDataLabels(this.donutDataLabels, {
+ hollowSize: this.donutSize,
+ centerX: this.centerX,
+ centerY: this.centerY,
+ opacity: this.donutDataLabels.show,
+ translateX,
+ translateY
+ })
+
+ this.ret.add(dataLabels)
+ }
+
+ if (w.config.grid.position === 'front' && this.chartType === 'polarArea') {
+ this.drawPolarElements(this.ret)
+ }
+
+ return this.ret
+ }
+
+ // core function for drawing pie arcs
+ drawArcs(sectorAngleArr, series) {
+ let w = this.w
+ const filters = new Filters(this.ctx)
+
+ let graphics = new Graphics(this.ctx)
+ let fill = new Fill(this.ctx)
+ let g = graphics.group({
+ class: 'apexcharts-slices'
+ })
+
+ let startAngle = this.initialAngle
+ let prevStartAngle = this.initialAngle
+ let endAngle = this.initialAngle
+ let prevEndAngle = this.initialAngle
+
+ this.strokeWidth = w.config.stroke.show ? w.config.stroke.width : 0
+
+ for (let i = 0; i < sectorAngleArr.length; i++) {
+ let elPieArc = graphics.group({
+ class: `apexcharts-series apexcharts-pie-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[i]),
+ rel: i + 1,
+ 'data:realIndex': i
+ })
+
+ g.add(elPieArc)
+
+ startAngle = endAngle
+ prevStartAngle = prevEndAngle
+
+ endAngle = startAngle + sectorAngleArr[i]
+ prevEndAngle = prevStartAngle + this.prevSectorAngleArr[i]
+
+ const angle =
+ endAngle < startAngle
+ ? this.fullAngle + endAngle - startAngle
+ : endAngle - startAngle
+
+ let pathFill = fill.fillPath({
+ seriesNumber: i,
+ size: this.sliceSizes[i],
+ value: series[i]
+ }) // additionally, pass size for gradient drawing in the fillPath function
+
+ let path = this.getChangedPath(prevStartAngle, prevEndAngle)
+
+ let elPath = graphics.drawPath({
+ d: path,
+ stroke: Array.isArray(this.lineColorArr)
+ ? this.lineColorArr[i]
+ : this.lineColorArr,
+ strokeWidth: 0,
+ fill: pathFill,
+ fillOpacity: w.config.fill.opacity,
+ classes: `apexcharts-pie-area apexcharts-${this.chartType.toLowerCase()}-slice-${i}`
+ })
+
+ elPath.attr({
+ index: 0,
+ j: i
+ })
+
+ filters.setSelectionFilter(elPath, 0, i)
+
+ if (w.config.chart.dropShadow.enabled) {
+ const shadow = w.config.chart.dropShadow
+ filters.dropShadow(elPath, shadow, i)
+ }
+
+ this.addListeners(elPath, this.donutDataLabels)
+
+ Graphics.setAttrs(elPath.node, {
+ 'data:angle': angle,
+ 'data:startAngle': startAngle,
+ 'data:strokeWidth': this.strokeWidth,
+ 'data:value': series[i]
+ })
+
+ let labelPosition = {
+ x: 0,
+ y: 0
+ }
+
+ if (this.chartType === 'pie' || this.chartType === 'polarArea') {
+ labelPosition = Utils.polarToCartesian(
+ this.centerX,
+ this.centerY,
+ w.globals.radialSize / 1.25 +
+ w.config.plotOptions.pie.dataLabels.offset,
+ (startAngle + angle / 2) % this.fullAngle
+ )
+ } else if (this.chartType === 'donut') {
+ labelPosition = Utils.polarToCartesian(
+ this.centerX,
+ this.centerY,
+ (w.globals.radialSize + this.donutSize) / 2 +
+ w.config.plotOptions.pie.dataLabels.offset,
+ (startAngle + angle / 2) % this.fullAngle
+ )
+ }
+
+ elPieArc.add(elPath)
+
+ // Animation code starts
+ let dur = 0
+ if (this.initialAnim && !w.globals.resized && !w.globals.dataChanged) {
+ dur = (angle / this.fullAngle) * w.config.chart.animations.speed
+
+ if (dur === 0) dur = 1
+ this.animDur = dur + this.animDur
+ this.animBeginArr.push(this.animDur)
+ } else {
+ this.animBeginArr.push(0)
+ }
+
+ if (this.dynamicAnim && w.globals.dataChanged) {
+ this.animatePaths(elPath, {
+ size: this.sliceSizes[i],
+ endAngle,
+ startAngle,
+ prevStartAngle,
+ prevEndAngle,
+ animateStartingPos: true,
+ i,
+ animBeginArr: this.animBeginArr,
+ shouldSetPrevPaths: true,
+ dur: w.config.chart.animations.dynamicAnimation.speed
+ })
+ } else {
+ this.animatePaths(elPath, {
+ size: this.sliceSizes[i],
+ endAngle,
+ startAngle,
+ i,
+ totalItems: sectorAngleArr.length - 1,
+ animBeginArr: this.animBeginArr,
+ dur
+ })
+ }
+ // animation code ends
+
+ if (
+ w.config.plotOptions.pie.expandOnClick &&
+ this.chartType !== 'polarArea'
+ ) {
+ elPath.click(this.pieClicked.bind(this, i))
+ }
+
+ if (
+ typeof w.globals.selectedDataPoints[0] !== 'undefined' &&
+ w.globals.selectedDataPoints[0].indexOf(i) > -1
+ ) {
+ this.pieClicked(i)
+ }
+
+ if (w.config.dataLabels.enabled) {
+ let xPos = labelPosition.x
+ let yPos = labelPosition.y
+ let text = (100 * angle) / this.fullAngle + '%'
+
+ if (
+ angle !== 0 &&
+ w.config.plotOptions.pie.dataLabels.minAngleToShowLabel <
+ sectorAngleArr[i]
+ ) {
+ let formatter = w.config.dataLabels.formatter
+ if (formatter !== undefined) {
+ text = formatter(w.globals.seriesPercent[i][0], {
+ seriesIndex: i,
+ w
+ })
+ }
+ let foreColor = w.globals.dataLabels.style.colors[i]
+
+ const elPieLabelWrap = graphics.group({
+ class: `apexcharts-datalabels`
+ })
+ let elPieLabel = graphics.drawText({
+ x: xPos,
+ y: yPos,
+ text,
+ textAnchor: 'middle',
+ fontSize: w.config.dataLabels.style.fontSize,
+ fontFamily: w.config.dataLabels.style.fontFamily,
+ fontWeight: w.config.dataLabels.style.fontWeight,
+ foreColor
+ })
+
+ elPieLabelWrap.add(elPieLabel)
+ if (w.config.dataLabels.dropShadow.enabled) {
+ const textShadow = w.config.dataLabels.dropShadow
+ filters.dropShadow(elPieLabel, textShadow)
+ }
+
+ elPieLabel.node.classList.add('apexcharts-pie-label')
+ if (
+ w.config.chart.animations.animate &&
+ w.globals.resized === false
+ ) {
+ elPieLabel.node.classList.add('apexcharts-pie-label-delay')
+ elPieLabel.node.style.animationDelay =
+ w.config.chart.animations.speed / 940 + 's'
+ }
+
+ this.sliceLabels.push(elPieLabelWrap)
+ }
+ }
+ }
+
+ return g
+ }
+
+ addListeners(elPath, dataLabels) {
+ const graphics = new Graphics(this.ctx)
+ // append filters on mouseenter and mouseleave
+ elPath.node.addEventListener(
+ 'mouseenter',
+ graphics.pathMouseEnter.bind(this, elPath)
+ )
+
+ elPath.node.addEventListener(
+ 'mouseleave',
+ graphics.pathMouseLeave.bind(this, elPath)
+ )
+ elPath.node.addEventListener(
+ 'mouseleave',
+ this.revertDataLabelsInner.bind(this, elPath.node, dataLabels)
+ )
+ elPath.node.addEventListener(
+ 'mousedown',
+ graphics.pathMouseDown.bind(this, elPath)
+ )
+
+ if (!this.donutDataLabels.total.showAlways) {
+ elPath.node.addEventListener(
+ 'mouseenter',
+ this.printDataLabelsInner.bind(this, elPath.node, dataLabels)
+ )
+
+ elPath.node.addEventListener(
+ 'mousedown',
+ this.printDataLabelsInner.bind(this, elPath.node, dataLabels)
+ )
+ }
+ }
+
+ // This function can be used for other circle charts too
+ animatePaths(el, opts) {
+ let w = this.w
+ let me = this
+
+ let angle =
+ opts.endAngle < opts.startAngle
+ ? this.fullAngle + opts.endAngle - opts.startAngle
+ : opts.endAngle - opts.startAngle
+ let prevAngle = angle
+
+ let fromStartAngle = opts.startAngle
+ let toStartAngle = opts.startAngle
+
+ if (opts.prevStartAngle !== undefined && opts.prevEndAngle !== undefined) {
+ fromStartAngle = opts.prevEndAngle
+ prevAngle =
+ opts.prevEndAngle < opts.prevStartAngle
+ ? this.fullAngle + opts.prevEndAngle - opts.prevStartAngle
+ : opts.prevEndAngle - opts.prevStartAngle
+ }
+ if (opts.i === w.config.series.length - 1) {
+ // some adjustments for the last overlapping paths
+ if (angle + toStartAngle > this.fullAngle) {
+ opts.endAngle = opts.endAngle - (angle + toStartAngle)
+ } else if (angle + toStartAngle < this.fullAngle) {
+ opts.endAngle =
+ opts.endAngle + (this.fullAngle - (angle + toStartAngle))
+ }
+ }
+
+ if (angle === this.fullAngle) angle = this.fullAngle - 0.01
+
+ me.animateArc(el, fromStartAngle, toStartAngle, angle, prevAngle, opts)
+ }
+
+ animateArc(el, fromStartAngle, toStartAngle, angle, prevAngle, opts) {
+ let me = this
+ const w = this.w
+ const animations = new Animations(this.ctx)
+
+ let size = opts.size
+
+ let path
+
+ if (isNaN(fromStartAngle) || isNaN(prevAngle)) {
+ fromStartAngle = toStartAngle
+ prevAngle = angle
+ opts.dur = 0
+ }
+
+ let currAngle = angle
+ let startAngle = toStartAngle
+ let fromAngle =
+ fromStartAngle < toStartAngle
+ ? this.fullAngle + fromStartAngle - toStartAngle
+ : fromStartAngle - toStartAngle
+
+ if (w.globals.dataChanged && opts.shouldSetPrevPaths) {
+ // to avoid flicker when updating, set prev path first and then animate from there
+ if (opts.prevEndAngle) {
+ path = me.getPiePath({
+ me,
+ startAngle: opts.prevStartAngle,
+ angle:
+ opts.prevEndAngle < opts.prevStartAngle
+ ? this.fullAngle + opts.prevEndAngle - opts.prevStartAngle
+ : opts.prevEndAngle - opts.prevStartAngle,
+ size
+ })
+ el.attr({ d: path })
+ }
+ }
+
+ if (opts.dur !== 0) {
+ el.animate(opts.dur, w.globals.easing, opts.animBeginArr[opts.i])
+ .afterAll(function() {
+ if (
+ me.chartType === 'pie' ||
+ me.chartType === 'donut' ||
+ me.chartType === 'polarArea'
+ ) {
+ this.animate(w.config.chart.animations.dynamicAnimation.speed).attr(
+ {
+ 'stroke-width': me.strokeWidth
+ }
+ )
+ }
+
+ if (opts.i === w.config.series.length - 1) {
+ animations.animationCompleted(el)
+ }
+ })
+ .during((pos) => {
+ currAngle = fromAngle + (angle - fromAngle) * pos
+ if (opts.animateStartingPos) {
+ currAngle = prevAngle + (angle - prevAngle) * pos
+ startAngle =
+ fromStartAngle -
+ prevAngle +
+ (toStartAngle - (fromStartAngle - prevAngle)) * pos
+ }
+
+ path = me.getPiePath({
+ me,
+ startAngle,
+ angle: currAngle,
+ size
+ })
+
+ el.node.setAttribute('data:pathOrig', path)
+
+ el.attr({
+ d: path
+ })
+ })
+ } else {
+ path = me.getPiePath({
+ me,
+ startAngle,
+ angle,
+ size
+ })
+
+ if (!opts.isTrack) {
+ w.globals.animationEnded = true
+ }
+ el.node.setAttribute('data:pathOrig', path)
+
+ el.attr({
+ d: path,
+ 'stroke-width': me.strokeWidth
+ })
+ }
+ }
+
+ pieClicked(i) {
+ let w = this.w
+ let me = this
+ let path
+
+ let size =
+ me.sliceSizes[i] + (w.config.plotOptions.pie.expandOnClick ? 4 : 0)
+ let elPath = w.globals.dom.Paper.select(
+ `.apexcharts-${me.chartType.toLowerCase()}-slice-${i}`
+ ).members[0]
+
+ if (elPath.attr('data:pieClicked') === 'true') {
+ elPath.attr({
+ 'data:pieClicked': 'false'
+ })
+ this.revertDataLabelsInner(elPath.node, this.donutDataLabels)
+
+ let origPath = elPath.attr('data:pathOrig')
+ elPath.attr({
+ d: origPath
+ })
+ return
+ } else {
+ // reset all elems
+ let allEls = w.globals.dom.baseEl.getElementsByClassName(
+ 'apexcharts-pie-area'
+ )
+ Array.prototype.forEach.call(allEls, (pieSlice) => {
+ pieSlice.setAttribute('data:pieClicked', 'false')
+ let origPath = pieSlice.getAttribute('data:pathOrig')
+ pieSlice.setAttribute('d', origPath)
+ })
+ elPath.attr('data:pieClicked', 'true')
+ }
+
+ let startAngle = parseInt(elPath.attr('data:startAngle'), 10)
+ let angle = parseInt(elPath.attr('data:angle'), 10)
+
+ path = me.getPiePath({
+ me,
+ startAngle,
+ angle,
+ size
+ })
+
+ if (angle === 360) return
+
+ elPath.plot(path)
+ }
+
+ getChangedPath(prevStartAngle, prevEndAngle) {
+ let path = ''
+ if (this.dynamicAnim && this.w.globals.dataChanged) {
+ path = this.getPiePath({
+ me: this,
+ startAngle: prevStartAngle,
+ angle: prevEndAngle - prevStartAngle,
+ size: this.size
+ })
+ }
+ return path
+ }
+
+ getPiePath({ me, startAngle, angle, size }) {
+ let path
+
+ let startDeg = startAngle
+ let startRadians = (Math.PI * (startDeg - 90)) / 180
+
+ let endDeg = angle + startAngle
+ // prevent overlap
+ if (
+ Math.ceil(endDeg) >=
+ this.fullAngle +
+ (this.w.config.plotOptions.pie.startAngle % this.fullAngle)
+ ) {
+ endDeg =
+ this.fullAngle +
+ (this.w.config.plotOptions.pie.startAngle % this.fullAngle) -
+ 0.01
+ }
+ if (Math.ceil(endDeg) > this.fullAngle) endDeg -= this.fullAngle
+
+ let endRadians = (Math.PI * (endDeg - 90)) / 180
+
+ let x1 = me.centerX + size * Math.cos(startRadians)
+ let y1 = me.centerY + size * Math.sin(startRadians)
+ let x2 = me.centerX + size * Math.cos(endRadians)
+ let y2 = me.centerY + size * Math.sin(endRadians)
+
+ let startInner = Utils.polarToCartesian(
+ me.centerX,
+ me.centerY,
+ me.donutSize,
+ endDeg
+ )
+ let endInner = Utils.polarToCartesian(
+ me.centerX,
+ me.centerY,
+ me.donutSize,
+ startDeg
+ )
+
+ let largeArc = angle > 180 ? 1 : 0
+
+ const pathBeginning = ['M', x1, y1, 'A', size, size, 0, largeArc, 1, x2, y2]
+
+ if (me.chartType === 'donut') {
+ path = [
+ ...pathBeginning,
+ 'L',
+ startInner.x,
+ startInner.y,
+ 'A',
+ me.donutSize,
+ me.donutSize,
+ 0,
+ largeArc,
+ 0,
+ endInner.x,
+ endInner.y,
+ 'L',
+ x1,
+ y1,
+ 'z'
+ ].join(' ')
+ } else if (me.chartType === 'pie' || me.chartType === 'polarArea') {
+ path = [...pathBeginning, 'L', me.centerX, me.centerY, 'L', x1, y1].join(
+ ' '
+ )
+ } else {
+ path = [...pathBeginning].join(' ')
+ }
+
+ return path
+ }
+
+ drawPolarElements(parent) {
+ const w = this.w
+ const scale = new Scales(this.ctx)
+ const graphics = new Graphics(this.ctx)
+ const helpers = new Helpers(this.ctx)
+
+ const gCircles = graphics.group()
+ const gYAxis = graphics.group()
+
+ const yScale = scale.niceScale(
+ 0,
+ Math.ceil(this.maxY),
+ w.config.yaxis[0].tickAmount,
+ 0,
+ true
+ )
+
+ const yTexts = yScale.result.reverse()
+ let len = yScale.result.length
+
+ this.maxY = yScale.niceMax
+
+ let circleSize = w.globals.radialSize
+ let diff = circleSize / (len - 1)
+
+ for (let i = 0; i < len - 1; i++) {
+ const circle = graphics.drawCircle(circleSize)
+
+ circle.attr({
+ cx: this.centerX,
+ cy: this.centerY,
+ fill: 'none',
+ 'stroke-width': w.config.plotOptions.polarArea.rings.strokeWidth,
+ stroke: w.config.plotOptions.polarArea.rings.strokeColor
+ })
+
+ if (w.config.yaxis[0].show) {
+ const yLabel = helpers.drawYAxisTexts(
+ this.centerX,
+ this.centerY -
+ circleSize +
+ parseInt(w.config.yaxis[0].labels.style.fontSize, 10) / 2,
+ i,
+ yTexts[i]
+ )
+
+ gYAxis.add(yLabel)
+ }
+
+ gCircles.add(circle)
+
+ circleSize = circleSize - diff
+ }
+
+ this.drawSpokes(parent)
+
+ parent.add(gCircles)
+ parent.add(gYAxis)
+ }
+
+ renderInnerDataLabels(dataLabelsConfig, opts) {
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let g = graphics.group({
+ class: 'apexcharts-datalabels-group',
+ transform: `translate(${opts.translateX ? opts.translateX : 0}, ${
+ opts.translateY ? opts.translateY : 0
+ }) scale(${w.config.plotOptions.pie.customScale})`
+ })
+
+ const showTotal = dataLabelsConfig.total.show
+
+ g.node.style.opacity = opts.opacity
+
+ let x = opts.centerX
+ let y = opts.centerY
+
+ let labelColor, valueColor
+
+ if (dataLabelsConfig.name.color === undefined) {
+ labelColor = w.globals.colors[0]
+ } else {
+ labelColor = dataLabelsConfig.name.color
+ }
+ let labelFontSize = dataLabelsConfig.name.fontSize
+ let labelFontFamily = dataLabelsConfig.name.fontFamily
+ let labelFontWeight = dataLabelsConfig.name.fontWeight
+
+ if (dataLabelsConfig.value.color === undefined) {
+ valueColor = w.config.chart.foreColor
+ } else {
+ valueColor = dataLabelsConfig.value.color
+ }
+
+ let lbFormatter = dataLabelsConfig.value.formatter
+ let val = ''
+ let name = ''
+
+ if (showTotal) {
+ labelColor = dataLabelsConfig.total.color
+ labelFontSize = dataLabelsConfig.total.fontSize
+ labelFontFamily = dataLabelsConfig.total.fontFamily
+ labelFontWeight = dataLabelsConfig.total.fontWeight
+ name = dataLabelsConfig.total.label
+ val = dataLabelsConfig.total.formatter(w)
+ } else {
+ if (w.globals.series.length === 1) {
+ val = lbFormatter(w.globals.series[0], w)
+ name = w.globals.seriesNames[0]
+ }
+ }
+
+ if (name) {
+ name = dataLabelsConfig.name.formatter(
+ name,
+ dataLabelsConfig.total.show,
+ w
+ )
+ }
+
+ if (dataLabelsConfig.name.show) {
+ let elLabel = graphics.drawText({
+ x,
+ y: y + parseFloat(dataLabelsConfig.name.offsetY),
+ text: name,
+ textAnchor: 'middle',
+ foreColor: labelColor,
+ fontSize: labelFontSize,
+ fontWeight: labelFontWeight,
+ fontFamily: labelFontFamily
+ })
+ elLabel.node.classList.add('apexcharts-datalabel-label')
+ g.add(elLabel)
+ }
+
+ if (dataLabelsConfig.value.show) {
+ let valOffset = dataLabelsConfig.name.show
+ ? parseFloat(dataLabelsConfig.value.offsetY) + 16
+ : dataLabelsConfig.value.offsetY
+
+ let elValue = graphics.drawText({
+ x,
+ y: y + valOffset,
+ text: val,
+ textAnchor: 'middle',
+ foreColor: valueColor,
+ fontWeight: dataLabelsConfig.value.fontWeight,
+ fontSize: dataLabelsConfig.value.fontSize,
+ fontFamily: dataLabelsConfig.value.fontFamily
+ })
+ elValue.node.classList.add('apexcharts-datalabel-value')
+ g.add(elValue)
+ }
+
+ // for a multi-series circle chart, we need to show total value instead of first series labels
+
+ return g
+ }
+
+ /**
+ *
+ * @param {string} name - The name of the series
+ * @param {string} val - The value of that series
+ * @param {object} el - Optional el (indicates which series was hovered/clicked). If this param is not present, means we need to show total
+ */
+ printInnerLabels(labelsConfig, name, val, el) {
+ const w = this.w
+
+ let labelColor
+
+ if (el) {
+ if (labelsConfig.name.color === undefined) {
+ labelColor =
+ w.globals.colors[parseInt(el.parentNode.getAttribute('rel'), 10) - 1]
+ } else {
+ labelColor = labelsConfig.name.color
+ }
+ } else {
+ if (w.globals.series.length > 1 && labelsConfig.total.show) {
+ labelColor = labelsConfig.total.color
+ }
+ }
+
+ let elLabel = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-datalabel-label'
+ )
+ let elValue = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-datalabel-value'
+ )
+
+ let lbFormatter = labelsConfig.value.formatter
+ val = lbFormatter(val, w)
+
+ // we need to show Total Val - so get the formatter of it
+ if (!el && typeof labelsConfig.total.formatter === 'function') {
+ val = labelsConfig.total.formatter(w)
+ }
+
+ const isTotal = name === labelsConfig.total.label
+ name = labelsConfig.name.formatter(name, isTotal, w)
+
+ if (elLabel !== null) {
+ elLabel.textContent = name
+ }
+
+ if (elValue !== null) {
+ elValue.textContent = val
+ }
+ if (elLabel !== null) {
+ elLabel.style.fill = labelColor
+ }
+ }
+
+ printDataLabelsInner(el, dataLabelsConfig) {
+ let w = this.w
+
+ let val = el.getAttribute('data:value')
+ let name =
+ w.globals.seriesNames[parseInt(el.parentNode.getAttribute('rel'), 10) - 1]
+
+ if (w.globals.series.length > 1) {
+ this.printInnerLabels(dataLabelsConfig, name, val, el)
+ }
+
+ let dataLabelsGroup = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-datalabels-group'
+ )
+ if (dataLabelsGroup !== null) {
+ dataLabelsGroup.style.opacity = 1
+ }
+ }
+
+ drawSpokes(parent) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+ const spokeConfig = w.config.plotOptions.polarArea.spokes
+
+ if (spokeConfig.strokeWidth === 0) return
+
+ let spokes = []
+
+ let angleDivision = 360 / w.globals.series.length
+ for (let i = 0; i < w.globals.series.length; i++) {
+ spokes.push(
+ Utils.polarToCartesian(
+ this.centerX,
+ this.centerY,
+ w.globals.radialSize,
+ w.config.plotOptions.pie.startAngle + angleDivision * i
+ )
+ )
+ }
+
+ spokes.forEach((p, i) => {
+ const line = graphics.drawLine(
+ p.x,
+ p.y,
+ this.centerX,
+ this.centerY,
+ Array.isArray(spokeConfig.connectorColors)
+ ? spokeConfig.connectorColors[i]
+ : spokeConfig.connectorColors
+ )
+
+ parent.add(line)
+ })
+ }
+
+ revertDataLabelsInner(elem, dataLabelsConfig, event) {
+ let w = this.w
+ let dataLabelsGroup = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-datalabels-group'
+ )
+
+ let sliceOut = false
+ const slices = w.globals.dom.baseEl.getElementsByClassName(
+ `apexcharts-pie-area`
+ )
+
+ const selectSlice = ({ makeSliceOut, printLabel }) => {
+ Array.prototype.forEach.call(slices, (s) => {
+ if (s.getAttribute('data:pieClicked') === 'true') {
+ if (makeSliceOut) {
+ sliceOut = true
+ }
+ if (printLabel) {
+ this.printDataLabelsInner(s, dataLabelsConfig)
+ }
+ }
+ })
+ }
+
+ selectSlice({ makeSliceOut: true, printLabel: false })
+
+ if (dataLabelsConfig.total.show && w.globals.series.length > 1) {
+ if (sliceOut && !dataLabelsConfig.total.showAlways) {
+ selectSlice({ makeSliceOut: false, printLabel: true })
+ } else {
+ this.printInnerLabels(
+ dataLabelsConfig,
+ dataLabelsConfig.total.label,
+ dataLabelsConfig.total.formatter(w)
+ )
+ }
+ } else {
+ selectSlice({ makeSliceOut: false, printLabel: true })
+
+ if (!sliceOut) {
+ if (
+ w.globals.selectedDataPoints.length &&
+ w.globals.series.length > 1
+ ) {
+ if (w.globals.selectedDataPoints[0].length > 0) {
+ const index = w.globals.selectedDataPoints[0]
+ const el = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-${this.chartType.toLowerCase()}-slice-${index}`
+ )
+
+ this.printDataLabelsInner(el, dataLabelsConfig)
+ } else if (
+ dataLabelsGroup &&
+ w.globals.selectedDataPoints.length &&
+ w.globals.selectedDataPoints[0].length === 0
+ ) {
+ dataLabelsGroup.style.opacity = 0
+ }
+ } else {
+ if (dataLabelsGroup && w.globals.series.length > 1) {
+ dataLabelsGroup.style.opacity = 0
+ }
+ }
+ }
+ }
+ }
+}
+
+export default Pie
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Radar.js b/cao_sunyata/static/libs/apexcharts/src/charts/Radar.js
new file mode 100644
index 0000000..21b93a6
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Radar.js
@@ -0,0 +1,524 @@
+import Fill from '../modules/Fill'
+import Graphics from '../modules/Graphics'
+import Markers from '../modules/Markers'
+import DataLabels from '../modules/DataLabels'
+import Filters from '../modules/Filters'
+import Utils from '../utils/Utils'
+import Helpers from './common/circle/Helpers'
+import CoreUtils from '../modules/CoreUtils'
+
+/**
+ * ApexCharts Radar Class for Spider/Radar Charts.
+ * @module Radar
+ **/
+
+class Radar {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.chartType = this.w.config.chart.type
+
+ this.initialAnim = this.w.config.chart.animations.enabled
+ this.dynamicAnim =
+ this.initialAnim &&
+ this.w.config.chart.animations.dynamicAnimation.enabled
+
+ this.animDur = 0
+
+ const w = this.w
+ this.graphics = new Graphics(this.ctx)
+
+ this.lineColorArr =
+ w.globals.stroke.colors !== undefined
+ ? w.globals.stroke.colors
+ : w.globals.colors
+
+ this.defaultSize =
+ w.globals.svgHeight < w.globals.svgWidth
+ ? w.globals.gridHeight + w.globals.goldenPadding * 1.5
+ : w.globals.gridWidth
+
+ this.isLog = w.config.yaxis[0].logarithmic
+
+ this.coreUtils = new CoreUtils(this.ctx)
+ this.maxValue = this.isLog
+ ? this.coreUtils.getLogVal(w.globals.maxY, 0)
+ : w.globals.maxY
+ this.minValue = this.isLog
+ ? this.coreUtils.getLogVal(this.w.globals.minY, 0)
+ : w.globals.minY
+
+ this.polygons = w.config.plotOptions.radar.polygons
+
+ this.strokeWidth = w.config.stroke.show ? w.config.stroke.width : 0
+
+ this.size =
+ this.defaultSize / 2.1 - this.strokeWidth - w.config.chart.dropShadow.blur
+
+ if (w.config.xaxis.labels.show) {
+ this.size = this.size - w.globals.xAxisLabelsWidth / 1.75
+ }
+
+ if (w.config.plotOptions.radar.size !== undefined) {
+ this.size = w.config.plotOptions.radar.size
+ }
+
+ this.dataRadiusOfPercent = []
+ this.dataRadius = []
+ this.angleArr = []
+
+ this.yaxisLabelsTextsPos = []
+ }
+
+ draw(series) {
+ let w = this.w
+ const fill = new Fill(this.ctx)
+
+ const allSeries = []
+ const dataLabels = new DataLabels(this.ctx)
+
+ if (series.length) {
+ this.dataPointsLen = series[w.globals.maxValsInArrayIndex].length
+ }
+ this.disAngle = (Math.PI * 2) / this.dataPointsLen
+
+ let halfW = w.globals.gridWidth / 2
+ let halfH = w.globals.gridHeight / 2
+ let translateX = halfW + w.config.plotOptions.radar.offsetX
+ let translateY = halfH + w.config.plotOptions.radar.offsetY
+
+ let ret = this.graphics.group({
+ class: 'apexcharts-radar-series apexcharts-plot-series',
+ transform: `translate(${translateX || 0}, ${translateY || 0})`
+ })
+
+ let dataPointsPos = []
+ let elPointsMain = null
+ let elDataPointsMain = null
+
+ this.yaxisLabels = this.graphics.group({
+ class: 'apexcharts-yaxis'
+ })
+
+ series.forEach((s, i) => {
+ let longestSeries = s.length === w.globals.dataPoints
+
+ // el to which series will be drawn
+ let elSeries = this.graphics.group().attr({
+ class: `apexcharts-series`,
+ 'data:longestSeries': longestSeries,
+ seriesName: Utils.escapeString(w.globals.seriesNames[i]),
+ rel: i + 1,
+ 'data:realIndex': i
+ })
+
+ this.dataRadiusOfPercent[i] = []
+ this.dataRadius[i] = []
+ this.angleArr[i] = []
+
+ s.forEach((dv, j) => {
+ const range = Math.abs(this.maxValue - this.minValue)
+ dv = dv + Math.abs(this.minValue)
+
+ if (this.isLog) {
+ dv = this.coreUtils.getLogVal(dv, 0)
+ }
+
+ this.dataRadiusOfPercent[i][j] = dv / range
+
+ this.dataRadius[i][j] = this.dataRadiusOfPercent[i][j] * this.size
+ this.angleArr[i][j] = j * this.disAngle
+ })
+
+ dataPointsPos = this.getDataPointsPos(
+ this.dataRadius[i],
+ this.angleArr[i]
+ )
+ const paths = this.createPaths(dataPointsPos, {
+ x: 0,
+ y: 0
+ })
+
+ // points
+ elPointsMain = this.graphics.group({
+ class: 'apexcharts-series-markers-wrap apexcharts-element-hidden'
+ })
+
+ // datapoints
+ elDataPointsMain = this.graphics.group({
+ class: `apexcharts-datalabels`,
+ 'data:realIndex': i
+ })
+
+ w.globals.delayedElements.push({
+ el: elPointsMain.node,
+ index: i
+ })
+
+ const defaultRenderedPathOptions = {
+ i,
+ realIndex: i,
+ animationDelay: i,
+ initialSpeed: w.config.chart.animations.speed,
+ dataChangeSpeed: w.config.chart.animations.dynamicAnimation.speed,
+ className: `apexcharts-radar`,
+ shouldClipToGrid: false,
+ bindEventsOnPaths: false,
+ stroke: w.globals.stroke.colors[i],
+ strokeLineCap: w.config.stroke.lineCap
+ }
+
+ let pathFrom = null
+
+ if (w.globals.previousPaths.length > 0) {
+ pathFrom = this.getPreviousPath(i)
+ }
+
+ for (let p = 0; p < paths.linePathsTo.length; p++) {
+ let renderedLinePath = this.graphics.renderPaths({
+ ...defaultRenderedPathOptions,
+ pathFrom: pathFrom === null ? paths.linePathsFrom[p] : pathFrom,
+ pathTo: paths.linePathsTo[p],
+ strokeWidth: Array.isArray(this.strokeWidth)
+ ? this.strokeWidth[i]
+ : this.strokeWidth,
+ fill: 'none',
+ drawShadow: false
+ })
+
+ elSeries.add(renderedLinePath)
+
+ let pathFill = fill.fillPath({
+ seriesNumber: i
+ })
+
+ let renderedAreaPath = this.graphics.renderPaths({
+ ...defaultRenderedPathOptions,
+ pathFrom: pathFrom === null ? paths.areaPathsFrom[p] : pathFrom,
+ pathTo: paths.areaPathsTo[p],
+ strokeWidth: 0,
+ fill: pathFill,
+ drawShadow: false
+ })
+
+ if (w.config.chart.dropShadow.enabled) {
+ const filters = new Filters(this.ctx)
+
+ const shadow = w.config.chart.dropShadow
+ filters.dropShadow(
+ renderedAreaPath,
+ Object.assign({}, shadow, { noUserSpaceOnUse: true }),
+ i
+ )
+ }
+
+ elSeries.add(renderedAreaPath)
+ }
+
+ s.forEach((sj, j) => {
+ let markers = new Markers(this.ctx)
+
+ let opts = markers.getMarkerConfig({
+ cssClass: 'apexcharts-marker',
+ seriesIndex: i,
+ dataPointIndex: j
+ })
+
+ let point = this.graphics.drawMarker(
+ dataPointsPos[j].x,
+ dataPointsPos[j].y,
+ opts
+ )
+
+ point.attr('rel', j)
+ point.attr('j', j)
+ point.attr('index', i)
+ point.node.setAttribute('default-marker-size', opts.pSize)
+
+ let elPointsWrap = this.graphics.group({
+ class: 'apexcharts-series-markers'
+ })
+
+ if (elPointsWrap) {
+ elPointsWrap.add(point)
+ }
+
+ elPointsMain.add(elPointsWrap)
+
+ elSeries.add(elPointsMain)
+
+ const dataLabelsConfig = w.config.dataLabels
+
+ if (dataLabelsConfig.enabled) {
+ let text = dataLabelsConfig.formatter(w.globals.series[i][j], {
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+
+ dataLabels.plotDataLabelsText({
+ x: dataPointsPos[j].x,
+ y: dataPointsPos[j].y,
+ text,
+ textAnchor: 'middle',
+ i,
+ j: i,
+ parent: elDataPointsMain,
+ offsetCorrection: false,
+ dataLabelsConfig: {
+ ...dataLabelsConfig
+ }
+ })
+ }
+ elSeries.add(elDataPointsMain)
+ })
+
+ allSeries.push(elSeries)
+ })
+
+ this.drawPolygons({
+ parent: ret
+ })
+
+ if (w.config.xaxis.labels.show) {
+ const xaxisTexts = this.drawXAxisTexts()
+ ret.add(xaxisTexts)
+ }
+
+ allSeries.forEach((elS) => {
+ ret.add(elS)
+ })
+
+ ret.add(this.yaxisLabels)
+
+ return ret
+ }
+
+ drawPolygons(opts) {
+ const w = this.w
+ const { parent } = opts
+ const helpers = new Helpers(this.ctx)
+
+ const yaxisTexts = w.globals.yAxisScale[0].result.reverse()
+ const layers = yaxisTexts.length
+
+ let radiusSizes = []
+ let layerDis = this.size / (layers - 1)
+ for (let i = 0; i < layers; i++) {
+ radiusSizes[i] = layerDis * i
+ }
+ radiusSizes.reverse()
+
+ let polygonStrings = []
+ let lines = []
+
+ radiusSizes.forEach((radiusSize, r) => {
+ const polygon = Utils.getPolygonPos(radiusSize, this.dataPointsLen)
+ let string = ''
+
+ polygon.forEach((p, i) => {
+ if (r === 0) {
+ const line = this.graphics.drawLine(
+ p.x,
+ p.y,
+ 0,
+ 0,
+ Array.isArray(this.polygons.connectorColors)
+ ? this.polygons.connectorColors[i]
+ : this.polygons.connectorColors
+ )
+
+ lines.push(line)
+ }
+
+ if (i === 0) {
+ this.yaxisLabelsTextsPos.push({
+ x: p.x,
+ y: p.y
+ })
+ }
+
+ string += p.x + ',' + p.y + ' '
+ })
+
+ polygonStrings.push(string)
+ })
+
+ polygonStrings.forEach((p, i) => {
+ const strokeColors = this.polygons.strokeColors
+ const strokeWidth = this.polygons.strokeWidth
+ const polygon = this.graphics.drawPolygon(
+ p,
+ Array.isArray(strokeColors) ? strokeColors[i] : strokeColors,
+ Array.isArray(strokeWidth) ? strokeWidth[i] : strokeWidth,
+ w.globals.radarPolygons.fill.colors[i]
+ )
+ parent.add(polygon)
+ })
+
+ lines.forEach((l) => {
+ parent.add(l)
+ })
+
+ if (w.config.yaxis[0].show) {
+ this.yaxisLabelsTextsPos.forEach((p, i) => {
+ const yText = helpers.drawYAxisTexts(p.x, p.y, i, yaxisTexts[i])
+ this.yaxisLabels.add(yText)
+ })
+ }
+ }
+
+ drawXAxisTexts() {
+ const w = this.w
+
+ const xaxisLabelsConfig = w.config.xaxis.labels
+ let elXAxisWrap = this.graphics.group({
+ class: 'apexcharts-xaxis'
+ })
+
+ let polygonPos = Utils.getPolygonPos(this.size, this.dataPointsLen)
+
+ w.globals.labels.forEach((label, i) => {
+ let formatter = w.config.xaxis.labels.formatter
+ let dataLabels = new DataLabels(this.ctx)
+
+ if (polygonPos[i]) {
+ let textPos = this.getTextPos(polygonPos[i], this.size)
+
+ let text = formatter(label, {
+ seriesIndex: -1,
+ dataPointIndex: i,
+ w
+ })
+
+ dataLabels.plotDataLabelsText({
+ x: textPos.newX,
+ y: textPos.newY,
+ text,
+ textAnchor: textPos.textAnchor,
+ i,
+ j: i,
+ parent: elXAxisWrap,
+ color:
+ Array.isArray(xaxisLabelsConfig.style.colors) &&
+ xaxisLabelsConfig.style.colors[i]
+ ? xaxisLabelsConfig.style.colors[i]
+ : '#a8a8a8',
+ dataLabelsConfig: {
+ textAnchor: textPos.textAnchor,
+ dropShadow: { enabled: false },
+ ...xaxisLabelsConfig
+ },
+ offsetCorrection: false
+ })
+ }
+ })
+
+ return elXAxisWrap
+ }
+
+ createPaths(pos, origin) {
+ let linePathsTo = []
+ let linePathsFrom = []
+ let areaPathsTo = []
+ let areaPathsFrom = []
+
+ if (pos.length) {
+ linePathsFrom = [this.graphics.move(origin.x, origin.y)]
+ areaPathsFrom = [this.graphics.move(origin.x, origin.y)]
+
+ let linePathTo = this.graphics.move(pos[0].x, pos[0].y)
+ let areaPathTo = this.graphics.move(pos[0].x, pos[0].y)
+
+ pos.forEach((p, i) => {
+ linePathTo += this.graphics.line(p.x, p.y)
+ areaPathTo += this.graphics.line(p.x, p.y)
+ if (i === pos.length - 1) {
+ linePathTo += 'Z'
+ areaPathTo += 'Z'
+ }
+ })
+
+ linePathsTo.push(linePathTo)
+ areaPathsTo.push(areaPathTo)
+ }
+
+ return {
+ linePathsFrom,
+ linePathsTo,
+ areaPathsFrom,
+ areaPathsTo
+ }
+ }
+
+ getTextPos(pos, polygonSize) {
+ let limit = 10
+ let textAnchor = 'middle'
+
+ let newX = pos.x
+ let newY = pos.y
+
+ if (Math.abs(pos.x) >= limit) {
+ if (pos.x > 0) {
+ textAnchor = 'start'
+ newX += 10
+ } else if (pos.x < 0) {
+ textAnchor = 'end'
+ newX -= 10
+ }
+ } else {
+ textAnchor = 'middle'
+ }
+ if (Math.abs(pos.y) >= polygonSize - limit) {
+ if (pos.y < 0) {
+ newY -= 10
+ } else if (pos.y > 0) {
+ newY += 10
+ }
+ }
+
+ return {
+ textAnchor,
+ newX,
+ newY
+ }
+ }
+
+ getPreviousPath(realIndex) {
+ let w = this.w
+ let pathFrom = null
+ for (let pp = 0; pp < w.globals.previousPaths.length; pp++) {
+ let gpp = w.globals.previousPaths[pp]
+
+ if (
+ gpp.paths.length > 0 &&
+ parseInt(gpp.realIndex, 10) === parseInt(realIndex, 10)
+ ) {
+ if (typeof w.globals.previousPaths[pp].paths[0] !== 'undefined') {
+ pathFrom = w.globals.previousPaths[pp].paths[0].d
+ }
+ }
+ }
+ return pathFrom
+ }
+
+ getDataPointsPos(
+ dataRadiusArr,
+ angleArr,
+ dataPointsLen = this.dataPointsLen
+ ) {
+ dataRadiusArr = dataRadiusArr || []
+ angleArr = angleArr || []
+ let dataPointsPosArray = []
+ for (let j = 0; j < dataPointsLen; j++) {
+ let curPointPos = {}
+ curPointPos.x = dataRadiusArr[j] * Math.sin(angleArr[j])
+ curPointPos.y = -dataRadiusArr[j] * Math.cos(angleArr[j])
+ dataPointsPosArray.push(curPointPos)
+ }
+ return dataPointsPosArray
+ }
+}
+
+export default Radar
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Radial.js b/cao_sunyata/static/libs/apexcharts/src/charts/Radial.js
new file mode 100644
index 0000000..caed41e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Radial.js
@@ -0,0 +1,469 @@
+import Pie from './Pie'
+import Utils from '../utils/Utils'
+import Fill from '../modules/Fill'
+import Graphics from '../modules/Graphics'
+import Filters from '../modules/Filters'
+
+/**
+ * ApexCharts Radial Class for drawing Circle / Semi Circle Charts.
+ * @module Radial
+ **/
+
+class Radial extends Pie {
+ constructor(ctx) {
+ super(ctx)
+
+ this.ctx = ctx
+ this.w = ctx.w
+ this.animBeginArr = [0]
+ this.animDur = 0
+
+ const w = this.w
+ this.startAngle = w.config.plotOptions.radialBar.startAngle
+ this.endAngle = w.config.plotOptions.radialBar.endAngle
+
+ this.totalAngle = Math.abs(
+ w.config.plotOptions.radialBar.endAngle -
+ w.config.plotOptions.radialBar.startAngle
+ )
+
+ this.trackStartAngle = w.config.plotOptions.radialBar.track.startAngle
+ this.trackEndAngle = w.config.plotOptions.radialBar.track.endAngle
+
+ this.donutDataLabels = this.w.config.plotOptions.radialBar.dataLabels
+ this.radialDataLabels = this.donutDataLabels // make a copy for easy reference
+
+ if (!this.trackStartAngle) this.trackStartAngle = this.startAngle
+ if (!this.trackEndAngle) this.trackEndAngle = this.endAngle
+
+ if (this.endAngle === 360) this.endAngle = 359.99
+
+ this.margin = parseInt(w.config.plotOptions.radialBar.track.margin, 10)
+ }
+
+ draw(series) {
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let ret = graphics.group({
+ class: 'apexcharts-radialbar'
+ })
+
+ if (w.globals.noData) return ret
+
+ let elSeries = graphics.group()
+
+ let centerY = this.defaultSize / 2
+ let centerX = w.globals.gridWidth / 2
+
+ let size = this.defaultSize / 2.05
+ if (!w.config.chart.sparkline.enabled) {
+ size = size - w.config.stroke.width - w.config.chart.dropShadow.blur
+ }
+ let colorArr = w.globals.fill.colors
+
+ if (w.config.plotOptions.radialBar.track.show) {
+ let elTracks = this.drawTracks({
+ size,
+ centerX,
+ centerY,
+ colorArr,
+ series
+ })
+ elSeries.add(elTracks)
+ }
+
+ let elG = this.drawArcs({
+ size,
+ centerX,
+ centerY,
+ colorArr,
+ series
+ })
+
+ let totalAngle = 360
+
+ if (w.config.plotOptions.radialBar.startAngle < 0) {
+ totalAngle = this.totalAngle
+ }
+
+ let angleRatio = (360 - totalAngle) / 360
+ w.globals.radialSize = size - size * angleRatio
+
+ if (this.radialDataLabels.value.show) {
+ let offset = Math.max(
+ this.radialDataLabels.value.offsetY,
+ this.radialDataLabels.name.offsetY
+ )
+ w.globals.radialSize += offset * angleRatio
+ }
+
+ elSeries.add(elG.g)
+
+ if (w.config.plotOptions.radialBar.hollow.position === 'front') {
+ elG.g.add(elG.elHollow)
+ if (elG.dataLabels) {
+ elG.g.add(elG.dataLabels)
+ }
+ }
+
+ ret.add(elSeries)
+
+ return ret
+ }
+
+ drawTracks(opts) {
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let g = graphics.group({
+ class: 'apexcharts-tracks'
+ })
+
+ let filters = new Filters(this.ctx)
+ let fill = new Fill(this.ctx)
+
+ let strokeWidth = this.getStrokeWidth(opts)
+
+ opts.size = opts.size - strokeWidth / 2
+
+ for (let i = 0; i < opts.series.length; i++) {
+ let elRadialBarTrack = graphics.group({
+ class: 'apexcharts-radialbar-track apexcharts-track'
+ })
+ g.add(elRadialBarTrack)
+
+ elRadialBarTrack.attr({
+ rel: i + 1
+ })
+
+ opts.size = opts.size - strokeWidth - this.margin
+
+ const trackConfig = w.config.plotOptions.radialBar.track
+ let pathFill = fill.fillPath({
+ seriesNumber: 0,
+ size: opts.size,
+ fillColors: Array.isArray(trackConfig.background)
+ ? trackConfig.background[i]
+ : trackConfig.background,
+ solid: true
+ })
+
+ let startAngle = this.trackStartAngle
+ let endAngle = this.trackEndAngle
+
+ if (Math.abs(endAngle) + Math.abs(startAngle) >= 360)
+ endAngle = 360 - Math.abs(this.startAngle) - 0.1
+
+ let elPath = graphics.drawPath({
+ d: '',
+ stroke: pathFill,
+ strokeWidth:
+ (strokeWidth * parseInt(trackConfig.strokeWidth, 10)) / 100,
+ fill: 'none',
+ strokeOpacity: trackConfig.opacity,
+ classes: 'apexcharts-radialbar-area'
+ })
+
+ if (trackConfig.dropShadow.enabled) {
+ const shadow = trackConfig.dropShadow
+ filters.dropShadow(elPath, shadow)
+ }
+
+ elRadialBarTrack.add(elPath)
+
+ elPath.attr('id', 'apexcharts-radialbarTrack-' + i)
+
+ this.animatePaths(elPath, {
+ centerX: opts.centerX,
+ centerY: opts.centerY,
+ endAngle,
+ startAngle,
+ size: opts.size,
+ i,
+ totalItems: 2,
+ animBeginArr: 0,
+ dur: 0,
+ isTrack: true,
+ easing: w.globals.easing
+ })
+ }
+
+ return g
+ }
+
+ drawArcs(opts) {
+ let w = this.w
+ // size, donutSize, centerX, centerY, colorArr, lineColorArr, sectorAngleArr, series
+
+ let graphics = new Graphics(this.ctx)
+ let fill = new Fill(this.ctx)
+ let filters = new Filters(this.ctx)
+ let g = graphics.group()
+
+ let strokeWidth = this.getStrokeWidth(opts)
+ opts.size = opts.size - strokeWidth / 2
+
+ let hollowFillID = w.config.plotOptions.radialBar.hollow.background
+ let hollowSize =
+ opts.size -
+ strokeWidth * opts.series.length -
+ this.margin * opts.series.length -
+ (strokeWidth *
+ parseInt(w.config.plotOptions.radialBar.track.strokeWidth, 10)) /
+ 100 /
+ 2
+
+ let hollowRadius = hollowSize - w.config.plotOptions.radialBar.hollow.margin
+
+ if (w.config.plotOptions.radialBar.hollow.image !== undefined) {
+ hollowFillID = this.drawHollowImage(opts, g, hollowSize, hollowFillID)
+ }
+
+ let elHollow = this.drawHollow({
+ size: hollowRadius,
+ centerX: opts.centerX,
+ centerY: opts.centerY,
+ fill: hollowFillID ? hollowFillID : 'transparent'
+ })
+
+ if (w.config.plotOptions.radialBar.hollow.dropShadow.enabled) {
+ const shadow = w.config.plotOptions.radialBar.hollow.dropShadow
+ filters.dropShadow(elHollow, shadow)
+ }
+
+ let shown = 1
+ if (!this.radialDataLabels.total.show && w.globals.series.length > 1) {
+ shown = 0
+ }
+
+ let dataLabels = null
+
+ if (this.radialDataLabels.show) {
+ dataLabels = this.renderInnerDataLabels(this.radialDataLabels, {
+ hollowSize,
+ centerX: opts.centerX,
+ centerY: opts.centerY,
+ opacity: shown
+ })
+ }
+
+ if (w.config.plotOptions.radialBar.hollow.position === 'back') {
+ g.add(elHollow)
+ if (dataLabels) {
+ g.add(dataLabels)
+ }
+ }
+
+ let reverseLoop = false
+ if (w.config.plotOptions.radialBar.inverseOrder) {
+ reverseLoop = true
+ }
+
+ for (
+ let i = reverseLoop ? opts.series.length - 1 : 0;
+ reverseLoop ? i >= 0 : i < opts.series.length;
+ reverseLoop ? i-- : i++
+ ) {
+ let elRadialBarArc = graphics.group({
+ class: `apexcharts-series apexcharts-radial-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[i])
+ })
+ g.add(elRadialBarArc)
+
+ elRadialBarArc.attr({
+ rel: i + 1,
+ 'data:realIndex': i
+ })
+
+ this.ctx.series.addCollapsedClassToSeries(elRadialBarArc, i)
+
+ opts.size = opts.size - strokeWidth - this.margin
+
+ let pathFill = fill.fillPath({
+ seriesNumber: i,
+ size: opts.size,
+ value: opts.series[i]
+ })
+
+ let startAngle = this.startAngle
+ let prevStartAngle
+
+ // if data exceeds 100, make it 100
+ const dataValue =
+ Utils.negToZero(opts.series[i] > 100 ? 100 : opts.series[i]) / 100
+
+ let endAngle = Math.round(this.totalAngle * dataValue) + this.startAngle
+
+ let prevEndAngle
+ if (w.globals.dataChanged) {
+ prevStartAngle = this.startAngle
+ prevEndAngle =
+ Math.round(
+ (this.totalAngle * Utils.negToZero(w.globals.previousPaths[i])) /
+ 100
+ ) + prevStartAngle
+ }
+
+ const currFullAngle = Math.abs(endAngle) + Math.abs(startAngle)
+ if (currFullAngle >= 360) {
+ endAngle = endAngle - 0.01
+ }
+
+ const prevFullAngle = Math.abs(prevEndAngle) + Math.abs(prevStartAngle)
+ if (prevFullAngle >= 360) {
+ prevEndAngle = prevEndAngle - 0.01
+ }
+
+ let angle = endAngle - startAngle
+
+ const dashArray = Array.isArray(w.config.stroke.dashArray)
+ ? w.config.stroke.dashArray[i]
+ : w.config.stroke.dashArray
+
+ let elPath = graphics.drawPath({
+ d: '',
+ stroke: pathFill,
+ strokeWidth,
+ fill: 'none',
+ fillOpacity: w.config.fill.opacity,
+ classes: 'apexcharts-radialbar-area apexcharts-radialbar-slice-' + i,
+ strokeDashArray: dashArray
+ })
+
+ Graphics.setAttrs(elPath.node, {
+ 'data:angle': angle,
+ 'data:value': opts.series[i]
+ })
+
+ if (w.config.chart.dropShadow.enabled) {
+ const shadow = w.config.chart.dropShadow
+ filters.dropShadow(elPath, shadow, i)
+ }
+ filters.setSelectionFilter(elPath, 0, i)
+
+ this.addListeners(elPath, this.radialDataLabels)
+
+ elRadialBarArc.add(elPath)
+
+ elPath.attr({
+ index: 0,
+ j: i
+ })
+
+ let dur = 0
+ if (this.initialAnim && !w.globals.resized && !w.globals.dataChanged) {
+ dur = w.config.chart.animations.speed
+ }
+
+ if (w.globals.dataChanged) {
+ dur = w.config.chart.animations.dynamicAnimation.speed
+ }
+ this.animDur = dur / (opts.series.length * 1.2) + this.animDur
+ this.animBeginArr.push(this.animDur)
+
+ this.animatePaths(elPath, {
+ centerX: opts.centerX,
+ centerY: opts.centerY,
+ endAngle,
+ startAngle,
+ prevEndAngle,
+ prevStartAngle,
+ size: opts.size,
+ i,
+ totalItems: 2,
+ animBeginArr: this.animBeginArr,
+ dur,
+ shouldSetPrevPaths: true,
+ easing: w.globals.easing
+ })
+ }
+
+ return {
+ g,
+ elHollow,
+ dataLabels
+ }
+ }
+
+ drawHollow(opts) {
+ const graphics = new Graphics(this.ctx)
+
+ let circle = graphics.drawCircle(opts.size * 2)
+
+ circle.attr({
+ class: 'apexcharts-radialbar-hollow',
+ cx: opts.centerX,
+ cy: opts.centerY,
+ r: opts.size,
+ fill: opts.fill
+ })
+
+ return circle
+ }
+
+ drawHollowImage(opts, g, hollowSize, hollowFillID) {
+ const w = this.w
+ let fill = new Fill(this.ctx)
+
+ let randID = Utils.randomId()
+ let hollowFillImg = w.config.plotOptions.radialBar.hollow.image
+
+ if (w.config.plotOptions.radialBar.hollow.imageClipped) {
+ fill.clippedImgArea({
+ width: hollowSize,
+ height: hollowSize,
+ image: hollowFillImg,
+ patternID: `pattern${w.globals.cuid}${randID}`
+ })
+ hollowFillID = `url(#pattern${w.globals.cuid}${randID})`
+ } else {
+ const imgWidth = w.config.plotOptions.radialBar.hollow.imageWidth
+ const imgHeight = w.config.plotOptions.radialBar.hollow.imageHeight
+ if (imgWidth === undefined && imgHeight === undefined) {
+ let image = w.globals.dom.Paper.image(hollowFillImg).loaded(function(
+ loader
+ ) {
+ this.move(
+ opts.centerX -
+ loader.width / 2 +
+ w.config.plotOptions.radialBar.hollow.imageOffsetX,
+ opts.centerY -
+ loader.height / 2 +
+ w.config.plotOptions.radialBar.hollow.imageOffsetY
+ )
+ })
+ g.add(image)
+ } else {
+ let image = w.globals.dom.Paper.image(hollowFillImg).loaded(function(
+ loader
+ ) {
+ this.move(
+ opts.centerX -
+ imgWidth / 2 +
+ w.config.plotOptions.radialBar.hollow.imageOffsetX,
+ opts.centerY -
+ imgHeight / 2 +
+ w.config.plotOptions.radialBar.hollow.imageOffsetY
+ )
+ this.size(imgWidth, imgHeight)
+ })
+ g.add(image)
+ }
+ }
+ return hollowFillID
+ }
+
+ getStrokeWidth(opts) {
+ const w = this.w
+ return (
+ (opts.size *
+ (100 - parseInt(w.config.plotOptions.radialBar.hollow.size, 10))) /
+ 100 /
+ (opts.series.length + 1) -
+ this.margin
+ )
+ }
+}
+
+export default Radial
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/RangeBar.js b/cao_sunyata/static/libs/apexcharts/src/charts/RangeBar.js
new file mode 100644
index 0000000..cdfb6bc
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/RangeBar.js
@@ -0,0 +1,454 @@
+import Bar from './Bar'
+import Graphics from '../modules/Graphics'
+import Utils from '../utils/Utils'
+import DateTime from '../utils/DateTime'
+
+/**
+ * ApexCharts RangeBar Class responsible for drawing Range/Timeline Bars.
+ *
+ * @module RangeBar
+ **/
+
+class RangeBar extends Bar {
+ draw(series, seriesIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ this.rangeBarOptions = this.w.config.plotOptions.rangeBar
+
+ this.series = series
+ this.seriesRangeStart = w.globals.seriesRangeStart
+ this.seriesRangeEnd = w.globals.seriesRangeEnd
+
+ this.barHelpers.initVariables(series)
+
+ let ret = graphics.group({
+ class: 'apexcharts-rangebar-series apexcharts-plot-series'
+ })
+
+ for (let i = 0; i < series.length; i++) {
+ let x,
+ y,
+ xDivision, // xDivision is the GRIDWIDTH divided by number of datapoints (columns)
+ yDivision, // yDivision is the GRIDHEIGHT divided by number of datapoints (bars)
+ zeroH, // zeroH is the baseline where 0 meets y axis
+ zeroW // zeroW is the baseline where 0 meets x axis
+
+ let realIndex = w.globals.comboCharts ? seriesIndex[i] : i
+
+ // el to which series will be drawn
+ let elSeries = graphics.group({
+ class: `apexcharts-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[realIndex]),
+ rel: i + 1,
+ 'data:realIndex': realIndex
+ })
+
+ this.ctx.series.addCollapsedClassToSeries(elSeries, realIndex)
+
+ if (series[i].length > 0) {
+ this.visibleI = this.visibleI + 1
+ }
+
+ let barHeight = 0
+ let barWidth = 0
+
+ if (this.yRatio.length > 1) {
+ this.yaxisIndex = realIndex
+ }
+
+ let initPositions = this.barHelpers.initialPositions()
+
+ y = initPositions.y
+ zeroW = initPositions.zeroW
+
+ x = initPositions.x
+ barWidth = initPositions.barWidth
+ xDivision = initPositions.xDivision
+ zeroH = initPositions.zeroH
+
+ // eldatalabels
+ let elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-datalabels',
+ 'data:realIndex': realIndex
+ })
+
+ let elGoalsMarkers = graphics.group({
+ class: 'apexcharts-rangebar-goals-markers',
+ style: `pointer-events: none`
+ })
+
+ for (let j = 0; j < w.globals.dataPoints; j++) {
+ const strokeWidth = this.barHelpers.getStrokeWidth(i, j, realIndex)
+
+ const y1 = this.seriesRangeStart[i][j]
+ const y2 = this.seriesRangeEnd[i][j]
+
+ let paths = null
+ let barYPosition = null
+ const params = { x, y, strokeWidth, elSeries }
+
+ yDivision = initPositions.yDivision
+ barHeight = initPositions.barHeight
+
+ if (this.isHorizontal) {
+ barYPosition = y + barHeight * this.visibleI
+
+ let seriesLen = this.seriesLen
+ if (w.config.plotOptions.bar.rangeBarGroupRows) {
+ seriesLen = 1
+ }
+
+ let srty = (yDivision - barHeight * seriesLen) / 2
+
+ if (typeof w.config.series[i].data[j] === 'undefined') {
+ // no data exists for further indexes, hence we need to get out the innr loop.
+ // As we are iterating over total datapoints, there is a possiblity the series might not have data for j index
+ break
+ }
+
+ if (w.config.series[i].data[j].x) {
+ let positions = this.detectOverlappingBars({
+ i,
+ j,
+ barYPosition,
+ srty,
+ barHeight,
+ yDivision,
+ initPositions
+ })
+
+ barHeight = positions.barHeight
+ barYPosition = positions.barYPosition
+ }
+
+ paths = this.drawRangeBarPaths({
+ indexes: { i, j, realIndex },
+ barHeight,
+ barYPosition,
+ zeroW,
+ yDivision,
+ y1,
+ y2,
+ ...params
+ })
+
+ barWidth = paths.barWidth
+ } else {
+ paths = this.drawRangeColumnPaths({
+ indexes: { i, j, realIndex },
+ zeroH,
+ barWidth,
+ xDivision,
+ ...params
+ })
+
+ barHeight = paths.barHeight
+ }
+
+ const barGoalLine = this.barHelpers.drawGoalLine({
+ barXPosition: paths.barXPosition,
+ barYPosition,
+ goalX: paths.goalX,
+ goalY: paths.goalY,
+ barHeight,
+ barWidth
+ })
+
+ if (barGoalLine) {
+ elGoalsMarkers.add(barGoalLine)
+ }
+
+ y = paths.y
+ x = paths.x
+
+ let pathFill = this.barHelpers.getPathFillColor(series, i, j, realIndex)
+
+ let lineFill = w.globals.stroke.colors[realIndex]
+
+ this.renderSeries({
+ realIndex,
+ pathFill,
+ lineFill,
+ j,
+ i,
+ x,
+ y,
+ y1,
+ y2,
+ pathFrom: paths.pathFrom,
+ pathTo: paths.pathTo,
+ strokeWidth,
+ elSeries,
+ series,
+ barHeight,
+ barYPosition,
+ barWidth,
+ elDataLabelsWrap,
+ elGoalsMarkers,
+ visibleSeries: this.visibleI,
+ type: 'rangebar'
+ })
+ }
+
+ ret.add(elSeries)
+ }
+
+ return ret
+ }
+
+ detectOverlappingBars({
+ i,
+ j,
+ barYPosition,
+ srty,
+ barHeight,
+ yDivision,
+ initPositions
+ }) {
+ const w = this.w
+ let overlaps = []
+ let rangeName = w.config.series[i].data[j].rangeName
+
+ const labelX = w.config.series[i].data[j].x
+ const rowIndex = w.globals.labels.indexOf(labelX)
+ const overlappedIndex = w.globals.seriesRangeBar[i].findIndex(
+ (tx) => tx.x === labelX && tx.overlaps.length > 0
+ )
+
+ if (w.config.plotOptions.bar.rangeBarGroupRows) {
+ barYPosition = srty + yDivision * rowIndex
+ } else {
+ barYPosition = srty + barHeight * this.visibleI + yDivision * rowIndex
+ }
+
+ if (overlappedIndex > -1 && !w.config.plotOptions.bar.rangeBarOverlap) {
+ overlaps = w.globals.seriesRangeBar[i][overlappedIndex].overlaps
+
+ if (overlaps.indexOf(rangeName) > -1) {
+ barHeight = initPositions.barHeight / overlaps.length
+
+ barYPosition =
+ barHeight * this.visibleI +
+ (yDivision * (100 - parseInt(this.barOptions.barHeight, 10))) /
+ 100 /
+ 2 +
+ barHeight * (this.visibleI + overlaps.indexOf(rangeName)) +
+ yDivision * rowIndex
+ }
+ }
+
+ return {
+ barYPosition,
+ barHeight
+ }
+ }
+
+ drawRangeColumnPaths({
+ indexes,
+ x,
+ strokeWidth,
+ xDivision,
+ barWidth,
+ zeroH
+ }) {
+ let w = this.w
+
+ let i = indexes.i
+ let j = indexes.j
+
+ const yRatio = this.yRatio[this.yaxisIndex]
+ let realIndex = indexes.realIndex
+
+ const range = this.getRangeValue(realIndex, j)
+
+ let y1 = Math.min(range.start, range.end)
+ let y2 = Math.max(range.start, range.end)
+
+ if (w.globals.isXNumeric) {
+ x =
+ (w.globals.seriesX[i][j] - w.globals.minX) / this.xRatio - barWidth / 2
+ }
+
+ let barXPosition = x + barWidth * this.visibleI
+
+ if (
+ typeof this.series[i][j] === 'undefined' ||
+ this.series[i][j] === null
+ ) {
+ y1 = zeroH
+ } else {
+ y1 = zeroH - y1 / yRatio
+ y2 = zeroH - y2 / yRatio
+ }
+ const barHeight = Math.abs(y2 - y1)
+
+ const paths = this.barHelpers.getColumnPaths({
+ barXPosition,
+ barWidth,
+ y1,
+ y2,
+ strokeWidth: this.strokeWidth,
+ series: this.seriesRangeEnd,
+ realIndex: indexes.realIndex,
+ i: realIndex,
+ j,
+ w
+ })
+
+ if (!w.globals.isXNumeric) {
+ x = x + xDivision
+ }
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ barHeight,
+ x,
+ y: y2,
+ goalY: this.barHelpers.getGoalValues('y', null, zeroH, i, j),
+ barXPosition
+ }
+ }
+
+ drawRangeBarPaths({
+ indexes,
+ y,
+ y1,
+ y2,
+ yDivision,
+ barHeight,
+ barYPosition,
+ zeroW
+ }) {
+ let w = this.w
+
+ const x1 = zeroW + y1 / this.invertedYRatio
+ const x2 = zeroW + y2 / this.invertedYRatio
+
+ const barWidth = Math.abs(x2 - x1)
+
+ const paths = this.barHelpers.getBarpaths({
+ barYPosition,
+ barHeight,
+ x1,
+ x2,
+ strokeWidth: this.strokeWidth,
+ series: this.seriesRangeEnd,
+ i: indexes.realIndex,
+ realIndex: indexes.realIndex,
+ j: indexes.j,
+ w
+ })
+
+ if (!w.globals.isXNumeric) {
+ y = y + yDivision
+ }
+
+ return {
+ pathTo: paths.pathTo,
+ pathFrom: paths.pathFrom,
+ barWidth,
+ x: x2,
+ goalX: this.barHelpers.getGoalValues(
+ 'x',
+ zeroW,
+ null,
+ indexes.realIndex,
+ indexes.j
+ ),
+ y
+ }
+ }
+
+ getRangeValue(i, j) {
+ const w = this.w
+ return {
+ start: w.globals.seriesRangeStart[i][j],
+ end: w.globals.seriesRangeEnd[i][j]
+ }
+ }
+
+ getTooltipValues({ ctx, seriesIndex, dataPointIndex, y1, y2, w }) {
+ let start = w.globals.seriesRangeStart[seriesIndex][dataPointIndex]
+ let end = w.globals.seriesRangeEnd[seriesIndex][dataPointIndex]
+ let ylabel = w.globals.labels[dataPointIndex]
+ let seriesName = w.config.series[seriesIndex].name
+ ? w.config.series[seriesIndex].name
+ : ''
+ const yLbFormatter = w.config.tooltip.y.formatter
+ const yLbTitleFormatter = w.config.tooltip.y.title.formatter
+
+ const opts = {
+ w,
+ seriesIndex,
+ dataPointIndex,
+ start,
+ end
+ }
+
+ if (typeof yLbTitleFormatter === 'function') {
+ seriesName = yLbTitleFormatter(seriesName, opts)
+ }
+
+ if (Number.isFinite(y1) && Number.isFinite(y2)) {
+ start = y1
+ end = y2
+
+ if (w.config.series[seriesIndex].data[dataPointIndex].x) {
+ ylabel = w.config.series[seriesIndex].data[dataPointIndex].x + ':'
+ }
+
+ if (typeof yLbFormatter === 'function') {
+ ylabel = yLbFormatter(ylabel, opts)
+ }
+ }
+
+ let startVal = ''
+ let endVal = ''
+
+ const color = w.globals.colors[seriesIndex]
+ if (w.config.tooltip.x.formatter === undefined) {
+ if (w.config.xaxis.type === 'datetime') {
+ let datetimeObj = new DateTime(ctx)
+ startVal = datetimeObj.formatDate(
+ datetimeObj.getDate(start),
+ w.config.tooltip.x.format
+ )
+ endVal = datetimeObj.formatDate(
+ datetimeObj.getDate(end),
+ w.config.tooltip.x.format
+ )
+ } else {
+ startVal = start
+ endVal = end
+ }
+ } else {
+ startVal = w.config.tooltip.x.formatter(start)
+ endVal = w.config.tooltip.x.formatter(end)
+ }
+
+ return { start, end, startVal, endVal, ylabel, color, seriesName }
+ }
+
+ buildCustomTooltipHTML({ color, seriesName, ylabel, start, end }) {
+ return (
+ '
'
+ )
+ }
+}
+
+export default RangeBar
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Scatter.js b/cao_sunyata/static/libs/apexcharts/src/charts/Scatter.js
new file mode 100644
index 0000000..9171da2
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Scatter.js
@@ -0,0 +1,267 @@
+import Animations from '../modules/Animations'
+import Fill from '../modules/Fill'
+import Filters from '../modules/Filters'
+import Graphics from '../modules/Graphics'
+import Markers from '../modules/Markers'
+
+/**
+ * ApexCharts Scatter Class.
+ * This Class also handles bubbles chart as currently there is no major difference in drawing them,
+ * @module Scatter
+ **/
+export default class Scatter {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.initialAnim = this.w.config.chart.animations.enabled
+ this.dynamicAnim =
+ this.initialAnim &&
+ this.w.config.chart.animations.dynamicAnimation.enabled
+ }
+
+ draw(elSeries, j, opts) {
+ let w = this.w
+
+ let graphics = new Graphics(this.ctx)
+
+ let realIndex = opts.realIndex
+ let pointsPos = opts.pointsPos
+ let zRatio = opts.zRatio
+ let elPointsMain = opts.elParent
+
+ let elPointsWrap = graphics.group({
+ class: `apexcharts-series-markers apexcharts-series-${w.config.chart.type}`
+ })
+
+ elPointsWrap.attr('clip-path', `url(#gridRectMarkerMask${w.globals.cuid})`)
+
+ if (Array.isArray(pointsPos.x)) {
+ for (let q = 0; q < pointsPos.x.length; q++) {
+ let dataPointIndex = j + 1
+ let shouldDraw = true
+
+ // a small hack as we have 2 points for the first val to connect it
+ if (j === 0 && q === 0) dataPointIndex = 0
+ if (j === 0 && q === 1) dataPointIndex = 1
+
+ let radius = 0
+ let finishRadius = w.globals.markers.size[realIndex]
+
+ if (zRatio !== Infinity) {
+ // means we have a bubble
+ finishRadius = w.globals.seriesZ[realIndex][dataPointIndex] / zRatio
+
+ const bubble = w.config.plotOptions.bubble
+ if (bubble.minBubbleRadius && finishRadius < bubble.minBubbleRadius) {
+ finishRadius = bubble.minBubbleRadius
+ }
+
+ if (bubble.maxBubbleRadius && finishRadius > bubble.maxBubbleRadius) {
+ finishRadius = bubble.maxBubbleRadius
+ }
+ }
+
+ if (!w.config.chart.animations.enabled) {
+ radius = finishRadius
+ }
+
+ let x = pointsPos.x[q]
+ let y = pointsPos.y[q]
+
+ radius = radius || 0
+
+ if (
+ y === null ||
+ typeof w.globals.series[realIndex][dataPointIndex] === 'undefined'
+ ) {
+ shouldDraw = false
+ }
+
+ if (shouldDraw) {
+ const point = this.drawPoint(
+ x,
+ y,
+ radius,
+ finishRadius,
+ realIndex,
+ dataPointIndex,
+ j
+ )
+ elPointsWrap.add(point)
+ }
+
+ elPointsMain.add(elPointsWrap)
+ }
+ }
+ }
+
+ drawPoint(x, y, radius, finishRadius, realIndex, dataPointIndex, j) {
+ const w = this.w
+
+ let i = realIndex
+ let anim = new Animations(this.ctx)
+ let filters = new Filters(this.ctx)
+ let fill = new Fill(this.ctx)
+ let markers = new Markers(this.ctx)
+ const graphics = new Graphics(this.ctx)
+
+ const markerConfig = markers.getMarkerConfig({
+ cssClass: 'apexcharts-marker',
+ seriesIndex: i,
+ dataPointIndex,
+ finishRadius:
+ w.config.chart.type === 'bubble' ||
+ (w.globals.comboCharts &&
+ w.config.series[realIndex] &&
+ w.config.series[realIndex].type === 'bubble')
+ ? finishRadius
+ : null
+ })
+
+ finishRadius = markerConfig.pSize
+
+ let pathFillCircle = fill.fillPath({
+ seriesNumber: realIndex,
+ dataPointIndex,
+ color: markerConfig.pointFillColor,
+ patternUnits: 'objectBoundingBox',
+ value: w.globals.series[realIndex][j]
+ })
+
+ let el
+ if (markerConfig.shape === 'circle') {
+ el = graphics.drawCircle(radius)
+ } else if (
+ markerConfig.shape === 'square' ||
+ markerConfig.shape === 'rect'
+ ) {
+ el = graphics.drawRect(
+ 0,
+ 0,
+ markerConfig.width - markerConfig.pointStrokeWidth / 2,
+ markerConfig.height - markerConfig.pointStrokeWidth / 2,
+ markerConfig.pRadius
+ )
+ }
+
+ if (w.config.series[i].data[dataPointIndex]) {
+ if (w.config.series[i].data[dataPointIndex].fillColor) {
+ pathFillCircle = w.config.series[i].data[dataPointIndex].fillColor
+ }
+ }
+
+ el.attr({
+ x: x - markerConfig.width / 2 - markerConfig.pointStrokeWidth / 2,
+ y: y - markerConfig.height / 2 - markerConfig.pointStrokeWidth / 2,
+ cx: x,
+ cy: y,
+ fill: pathFillCircle,
+ 'fill-opacity': markerConfig.pointFillOpacity,
+ stroke: markerConfig.pointStrokeColor,
+ r: finishRadius,
+ 'stroke-width': markerConfig.pointStrokeWidth,
+ 'stroke-dasharray': markerConfig.pointStrokeDashArray,
+ 'stroke-opacity': markerConfig.pointStrokeOpacity
+ })
+
+ if (w.config.chart.dropShadow.enabled) {
+ const dropShadow = w.config.chart.dropShadow
+ filters.dropShadow(el, dropShadow, realIndex)
+ }
+
+ if (this.initialAnim && !w.globals.dataChanged && !w.globals.resized) {
+ let speed = w.config.chart.animations.speed
+
+ anim.animateMarker(
+ el,
+ 0,
+ markerConfig.shape === 'circle'
+ ? finishRadius
+ : { width: markerConfig.width, height: markerConfig.height },
+ speed,
+ w.globals.easing,
+ () => {
+ window.setTimeout(() => {
+ anim.animationCompleted(el)
+ }, 100)
+ }
+ )
+ } else {
+ w.globals.animationEnded = true
+ }
+
+ if (w.globals.dataChanged && markerConfig.shape === 'circle') {
+ if (this.dynamicAnim) {
+ let speed = w.config.chart.animations.dynamicAnimation.speed
+ let prevX, prevY, prevR
+
+ let prevPathJ = null
+
+ prevPathJ =
+ w.globals.previousPaths[realIndex] &&
+ w.globals.previousPaths[realIndex][j]
+
+ if (typeof prevPathJ !== 'undefined' && prevPathJ !== null) {
+ // series containing less elements will ignore these values and revert to 0
+ prevX = prevPathJ.x
+ prevY = prevPathJ.y
+ prevR =
+ typeof prevPathJ.r !== 'undefined' ? prevPathJ.r : finishRadius
+ }
+
+ for (let cs = 0; cs < w.globals.collapsedSeries.length; cs++) {
+ if (w.globals.collapsedSeries[cs].index === realIndex) {
+ speed = 1
+ finishRadius = 0
+ }
+ }
+
+ if (x === 0 && y === 0) finishRadius = 0
+
+ anim.animateCircle(
+ el,
+ {
+ cx: prevX,
+ cy: prevY,
+ r: prevR
+ },
+ {
+ cx: x,
+ cy: y,
+ r: finishRadius
+ },
+ speed,
+ w.globals.easing
+ )
+ } else {
+ el.attr({
+ r: finishRadius
+ })
+ }
+ }
+
+ el.attr({
+ rel: dataPointIndex,
+ j: dataPointIndex,
+ index: realIndex,
+ 'default-marker-size': finishRadius
+ })
+
+ filters.setSelectionFilter(el, realIndex, dataPointIndex)
+ markers.addEvents(el)
+
+ el.node.classList.add('apexcharts-marker')
+
+ return el
+ }
+
+ centerTextInBubble(y) {
+ let w = this.w
+ y = y + parseInt(w.config.dataLabels.style.fontSize, 10) / 4
+
+ return {
+ y
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/Treemap.js b/cao_sunyata/static/libs/apexcharts/src/charts/Treemap.js
new file mode 100644
index 0000000..dede195
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/Treemap.js
@@ -0,0 +1,302 @@
+import '../libs/Treemap-squared'
+import Graphics from '../modules/Graphics'
+import Animations from '../modules/Animations'
+import Fill from '../modules/Fill'
+import Helpers from './common/treemap/Helpers'
+import Filters from '../modules/Filters'
+
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts TreemapChart Class.
+ * @module TreemapChart
+ **/
+
+export default class TreemapChart {
+ constructor(ctx, xyRatios) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.strokeWidth = this.w.config.stroke.width
+ this.helpers = new Helpers(ctx)
+ this.dynamicAnim = this.w.config.chart.animations.dynamicAnimation
+
+ this.labels = []
+ }
+
+ draw(series) {
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+ const fill = new Fill(this.ctx)
+
+ let ret = graphics.group({
+ class: 'apexcharts-treemap'
+ })
+
+ if (w.globals.noData) return ret
+
+ let ser = []
+ series.forEach((s) => {
+ let d = s.map((v) => {
+ return Math.abs(v)
+ })
+ ser.push(d)
+ })
+
+ this.negRange = this.helpers.checkColorRange()
+
+ w.config.series.forEach((s, i) => {
+ s.data.forEach((l) => {
+ if (!Array.isArray(this.labels[i])) this.labels[i] = []
+ this.labels[i].push(l.x)
+ })
+ })
+
+ const nodes = window.TreemapSquared.generate(
+ ser,
+ w.globals.gridWidth,
+ w.globals.gridHeight
+ )
+
+ nodes.forEach((node, i) => {
+ let elSeries = graphics.group({
+ class: `apexcharts-series apexcharts-treemap-series`,
+ seriesName: Utils.escapeString(w.globals.seriesNames[i]),
+ rel: i + 1,
+ 'data:realIndex': i
+ })
+
+ if (w.config.chart.dropShadow.enabled) {
+ const shadow = w.config.chart.dropShadow
+ const filters = new Filters(this.ctx)
+ filters.dropShadow(ret, shadow, i)
+ }
+
+ let elDataLabelWrap = graphics.group({
+ class: 'apexcharts-data-labels'
+ })
+
+ node.forEach((r, j) => {
+ const x1 = r[0]
+ const y1 = r[1]
+ const x2 = r[2]
+ const y2 = r[3]
+ let elRect = graphics.drawRect(
+ x1,
+ y1,
+ x2 - x1,
+ y2 - y1,
+ 0,
+ '#fff',
+ 1,
+ this.strokeWidth,
+ w.config.plotOptions.treemap.useFillColorAsStroke
+ ? color
+ : w.globals.stroke.colors[i]
+ )
+ elRect.attr({
+ cx: x1,
+ cy: y1,
+ index: i,
+ i,
+ j,
+ width: x2 - x1,
+ height: y2 - y1
+ })
+
+ let colorProps = this.helpers.getShadeColor(
+ w.config.chart.type,
+ i,
+ j,
+ this.negRange
+ )
+ let color = colorProps.color
+
+ if (
+ typeof w.config.series[i].data[j] !== 'undefined' &&
+ w.config.series[i].data[j].fillColor
+ ) {
+ color = w.config.series[i].data[j].fillColor
+ }
+ let pathFill = fill.fillPath({
+ color,
+ seriesNumber: i,
+ dataPointIndex: j
+ })
+
+ elRect.node.classList.add('apexcharts-treemap-rect')
+
+ elRect.attr({
+ fill: pathFill
+ })
+
+ this.helpers.addListeners(elRect)
+
+ let fromRect = {
+ x: x1 + (x2 - x1) / 2,
+ y: y1 + (y2 - y1) / 2,
+ width: 0,
+ height: 0
+ }
+ let toRect = {
+ x: x1,
+ y: y1,
+ width: x2 - x1,
+ height: y2 - y1
+ }
+
+ if (w.config.chart.animations.enabled && !w.globals.dataChanged) {
+ let speed = 1
+ if (!w.globals.resized) {
+ speed = w.config.chart.animations.speed
+ }
+ this.animateTreemap(elRect, fromRect, toRect, speed)
+ }
+ if (w.globals.dataChanged) {
+ let speed = 1
+ if (this.dynamicAnim.enabled && w.globals.shouldAnimate) {
+ speed = this.dynamicAnim.speed
+
+ if (
+ w.globals.previousPaths[i] &&
+ w.globals.previousPaths[i][j] &&
+ w.globals.previousPaths[i][j].rect
+ ) {
+ fromRect = w.globals.previousPaths[i][j].rect
+ }
+
+ this.animateTreemap(elRect, fromRect, toRect, speed)
+ }
+ }
+
+ const fontSize = this.getFontSize(r)
+
+ let formattedText = w.config.dataLabels.formatter(this.labels[i][j], {
+ value: w.globals.series[i][j],
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ let dataLabels = this.helpers.calculateDataLabels({
+ text: formattedText,
+ x: (x1 + x2) / 2,
+ y: (y1 + y2) / 2 + this.strokeWidth / 2 + fontSize / 3,
+ i,
+ j,
+ colorProps,
+ fontSize,
+ series
+ })
+ if (w.config.dataLabels.enabled && dataLabels) {
+ this.rotateToFitLabel(dataLabels, formattedText, x1, y1, x2, y2)
+ }
+ elSeries.add(elRect)
+
+ if (dataLabels !== null) {
+ elSeries.add(dataLabels)
+ }
+ })
+ elSeries.add(elDataLabelWrap)
+
+ ret.add(elSeries)
+ })
+
+ return ret
+ }
+
+ // This calculates a font-size based upon
+ // average label length and the size of the box the label is
+ // going into. The maximum font size is set in chart config.
+ getFontSize(coordinates) {
+ const w = this.w
+
+ // total length of labels (i.e [["Italy"],["Spain", "Greece"]] -> 16)
+ function totalLabelLength(arr) {
+ let i,
+ total = 0
+ if (Array.isArray(arr[0])) {
+ for (i = 0; i < arr.length; i++) {
+ total += totalLabelLength(arr[i])
+ }
+ } else {
+ for (i = 0; i < arr.length; i++) {
+ total += arr[i].length
+ }
+ }
+ return total
+ }
+
+ // count of labels (i.e [["Italy"],["Spain", "Greece"]] -> 3)
+ function countLabels(arr) {
+ let i,
+ total = 0
+ if (Array.isArray(arr[0])) {
+ for (i = 0; i < arr.length; i++) {
+ total += countLabels(arr[i])
+ }
+ } else {
+ for (i = 0; i < arr.length; i++) {
+ total += 1
+ }
+ }
+ return total
+ }
+ let averagelabelsize =
+ totalLabelLength(this.labels) / countLabels(this.labels)
+
+ function fontSize(width, height) {
+ // the font size should be proportional to the size of the box (and the value)
+ // otherwise you can end up creating a visual distortion where two boxes of identical
+ // size have different sized labels, and thus make it look as if the two boxes
+ // represent different sizes
+ let area = width * height
+ let arearoot = Math.pow(area, 0.5)
+ return Math.min(
+ arearoot / averagelabelsize,
+ parseInt(w.config.dataLabels.style.fontSize, 10)
+ )
+ }
+
+ return fontSize(
+ coordinates[2] - coordinates[0],
+ coordinates[3] - coordinates[1]
+ )
+ }
+
+ rotateToFitLabel(elText, text, x1, y1, x2, y2) {
+ const graphics = new Graphics(this.ctx)
+ const textRect = graphics.getTextRects(text)
+ //if the label fits better sideways then rotate it
+ if (textRect.width + 5 > x2 - x1 && textRect.width <= y2 - y1) {
+ let labelRotatingCenter = graphics.rotateAroundCenter(elText.node)
+
+ elText.node.setAttribute(
+ 'transform',
+ `rotate(-90 ${labelRotatingCenter.x} ${labelRotatingCenter.y})`
+ )
+ }
+ }
+
+ animateTreemap(el, fromRect, toRect, speed) {
+ const animations = new Animations(this.ctx)
+ animations.animateRect(
+ el,
+ {
+ x: fromRect.x,
+ y: fromRect.y,
+ width: fromRect.width,
+ height: fromRect.height
+ },
+ {
+ x: toRect.x,
+ y: toRect.y,
+ width: toRect.width,
+ height: toRect.height
+ },
+ speed,
+ () => {
+ animations.animationCompleted(el)
+ }
+ )
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/DataLabels.js b/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/DataLabels.js
new file mode 100644
index 0000000..833245c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/DataLabels.js
@@ -0,0 +1,442 @@
+import Graphics from '../../../modules/Graphics'
+import DataLabels from '../../../modules/DataLabels'
+
+export default class BarDataLabels {
+ constructor(barCtx) {
+ this.w = barCtx.w
+ this.barCtx = barCtx
+ }
+ /** handleBarDataLabels is used to calculate the positions for the data-labels
+ * It also sets the element's data attr for bars and calls drawCalculatedBarDataLabels()
+ * After calculating, it also calls the function to draw data labels
+ * @memberof Bar
+ * @param {object} {barProps} most of the bar properties used throughout the bar
+ * drawing function
+ * @return {object} dataLabels node-element which you can append later
+ **/
+ handleBarDataLabels(opts) {
+ let {
+ x,
+ y,
+ y1,
+ y2,
+ i,
+ j,
+ realIndex,
+ series,
+ barHeight,
+ barWidth,
+ barYPosition,
+ visibleSeries,
+ renderedPath
+ } = opts
+ let w = this.w
+ let graphics = new Graphics(this.barCtx.ctx)
+
+ let strokeWidth = Array.isArray(this.barCtx.strokeWidth)
+ ? this.barCtx.strokeWidth[realIndex]
+ : this.barCtx.strokeWidth
+
+ let bcx = x + parseFloat(barWidth * visibleSeries)
+ let bcy = y + parseFloat(barHeight * visibleSeries)
+
+ if (w.globals.isXNumeric && !w.globals.isBarHorizontal) {
+ bcx = x + parseFloat(barWidth * (visibleSeries + 1))
+ bcy = y + parseFloat(barHeight * (visibleSeries + 1)) - strokeWidth
+ }
+
+ let dataLabels = null
+ let dataLabelsX = x
+ let dataLabelsY = y
+ let dataLabelsPos = {}
+ let dataLabelsConfig = w.config.dataLabels
+ let barDataLabelsConfig = this.barCtx.barOptions.dataLabels
+
+ if (typeof barYPosition !== 'undefined' && this.barCtx.isRangeBar) {
+ bcy = barYPosition
+ dataLabelsY = barYPosition
+ }
+
+ const offX = dataLabelsConfig.offsetX
+ const offY = dataLabelsConfig.offsetY
+
+ let textRects = {
+ width: 0,
+ height: 0
+ }
+ if (w.config.dataLabels.enabled) {
+ const yLabel = this.barCtx.series[i][j]
+
+ textRects = graphics.getTextRects(
+ w.globals.yLabelFormatters[0](yLabel),
+ parseFloat(dataLabelsConfig.style.fontSize)
+ )
+ }
+
+ const params = {
+ x,
+ y,
+ i,
+ j,
+ renderedPath,
+ bcx,
+ bcy,
+ barHeight,
+ barWidth,
+ textRects,
+ strokeWidth,
+ dataLabelsX,
+ dataLabelsY,
+ barDataLabelsConfig,
+ offX,
+ offY
+ }
+
+ if (this.barCtx.isHorizontal) {
+ dataLabelsPos = this.calculateBarsDataLabelsPosition(params)
+ } else {
+ dataLabelsPos = this.calculateColumnsDataLabelsPosition(params)
+ }
+
+ renderedPath.attr({
+ cy: dataLabelsPos.bcy,
+ cx: dataLabelsPos.bcx,
+ j,
+ val: series[i][j],
+ barHeight,
+ barWidth
+ })
+
+ dataLabels = this.drawCalculatedDataLabels({
+ x: dataLabelsPos.dataLabelsX,
+ y: dataLabelsPos.dataLabelsY,
+ val: this.barCtx.isRangeBar ? [y1, y2] : series[i][j],
+ i: realIndex,
+ j,
+ barWidth,
+ barHeight,
+ textRects,
+ dataLabelsConfig
+ })
+
+ return dataLabels
+ }
+
+ calculateColumnsDataLabelsPosition(opts) {
+ const w = this.w
+ let {
+ i,
+ j,
+ y,
+ bcx,
+ barWidth,
+ barHeight,
+ textRects,
+ dataLabelsY,
+ barDataLabelsConfig,
+ strokeWidth,
+ offX,
+ offY
+ } = opts
+
+ let dataLabelsX
+ barHeight = Math.abs(barHeight)
+
+ let vertical =
+ w.config.plotOptions.bar.dataLabels.orientation === 'vertical'
+
+ bcx = bcx - strokeWidth / 2
+
+ let dataPointsDividedWidth = w.globals.gridWidth / w.globals.dataPoints
+ if (w.globals.isXNumeric) {
+ dataLabelsX = bcx - barWidth / 2 + offX
+ } else {
+ dataLabelsX = bcx - dataPointsDividedWidth + barWidth / 2 + offX
+ }
+
+ if (vertical) {
+ const offsetDLX = 2
+ dataLabelsX =
+ dataLabelsX + textRects.height / 2 - strokeWidth / 2 - offsetDLX
+ }
+
+ let valIsNegative = this.barCtx.series[i][j] < 0
+
+ let newY = y
+ if (this.barCtx.isReversed) {
+ newY = y - barHeight + (valIsNegative ? barHeight * 2 : 0)
+ y = y - barHeight
+ }
+
+ switch (barDataLabelsConfig.position) {
+ case 'center':
+ if (vertical) {
+ if (valIsNegative) {
+ dataLabelsY = newY + barHeight / 2 + offY
+ } else {
+ dataLabelsY = newY + barHeight / 2 - offY
+ }
+ } else {
+ if (valIsNegative) {
+ dataLabelsY = newY - barHeight / 2 + textRects.height / 2 + offY
+ } else {
+ dataLabelsY = newY + barHeight / 2 + textRects.height / 2 - offY
+ }
+ }
+ break
+ case 'bottom':
+ if (vertical) {
+ if (valIsNegative) {
+ dataLabelsY = newY + barHeight + offY
+ } else {
+ dataLabelsY = newY + barHeight - offY
+ }
+ } else {
+ if (valIsNegative) {
+ dataLabelsY =
+ newY - barHeight + textRects.height + strokeWidth + offY
+ } else {
+ dataLabelsY =
+ newY + barHeight - textRects.height / 2 + strokeWidth - offY
+ }
+ }
+ break
+ case 'top':
+ if (vertical) {
+ if (valIsNegative) {
+ dataLabelsY = newY + offY
+ } else {
+ dataLabelsY = newY - offY
+ }
+ } else {
+ if (valIsNegative) {
+ dataLabelsY = newY - textRects.height / 2 - offY
+ } else {
+ dataLabelsY = newY + textRects.height + offY
+ }
+ }
+ break
+ }
+
+ if (!w.config.chart.stacked) {
+ if (dataLabelsY < 0) {
+ dataLabelsY = 0 + strokeWidth
+ } else if (dataLabelsY + textRects.height / 3 > w.globals.gridHeight) {
+ dataLabelsY = w.globals.gridHeight - strokeWidth
+ }
+ }
+
+ return {
+ bcx,
+ bcy: y,
+ dataLabelsX,
+ dataLabelsY
+ }
+ }
+
+ calculateBarsDataLabelsPosition(opts) {
+ const w = this.w
+ let {
+ x,
+ i,
+ j,
+ bcy,
+ barHeight,
+ barWidth,
+ textRects,
+ dataLabelsX,
+ strokeWidth,
+ barDataLabelsConfig,
+ offX,
+ offY
+ } = opts
+
+ let dataPointsDividedHeight = w.globals.gridHeight / w.globals.dataPoints
+
+ barWidth = Math.abs(barWidth)
+
+ let dataLabelsY =
+ bcy -
+ (this.barCtx.isRangeBar ? 0 : dataPointsDividedHeight) +
+ barHeight / 2 +
+ textRects.height / 2 +
+ offY -
+ 3
+
+ let valIsNegative = this.barCtx.series[i][j] < 0
+
+ let newX = x
+ if (this.barCtx.isReversed) {
+ newX = x + barWidth - (valIsNegative ? barWidth * 2 : 0)
+ x = w.globals.gridWidth - barWidth
+ }
+
+ switch (barDataLabelsConfig.position) {
+ case 'center':
+ if (valIsNegative) {
+ dataLabelsX = newX + barWidth / 2 - offX
+ } else {
+ dataLabelsX =
+ Math.max(textRects.width / 2, newX - barWidth / 2) + offX
+ }
+ break
+ case 'bottom':
+ if (valIsNegative) {
+ dataLabelsX =
+ newX +
+ barWidth -
+ strokeWidth -
+ Math.round(textRects.width / 2) -
+ offX
+ } else {
+ dataLabelsX =
+ newX -
+ barWidth +
+ strokeWidth +
+ Math.round(textRects.width / 2) +
+ offX
+ }
+ break
+ case 'top':
+ if (valIsNegative) {
+ dataLabelsX =
+ newX - strokeWidth + Math.round(textRects.width / 2) - offX
+ } else {
+ dataLabelsX =
+ newX - strokeWidth - Math.round(textRects.width / 2) + offX
+ }
+ break
+ }
+
+ if (!w.config.chart.stacked) {
+ if (dataLabelsX < 0) {
+ dataLabelsX = dataLabelsX + textRects.width + strokeWidth
+ } else if (dataLabelsX + textRects.width / 2 > w.globals.gridWidth) {
+ dataLabelsX = w.globals.gridWidth - textRects.width - strokeWidth
+ }
+ }
+
+ return {
+ bcx: x,
+ bcy,
+ dataLabelsX,
+ dataLabelsY
+ }
+ }
+
+ drawCalculatedDataLabels({
+ x,
+ y,
+ val,
+ i,
+ j,
+ textRects,
+ barHeight,
+ barWidth,
+ dataLabelsConfig
+ }) {
+ const w = this.w
+ let rotate = 'rotate(0)'
+ if (w.config.plotOptions.bar.dataLabels.orientation === 'vertical')
+ rotate = `rotate(-90, ${x}, ${y})`
+
+ const dataLabels = new DataLabels(this.barCtx.ctx)
+ const graphics = new Graphics(this.barCtx.ctx)
+ const formatter = dataLabelsConfig.formatter
+
+ let elDataLabelsWrap = null
+
+ const isSeriesNotCollapsed =
+ w.globals.collapsedSeriesIndices.indexOf(i) > -1
+
+ if (dataLabelsConfig.enabled && !isSeriesNotCollapsed) {
+ elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-data-labels',
+ transform: rotate
+ })
+
+ let text = ''
+ if (typeof val !== 'undefined') {
+ text = formatter(val, {
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+
+ let valIsNegative = w.globals.series[i][j] < 0
+ let position = w.config.plotOptions.bar.dataLabels.position
+ if (w.config.plotOptions.bar.dataLabels.orientation === 'vertical') {
+ if (position === 'top') {
+ if (valIsNegative) dataLabelsConfig.textAnchor = 'end'
+ else dataLabelsConfig.textAnchor = 'start'
+ }
+ if (position === 'center') {
+ dataLabelsConfig.textAnchor = 'middle'
+ }
+ if (position === 'bottom') {
+ if (valIsNegative) dataLabelsConfig.textAnchor = 'end'
+ else dataLabelsConfig.textAnchor = 'start'
+ }
+ }
+
+ if (
+ this.barCtx.isRangeBar &&
+ this.barCtx.barOptions.dataLabels.hideOverflowingLabels
+ ) {
+ // hide the datalabel if it cannot fit into the rect
+ const txRect = graphics.getTextRects(
+ text,
+ parseFloat(dataLabelsConfig.style.fontSize)
+ )
+ if (barWidth < txRect.width) {
+ text = ''
+ }
+ }
+
+ if (
+ w.config.chart.stacked &&
+ this.barCtx.barOptions.dataLabels.hideOverflowingLabels
+ ) {
+ // if there is not enough space to draw the label in the bar/column rect, check hideOverflowingLabels property to prevent overflowing on wrong rect
+ // Note: This issue is only seen in stacked charts
+ if (this.barCtx.isHorizontal) {
+ if (textRects.width / 1.6 > Math.abs(barWidth)) {
+ text = ''
+ }
+ } else {
+ if (textRects.height / 1.6 > Math.abs(barHeight)) {
+ text = ''
+ }
+ }
+ }
+
+ let modifiedDataLabelsConfig = {
+ ...dataLabelsConfig
+ }
+ if (this.barCtx.isHorizontal) {
+ if (val < 0) {
+ if (dataLabelsConfig.textAnchor === 'start') {
+ modifiedDataLabelsConfig.textAnchor = 'end'
+ } else if (dataLabelsConfig.textAnchor === 'end') {
+ modifiedDataLabelsConfig.textAnchor = 'start'
+ }
+ }
+ }
+
+ dataLabels.plotDataLabelsText({
+ x,
+ y,
+ text,
+ i,
+ j,
+ parent: elDataLabelsWrap,
+ dataLabelsConfig: modifiedDataLabelsConfig,
+ alwaysDrawDataLabel: true,
+ offsetCorrection: true
+ })
+ }
+
+ return elDataLabelsWrap
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/Helpers.js
new file mode 100644
index 0000000..7ab8010
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/common/bar/Helpers.js
@@ -0,0 +1,638 @@
+import Fill from '../../../modules/Fill'
+import Graphics from '../../../modules/Graphics'
+import Series from '../../../modules/Series'
+
+export default class Helpers {
+ constructor(barCtx) {
+ this.w = barCtx.w
+ this.barCtx = barCtx
+ }
+
+ initVariables(series) {
+ const w = this.w
+ this.barCtx.series = series
+ this.barCtx.totalItems = 0
+ this.barCtx.seriesLen = 0
+ this.barCtx.visibleI = -1 // visible Series
+ this.barCtx.visibleItems = 1 // number of visible bars after user zoomed in/out
+
+ for (let sl = 0; sl < series.length; sl++) {
+ if (series[sl].length > 0) {
+ this.barCtx.seriesLen = this.barCtx.seriesLen + 1
+ this.barCtx.totalItems += series[sl].length
+ }
+ if (w.globals.isXNumeric) {
+ // get max visible items
+ for (let j = 0; j < series[sl].length; j++) {
+ if (
+ w.globals.seriesX[sl][j] > w.globals.minX &&
+ w.globals.seriesX[sl][j] < w.globals.maxX
+ ) {
+ this.barCtx.visibleItems++
+ }
+ }
+ } else {
+ this.barCtx.visibleItems = w.globals.dataPoints
+ }
+ }
+
+ if (this.barCtx.seriesLen === 0) {
+ // A small adjustment when combo charts are used
+ this.barCtx.seriesLen = 1
+ }
+ this.barCtx.zeroSerieses = []
+ this.barCtx.radiusOnSeriesNumber = series.length - 1 // which series to draw ending shape on
+
+ if (!w.globals.comboCharts) {
+ this.checkZeroSeries({ series })
+ }
+ }
+
+ initialPositions() {
+ let w = this.w
+ let x, y, yDivision, xDivision, barHeight, barWidth, zeroH, zeroW
+
+ let dataPoints = w.globals.dataPoints
+ if (this.barCtx.isRangeBar) {
+ // timeline rangebar chart
+ dataPoints = w.globals.labels.length
+ }
+
+ let seriesLen = this.barCtx.seriesLen
+ if (w.config.plotOptions.bar.rangeBarGroupRows) {
+ seriesLen = 1
+ }
+
+ if (this.barCtx.isHorizontal) {
+ // height divided into equal parts
+ yDivision = w.globals.gridHeight / dataPoints
+ barHeight = yDivision / seriesLen
+
+ if (w.globals.isXNumeric) {
+ yDivision = w.globals.gridHeight / this.barCtx.totalItems
+ barHeight = yDivision / this.barCtx.seriesLen
+ }
+
+ barHeight =
+ (barHeight * parseInt(this.barCtx.barOptions.barHeight, 10)) / 100
+
+ zeroW =
+ this.barCtx.baseLineInvertedY +
+ w.globals.padHorizontal +
+ (this.barCtx.isReversed ? w.globals.gridWidth : 0) -
+ (this.barCtx.isReversed ? this.barCtx.baseLineInvertedY * 2 : 0)
+
+ y = (yDivision - barHeight * this.barCtx.seriesLen) / 2
+ } else {
+ // width divided into equal parts
+ xDivision = w.globals.gridWidth / this.barCtx.visibleItems
+ if (w.config.xaxis.convertedCatToNumeric) {
+ xDivision = w.globals.gridWidth / w.globals.dataPoints
+ }
+ barWidth =
+ ((xDivision / this.barCtx.seriesLen) *
+ parseInt(this.barCtx.barOptions.columnWidth, 10)) /
+ 100
+
+ if (w.globals.isXNumeric) {
+ // max barwidth should be equal to minXDiff to avoid overlap
+ let xRatio = this.barCtx.xRatio
+ if (w.config.xaxis.convertedCatToNumeric) {
+ xRatio = this.barCtx.initialXRatio
+ }
+ if (
+ w.globals.minXDiff &&
+ w.globals.minXDiff !== 0.5 &&
+ w.globals.minXDiff / xRatio > 0
+ ) {
+ xDivision = w.globals.minXDiff / xRatio
+ }
+
+ barWidth =
+ ((xDivision / this.barCtx.seriesLen) *
+ parseInt(this.barCtx.barOptions.columnWidth, 10)) /
+ 100
+
+ if (barWidth < 1) {
+ barWidth = 1
+ }
+ }
+
+ zeroH =
+ w.globals.gridHeight -
+ this.barCtx.baseLineY[this.barCtx.yaxisIndex] -
+ (this.barCtx.isReversed ? w.globals.gridHeight : 0) +
+ (this.barCtx.isReversed
+ ? this.barCtx.baseLineY[this.barCtx.yaxisIndex] * 2
+ : 0)
+
+ x =
+ w.globals.padHorizontal +
+ (xDivision - barWidth * this.barCtx.seriesLen) / 2
+ }
+
+ return {
+ x,
+ y,
+ yDivision,
+ xDivision,
+ barHeight,
+ barWidth,
+ zeroH,
+ zeroW
+ }
+ }
+
+ getPathFillColor(series, i, j, realIndex) {
+ const w = this.w
+ let fill = new Fill(this.barCtx.ctx)
+
+ let fillColor = null
+ let seriesNumber = this.barCtx.barOptions.distributed ? j : i
+
+ if (this.barCtx.barOptions.colors.ranges.length > 0) {
+ const colorRange = this.barCtx.barOptions.colors.ranges
+ colorRange.map((range) => {
+ if (series[i][j] >= range.from && series[i][j] <= range.to) {
+ fillColor = range.color
+ }
+ })
+ }
+
+ if (w.config.series[i].data[j] && w.config.series[i].data[j].fillColor) {
+ fillColor = w.config.series[i].data[j].fillColor
+ }
+
+ let pathFill = fill.fillPath({
+ seriesNumber: this.barCtx.barOptions.distributed
+ ? seriesNumber
+ : realIndex,
+ dataPointIndex: j,
+ color: fillColor,
+ value: series[i][j]
+ })
+
+ return pathFill
+ }
+
+ getStrokeWidth(i, j, realIndex) {
+ let strokeWidth = 0
+ const w = this.w
+
+ if (
+ typeof this.barCtx.series[i][j] === 'undefined' ||
+ this.barCtx.series[i][j] === null
+ ) {
+ this.barCtx.isNullValue = true
+ } else {
+ this.barCtx.isNullValue = false
+ }
+ if (w.config.stroke.show) {
+ if (!this.barCtx.isNullValue) {
+ strokeWidth = Array.isArray(this.barCtx.strokeWidth)
+ ? this.barCtx.strokeWidth[realIndex]
+ : this.barCtx.strokeWidth
+ }
+ }
+ return strokeWidth
+ }
+
+ barBackground({ j, i, x1, x2, y1, y2, elSeries }) {
+ const w = this.w
+ const graphics = new Graphics(this.barCtx.ctx)
+
+ const sr = new Series(this.barCtx.ctx)
+ let activeSeriesIndex = sr.getActiveConfigSeriesIndex()
+
+ if (
+ this.barCtx.barOptions.colors.backgroundBarColors.length > 0 &&
+ activeSeriesIndex === i
+ ) {
+ if (j >= this.barCtx.barOptions.colors.backgroundBarColors.length) {
+ j %= this.barCtx.barOptions.colors.backgroundBarColors.length
+ }
+
+ let bcolor = this.barCtx.barOptions.colors.backgroundBarColors[j]
+ let rect = graphics.drawRect(
+ typeof x1 !== 'undefined' ? x1 : 0,
+ typeof y1 !== 'undefined' ? y1 : 0,
+ typeof x2 !== 'undefined' ? x2 : w.globals.gridWidth,
+ typeof y2 !== 'undefined' ? y2 : w.globals.gridHeight,
+ this.barCtx.barOptions.colors.backgroundBarRadius,
+ bcolor,
+ this.barCtx.barOptions.colors.backgroundBarOpacity
+ )
+ elSeries.add(rect)
+ rect.node.classList.add('apexcharts-backgroundBar')
+ }
+ }
+
+ getColumnPaths({
+ barWidth,
+ barXPosition,
+ yRatio,
+ y1,
+ y2,
+ strokeWidth,
+ series,
+ realIndex,
+ i,
+ j,
+ w
+ }) {
+ const graphics = new Graphics(this.barCtx.ctx)
+ strokeWidth = Array.isArray(strokeWidth)
+ ? strokeWidth[realIndex]
+ : strokeWidth
+ if (!strokeWidth) strokeWidth = 0
+
+ let shapeOpts = {
+ barWidth,
+ strokeWidth,
+ yRatio,
+ barXPosition,
+ y1,
+ y2
+ }
+ let newPath = this.getRoundedBars(w, shapeOpts, series, i, j)
+
+ const x1 = barXPosition
+ const x2 = barXPosition + barWidth
+
+ let pathTo = graphics.move(x1, y1)
+ let pathFrom = graphics.move(x1, y1)
+
+ const sl = graphics.line(x2 - strokeWidth, y1)
+ if (w.globals.previousPaths.length > 0) {
+ pathFrom = this.barCtx.getPreviousPath(realIndex, j, false)
+ }
+
+ pathTo =
+ pathTo +
+ graphics.line(x1, newPath.y2) +
+ newPath.pathWithRadius +
+ graphics.line(x2 - strokeWidth, newPath.y2) +
+ sl +
+ sl +
+ 'z'
+
+ // the lines in pathFrom are repeated to equal it to the points of pathTo
+ // this is to avoid weird animation (bug in svg.js)
+ pathFrom =
+ pathFrom +
+ graphics.line(x1, y1) +
+ sl +
+ sl +
+ sl +
+ sl +
+ sl +
+ graphics.line(x1, y1)
+
+ if (w.config.chart.stacked) {
+ this.barCtx.yArrj.push(newPath.y2)
+ this.barCtx.yArrjF.push(Math.abs(y1 - newPath.y2))
+ this.barCtx.yArrjVal.push(this.barCtx.series[i][j])
+ }
+
+ return {
+ pathTo,
+ pathFrom
+ }
+ }
+
+ getBarpaths({
+ barYPosition,
+ barHeight,
+ x1,
+ x2,
+ strokeWidth,
+ series,
+ realIndex,
+ i,
+ j,
+ w
+ }) {
+ const graphics = new Graphics(this.barCtx.ctx)
+ strokeWidth = Array.isArray(strokeWidth)
+ ? strokeWidth[realIndex]
+ : strokeWidth
+ if (!strokeWidth) strokeWidth = 0
+
+ let shapeOpts = {
+ barHeight,
+ strokeWidth,
+ barYPosition,
+ x2,
+ x1
+ }
+
+ let newPath = this.getRoundedBars(w, shapeOpts, series, i, j)
+
+ let pathTo = graphics.move(x1, barYPosition)
+ let pathFrom = graphics.move(x1, barYPosition)
+
+ if (w.globals.previousPaths.length > 0) {
+ pathFrom = this.barCtx.getPreviousPath(realIndex, j, false)
+ }
+
+ const y1 = barYPosition
+ const y2 = barYPosition + barHeight
+
+ const sl = graphics.line(x1, y2 - strokeWidth)
+ pathTo =
+ pathTo +
+ graphics.line(newPath.x2, y1) +
+ newPath.pathWithRadius +
+ graphics.line(newPath.x2, y2 - strokeWidth) +
+ sl +
+ sl +
+ 'z'
+
+ pathFrom =
+ pathFrom +
+ graphics.line(x1, y1) +
+ sl +
+ sl +
+ sl +
+ sl +
+ sl +
+ graphics.line(x1, y1)
+
+ if (w.config.chart.stacked) {
+ this.barCtx.xArrj.push(newPath.x2)
+ this.barCtx.xArrjF.push(Math.abs(x1 - newPath.x2))
+ this.barCtx.xArrjVal.push(this.barCtx.series[i][j])
+ }
+ return {
+ pathTo,
+ pathFrom
+ }
+ }
+
+ /** getRoundedBars draws border radius for bars/columns
+ * @memberof Bar
+ * @param {object} w - chart context
+ * @param {object} opts - consists several properties like barHeight/barWidth
+ * @param {array} series - global primary series
+ * @param {int} i - current iterating series's index
+ * @param {int} j - series's j of i
+ * @return {object} pathWithRadius - ending shape path string
+ * newY/newX - which is calculated from existing x/y based on rounded border
+ **/
+ getRoundedBars(w, opts, series, i, j) {
+ let graphics = new Graphics(this.barCtx.ctx)
+ let radius = 0
+
+ const borderRadius = w.config.plotOptions.bar.borderRadius
+ const borderRadiusIsArray = Array.isArray(borderRadius)
+ if (borderRadiusIsArray) {
+ const radiusIndex =
+ i > borderRadius.length - 1 ? borderRadius.length - 1 : i
+ radius = borderRadius[radiusIndex]
+ } else {
+ radius = borderRadius
+ }
+
+ if (
+ w.config.chart.stacked &&
+ series.length > 1 &&
+ i !== this.barCtx.radiusOnSeriesNumber &&
+ !borderRadiusIsArray
+ ) {
+ radius = 0
+ }
+
+ if (this.barCtx.isHorizontal) {
+ let pathWithRadius = ''
+ let x2 = opts.x2
+
+ if (Math.abs(opts.x1 - opts.x2) < radius) {
+ radius = Math.abs(opts.x1 - opts.x2)
+ }
+
+ if (typeof series[i][j] !== 'undefined' || series[i][j] !== null) {
+ let inverse = this.barCtx.isReversed
+ ? series[i][j] > 0
+ : series[i][j] < 0
+
+ if (inverse) radius = radius * -1
+
+ x2 = x2 - radius
+
+ pathWithRadius =
+ graphics.quadraticCurve(
+ x2 + radius,
+ opts.barYPosition,
+ x2 + radius,
+ opts.barYPosition + (!inverse ? radius : radius * -1)
+ ) +
+ graphics.line(
+ x2 + radius,
+ opts.barYPosition +
+ opts.barHeight -
+ opts.strokeWidth -
+ (!inverse ? radius : radius * -1)
+ ) +
+ graphics.quadraticCurve(
+ x2 + radius,
+ opts.barYPosition + opts.barHeight - opts.strokeWidth,
+ x2,
+ opts.barYPosition + opts.barHeight - opts.strokeWidth
+ )
+ }
+
+ return {
+ pathWithRadius,
+ x2
+ }
+ } else {
+ let pathWithRadius = ''
+ let y2 = opts.y2
+
+ if (Math.abs(opts.y1 - opts.y2) < radius) {
+ radius = Math.abs(opts.y1 - opts.y2)
+ }
+
+ if (typeof series[i][j] !== 'undefined' || series[i][j] !== null) {
+ let inverse = series[i][j] < 0
+
+ if (inverse) radius = radius * -1
+
+ y2 = y2 + radius
+
+ pathWithRadius =
+ graphics.quadraticCurve(
+ opts.barXPosition,
+ y2 - radius,
+ opts.barXPosition + (!inverse ? radius : radius * -1),
+ y2 - radius
+ ) +
+ graphics.line(
+ opts.barXPosition +
+ opts.barWidth -
+ opts.strokeWidth -
+ (!inverse ? radius : radius * -1),
+ y2 - radius
+ ) +
+ graphics.quadraticCurve(
+ opts.barXPosition + opts.barWidth - opts.strokeWidth,
+ y2 - radius,
+ opts.barXPosition + opts.barWidth - opts.strokeWidth,
+ y2
+ )
+ }
+
+ return {
+ pathWithRadius,
+ y2
+ }
+ }
+ }
+
+ checkZeroSeries({ series }) {
+ let w = this.w
+ for (let zs = 0; zs < series.length; zs++) {
+ let total = 0
+ for (
+ let zsj = 0;
+ zsj < series[w.globals.maxValsInArrayIndex].length;
+ zsj++
+ ) {
+ total += series[zs][zsj]
+ }
+ if (total === 0) {
+ this.barCtx.zeroSerieses.push(zs)
+ }
+ }
+
+ // After getting all zeroserieses, we need to ensure whether radiusOnSeriesNumber is not in that zeroseries array
+ for (let s = series.length - 1; s >= 0; s--) {
+ if (
+ this.barCtx.zeroSerieses.indexOf(s) > -1 &&
+ s === this.radiusOnSeriesNumber
+ ) {
+ this.barCtx.radiusOnSeriesNumber -= 1
+ }
+ }
+
+ for (let s = series.length - 1; s >= 0; s--) {
+ if (
+ w.globals.collapsedSeriesIndices.indexOf(
+ this.barCtx.radiusOnSeriesNumber
+ ) > -1
+ ) {
+ this.barCtx.radiusOnSeriesNumber -= 1
+ }
+ }
+ }
+
+ getXForValue(value, zeroW, zeroPositionForNull = true) {
+ let xForVal = zeroPositionForNull ? zeroW : null
+ if (typeof value !== 'undefined' && value !== null) {
+ xForVal =
+ zeroW +
+ value / this.barCtx.invertedYRatio -
+ (this.barCtx.isReversed ? value / this.barCtx.invertedYRatio : 0) * 2
+ }
+ return xForVal
+ }
+
+ getYForValue(value, zeroH, zeroPositionForNull = true) {
+ let yForVal = zeroPositionForNull ? zeroH : null
+ if (typeof value !== 'undefined' && value !== null) {
+ yForVal =
+ zeroH -
+ value / this.barCtx.yRatio[this.barCtx.yaxisIndex] +
+ (this.barCtx.isReversed
+ ? value / this.barCtx.yRatio[this.barCtx.yaxisIndex]
+ : 0) *
+ 2
+ }
+ return yForVal
+ }
+
+ getGoalValues(type, zeroW, zeroH, i, j) {
+ const w = this.w
+
+ let goals = []
+ if (
+ w.globals.seriesGoals[i] &&
+ w.globals.seriesGoals[i][j] &&
+ Array.isArray(w.globals.seriesGoals[i][j])
+ ) {
+ w.globals.seriesGoals[i][j].forEach((goal) => {
+ goals.push({
+ [type]:
+ type === 'x'
+ ? this.getXForValue(goal.value, zeroW, false)
+ : this.getYForValue(goal.value, zeroH, false),
+ attrs: goal
+ })
+ })
+ }
+ return goals
+ }
+
+ drawGoalLine({
+ barXPosition,
+ barYPosition,
+ goalX,
+ goalY,
+ barWidth,
+ barHeight
+ }) {
+ let graphics = new Graphics(this.barCtx.ctx)
+ const lineGroup = graphics.group({
+ className: 'apexcharts-bar-goals-groups'
+ })
+
+ let line = null
+ if (this.barCtx.isHorizontal) {
+ if (Array.isArray(goalX)) {
+ goalX.forEach((goal) => {
+ let sHeight =
+ typeof goal.attrs.strokeHeight !== 'undefined'
+ ? goal.attrs.strokeHeight
+ : barHeight / 2
+ let y = barYPosition + sHeight + barHeight / 2
+
+ line = graphics.drawLine(
+ goal.x,
+ y - sHeight * 2,
+ goal.x,
+ y,
+ goal.attrs.strokeColor ? goal.attrs.strokeColor : undefined,
+ goal.attrs.strokeDashArray,
+ goal.attrs.strokeWidth ? goal.attrs.strokeWidth : 2,
+ goal.attrs.strokeLineCap
+ )
+ lineGroup.add(line)
+ })
+ }
+ } else {
+ if (Array.isArray(goalY)) {
+ goalY.forEach((goal) => {
+ let sWidth =
+ typeof goal.attrs.strokeWidth !== 'undefined'
+ ? goal.attrs.strokeWidth
+ : barWidth / 2
+ let x = barXPosition + sWidth + barWidth / 2
+
+ line = graphics.drawLine(
+ x - sWidth * 2,
+ goal.y,
+ x,
+ goal.y,
+ goal.attrs.strokeColor ? goal.attrs.strokeColor : undefined,
+ goal.attrs.strokeDashArray,
+ goal.attrs.strokeHeight ? goal.attrs.strokeHeight : 2,
+ goal.attrs.strokeLineCap
+ )
+ lineGroup.add(line)
+ })
+ }
+ }
+
+ return lineGroup
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/common/circle/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/charts/common/circle/Helpers.js
new file mode 100644
index 0000000..522a353
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/common/circle/Helpers.js
@@ -0,0 +1,30 @@
+import Graphics from '../../../modules/Graphics'
+
+export default class CircularChartsHelpers {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ drawYAxisTexts(x, y, i, text) {
+ const w = this.w
+
+ const yaxisConfig = w.config.yaxis[0]
+ const formatter = w.globals.yLabelFormatters[0]
+
+ const graphics = new Graphics(this.ctx)
+ const yaxisLabel = graphics.drawText({
+ x: x + yaxisConfig.labels.offsetX,
+ y: y + yaxisConfig.labels.offsetY,
+ text: formatter(text, i),
+ textAnchor: 'middle',
+ fontSize: yaxisConfig.labels.style.fontSize,
+ fontFamily: yaxisConfig.labels.style.fontFamily,
+ foreColor: Array.isArray(yaxisConfig.labels.style.colors)
+ ? yaxisConfig.labels.style.colors[i]
+ : yaxisConfig.labels.style.colors
+ })
+
+ return yaxisLabel
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/common/line/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/charts/common/line/Helpers.js
new file mode 100644
index 0000000..4aec0af
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/common/line/Helpers.js
@@ -0,0 +1,149 @@
+import CoreUtils from '../../../modules/CoreUtils'
+import Utils from '../../../utils/Utils'
+
+export default class Helpers {
+ constructor(lineCtx) {
+ this.w = lineCtx.w
+ this.lineCtx = lineCtx
+ }
+
+ sameValueSeriesFix(i, series) {
+ const w = this.w
+
+ if (
+ w.config.chart.type === 'line' &&
+ (w.config.fill.type === 'gradient' ||
+ w.config.fill.type[i] === 'gradient')
+ ) {
+ const coreUtils = new CoreUtils(this.lineCtx.ctx, w)
+
+ // a small adjustment to allow gradient line to draw correctly for all same values
+ /* #fix https://github.com/apexcharts/apexcharts.js/issues/358 */
+ if (coreUtils.seriesHaveSameValues(i)) {
+ let gSeries = series[i].slice()
+ gSeries[gSeries.length - 1] = gSeries[gSeries.length - 1] + 0.000001
+ series[i] = gSeries
+ }
+ }
+ return series
+ }
+
+ calculatePoints({ series, realIndex, x, y, i, j, prevY }) {
+ let w = this.w
+
+ let ptX = []
+ let ptY = []
+
+ if (j === 0) {
+ let xPT1st =
+ this.lineCtx.categoryAxisCorrection + w.config.markers.offsetX
+ // the first point for line series
+ // we need to check whether it's not a time series, because a time series may
+ // start from the middle of the x axis
+ if (w.globals.isXNumeric) {
+ xPT1st =
+ (w.globals.seriesX[realIndex][0] - w.globals.minX) /
+ this.lineCtx.xRatio +
+ w.config.markers.offsetX
+ }
+
+ // push 2 points for the first data values
+ ptX.push(xPT1st)
+ ptY.push(
+ Utils.isNumber(series[i][0]) ? prevY + w.config.markers.offsetY : null
+ )
+ ptX.push(x + w.config.markers.offsetX)
+ ptY.push(
+ Utils.isNumber(series[i][j + 1]) ? y + w.config.markers.offsetY : null
+ )
+ } else {
+ ptX.push(x + w.config.markers.offsetX)
+ ptY.push(
+ Utils.isNumber(series[i][j + 1]) ? y + w.config.markers.offsetY : null
+ )
+ }
+
+ let pointsPos = {
+ x: ptX,
+ y: ptY
+ }
+
+ return pointsPos
+ }
+
+ checkPreviousPaths({ pathFromLine, pathFromArea, realIndex }) {
+ let w = this.w
+
+ for (let pp = 0; pp < w.globals.previousPaths.length; pp++) {
+ let gpp = w.globals.previousPaths[pp]
+
+ if (
+ (gpp.type === 'line' || gpp.type === 'area') &&
+ gpp.paths.length > 0 &&
+ parseInt(gpp.realIndex, 10) === parseInt(realIndex, 10)
+ ) {
+ if (gpp.type === 'line') {
+ this.lineCtx.appendPathFrom = false
+ pathFromLine = w.globals.previousPaths[pp].paths[0].d
+ } else if (gpp.type === 'area') {
+ this.lineCtx.appendPathFrom = false
+ pathFromArea = w.globals.previousPaths[pp].paths[0].d
+
+ if (w.config.stroke.show && w.globals.previousPaths[pp].paths[1]) {
+ pathFromLine = w.globals.previousPaths[pp].paths[1].d
+ }
+ }
+ }
+ }
+
+ return {
+ pathFromLine,
+ pathFromArea
+ }
+ }
+
+ determineFirstPrevY({ i, series, prevY, lineYPosition }) {
+ let w = this.w
+ if (typeof series[i][0] !== 'undefined') {
+ if (w.config.chart.stacked) {
+ if (i > 0) {
+ // 1st y value of previous series
+ lineYPosition = this.lineCtx.prevSeriesY[i - 1][0]
+ } else {
+ // the first series will not have prevY values
+ lineYPosition = this.lineCtx.zeroY
+ }
+ } else {
+ lineYPosition = this.lineCtx.zeroY
+ }
+ prevY =
+ lineYPosition -
+ series[i][0] / this.lineCtx.yRatio[this.lineCtx.yaxisIndex] +
+ (this.lineCtx.isReversed
+ ? series[i][0] / this.lineCtx.yRatio[this.lineCtx.yaxisIndex]
+ : 0) *
+ 2
+ } else {
+ // the first value in the current series is null
+ if (
+ w.config.chart.stacked &&
+ i > 0 &&
+ typeof series[i][0] === 'undefined'
+ ) {
+ // check for undefined value (undefined value will occur when we clear the series while user clicks on legend to hide serieses)
+ for (let s = i - 1; s >= 0; s--) {
+ // for loop to get to 1st previous value until we get it
+ if (series[s][0] !== null && typeof series[s][0] !== 'undefined') {
+ lineYPosition = this.lineCtx.prevSeriesY[s][0]
+ prevY = lineYPosition
+ break
+ }
+ }
+ }
+ }
+ return {
+ prevY,
+ lineYPosition
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/charts/common/treemap/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/charts/common/treemap/Helpers.js
new file mode 100644
index 0000000..c518cc7
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/charts/common/treemap/Helpers.js
@@ -0,0 +1,192 @@
+import Utils from '../../../utils/Utils'
+import Graphics from '../../../modules/Graphics'
+import DataLabels from '../../../modules/DataLabels'
+
+export default class TreemapHelpers {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ checkColorRange() {
+ const w = this.w
+
+ let negRange = false
+ let chartOpts = w.config.plotOptions[w.config.chart.type]
+
+ if (chartOpts.colorScale.ranges.length > 0) {
+ chartOpts.colorScale.ranges.map((range, index) => {
+ if (range.from <= 0) {
+ negRange = true
+ }
+ })
+ }
+ return negRange
+ }
+
+ getShadeColor(chartType, i, j, negRange) {
+ const w = this.w
+
+ let colorShadePercent = 1
+ let shadeIntensity = w.config.plotOptions[chartType].shadeIntensity
+
+ const colorProps = this.determineColor(chartType, i, j)
+
+ if (w.globals.hasNegs || negRange) {
+ if (w.config.plotOptions[chartType].reverseNegativeShade) {
+ if (colorProps.percent < 0) {
+ colorShadePercent =
+ (colorProps.percent / 100) * (shadeIntensity * 1.25)
+ } else {
+ colorShadePercent =
+ (1 - colorProps.percent / 100) * (shadeIntensity * 1.25)
+ }
+ } else {
+ if (colorProps.percent <= 0) {
+ colorShadePercent =
+ 1 - (1 + colorProps.percent / 100) * shadeIntensity
+ } else {
+ colorShadePercent = (1 - colorProps.percent / 100) * shadeIntensity
+ }
+ }
+ } else {
+ colorShadePercent = 1 - colorProps.percent / 100
+ if (chartType === 'treemap') {
+ colorShadePercent =
+ (1 - colorProps.percent / 100) * (shadeIntensity * 1.25)
+ }
+ }
+
+ let color = colorProps.color
+ let utils = new Utils()
+
+ if (w.config.plotOptions[chartType].enableShades) {
+ if (this.w.config.theme.mode === 'dark') {
+ color = Utils.hexToRgba(
+ utils.shadeColor(colorShadePercent * -1, colorProps.color),
+ w.config.fill.opacity
+ )
+ } else {
+ color = Utils.hexToRgba(
+ utils.shadeColor(colorShadePercent, colorProps.color),
+ w.config.fill.opacity
+ )
+ }
+ }
+
+ return { color, colorProps }
+ }
+
+ determineColor(chartType, i, j) {
+ const w = this.w
+
+ let val = w.globals.series[i][j]
+
+ let chartOpts = w.config.plotOptions[chartType]
+
+ let seriesNumber = chartOpts.colorScale.inverse ? j : i
+
+ if (chartOpts.distributed && w.config.chart.type === 'treemap') {
+ seriesNumber = j
+ }
+
+ let color = w.globals.colors[seriesNumber]
+ let foreColor = null
+ let min = Math.min(...w.globals.series[i])
+ let max = Math.max(...w.globals.series[i])
+
+ if (!chartOpts.distributed && chartType === 'heatmap') {
+ min = w.globals.minY
+ max = w.globals.maxY
+ }
+
+ if (typeof chartOpts.colorScale.min !== 'undefined') {
+ min =
+ chartOpts.colorScale.min < w.globals.minY
+ ? chartOpts.colorScale.min
+ : w.globals.minY
+ max =
+ chartOpts.colorScale.max > w.globals.maxY
+ ? chartOpts.colorScale.max
+ : w.globals.maxY
+ }
+
+ let total = Math.abs(max) + Math.abs(min)
+
+ let percent = (100 * val) / (total === 0 ? total - 0.000001 : total)
+
+ if (chartOpts.colorScale.ranges.length > 0) {
+ const colorRange = chartOpts.colorScale.ranges
+ colorRange.map((range, index) => {
+ if (val >= range.from && val <= range.to) {
+ color = range.color
+ foreColor = range.foreColor ? range.foreColor : null
+ min = range.from
+ max = range.to
+ let rTotal = Math.abs(max) + Math.abs(min)
+ percent = (100 * val) / (rTotal === 0 ? rTotal - 0.000001 : rTotal)
+ }
+ })
+ }
+
+ return {
+ color,
+ foreColor,
+ percent
+ }
+ }
+
+ calculateDataLabels({ text, x, y, i, j, colorProps, fontSize }) {
+ let w = this.w
+ let dataLabelsConfig = w.config.dataLabels
+
+ const graphics = new Graphics(this.ctx)
+
+ let dataLabels = new DataLabels(this.ctx)
+
+ let elDataLabelsWrap = null
+
+ if (dataLabelsConfig.enabled) {
+ elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-data-labels'
+ })
+
+ const offX = dataLabelsConfig.offsetX
+ const offY = dataLabelsConfig.offsetY
+
+ let dataLabelsX = x + offX
+ let dataLabelsY =
+ y + parseFloat(dataLabelsConfig.style.fontSize) / 3 + offY
+
+ dataLabels.plotDataLabelsText({
+ x: dataLabelsX,
+ y: dataLabelsY,
+ text,
+ i,
+ j,
+ color: colorProps.foreColor,
+ parent: elDataLabelsWrap,
+ fontSize,
+ dataLabelsConfig
+ })
+ }
+
+ return elDataLabelsWrap
+ }
+
+ addListeners(elRect) {
+ const graphics = new Graphics(this.ctx)
+ elRect.node.addEventListener(
+ 'mouseenter',
+ graphics.pathMouseEnter.bind(this, elRect)
+ )
+ elRect.node.addEventListener(
+ 'mouseleave',
+ graphics.pathMouseLeave.bind(this, elRect)
+ )
+ elRect.node.addEventListener(
+ 'mousedown',
+ graphics.pathMouseDown.bind(this, elRect)
+ )
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/libs/Treemap-squared.js b/cao_sunyata/static/libs/apexcharts/src/libs/Treemap-squared.js
new file mode 100644
index 0000000..a9ae841
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/libs/Treemap-squared.js
@@ -0,0 +1,290 @@
+/*
+ * treemap-squarify.js - open source implementation of squarified treemaps
+ *
+ * Treemap Squared 0.5 - Treemap Charting library
+ *
+ * https://github.com/imranghory/treemap-squared/
+ *
+ * Copyright (c) 2012 Imran Ghory (imranghory@gmail.com)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
+ *
+ *
+ * Implementation of the squarify treemap algorithm described in:
+ *
+ * Bruls, Mark; Huizing, Kees; van Wijk, Jarke J. (2000), "Squarified treemaps"
+ * in de Leeuw, W.; van Liere, R., Data Visualization 2000:
+ * Proc. Joint Eurographics and IEEE TCVG Symp. on Visualization, Springer-Verlag, pp. 33–42.
+ *
+ * Paper is available online at: http://www.win.tue.nl/~vanwijk/stm.pdf
+ *
+ * The code in this file is completeley decoupled from the drawing code so it should be trivial
+ * to port it to any other vector drawing library. Given an array of datapoints this library returns
+ * an array of cartesian coordinates that represent the rectangles that make up the treemap.
+ *
+ * The library also supports multidimensional data (nested treemaps) and performs normalization on the data.
+ *
+ * See the README file for more details.
+ */
+
+window.TreemapSquared = {}
+;(function() {
+ 'use strict'
+ window.TreemapSquared.generate = (function() {
+ function Container(xoffset, yoffset, width, height) {
+ this.xoffset = xoffset // offset from the the top left hand corner
+ this.yoffset = yoffset // ditto
+ this.height = height
+ this.width = width
+
+ this.shortestEdge = function() {
+ return Math.min(this.height, this.width)
+ }
+
+ // getCoordinates - for a row of boxes which we've placed
+ // return an array of their cartesian coordinates
+ this.getCoordinates = function(row) {
+ let coordinates = []
+ let subxoffset = this.xoffset,
+ subyoffset = this.yoffset //our offset within the container
+ let areawidth = sumArray(row) / this.height
+ let areaheight = sumArray(row) / this.width
+ let i
+
+ if (this.width >= this.height) {
+ for (i = 0; i < row.length; i++) {
+ coordinates.push([
+ subxoffset,
+ subyoffset,
+ subxoffset + areawidth,
+ subyoffset + row[i] / areawidth
+ ])
+ subyoffset = subyoffset + row[i] / areawidth
+ }
+ } else {
+ for (i = 0; i < row.length; i++) {
+ coordinates.push([
+ subxoffset,
+ subyoffset,
+ subxoffset + row[i] / areaheight,
+ subyoffset + areaheight
+ ])
+ subxoffset = subxoffset + row[i] / areaheight
+ }
+ }
+ return coordinates
+ }
+
+ // cutArea - once we've placed some boxes into an row we then need to identify the remaining area,
+ // this function takes the area of the boxes we've placed and calculates the location and
+ // dimensions of the remaining space and returns a container box defined by the remaining area
+ this.cutArea = function(area) {
+ let newcontainer
+
+ if (this.width >= this.height) {
+ let areawidth = area / this.height
+ let newwidth = this.width - areawidth
+ newcontainer = new Container(
+ this.xoffset + areawidth,
+ this.yoffset,
+ newwidth,
+ this.height
+ )
+ } else {
+ let areaheight = area / this.width
+ let newheight = this.height - areaheight
+ newcontainer = new Container(
+ this.xoffset,
+ this.yoffset + areaheight,
+ this.width,
+ newheight
+ )
+ }
+ return newcontainer
+ }
+ }
+
+ // normalize - the Bruls algorithm assumes we're passing in areas that nicely fit into our
+ // container box, this method takes our raw data and normalizes the data values into
+ // area values so that this assumption is valid.
+ function normalize(data, area) {
+ let normalizeddata = []
+ let sum = sumArray(data)
+ let multiplier = area / sum
+ let i
+
+ for (i = 0; i < data.length; i++) {
+ normalizeddata[i] = data[i] * multiplier
+ }
+ return normalizeddata
+ }
+
+ // treemapMultidimensional - takes multidimensional data (aka [[23,11],[11,32]] - nested array)
+ // and recursively calls itself using treemapSingledimensional
+ // to create a patchwork of treemaps and merge them
+ function treemapMultidimensional(data, width, height, xoffset, yoffset) {
+ xoffset = typeof xoffset === 'undefined' ? 0 : xoffset
+ yoffset = typeof yoffset === 'undefined' ? 0 : yoffset
+
+ let mergeddata = []
+ let mergedtreemap
+ let results = []
+ let i
+
+ if (isArray(data[0])) {
+ // if we've got more dimensions of depth
+ for (i = 0; i < data.length; i++) {
+ mergeddata[i] = sumMultidimensionalArray(data[i])
+ }
+ mergedtreemap = treemapSingledimensional(
+ mergeddata,
+ width,
+ height,
+ xoffset,
+ yoffset
+ )
+
+ for (i = 0; i < data.length; i++) {
+ results.push(
+ treemapMultidimensional(
+ data[i],
+ mergedtreemap[i][2] - mergedtreemap[i][0],
+ mergedtreemap[i][3] - mergedtreemap[i][1],
+ mergedtreemap[i][0],
+ mergedtreemap[i][1]
+ )
+ )
+ }
+ } else {
+ results = treemapSingledimensional(
+ data,
+ width,
+ height,
+ xoffset,
+ yoffset
+ )
+ }
+ return results
+ }
+
+ // treemapSingledimensional - simple wrapper around squarify
+ function treemapSingledimensional(data, width, height, xoffset, yoffset) {
+ xoffset = typeof xoffset === 'undefined' ? 0 : xoffset
+ yoffset = typeof yoffset === 'undefined' ? 0 : yoffset
+
+ let rawtreemap = squarify(
+ normalize(data, width * height),
+ [],
+ new Container(xoffset, yoffset, width, height),
+ []
+ )
+ return flattenTreemap(rawtreemap)
+ }
+
+ // flattenTreemap - squarify implementation returns an array of arrays of coordinates
+ // because we have a new array everytime we switch to building a new row
+ // this converts it into an array of coordinates.
+ function flattenTreemap(rawtreemap) {
+ let flattreemap = []
+ let i, j
+
+ for (i = 0; i < rawtreemap.length; i++) {
+ for (j = 0; j < rawtreemap[i].length; j++) {
+ flattreemap.push(rawtreemap[i][j])
+ }
+ }
+ return flattreemap
+ }
+
+ // squarify - as per the Bruls paper
+ // plus coordinates stack and containers so we get
+ // usable data out of it
+ function squarify(data, currentrow, container, stack) {
+ let length
+ let nextdatapoint
+ let newcontainer
+
+ if (data.length === 0) {
+ stack.push(container.getCoordinates(currentrow))
+ return
+ }
+
+ length = container.shortestEdge()
+ nextdatapoint = data[0]
+
+ if (improvesRatio(currentrow, nextdatapoint, length)) {
+ currentrow.push(nextdatapoint)
+ squarify(data.slice(1), currentrow, container, stack)
+ } else {
+ newcontainer = container.cutArea(sumArray(currentrow), stack)
+ stack.push(container.getCoordinates(currentrow))
+ squarify(data, [], newcontainer, stack)
+ }
+ return stack
+ }
+
+ // improveRatio - implements the worse calculation and comparision as given in Bruls
+ // (note the error in the original paper; fixed here)
+ function improvesRatio(currentrow, nextnode, length) {
+ let newrow
+
+ if (currentrow.length === 0) {
+ return true
+ }
+
+ newrow = currentrow.slice()
+ newrow.push(nextnode)
+
+ let currentratio = calculateRatio(currentrow, length)
+ let newratio = calculateRatio(newrow, length)
+
+ // the pseudocode in the Bruls paper has the direction of the comparison
+ // wrong, this is the correct one.
+ return currentratio >= newratio
+ }
+
+ // calculateRatio - calculates the maximum width to height ratio of the
+ // boxes in this row
+ function calculateRatio(row, length) {
+ let min = Math.min.apply(Math, row)
+ let max = Math.max.apply(Math, row)
+ let sum = sumArray(row)
+ return Math.max(
+ (Math.pow(length, 2) * max) / Math.pow(sum, 2),
+ Math.pow(sum, 2) / (Math.pow(length, 2) * min)
+ )
+ }
+
+ // isArray - checks if arr is an array
+ function isArray(arr) {
+ return arr && arr.constructor === Array
+ }
+
+ // sumArray - sums a single dimensional array
+ function sumArray(arr) {
+ let sum = 0
+ let i
+
+ for (i = 0; i < arr.length; i++) {
+ sum += arr[i]
+ }
+ return sum
+ }
+
+ // sumMultidimensionalArray - sums the values in a nested array (aka [[0,1],[[2,3]]])
+ function sumMultidimensionalArray(arr) {
+ let i,
+ total = 0
+
+ if (isArray(arr[0])) {
+ for (i = 0; i < arr.length; i++) {
+ total += sumMultidimensionalArray(arr[i])
+ }
+ } else {
+ total = sumArray(arr)
+ }
+ return total
+ }
+
+ return treemapMultidimensional
+ })()
+})()
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ar.json b/cao_sunyata/static/libs/apexcharts/src/locales/ar.json
new file mode 100644
index 0000000..f13eab3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ar.json
@@ -0,0 +1,63 @@
+{
+"name": "ar",
+"options": {
+"months": [
+"يناير",
+"فبراير",
+"مارس",
+"أبريل",
+"مايو",
+"يونيو",
+"يوليو",
+"أغسطس",
+"سبتمبر",
+"أكتوبر",
+"نوفمبر",
+"ديسمبر"
+],
+"shortMonths": [
+"يناير",
+"فبراير",
+"مارس",
+"أبريل",
+"مايو",
+"يونيو",
+"يوليو",
+"أغسطس",
+"سبتمبر",
+"أكتوبر",
+"نوفمبر",
+"ديسمبر"
+],
+"days": [
+"الأحد",
+"الإثنين",
+"الثلاثاء",
+"الأربعاء",
+"الخميس",
+"الجمعة",
+"السبت"
+],
+"shortDays": [
+"أحد",
+"إثنين",
+"ثلاثاء",
+"أربعاء",
+"خميس",
+"جمعة",
+"سبت"
+],
+"toolbar": {
+"exportToSVG": "تحميل بصيغة SVG",
+"exportToPNG": "تحميل بصيغة PNG",
+"exportToCSV": "تحميل بصيغة CSV",
+"menu": "القائمة",
+"selection": "تحديد",
+"selectionZoom": "تكبير التحديد",
+"zoomIn": "تكبير",
+"zoomOut": "تصغير",
+"pan": "تحريك",
+"reset": "إعادة التعيين"
+}
+}
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ca.json b/cao_sunyata/static/libs/apexcharts/src/locales/ca.json
new file mode 100644
index 0000000..cef7d1a
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ca.json
@@ -0,0 +1,55 @@
+{
+ "name": "ca",
+ "options": {
+ "months": [
+ "Gener",
+ "Febrer",
+ "Març",
+ "Abril",
+ "Maig",
+ "Juny",
+ "Juliol",
+ "Agost",
+ "Setembre",
+ "Octubre",
+ "Novembre",
+ "Desembre"
+ ],
+ "shortMonths": [
+ "Gen.",
+ "Febr.",
+ "Març",
+ "Abr.",
+ "Maig",
+ "Juny",
+ "Jul.",
+ "Ag.",
+ "Set.",
+ "Oct.",
+ "Nov.",
+ "Des."
+ ],
+ "days": [
+ "Diumenge",
+ "Dilluns",
+ "Dimarts",
+ "Dimecres",
+ "Dijous",
+ "Divendres",
+ "Dissabte"
+ ],
+ "shortDays": ["Dg", "Dl", "Dt", "Dc", "Dj", "Dv", "Ds"],
+ "toolbar": {
+ "exportToSVG": "Descarregar SVG",
+ "exportToPNG": "Descarregar PNG",
+ "exportToCSV": "Descarregar CSV",
+ "menu": "Menú",
+ "selection": "Seleccionar",
+ "selectionZoom": "Seleccionar Zoom",
+ "zoomIn": "Augmentar",
+ "zoomOut": "Disminuir",
+ "pan": "Navegació",
+ "reset": "Reiniciar Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/cs.json b/cao_sunyata/static/libs/apexcharts/src/locales/cs.json
new file mode 100644
index 0000000..b8d9d40
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/cs.json
@@ -0,0 +1,55 @@
+{
+ "name": "cs",
+ "options": {
+ "months": [
+ "Leden",
+ "Únor",
+ "Březen",
+ "Duben",
+ "Květen",
+ "Červen",
+ "Červenec",
+ "Srpen",
+ "Září",
+ "Říjen",
+ "Listopad",
+ "Prosinec"
+ ],
+ "shortMonths": [
+ "Led",
+ "Úno",
+ "Bře",
+ "Dub",
+ "Kvě",
+ "Čvn",
+ "Čvc",
+ "Srp",
+ "Zář",
+ "Říj",
+ "Lis",
+ "Pro"
+ ],
+ "days": [
+ "Neděle",
+ "Pondělí",
+ "Úterý",
+ "Středa",
+ "Čtvrtek",
+ "Pátek",
+ "Sobota"
+ ],
+ "shortDays": ["Ne", "Po", "Út", "St", "Čt", "Pá", "So"],
+ "toolbar": {
+ "exportToSVG": "Stáhnout SVG",
+ "exportToPNG": "Stáhnout PNG",
+ "exportToCSV": "Stáhnout CSV",
+ "menu": "Menu",
+ "selection": "Vybrat",
+ "selectionZoom": "Zoom: Vybrat",
+ "zoomIn": "Zoom: Přiblížit",
+ "zoomOut": "Zoom: Oddálit",
+ "pan": "Přesouvat",
+ "reset": "Resetovat"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/de.json b/cao_sunyata/static/libs/apexcharts/src/locales/de.json
new file mode 100644
index 0000000..af625e3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/de.json
@@ -0,0 +1,55 @@
+{
+ "name": "de",
+ "options": {
+ "months": [
+ "Januar",
+ "Februar",
+ "März",
+ "April",
+ "Mai",
+ "Juni",
+ "Juli",
+ "August",
+ "September",
+ "Oktober",
+ "November",
+ "Dezember"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mär",
+ "Apr",
+ "Mai",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dez"
+ ],
+ "days": [
+ "Sonntag",
+ "Montag",
+ "Dienstag",
+ "Mittwoch",
+ "Donnerstag",
+ "Freitag",
+ "Samstag"
+ ],
+ "shortDays": ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
+ "toolbar": {
+ "exportToSVG": "SVG speichern",
+ "exportToPNG": "PNG speichern",
+ "exportToCSV": "CSV speichern",
+ "menu": "Menü",
+ "selection": "Auswahl",
+ "selectionZoom": "Auswahl vergrößern",
+ "zoomIn": "Vergrößern",
+ "zoomOut": "Verkleinern",
+ "pan": "Verschieben",
+ "reset": "Zoom zurücksetzen"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/el.json b/cao_sunyata/static/libs/apexcharts/src/locales/el.json
new file mode 100644
index 0000000..e547e54
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/el.json
@@ -0,0 +1,55 @@
+{
+ "name": "el",
+ "options": {
+ "months": [
+ "Ιανουάριος",
+ "Φεβρουάριος",
+ "Μάρτιος",
+ "Απρίλιος",
+ "Μάιος",
+ "Ιούνιος",
+ "Ιούλιος",
+ "Αύγουστος",
+ "Σεπτέμβριος",
+ "Οκτώβριος",
+ "Νοέμβριος",
+ "Δεκέμβριος"
+ ],
+ "shortMonths": [
+ "Ιαν",
+ "Φευ",
+ "Μαρ",
+ "Απρ",
+ "Μάι",
+ "Ιουν",
+ "Ιουλ",
+ "Αυγ",
+ "Σεπ",
+ "Οκτ",
+ "Νοε",
+ "Δεκ"
+ ],
+ "days": [
+ "Κυριακή",
+ "Δευτέρα",
+ "Τρίτη",
+ "Τετάρτη",
+ "Πέμπτη",
+ "Παρασκευή",
+ "Σάββατο"
+ ],
+ "shortDays": ["Κυρ", "Δευ", "Τρι", "Τετ", "Πεμ", "Παρ", "Σαβ"],
+ "toolbar": {
+ "exportToSVG": "Λήψη SVG",
+ "exportToPNG": "Λήψη PNG",
+ "exportToCSV": "Λήψη CSV",
+ "menu": "Menu",
+ "selection": "Επιλογή",
+ "selectionZoom": "Μεγένθυση βάση επιλογής",
+ "zoomIn": "Μεγένθυνση",
+ "zoomOut": "Σμίκρυνση",
+ "pan": "Μετατόπιση",
+ "reset": "Επαναφορά μεγένθυνσης"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/en.json b/cao_sunyata/static/libs/apexcharts/src/locales/en.json
new file mode 100644
index 0000000..7b12481
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/en.json
@@ -0,0 +1,55 @@
+{
+ "name": "en",
+ "options": {
+ "months": [
+ "January",
+ "February",
+ "March",
+ "April",
+ "May",
+ "June",
+ "July",
+ "August",
+ "September",
+ "October",
+ "November",
+ "December"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Sunday",
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday"
+ ],
+ "shortDays": ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+ "toolbar": {
+ "exportToSVG": "Download SVG",
+ "exportToPNG": "Download PNG",
+ "exportToCSV": "Download CSV",
+ "menu": "Menu",
+ "selection": "Selection",
+ "selectionZoom": "Selection Zoom",
+ "zoomIn": "Zoom In",
+ "zoomOut": "Zoom Out",
+ "pan": "Panning",
+ "reset": "Reset Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/es.json b/cao_sunyata/static/libs/apexcharts/src/locales/es.json
new file mode 100644
index 0000000..8c465f6
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/es.json
@@ -0,0 +1,55 @@
+{
+ "name": "es",
+ "options": {
+ "months": [
+ "Enero",
+ "Febrero",
+ "Marzo",
+ "Abril",
+ "Mayo",
+ "Junio",
+ "Julio",
+ "Agosto",
+ "Septiembre",
+ "Octubre",
+ "Noviembre",
+ "Diciembre"
+ ],
+ "shortMonths": [
+ "Ene",
+ "Feb",
+ "Mar",
+ "Abr",
+ "May",
+ "Jun",
+ "Jul",
+ "Ago",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dic"
+ ],
+ "days": [
+ "Domingo",
+ "Lunes",
+ "Martes",
+ "Miércoles",
+ "Jueves",
+ "Viernes",
+ "Sábado"
+ ],
+ "shortDays": ["Dom", "Lun", "Mar", "Mie", "Jue", "Vie", "Sab"],
+ "toolbar": {
+ "exportToSVG": "Descargar SVG",
+ "exportToPNG": "Descargar PNG",
+ "exportToCSV": "Descargar CSV",
+ "menu": "Menu",
+ "selection": "Seleccionar",
+ "selectionZoom": "Seleccionar Zoom",
+ "zoomIn": "Aumentar",
+ "zoomOut": "Disminuir",
+ "pan": "Navegación",
+ "reset": "Reiniciar Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/et.json b/cao_sunyata/static/libs/apexcharts/src/locales/et.json
new file mode 100644
index 0000000..5aa5248
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/et.json
@@ -0,0 +1,63 @@
+{
+ "name": "et",
+ "options": {
+ "months": [
+ "jaanuar",
+ "veebruar",
+ "märts",
+ "aprill",
+ "mai",
+ "juuni",
+ "juuli",
+ "august",
+ "september",
+ "oktoober",
+ "november",
+ "detsember"
+ ],
+ "shortMonths": [
+ "jaan",
+ "veebr",
+ "märts",
+ "apr",
+ "mai",
+ "juuni",
+ "juuli",
+ "aug",
+ "sept",
+ "okt",
+ "nov",
+ "dets"
+ ],
+ "days": [
+ "pühapäev",
+ "esmaspäev",
+ "teisipäev",
+ "kolmapäev",
+ "neljapäev",
+ "reede",
+ "laupäev"
+ ],
+ "shortDays": [
+ "P",
+ "E",
+ "T",
+ "K",
+ "N",
+ "R",
+ "L"
+ ],
+ "toolbar": {
+ "exportToSVG": "Lae alla SVG",
+ "exportToPNG": "Lae alla PNG",
+ "exportToCSV": "Lae alla CSV",
+ "menu": "Menüü",
+ "selection": "Valik",
+ "selectionZoom": "Valiku suum",
+ "zoomIn": "Suurenda",
+ "zoomOut": "Vähenda",
+ "pan": "Panoraamimine",
+ "reset": "Lähtesta suum"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/fa.json b/cao_sunyata/static/libs/apexcharts/src/locales/fa.json
new file mode 100644
index 0000000..a4c38f7
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/fa.json
@@ -0,0 +1,55 @@
+{
+ "name": "fa",
+ "options": {
+ "months": [
+ "فروردین",
+ "اردیبهشت",
+ "خرداد",
+ "تیر",
+ "مرداد",
+ "شهریور",
+ "مهر",
+ "آبان",
+ "آذر",
+ "دی",
+ "بهمن",
+ "اسفند"
+ ],
+ "shortMonths": [
+ "فرو",
+ "ارد",
+ "خرد",
+ "تیر",
+ "مرد",
+ "شهر",
+ "مهر",
+ "آبا",
+ "آذر",
+ "دی",
+ "بهمـ",
+ "اسفـ"
+ ],
+ "days": [
+ "یکشنبه",
+ "دوشنبه",
+ "سه شنبه",
+ "چهارشنبه",
+ "پنجشنبه",
+ "جمعه",
+ "شنبه"
+ ],
+ "shortDays": ["ی", "د", "س", "چ", "پ", "ج", "ش"],
+ "toolbar": {
+ "exportToSVG": "دانلود SVG",
+ "exportToPNG": "دانلود PNG",
+ "exportToCSV": "دانلود CSV",
+ "menu": "منو",
+ "selection": "انتخاب",
+ "selectionZoom": "بزرگنمایی انتخابی",
+ "zoomIn": "بزرگنمایی",
+ "zoomOut": "کوچکنمایی",
+ "pan": "پیمایش",
+ "reset": "بازنشانی بزرگنمایی"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/fi.json b/cao_sunyata/static/libs/apexcharts/src/locales/fi.json
new file mode 100644
index 0000000..73df095
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/fi.json
@@ -0,0 +1,55 @@
+{
+ "name": "fi",
+ "options": {
+ "months": [
+ "Tammikuu",
+ "Helmikuu",
+ "Maaliskuu",
+ "Huhtikuu",
+ "Toukokuu",
+ "Kesäkuu",
+ "Heinäkuu",
+ "Elokuu",
+ "Syyskuu",
+ "Lokakuu",
+ "Marraskuu",
+ "Joulukuu"
+ ],
+ "shortMonths": [
+ "Tammi",
+ "Helmi",
+ "Maalis",
+ "Huhti",
+ "Touko",
+ "Kesä",
+ "Heinä",
+ "Elo",
+ "Syys",
+ "Loka",
+ "Marras",
+ "Joulu"
+ ],
+ "days": [
+ "Sunnuntai",
+ "Maanantai",
+ "Tiistai",
+ "Keskiviikko",
+ "Torstai",
+ "Perjantai",
+ "Lauantai"
+ ],
+ "shortDays": ["Su", "Ma", "Ti", "Ke", "To", "Pe", "La"],
+ "toolbar": {
+ "exportToSVG": "Lataa SVG",
+ "exportToPNG": "Lataa PNG",
+ "exportToCSV": "Lataa CSV",
+ "menu": "Valikko",
+ "selection": "Valinta",
+ "selectionZoom": "Valinnan zoomaus",
+ "zoomIn": "Lähennä",
+ "zoomOut": "Loitonna",
+ "pan": "Panoroi",
+ "reset": "Nollaa zoomaus"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/fr.json b/cao_sunyata/static/libs/apexcharts/src/locales/fr.json
new file mode 100644
index 0000000..959ce0b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/fr.json
@@ -0,0 +1,55 @@
+{
+ "name": "fr",
+ "options": {
+ "months": [
+ "janvier",
+ "février",
+ "mars",
+ "avril",
+ "mai",
+ "juin",
+ "juillet",
+ "août",
+ "septembre",
+ "octobre",
+ "novembre",
+ "décembre"
+ ],
+ "shortMonths": [
+ "janv.",
+ "févr.",
+ "mars",
+ "avr.",
+ "mai",
+ "juin",
+ "juill.",
+ "août",
+ "sept.",
+ "oct.",
+ "nov.",
+ "déc."
+ ],
+ "days": [
+ "dimanche",
+ "lundi",
+ "mardi",
+ "mercredi",
+ "jeudi",
+ "vendredi",
+ "samedi"
+ ],
+ "shortDays": ["dim.", "lun.", "mar.", "mer.", "jeu.", "ven.", "sam."],
+ "toolbar": {
+ "exportToSVG": "Télécharger au format SVG",
+ "exportToPNG": "Télécharger au format PNG",
+ "exportToCSV": "Télécharger au format CSV",
+ "menu": "Menu",
+ "selection": "Sélection",
+ "selectionZoom": "Sélection et zoom",
+ "zoomIn": "Zoomer",
+ "zoomOut": "Dézoomer",
+ "pan": "Navigation",
+ "reset": "Réinitialiser le zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/he.json b/cao_sunyata/static/libs/apexcharts/src/locales/he.json
new file mode 100644
index 0000000..bafff3e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/he.json
@@ -0,0 +1,55 @@
+{
+ "name": "he",
+ "options": {
+ "months": [
+ "ינואר",
+ "פברואר",
+ "מרץ",
+ "אפריל",
+ "מאי",
+ "יוני",
+ "יולי",
+ "אוגוסט",
+ "ספטמבר",
+ "אוקטובר",
+ "נובמבר",
+ "דצמבר"
+ ],
+ "shortMonths": [
+ "ינו׳",
+ "פבר׳",
+ "מרץ",
+ "אפר׳",
+ "מאי",
+ "יוני",
+ "יולי",
+ "אוג׳",
+ "ספט׳",
+ "אוק׳",
+ "נוב׳",
+ "דצמ׳"
+ ],
+ "days": [
+ "ראשון",
+ "שני",
+ "שלישי",
+ "רביעי",
+ "חמישי",
+ "שישי",
+ "שבת"
+ ],
+ "shortDays": ["א׳", "ב׳", "ג׳", "ד׳", "ה׳", "ו׳", "ש׳"],
+ "toolbar": {
+ "exportToSVG": "הורד SVG",
+ "exportToPNG": "הורד PNG",
+ "exportToCSV": "הורד CSV",
+ "menu": "תפריט",
+ "selection": "בחירה",
+ "selectionZoom": "זום בחירה",
+ "zoomIn": "הגדלה",
+ "zoomOut": "הקטנה",
+ "pan": "הזזה",
+ "reset": "איפוס תצוגה"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/hi.json b/cao_sunyata/static/libs/apexcharts/src/locales/hi.json
new file mode 100644
index 0000000..2191342
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/hi.json
@@ -0,0 +1,55 @@
+{
+ "name": "hi",
+ "options": {
+ "months": [
+ "जनवरी",
+ "फ़रवरी",
+ "मार्च",
+ "अप्रैल",
+ "मई",
+ "जून",
+ "जुलाई",
+ "अगस्त",
+ "सितंबर",
+ "अक्टूबर",
+ "नवंबर",
+ "दिसंबर"
+ ],
+ "shortMonths": [
+ "जनवरी",
+ "फ़रवरी",
+ "मार्च",
+ "अप्रैल",
+ "मई",
+ "जून",
+ "जुलाई",
+ "अगस्त",
+ "सितंबर",
+ "अक्टूबर",
+ "नवंबर",
+ "दिसंबर"
+ ],
+ "days": [
+ "रविवार",
+ "सोमवार",
+ "मंगलवार",
+ "बुधवार",
+ "गुरुवार",
+ "शुक्रवार",
+ "शनिवार"
+ ],
+ "shortDays": ["रवि", "सोम", "मंगल", "बुध", "गुरु", "शुक्र", "शनि"],
+ "toolbar": {
+ "exportToSVG": "निर्यात SVG",
+ "exportToPNG": "निर्यात PNG",
+ "exportToCSV": "निर्यात CSV",
+ "menu": "सूची",
+ "selection": "चयन",
+ "selectionZoom": "ज़ूम करना",
+ "zoomIn": "ज़ूम इन",
+ "zoomOut": "ज़ूम आउट",
+ "pan": "पैनिंग",
+ "reset": "फिर से कायम करना"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/hr.json b/cao_sunyata/static/libs/apexcharts/src/locales/hr.json
new file mode 100644
index 0000000..52ab2fc
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/hr.json
@@ -0,0 +1,55 @@
+{
+ "name": "hr",
+ "options": {
+ "months": [
+ "Siječanj",
+ "Veljača",
+ "Ožujak",
+ "Travanj",
+ "Svibanj",
+ "Lipanj",
+ "Srpanj",
+ "Kolovoz",
+ "Rujan",
+ "Listopad",
+ "Studeni",
+ "Prosinac"
+ ],
+ "shortMonths": [
+ "Sij",
+ "Velj",
+ "Ožu",
+ "Tra",
+ "Svi",
+ "Lip",
+ "Srp",
+ "Kol",
+ "Ruj",
+ "Lis",
+ "Stu",
+ "Pro"
+ ],
+ "days": [
+ "Nedjelja",
+ "Ponedjeljak",
+ "Utorak",
+ "Srijeda",
+ "Četvrtak",
+ "Petak",
+ "Subota"
+ ],
+ "shortDays": ["Ned", "Pon", "Uto", "Sri", "Čet", "Pet", "Sub"],
+ "toolbar": {
+ "exportToSVG": "Preuzmi SVG",
+ "exportToPNG": "Preuzmi PNG",
+ "exportToCSV": "Preuzmi CSV",
+ "menu": "Izbornik",
+ "selection": "Odabir",
+ "selectionZoom": "Odabirno povećanje",
+ "zoomIn": "Uvećajte prikaz",
+ "zoomOut": "Umanjite prikaz",
+ "pan": "Pomicanje",
+ "reset": "Povratak na zadani prikaz"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/hu.json b/cao_sunyata/static/libs/apexcharts/src/locales/hu.json
new file mode 100644
index 0000000..04142a0
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/hu.json
@@ -0,0 +1,64 @@
+{
+ "name": "hu",
+ "options": {
+ "months": [
+ "január",
+ "február",
+ "március",
+ "április",
+ "május",
+ "június",
+ "július",
+ "augusztus",
+ "szeptember",
+ "október",
+ "november",
+ "december"
+ ],
+ "shortMonths": [
+ "jan",
+ "feb",
+ "mar",
+ "ápr",
+ "máj",
+ "jún",
+ "júl",
+ "aug",
+ "szept",
+ "okt",
+ "nov",
+ "dec"
+ ],
+ "days": [
+ "hétfő",
+ "kedd",
+ "szerda",
+ "csütörtök",
+ "péntek",
+ "szombat",
+ "vasárnap"
+ ],
+ "shortDays": [
+ "H",
+ "K",
+ "Sze",
+ "Cs",
+ "P",
+ "Szo",
+ "V"
+ ],
+ "toolbar": {
+ "exportToSVG": "Exportálás SVG-be",
+ "exportToPNG": "Exportálás PNG-be",
+ "exportToCSV": "Exportálás CSV-be",
+ "menu": "Fő ajánlat",
+ "download": "SVG letöltése",
+ "selection": "Kiválasztás",
+ "selectionZoom": "Nagyító kiválasztása",
+ "zoomIn": "Nagyítás",
+ "zoomOut": "Kicsinyítés",
+ "pan": "Képcsúsztatás",
+ "reset": "Nagyító visszaállítása"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/hy.json b/cao_sunyata/static/libs/apexcharts/src/locales/hy.json
new file mode 100644
index 0000000..cdbe469
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/hy.json
@@ -0,0 +1,55 @@
+{
+ "name": "hy",
+ "options": {
+ "months": [
+ "Հունվար",
+ "Փետրվար",
+ "Մարտ",
+ "Ապրիլ",
+ "Մայիս",
+ "Հունիս",
+ "Հուլիս",
+ "Օգոստոս",
+ "Սեպտեմբեր",
+ "Հոկտեմբեր",
+ "Նոյեմբեր",
+ "Դեկտեմբեր"
+ ],
+ "shortMonths": [
+ "Հնվ",
+ "Փտվ",
+ "Մրտ",
+ "Ապր",
+ "Մյս",
+ "Հնս",
+ "Հլիս",
+ "Օգս",
+ "Սեպ",
+ "Հոկ",
+ "Նոյ",
+ "Դեկ"
+ ],
+ "days": [
+ "Կիրակի",
+ "Երկուշաբթի",
+ "Երեքշաբթի",
+ "Չորեքշաբթի",
+ "Հինգշաբթի",
+ "Ուրբաթ",
+ "Շաբաթ"
+ ],
+ "shortDays": ["Կիր", "Երկ", "Երք", "Չրք", "Հնգ", "Ուրբ", "Շբթ"],
+ "toolbar": {
+ "exportToSVG": "Բեռնել SVG",
+ "exportToPNG": "Բեռնել PNG",
+ "exportToCSV": "Բեռնել CSV",
+ "menu": "Մենյու",
+ "selection": "Ընտրված",
+ "selectionZoom": "Ընտրված հատվածի խոշորացում",
+ "zoomIn": "Խոշորացնել",
+ "zoomOut": "Մանրացնել",
+ "pan": "Տեղափոխում",
+ "reset": "Բերել սկզբնական վիճակի"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/id.json b/cao_sunyata/static/libs/apexcharts/src/locales/id.json
new file mode 100644
index 0000000..52a34b6
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/id.json
@@ -0,0 +1,47 @@
+{
+ "name": "id",
+ "options": {
+ "months": [
+ "Januari",
+ "Februari",
+ "Maret",
+ "April",
+ "Mei",
+ "Juni",
+ "Juli",
+ "Agustus",
+ "September",
+ "Oktober",
+ "November",
+ "Desember"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Mei",
+ "Jun",
+ "Jul",
+ "Agu",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Des"
+ ],
+ "days": ["Minggu", "Senin", "Selasa", "Rabu", "kamis", "Jumat", "Sabtu"],
+ "shortDays": ["Min", "Sen", "Sel", "Rab", "Kam", "Jum", "Sab"],
+ "toolbar": {
+ "exportToSVG": "Unduh SVG",
+ "exportToPNG": "Unduh PNG",
+ "exportToCSV": "Unduh CSV",
+ "menu": "Menu",
+ "selection": "Pilihan",
+ "selectionZoom": "Perbesar Pilihan",
+ "zoomIn": "Perbesar",
+ "zoomOut": "Perkecil",
+ "pan": "Geser",
+ "reset": "Atur Ulang Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/it.json b/cao_sunyata/static/libs/apexcharts/src/locales/it.json
new file mode 100644
index 0000000..7facfea
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/it.json
@@ -0,0 +1,55 @@
+{
+ "name": "it",
+ "options": {
+ "months": [
+ "Gennaio",
+ "Febbraio",
+ "Marzo",
+ "Aprile",
+ "Maggio",
+ "Giugno",
+ "Luglio",
+ "Agosto",
+ "Settembre",
+ "Ottobre",
+ "Novembre",
+ "Dicembre"
+ ],
+ "shortMonths": [
+ "Gen",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Mag",
+ "Giu",
+ "Lug",
+ "Ago",
+ "Set",
+ "Ott",
+ "Nov",
+ "Dic"
+ ],
+ "days": [
+ "Domenica",
+ "Lunedì",
+ "Martedì",
+ "Mercoledì",
+ "Giovedì",
+ "Venerdì",
+ "Sabato"
+ ],
+ "shortDays": ["Dom", "Lun", "Mar", "Mer", "Gio", "Ven", "Sab"],
+ "toolbar": {
+ "exportToSVG": "Scarica SVG",
+ "exportToPNG": "Scarica PNG",
+ "exportToCSV": "Scarica CSV",
+ "menu": "Menu",
+ "selection": "Selezione",
+ "selectionZoom": "Seleziona Zoom",
+ "zoomIn": "Zoom In",
+ "zoomOut": "Zoom Out",
+ "pan": "Sposta",
+ "reset": "Reimposta Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ja.json b/cao_sunyata/static/libs/apexcharts/src/locales/ja.json
new file mode 100644
index 0000000..2b3af52
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ja.json
@@ -0,0 +1,55 @@
+{
+ "name": "ja",
+ "options": {
+ "months": [
+ "1月",
+ "2月",
+ "3月",
+ "4月",
+ "5月",
+ "6月",
+ "7月",
+ "8月",
+ "9月",
+ "10月",
+ "11月",
+ "12月"
+ ],
+ "shortMonths": [
+ "1月",
+ "2月",
+ "3月",
+ "4月",
+ "5月",
+ "6月",
+ "7月",
+ "8月",
+ "9月",
+ "10月",
+ "11月",
+ "12月"
+ ],
+ "days": [
+ "日曜日",
+ "月曜日",
+ "火曜日",
+ "水曜日",
+ "木曜日",
+ "金曜日",
+ "土曜日"
+ ],
+ "shortDays": ["日", "月", "火", "水", "木", "金", "土"],
+ "toolbar": {
+ "exportToSVG": "SVGダウンロード",
+ "exportToPNG": "PNGダウンロード",
+ "exportToCSV": "CSVダウンロード",
+ "menu": "メニュー",
+ "selection": "選択",
+ "selectionZoom": "選択ズーム",
+ "zoomIn": "拡大",
+ "zoomOut": "縮小",
+ "pan": "パン",
+ "reset": "ズームリセット"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ka.json b/cao_sunyata/static/libs/apexcharts/src/locales/ka.json
new file mode 100644
index 0000000..b3c8a0f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ka.json
@@ -0,0 +1,55 @@
+{
+ "name": "ka",
+ "options": {
+ "months": [
+ "იანვარი",
+ "თებერვალი",
+ "მარტი",
+ "აპრილი",
+ "მაისი",
+ "ივნისი",
+ "ივლისი",
+ "აგვისტო",
+ "სექტემბერი",
+ "ოქტომბერი",
+ "ნოემბერი",
+ "დეკემბერი"
+ ],
+ "shortMonths": [
+ "იან",
+ "თებ",
+ "მარ",
+ "აპრ",
+ "მაი",
+ "ივნ",
+ "ივლ",
+ "აგვ",
+ "სექ",
+ "ოქტ",
+ "ნოე",
+ "დეკ"
+ ],
+ "days": [
+ "კვირა",
+ "ორშაბათი",
+ "სამშაბათი",
+ "ოთხშაბათი",
+ "ხუთშაბათი",
+ "პარასკევი",
+ "შაბათი"
+ ],
+ "shortDays": ["კვი", "ორშ", "სამ", "ოთხ", "ხუთ", "პარ", "შაბ"],
+ "toolbar": {
+ "exportToSVG": "გადმოქაჩე SVG",
+ "exportToPNG": "გადმოქაჩე PNG",
+ "exportToCSV": "გადმოქაჩე CSV",
+ "menu": "მენიუ",
+ "selection": "არჩევა",
+ "selectionZoom": "არჩეულის გადიდება",
+ "zoomIn": "გადიდება",
+ "zoomOut": "დაპატარაება",
+ "pan": "გადაჩოჩება",
+ "reset": "გადიდების გაუქმება"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ko.json b/cao_sunyata/static/libs/apexcharts/src/locales/ko.json
new file mode 100644
index 0000000..181196d
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ko.json
@@ -0,0 +1,55 @@
+{
+ "name": "ko",
+ "options": {
+ "months": [
+ "1월",
+ "2월",
+ "3월",
+ "4월",
+ "5월",
+ "6월",
+ "7월",
+ "8월",
+ "9월",
+ "10월",
+ "11월",
+ "12월"
+ ],
+ "shortMonths": [
+ "1월",
+ "2월",
+ "3월",
+ "4월",
+ "5월",
+ "6월",
+ "7월",
+ "8월",
+ "9월",
+ "10월",
+ "11월",
+ "12월"
+ ],
+ "days": [
+ "일요일",
+ "월요일",
+ "화요일",
+ "수요일",
+ "목요일",
+ "금요일",
+ "토요일"
+ ],
+ "shortDays": ["일", "월", "화", "수", "목", "금", "토"],
+ "toolbar": {
+ "exportToSVG": "SVG 다운로드",
+ "exportToPNG": "PNG 다운로드",
+ "exportToCSV": "CSV 다운로드",
+ "menu": "메뉴",
+ "selection": "선택",
+ "selectionZoom": "선택영역 확대",
+ "zoomIn": "확대",
+ "zoomOut": "축소",
+ "pan": "패닝",
+ "reset": "원래대로"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/lt.json b/cao_sunyata/static/libs/apexcharts/src/locales/lt.json
new file mode 100644
index 0000000..4ed1520
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/lt.json
@@ -0,0 +1,55 @@
+{
+ "name": "lt",
+ "options": {
+ "months": [
+ "Sausis",
+ "Vasaris",
+ "Kovas",
+ "Balandis",
+ "Gegužė",
+ "Birželis",
+ "Liepa",
+ "Rugpjūtis",
+ "Rugsėjis",
+ "Spalis",
+ "Lapkritis",
+ "Gruodis"
+ ],
+ "shortMonths": [
+ "Sau",
+ "Vas",
+ "Kov",
+ "Bal",
+ "Geg",
+ "Bir",
+ "Lie",
+ "Rgp",
+ "Rgs",
+ "Spl",
+ "Lap",
+ "Grd"
+ ],
+ "days": [
+ "Sekmadienis",
+ "Pirmadienis",
+ "Antradienis",
+ "Trečiadienis",
+ "Ketvirtadienis",
+ "Penktadienis",
+ "Šeštadienis"
+ ],
+ "shortDays": ["Sk", "Per", "An", "Tr", "Kt", "Pn", "Št"],
+ "toolbar": {
+ "exportToSVG": "Atsisiųsti SVG",
+ "exportToPNG": "Atsisiųsti PNG",
+ "exportToCSV": "Atsisiųsti CSV",
+ "menu": "Menu",
+ "selection": "Pasirinkimas",
+ "selectionZoom": "Zoom: Pasirinkimas",
+ "zoomIn": "Zoom: Priartinti",
+ "zoomOut": "Zoom: Atitolinti",
+ "pan": "Perkėlimas",
+ "reset": "Atstatyti"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/lv.json b/cao_sunyata/static/libs/apexcharts/src/locales/lv.json
new file mode 100644
index 0000000..8a845dd
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/lv.json
@@ -0,0 +1,64 @@
+{
+ "name": "lv",
+ "options": {
+ "months": [
+ "janvāris",
+ "februāris",
+ "marts",
+ "aprīlis",
+ "maijs",
+ "jūnijs",
+ "jūlijs",
+ "augusts",
+ "septembris",
+ "oktobris",
+ "novembris",
+ "decembris"
+ ],
+ "shortMonths": [
+ "janv",
+ "febr",
+ "marts",
+ "apr",
+ "maijs",
+ "jūn",
+ "jūl",
+ "aug",
+ "sept",
+ "okt",
+ "nov",
+ "dec"
+ ],
+ "days": [
+ "svētdiena",
+ "pirmdiena",
+ "otrdiena",
+ "trešdiena",
+ "ceturtdiena",
+ "piektdiena",
+ "sestdiena"
+ ],
+ "shortDays": [
+ "Sv",
+ "P",
+ "O",
+ "T",
+ "C",
+ "P",
+ "S"
+ ],
+ "toolbar": {
+ "exportToSVG": "Lejuplādēt SVG",
+ "exportToPNG": "Lejuplādēt PNG",
+ "exportToCSV": "Lejuplādēt CSV",
+ "menu": "Izvēlne",
+ "selection": "Atlase",
+ "selectionZoom": "Pietuvināt atlasi",
+ "zoomIn": "Pietuvināt",
+ "zoomOut": "Attālināt",
+ "pan": "Pārvietoties diagrammā",
+ "reset": "Atiestatīt pietuvinājumu"
+ }
+ }
+}
+
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/nb.json b/cao_sunyata/static/libs/apexcharts/src/locales/nb.json
new file mode 100644
index 0000000..3339d2c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/nb.json
@@ -0,0 +1,55 @@
+{
+ "name": "nb",
+ "options": {
+ "months": [
+ "Januar",
+ "Februar",
+ "Mars",
+ "April",
+ "Mai",
+ "Juni",
+ "Juli",
+ "August",
+ "September",
+ "Oktober",
+ "November",
+ "Desember"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Mai",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Des"
+ ],
+ "days": [
+ "Søndag",
+ "Mandag",
+ "Tirsdag",
+ "Onsdag",
+ "Torsdag",
+ "Fredag",
+ "Lørdag"
+ ],
+ "shortDays": ["Sø", "Ma", "Ti", "On", "To", "Fr", "Lø"],
+ "toolbar": {
+ "exportToSVG": "Last ned SVG",
+ "exportToPNG": "Last ned PNG",
+ "exportToCSV": "Last ned CSV",
+ "menu": "Menu",
+ "selection": "Velg",
+ "selectionZoom": "Zoom: Velg",
+ "zoomIn": "Zoome inn",
+ "zoomOut": "Zoome ut",
+ "pan": "Skyving",
+ "reset": "Start på nytt"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/nl.json b/cao_sunyata/static/libs/apexcharts/src/locales/nl.json
new file mode 100644
index 0000000..0c2126a
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/nl.json
@@ -0,0 +1,55 @@
+{
+ "name": "nl",
+ "options": {
+ "months": [
+ "Januari",
+ "Februari",
+ "Maart",
+ "April",
+ "Mei",
+ "Juni",
+ "Juli",
+ "Augustus",
+ "September",
+ "Oktober",
+ "November",
+ "December"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mrt",
+ "Apr",
+ "Mei",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Zondag",
+ "Maandag",
+ "Dinsdag",
+ "Woensdag",
+ "Donderdag",
+ "Vrijdag",
+ "Zaterdag"
+ ],
+ "shortDays": ["Zo", "Ma", "Di", "Wo", "Do", "Vr", "Za"],
+ "toolbar": {
+ "exportToSVG": "Download SVG",
+ "exportToPNG": "Download PNG",
+ "exportToCSV": "Download CSV",
+ "menu": "Menu",
+ "selection": "Selectie",
+ "selectionZoom": "Zoom selectie",
+ "zoomIn": "Zoom in",
+ "zoomOut": "Zoom out",
+ "pan": "Verplaatsen",
+ "reset": "Standaardwaarden"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/pl.json b/cao_sunyata/static/libs/apexcharts/src/locales/pl.json
new file mode 100644
index 0000000..3df3c16
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/pl.json
@@ -0,0 +1,55 @@
+{
+ "name": "pl",
+ "options": {
+ "months": [
+ "Styczeń",
+ "Luty",
+ "Marzec",
+ "Kwiecień",
+ "Maj",
+ "Czerwiec",
+ "Lipiec",
+ "Sierpień",
+ "Wrzesień",
+ "Październik",
+ "Listopad",
+ "Grudzień"
+ ],
+ "shortMonths": [
+ "Sty",
+ "Lut",
+ "Mar",
+ "Kwi",
+ "Maj",
+ "Cze",
+ "Lip",
+ "Sie",
+ "Wrz",
+ "Paź",
+ "Lis",
+ "Gru"
+ ],
+ "days": [
+ "Niedziela",
+ "Poniedziałek",
+ "Wtorek",
+ "Środa",
+ "Czwartek",
+ "Piątek",
+ "Sobota"
+ ],
+ "shortDays": ["Nd", "Pn", "Wt", "Śr", "Cz", "Pt", "Sb"],
+ "toolbar": {
+ "exportToSVG": "Pobierz SVG",
+ "exportToPNG": "Pobierz PNG",
+ "exportToCSV": "Pobierz CSV",
+ "menu": "Menu",
+ "selection": "Wybieranie",
+ "selectionZoom": "Zoom: Wybieranie",
+ "zoomIn": "Zoom: Przybliż",
+ "zoomOut": "Zoom: Oddal",
+ "pan": "Przesuwanie",
+ "reset": "Resetuj"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/pt-br.json b/cao_sunyata/static/libs/apexcharts/src/locales/pt-br.json
new file mode 100644
index 0000000..a2932fc
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/pt-br.json
@@ -0,0 +1,55 @@
+{
+ "name": "pt-br",
+ "options": {
+ "months": [
+ "Janeiro",
+ "Fevereiro",
+ "Março",
+ "Abril",
+ "Maio",
+ "Junho",
+ "Julho",
+ "Agosto",
+ "Setembro",
+ "Outubro",
+ "Novembro",
+ "Dezembro"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Fev",
+ "Mar",
+ "Abr",
+ "Mai",
+ "Jun",
+ "Jul",
+ "Ago",
+ "Set",
+ "Out",
+ "Nov",
+ "Dez"
+ ],
+ "days": [
+ "Domingo",
+ "Segunda",
+ "Terça",
+ "Quarta",
+ "Quinta",
+ "Sexta",
+ "Sábado"
+ ],
+ "shortDays": ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sab"],
+ "toolbar": {
+ "exportToSVG": "Baixar SVG",
+ "exportToPNG": "Baixar PNG",
+ "exportToCSV": "Baixar CSV",
+ "menu": "Menu",
+ "selection": "Selecionar",
+ "selectionZoom": "Selecionar Zoom",
+ "zoomIn": "Aumentar",
+ "zoomOut": "Diminuir",
+ "pan": "Navegação",
+ "reset": "Reiniciar Zoom"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/pt.json b/cao_sunyata/static/libs/apexcharts/src/locales/pt.json
new file mode 100644
index 0000000..3f93db3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/pt.json
@@ -0,0 +1,55 @@
+{
+ "name": "pt",
+ "options": {
+ "months": [
+ "Janeiro",
+ "Fevereiro",
+ "Março",
+ "Abril",
+ "Maio",
+ "Junho",
+ "Julho",
+ "Agosto",
+ "Setembro",
+ "Outubro",
+ "Novembro",
+ "Dezembro"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Fev",
+ "Mar",
+ "Abr",
+ "Mai",
+ "Jun",
+ "Jul",
+ "Ag",
+ "Set",
+ "Out",
+ "Nov",
+ "Dez"
+ ],
+ "days": [
+ "Domingo",
+ "Segunda-feira",
+ "Terça-feira",
+ "Quarta-feira",
+ "Quinta-feira",
+ "Sexta-feira",
+ "Sábado"
+ ],
+ "shortDays": ["Do", "Se", "Te", "Qa", "Qi", "Sx", "Sa"],
+ "toolbar": {
+ "exportToSVG": "Baixar SVG",
+ "exportToPNG": "Baixar PNG",
+ "exportToCSV": "Baixar CSV",
+ "menu": "Menu",
+ "selection": "Selecionar",
+ "selectionZoom": "Zoom: Selecionar",
+ "zoomIn": "Zoom: Aumentar",
+ "zoomOut": "Zoom: Diminuir",
+ "pan": "Deslocamento",
+ "reset": "Redefinir"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/rs.json b/cao_sunyata/static/libs/apexcharts/src/locales/rs.json
new file mode 100644
index 0000000..c4fff61
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/rs.json
@@ -0,0 +1,55 @@
+{
+ "name": "rs",
+ "options": {
+ "months": [
+ "Januar",
+ "Februar",
+ "Mart",
+ "April",
+ "Maj",
+ "Jun",
+ "Jul",
+ "Avgust",
+ "Septembar",
+ "Oktobar",
+ "Novembar",
+ "Decembar"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Maj",
+ "Jun",
+ "Jul",
+ "Avg",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Nedelja",
+ "Ponedeljak",
+ "Utorak",
+ "Sreda",
+ "Četvrtak",
+ "Petak",
+ "Subota"
+ ],
+ "shortDays": ["Ned", "Pon", "Uto", "Sre", "Čet", "Pet", "Sub"],
+ "toolbar": {
+ "exportToSVG": "Preuzmi SVG",
+ "exportToPNG": "Preuzmi PNG",
+ "exportToCSV": "Preuzmi CSV",
+ "menu": "Meni",
+ "selection": "Odabir",
+ "selectionZoom": "Odabirno povećanje",
+ "zoomIn": "Uvećajte prikaz",
+ "zoomOut": "Umanjite prikaz",
+ "pan": "Pomeranje",
+ "reset": "Resetuj prikaz"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ru.json b/cao_sunyata/static/libs/apexcharts/src/locales/ru.json
new file mode 100644
index 0000000..55f3a0c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ru.json
@@ -0,0 +1,55 @@
+{
+ "name": "ru",
+ "options": {
+ "months": [
+ "Январь",
+ "Февраль",
+ "Март",
+ "Апрель",
+ "Май",
+ "Июнь",
+ "Июль",
+ "Август",
+ "Сентябрь",
+ "Октябрь",
+ "Ноябрь",
+ "Декабрь"
+ ],
+ "shortMonths": [
+ "Янв",
+ "Фев",
+ "Мар",
+ "Апр",
+ "Май",
+ "Июн",
+ "Июл",
+ "Авг",
+ "Сен",
+ "Окт",
+ "Ноя",
+ "Дек"
+ ],
+ "days": [
+ "Воскресенье",
+ "Понедельник",
+ "Вторник",
+ "Среда",
+ "Четверг",
+ "Пятница",
+ "Суббота"
+ ],
+ "shortDays": ["Вс", "Пн", "Вт", "Ср", "Чт", "Пт", "Сб"],
+ "toolbar": {
+ "exportToSVG": "Сохранить SVG",
+ "exportToPNG": "Сохранить PNG",
+ "exportToCSV": "Сохранить CSV",
+ "menu": "Меню",
+ "selection": "Выбор",
+ "selectionZoom": "Выбор с увеличением",
+ "zoomIn": "Увеличить",
+ "zoomOut": "Уменьшить",
+ "pan": "Перемещение",
+ "reset": "Сбросить увеличение"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/se.json b/cao_sunyata/static/libs/apexcharts/src/locales/se.json
new file mode 100644
index 0000000..e9409e5
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/se.json
@@ -0,0 +1,55 @@
+{
+ "name": "se",
+ "options": {
+ "months": [
+ "Januari",
+ "Februari",
+ "Mars",
+ "April",
+ "Maj",
+ "Juni",
+ "Juli",
+ "Augusti",
+ "September",
+ "Oktober",
+ "November",
+ "December"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Maj",
+ "Juni",
+ "Juli",
+ "Aug",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Söndag",
+ "Måndag",
+ "Tisdag",
+ "Onsdag",
+ "Torsdag",
+ "Fredag",
+ "Lördag"
+ ],
+ "shortDays": ["Sön", "Mån", "Tis", "Ons", "Tor", "Fre", "Lör"],
+ "toolbar": {
+ "exportToSVG": "Ladda SVG",
+ "exportToPNG": "Ladda PNG",
+ "exportToCSV": "Ladda CSV",
+ "menu": "Meny",
+ "selection": "Selektion",
+ "selectionZoom": "Val av zoom",
+ "zoomIn": "Zooma in",
+ "zoomOut": "Zooma ut",
+ "pan": "Panorering",
+ "reset": "Återställ zoomning"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/sk.json b/cao_sunyata/static/libs/apexcharts/src/locales/sk.json
new file mode 100644
index 0000000..03e69aa
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/sk.json
@@ -0,0 +1,55 @@
+{
+ "name": "sk",
+ "options": {
+ "months": [
+ "Január",
+ "Február",
+ "Marec",
+ "Apríl",
+ "Máj",
+ "Jún",
+ "Júl",
+ "August",
+ "September",
+ "Október",
+ "November",
+ "December"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Máj",
+ "Jún",
+ "Júl",
+ "Aug",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Nedeľa",
+ "Pondelok",
+ "Utorok",
+ "Streda",
+ "Štvrtok",
+ "Piatok",
+ "Sobota"
+ ],
+ "shortDays": ["Ne", "Po", "Ut", "St", "Št", "Pi", "So"],
+ "toolbar": {
+ "exportToSVG": "Stiahnuť SVG",
+ "exportToPNG": "Stiahnuť PNG",
+ "exportToCSV": "Stiahnuť CSV",
+ "menu": "Menu",
+ "selection": "Vyberanie",
+ "selectionZoom": "Zoom: Vyberanie",
+ "zoomIn": "Zoom: Priblížiť",
+ "zoomOut": "Zoom: Vzdialiť",
+ "pan": "Presúvanie",
+ "reset": "Resetovať"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/sl.json b/cao_sunyata/static/libs/apexcharts/src/locales/sl.json
new file mode 100644
index 0000000..793ff56
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/sl.json
@@ -0,0 +1,55 @@
+{
+ "name": "sl",
+ "options": {
+ "months": [
+ "Januar",
+ "Februar",
+ "Marec",
+ "April",
+ "Maj",
+ "Junij",
+ "Julij",
+ "Avgust",
+ "Septemer",
+ "Oktober",
+ "November",
+ "December"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "Maj",
+ "Jun",
+ "Jul",
+ "Avg",
+ "Sep",
+ "Okt",
+ "Nov",
+ "Dec"
+ ],
+ "days": [
+ "Nedelja",
+ "Ponedeljek",
+ "Torek",
+ "Sreda",
+ "Četrtek",
+ "Petek",
+ "Sobota"
+ ],
+ "shortDays": ["Ne", "Po", "To", "Sr", "Če", "Pe", "So"],
+ "toolbar": {
+ "exportToSVG": "Prenesi SVG",
+ "exportToPNG": "Prenesi PNG",
+ "exportToCSV": "Prenesi CSV",
+ "menu": "Menu",
+ "selection": "Izbiranje",
+ "selectionZoom": "Zoom: Izbira",
+ "zoomIn": "Zoom: Približaj",
+ "zoomOut": "Zoom: Oddalji",
+ "pan": "Pomikanje",
+ "reset": "Resetiraj"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/sq.json b/cao_sunyata/static/libs/apexcharts/src/locales/sq.json
new file mode 100644
index 0000000..a478591
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/sq.json
@@ -0,0 +1,55 @@
+{
+ "name": "sq",
+ "options": {
+ "months": [
+ "Janar",
+ "Shkurt",
+ "Mars",
+ "Prill",
+ "Maj",
+ "Qershor",
+ "Korrik",
+ "Gusht",
+ "Shtator",
+ "Tetor",
+ "Nëntor",
+ "Dhjetor"
+ ],
+ "shortMonths": [
+ "Jan",
+ "Shk",
+ "Mar",
+ "Pr",
+ "Maj",
+ "Qer",
+ "Korr",
+ "Gush",
+ "Sht",
+ "Tet",
+ "Nën",
+ "Dhj"
+ ],
+ "days": [
+ "e Dielë",
+ "e Hënë",
+ "e Martë",
+ "e Mërkurë",
+ "e Enjte",
+ "e Premte",
+ "e Shtunë"
+ ],
+ "shortDays": ["Die", "Hën", "Mar", "Mër", "Enj", "Pre", "Sht"],
+ "toolbar": {
+ "exportToSVG": "Shkarko SVG",
+ "exportToPNG": "Shkarko PNG",
+ "exportToCSV": "Shkarko CSV",
+ "menu": "Menu",
+ "selection": "Seleksiono",
+ "selectionZoom": "Seleksiono Zmadhim",
+ "zoomIn": "Zmadho",
+ "zoomOut": "Zvogëlo",
+ "pan": "Spostoje",
+ "reset": "Rikthe dimensionin"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/th.json b/cao_sunyata/static/libs/apexcharts/src/locales/th.json
new file mode 100644
index 0000000..2b3b109
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/th.json
@@ -0,0 +1,55 @@
+{
+ "name": "th",
+ "options": {
+ "months": [
+ "มกราคม",
+ "กุมภาพันธ์",
+ "มีนาคม",
+ "เมษายน",
+ "พฤษภาคม",
+ "มิถุนายน",
+ "กรกฎาคม",
+ "สิงหาคม",
+ "กันยายน",
+ "ตุลาคม",
+ "พฤศจิกายน",
+ "ธันวาคม"
+ ],
+ "shortMonths": [
+ "ม.ค.",
+ "ก.พ.",
+ "มี.ค.",
+ "เม.ย.",
+ "พ.ค.",
+ "มิ.ย.",
+ "ก.ค.",
+ "ส.ค.",
+ "ก.ย.",
+ "ต.ค.",
+ "พ.ย.",
+ "ธ.ค."
+ ],
+ "days": [
+ "อาทิตย์",
+ "จันทร์",
+ "อังคาร",
+ "พุธ",
+ "พฤหัสบดี",
+ "ศุกร์",
+ "เสาร์"
+ ],
+ "shortDays": ["อา", "จ", "อ", "พ", "พฤ", "ศ", "ส"],
+ "toolbar": {
+ "exportToSVG": "ดาวน์โหลด SVG",
+ "exportToPNG": "ดาวน์โหลด PNG",
+ "exportToCSV": "ดาวน์โหลด CSV",
+ "menu": "เมนู",
+ "selection": "เลือก",
+ "selectionZoom": "เลือกจุดที่จะซูม",
+ "zoomIn": "ซูมเข้า",
+ "zoomOut": "ซูมออก",
+ "pan": "ปรากฎว่า",
+ "reset": "รีเซ็ตการซูม"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/tr.json b/cao_sunyata/static/libs/apexcharts/src/locales/tr.json
new file mode 100644
index 0000000..dda01e8
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/tr.json
@@ -0,0 +1,55 @@
+{
+ "name": "tr",
+ "options": {
+ "months": [
+ "Ocak",
+ "Şubat",
+ "Mart",
+ "Nisan",
+ "Mayıs",
+ "Haziran",
+ "Temmuz",
+ "Ağustos",
+ "Eylül",
+ "Ekim",
+ "Kasım",
+ "Aralık"
+ ],
+ "shortMonths": [
+ "Oca",
+ "Şub",
+ "Mar",
+ "Nis",
+ "May",
+ "Haz",
+ "Tem",
+ "Ağu",
+ "Eyl",
+ "Eki",
+ "Kas",
+ "Ara"
+ ],
+ "days": [
+ "Pazar",
+ "Pazartesi",
+ "Salı",
+ "Çarşamba",
+ "Perşembe",
+ "Cuma",
+ "Cumartesi"
+ ],
+ "shortDays": ["Paz", "Pzt", "Sal", "Çar", "Per", "Cum", "Cmt"],
+ "toolbar": {
+ "exportToSVG": "SVG İndir",
+ "exportToPNG": "PNG İndir",
+ "exportToCSV": "CSV İndir",
+ "menu": "Menü",
+ "selection": "Seçim",
+ "selectionZoom": "Seçim Yakınlaştır",
+ "zoomIn": "Yakınlaştır",
+ "zoomOut": "Uzaklaştır",
+ "pan": "Kaydır",
+ "reset": "Yakınlaştırmayı Sıfırla"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/ua.json b/cao_sunyata/static/libs/apexcharts/src/locales/ua.json
new file mode 100644
index 0000000..d6f81de
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/ua.json
@@ -0,0 +1,55 @@
+{
+ "name": "ua",
+ "options": {
+ "months": [
+ "Січень",
+ "Лютий",
+ "Березень",
+ "Квітень",
+ "Травень",
+ "Червень",
+ "Липень",
+ "Серпень",
+ "Вересень",
+ "Жовтень",
+ "Листопад",
+ "Грудень"
+ ],
+ "shortMonths": [
+ "Січ",
+ "Лют",
+ "Бер",
+ "Кві",
+ "Тра",
+ "Чер",
+ "Лип",
+ "Сер",
+ "Вер",
+ "Жов",
+ "Лис",
+ "Гру"
+ ],
+ "days": [
+ "Неділя",
+ "Понеділок",
+ "Вівторок",
+ "Середа",
+ "Четвер",
+ "П'ятниця",
+ "Субота"
+ ],
+ "shortDays": ["Нд", "Пн", "Вт", "Ср", "Чт", "Пт", "Сб"],
+ "toolbar": {
+ "exportToSVG": "Зберегти SVG",
+ "exportToPNG": "Зберегти PNG",
+ "exportToCSV": "Зберегти CSV",
+ "menu": "Меню",
+ "selection": "Вибір",
+ "selectionZoom": "Вибір із збільшенням",
+ "zoomIn": "Збільшити",
+ "zoomOut": "Зменшити",
+ "pan": "Переміщення",
+ "reset": "Скинути збільшення"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/zh-cn.json b/cao_sunyata/static/libs/apexcharts/src/locales/zh-cn.json
new file mode 100644
index 0000000..8944659
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/zh-cn.json
@@ -0,0 +1,55 @@
+{
+ "name": "zh-cn",
+ "options": {
+ "months": [
+ "一月",
+ "二月",
+ "三月",
+ "四月",
+ "五月",
+ "六月",
+ "七月",
+ "八月",
+ "九月",
+ "十月",
+ "十一月",
+ "十二月"
+ ],
+ "shortMonths": [
+ "一月",
+ "二月",
+ "三月",
+ "四月",
+ "五月",
+ "六月",
+ "七月",
+ "八月",
+ "九月",
+ "十月",
+ "十一月",
+ "十二月"
+ ],
+ "days": [
+ "星期天",
+ "星期一",
+ "星期二",
+ "星期三",
+ "星期四",
+ "星期五",
+ "星期六"
+ ],
+ "shortDays": ["周日", "周一", "周二", "周三", "周四", "周五", "周六"],
+ "toolbar": {
+ "exportToSVG": "下载 SVG",
+ "exportToPNG": "下载 PNG",
+ "exportToCSV": "下载 CSV",
+ "menu": "菜单",
+ "selection": "选择",
+ "selectionZoom": "选择缩放",
+ "zoomIn": "放大",
+ "zoomOut": "缩小",
+ "pan": "平移",
+ "reset": "重置缩放"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/locales/zh-tw.json b/cao_sunyata/static/libs/apexcharts/src/locales/zh-tw.json
new file mode 100644
index 0000000..8e3bd1e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/locales/zh-tw.json
@@ -0,0 +1,55 @@
+{
+ "name": "zh-tw",
+ "options": {
+ "months": [
+ "一月",
+ "二月",
+ "三月",
+ "四月",
+ "五月",
+ "六月",
+ "七月",
+ "八月",
+ "九月",
+ "十月",
+ "十一月",
+ "十二月"
+ ],
+ "shortMonths": [
+ "一月",
+ "二月",
+ "三月",
+ "四月",
+ "五月",
+ "六月",
+ "七月",
+ "八月",
+ "九月",
+ "十月",
+ "十一月",
+ "十二月"
+ ],
+ "days": [
+ "星期日",
+ "星期一",
+ "星期二",
+ "星期三",
+ "星期四",
+ "星期五",
+ "星期六"
+ ],
+ "shortDays": ["週日", "週一", "週二", "週三", "週四", "週五", "週六"],
+ "toolbar": {
+ "exportToSVG": "下載 SVG",
+ "exportToPNG": "下載 PNG",
+ "exportToCSV": "下載 CSV",
+ "menu": "菜單",
+ "selection": "選擇",
+ "selectionZoom": "選擇縮放",
+ "zoomIn": "放大",
+ "zoomOut": "縮小",
+ "pan": "平移",
+ "reset": "重置縮放"
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Animations.js b/cao_sunyata/static/libs/apexcharts/src/modules/Animations.js
new file mode 100644
index 0000000..6f28d63
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Animations.js
@@ -0,0 +1,261 @@
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Animation Class.
+ *
+ * @module Animations
+ **/
+
+export default class Animations {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.setEasingFunctions()
+ }
+
+ setEasingFunctions() {
+ let easing
+
+ if (this.w.globals.easing) return
+
+ const userDefinedEasing = this.w.config.chart.animations.easing
+
+ switch (userDefinedEasing) {
+ case 'linear': {
+ easing = '-'
+ break
+ }
+ case 'easein': {
+ easing = '<'
+ break
+ }
+ case 'easeout': {
+ easing = '>'
+ break
+ }
+ case 'easeinout': {
+ easing = '<>'
+ break
+ }
+ case 'swing': {
+ easing = (pos) => {
+ let s = 1.70158
+ let ret = (pos -= 1) * pos * ((s + 1) * pos + s) + 1
+ return ret
+ }
+ break
+ }
+ case 'bounce': {
+ easing = (pos) => {
+ let ret = ''
+ if (pos < 1 / 2.75) {
+ ret = 7.5625 * pos * pos
+ } else if (pos < 2 / 2.75) {
+ ret = 7.5625 * (pos -= 1.5 / 2.75) * pos + 0.75
+ } else if (pos < 2.5 / 2.75) {
+ ret = 7.5625 * (pos -= 2.25 / 2.75) * pos + 0.9375
+ } else {
+ ret = 7.5625 * (pos -= 2.625 / 2.75) * pos + 0.984375
+ }
+ return ret
+ }
+ break
+ }
+ case 'elastic': {
+ easing = (pos) => {
+ if (pos === !!pos) return pos
+ return (
+ Math.pow(2, -10 * pos) *
+ Math.sin(((pos - 0.075) * (2 * Math.PI)) / 0.3) +
+ 1
+ )
+ }
+ break
+ }
+
+ default: {
+ easing = '<>'
+ }
+ }
+
+ this.w.globals.easing = easing
+ }
+
+ animateLine(el, from, to, speed) {
+ el.attr(from)
+ .animate(speed)
+ .attr(to)
+ }
+
+ /*
+ ** Animate radius of a circle element
+ */
+ animateMarker(el, from, to, speed, easing, cb) {
+ if (!from) from = 0
+
+ el.attr({
+ r: from,
+ width: from,
+ height: from
+ })
+ .animate(speed, easing)
+ .attr({
+ r: to,
+ width: to.width,
+ height: to.height
+ })
+ .afterAll(() => {
+ cb()
+ })
+ }
+
+ /*
+ ** Animate radius and position of a circle element
+ */
+ animateCircle(el, from, to, speed, easing) {
+ el.attr({
+ r: from.r,
+ cx: from.cx,
+ cy: from.cy
+ })
+ .animate(speed, easing)
+ .attr({
+ r: to.r,
+ cx: to.cx,
+ cy: to.cy
+ })
+ }
+
+ /*
+ ** Animate rect properties
+ */
+ animateRect(el, from, to, speed, fn) {
+ el.attr(from)
+ .animate(speed)
+ .attr(to)
+ .afterAll(() => fn())
+ }
+
+ animatePathsGradually(params) {
+ let { el, realIndex, j, fill, pathFrom, pathTo, speed, delay } = params
+
+ let me = this
+ let w = this.w
+
+ let delayFactor = 0
+
+ if (w.config.chart.animations.animateGradually.enabled) {
+ delayFactor = w.config.chart.animations.animateGradually.delay
+ }
+
+ if (
+ w.config.chart.animations.dynamicAnimation.enabled &&
+ w.globals.dataChanged &&
+ w.config.chart.type !== 'bar'
+ ) {
+ // disabled due to this bug - https://github.com/apexcharts/vue-apexcharts/issues/75
+ delayFactor = 0
+ }
+ me.morphSVG(
+ el,
+ realIndex,
+ j,
+ w.config.chart.type === 'line' && !w.globals.comboCharts
+ ? 'stroke'
+ : fill,
+ pathFrom,
+ pathTo,
+ speed,
+ delay * delayFactor
+ )
+ }
+
+ showDelayedElements() {
+ this.w.globals.delayedElements.forEach((d) => {
+ const ele = d.el
+ ele.classList.remove('apexcharts-element-hidden')
+ })
+ }
+
+ animationCompleted(el) {
+ const w = this.w
+ if (w.globals.animationEnded) return
+
+ w.globals.animationEnded = true
+ this.showDelayedElements()
+
+ if (typeof w.config.chart.events.animationEnd === 'function') {
+ w.config.chart.events.animationEnd(this.ctx, { el, w })
+ }
+ }
+
+ // SVG.js animation for morphing one path to another
+ morphSVG(el, realIndex, j, fill, pathFrom, pathTo, speed, delay) {
+ let w = this.w
+
+ if (!pathFrom) {
+ pathFrom = el.attr('pathFrom')
+ }
+
+ if (!pathTo) {
+ pathTo = el.attr('pathTo')
+ }
+
+ const disableAnimationForCorrupPath = (path) => {
+ if (w.config.chart.type === 'radar') {
+ // radar chart drops the path to bottom and hence a corrup path looks ugly
+ // therefore, disable animation for such a case
+ speed = 1
+ }
+ return `M 0 ${w.globals.gridHeight}`
+ }
+
+ if (
+ !pathFrom ||
+ pathFrom.indexOf('undefined') > -1 ||
+ pathFrom.indexOf('NaN') > -1
+ ) {
+ pathFrom = disableAnimationForCorrupPath()
+ }
+
+ if (
+ !pathTo ||
+ pathTo.indexOf('undefined') > -1 ||
+ pathTo.indexOf('NaN') > -1
+ ) {
+ pathTo = disableAnimationForCorrupPath()
+ }
+ if (!w.globals.shouldAnimate) {
+ speed = 1
+ }
+
+ el.plot(pathFrom)
+ .animate(1, w.globals.easing, delay)
+ .plot(pathFrom)
+ .animate(speed, w.globals.easing, delay)
+ .plot(pathTo)
+ .afterAll(() => {
+ // a flag to indicate that the original mount function can return true now as animation finished here
+
+ if (Utils.isNumber(j)) {
+ if (
+ j === w.globals.series[w.globals.maxValsInArrayIndex].length - 2 &&
+ w.globals.shouldAnimate
+ ) {
+ this.animationCompleted(el)
+ }
+ } else if (fill !== 'none' && w.globals.shouldAnimate) {
+ if (
+ (!w.globals.comboCharts &&
+ realIndex === w.globals.series.length - 1) ||
+ w.globals.comboCharts
+ ) {
+ this.animationCompleted(el)
+ }
+ }
+
+ this.showDelayedElements()
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Base.js b/cao_sunyata/static/libs/apexcharts/src/modules/Base.js
new file mode 100644
index 0000000..87cdfb1
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Base.js
@@ -0,0 +1,25 @@
+import Config from './settings/Config'
+import Globals from './settings/Globals'
+
+/**
+ * ApexCharts Base Class for extending user options with pre-defined ApexCharts config.
+ *
+ * @module Base
+ **/
+export default class Base {
+ constructor(opts) {
+ this.opts = opts
+ }
+
+ init() {
+ const config = new Config(this.opts).init({ responsiveOverride: false })
+ const globals = new Globals().init(config)
+
+ const w = {
+ config,
+ globals
+ }
+
+ return w
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Core.js b/cao_sunyata/static/libs/apexcharts/src/modules/Core.js
new file mode 100644
index 0000000..0845739
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Core.js
@@ -0,0 +1,614 @@
+import Bar from '../charts/Bar'
+import BarStacked from '../charts/BarStacked'
+import BoxCandleStick from '../charts/BoxCandleStick'
+import CoreUtils from './CoreUtils'
+import Crosshairs from './Crosshairs'
+import HeatMap from '../charts/HeatMap'
+import Globals from '../modules/settings/Globals'
+import Pie from '../charts/Pie'
+import Radar from '../charts/Radar'
+import Radial from '../charts/Radial'
+import RangeBar from '../charts/RangeBar'
+import Legend from './legend/Legend'
+import Line from '../charts/Line'
+import Treemap from '../charts/Treemap'
+import Graphics from './Graphics'
+import Range from './Range'
+import Utils from '../utils/Utils'
+import Scales from './Scales'
+import TimeScale from './TimeScale'
+
+/**
+ * ApexCharts Core Class responsible for major calculations and creating elements.
+ *
+ * @module Core
+ **/
+
+export default class Core {
+ constructor(el, ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ this.el = el
+ }
+
+ // get data and store into appropriate vars
+
+ setupElements() {
+ let gl = this.w.globals
+ let cnf = this.w.config
+
+ // const graphics = new Graphics(this.ctx)
+
+ let ct = cnf.chart.type
+ let axisChartsArrTypes = [
+ 'line',
+ 'area',
+ 'bar',
+ 'rangeBar',
+ 'candlestick',
+ 'boxPlot',
+ 'scatter',
+ 'bubble',
+ 'radar',
+ 'heatmap',
+ 'treemap'
+ ]
+
+ let xyChartsArrTypes = [
+ 'line',
+ 'area',
+ 'bar',
+ 'rangeBar',
+ 'candlestick',
+ 'boxPlot',
+ 'scatter',
+ 'bubble'
+ ]
+
+ gl.axisCharts = axisChartsArrTypes.indexOf(ct) > -1
+
+ gl.xyCharts = xyChartsArrTypes.indexOf(ct) > -1
+
+ gl.isBarHorizontal =
+ (cnf.chart.type === 'bar' ||
+ cnf.chart.type === 'rangeBar' ||
+ cnf.chart.type === 'boxPlot') &&
+ cnf.plotOptions.bar.horizontal
+
+ gl.chartClass = '.apexcharts' + gl.chartID
+
+ gl.dom.baseEl = this.el
+
+ gl.dom.elWrap = document.createElement('div')
+ Graphics.setAttrs(gl.dom.elWrap, {
+ id: gl.chartClass.substring(1),
+ class: 'apexcharts-canvas ' + gl.chartClass.substring(1)
+ })
+ this.el.appendChild(gl.dom.elWrap)
+
+ gl.dom.Paper = new window.SVG.Doc(gl.dom.elWrap)
+ gl.dom.Paper.attr({
+ class: 'apexcharts-svg',
+ 'xmlns:data': 'ApexChartsNS',
+ transform: `translate(${cnf.chart.offsetX}, ${cnf.chart.offsetY})`
+ })
+
+ gl.dom.Paper.node.style.background = cnf.chart.background
+
+ this.setSVGDimensions()
+
+ gl.dom.elGraphical = gl.dom.Paper.group().attr({
+ class: 'apexcharts-inner apexcharts-graphical'
+ })
+
+ gl.dom.elAnnotations = gl.dom.Paper.group().attr({
+ class: 'apexcharts-annotations'
+ })
+
+ gl.dom.elDefs = gl.dom.Paper.defs()
+
+ gl.dom.elLegendWrap = document.createElement('div')
+ gl.dom.elLegendWrap.classList.add('apexcharts-legend')
+ gl.dom.elWrap.appendChild(gl.dom.elLegendWrap)
+ gl.dom.Paper.add(gl.dom.elGraphical)
+ gl.dom.elGraphical.add(gl.dom.elDefs)
+ }
+
+ plotChartType(ser, xyRatios) {
+ const w = this.w
+ const cnf = w.config
+ const gl = w.globals
+
+ let lineSeries = {
+ series: [],
+ i: []
+ }
+ let areaSeries = {
+ series: [],
+ i: []
+ }
+ let scatterSeries = {
+ series: [],
+ i: []
+ }
+
+ let bubbleSeries = {
+ series: [],
+ i: []
+ }
+
+ let columnSeries = {
+ series: [],
+ i: []
+ }
+
+ let candlestickSeries = {
+ series: [],
+ i: []
+ }
+
+ let boxplotSeries = {
+ series: [],
+ i: []
+ }
+
+ gl.series.map((series, st) => {
+ let comboCount = 0
+ // if user has specified a particular type for particular series
+ if (typeof ser[st].type !== 'undefined') {
+ if (ser[st].type === 'column' || ser[st].type === 'bar') {
+ if (gl.series.length > 1 && cnf.plotOptions.bar.horizontal) {
+ // horizontal bars not supported in mixed charts, hence show a warning
+ console.warn(
+ 'Horizontal bars are not supported in a mixed/combo chart. Please turn off `plotOptions.bar.horizontal`'
+ )
+ }
+ columnSeries.series.push(series)
+ columnSeries.i.push(st)
+ comboCount++
+ w.globals.columnSeries = columnSeries.series
+ } else if (ser[st].type === 'area') {
+ areaSeries.series.push(series)
+ areaSeries.i.push(st)
+ comboCount++
+ } else if (ser[st].type === 'line') {
+ lineSeries.series.push(series)
+ lineSeries.i.push(st)
+ comboCount++
+ } else if (ser[st].type === 'scatter') {
+ scatterSeries.series.push(series)
+ scatterSeries.i.push(st)
+ } else if (ser[st].type === 'bubble') {
+ bubbleSeries.series.push(series)
+ bubbleSeries.i.push(st)
+ comboCount++
+ } else if (ser[st].type === 'candlestick') {
+ candlestickSeries.series.push(series)
+ candlestickSeries.i.push(st)
+ comboCount++
+ } else if (ser[st].type === 'boxPlot') {
+ boxplotSeries.series.push(series)
+ boxplotSeries.i.push(st)
+ comboCount++
+ } else {
+ // user has specified type, but it is not valid (other than line/area/column)
+ console.warn(
+ 'You have specified an unrecognized chart type. Available types for this property are line/area/column/bar/scatter/bubble'
+ )
+ }
+ if (comboCount > 1) {
+ gl.comboCharts = true
+ }
+ } else {
+ lineSeries.series.push(series)
+ lineSeries.i.push(st)
+ }
+ })
+
+ let line = new Line(this.ctx, xyRatios)
+ let boxCandlestick = new BoxCandleStick(this.ctx, xyRatios)
+ this.ctx.pie = new Pie(this.ctx)
+ let radialBar = new Radial(this.ctx)
+ this.ctx.rangeBar = new RangeBar(this.ctx, xyRatios)
+ let radar = new Radar(this.ctx)
+ let elGraph = []
+
+ if (gl.comboCharts) {
+ if (areaSeries.series.length > 0) {
+ elGraph.push(line.draw(areaSeries.series, 'area', areaSeries.i))
+ }
+ if (columnSeries.series.length > 0) {
+ if (w.config.chart.stacked) {
+ let barStacked = new BarStacked(this.ctx, xyRatios)
+ elGraph.push(barStacked.draw(columnSeries.series, columnSeries.i))
+ } else {
+ this.ctx.bar = new Bar(this.ctx, xyRatios)
+ elGraph.push(this.ctx.bar.draw(columnSeries.series, columnSeries.i))
+ }
+ }
+ if (lineSeries.series.length > 0) {
+ elGraph.push(line.draw(lineSeries.series, 'line', lineSeries.i))
+ }
+ if (candlestickSeries.series.length > 0) {
+ elGraph.push(
+ boxCandlestick.draw(candlestickSeries.series, candlestickSeries.i)
+ )
+ }
+ if (boxplotSeries.series.length > 0) {
+ elGraph.push(boxCandlestick.draw(boxplotSeries.series, boxplotSeries.i))
+ }
+ if (scatterSeries.series.length > 0) {
+ const scatterLine = new Line(this.ctx, xyRatios, true)
+ elGraph.push(
+ scatterLine.draw(scatterSeries.series, 'scatter', scatterSeries.i)
+ )
+ }
+ if (bubbleSeries.series.length > 0) {
+ const bubbleLine = new Line(this.ctx, xyRatios, true)
+ elGraph.push(
+ bubbleLine.draw(bubbleSeries.series, 'bubble', bubbleSeries.i)
+ )
+ }
+ } else {
+ switch (cnf.chart.type) {
+ case 'line':
+ elGraph = line.draw(gl.series, 'line')
+ break
+ case 'area':
+ elGraph = line.draw(gl.series, 'area')
+ break
+ case 'bar':
+ if (cnf.chart.stacked) {
+ let barStacked = new BarStacked(this.ctx, xyRatios)
+ elGraph = barStacked.draw(gl.series)
+ } else {
+ this.ctx.bar = new Bar(this.ctx, xyRatios)
+ elGraph = this.ctx.bar.draw(gl.series)
+ }
+ break
+ case 'candlestick':
+ let candleStick = new BoxCandleStick(this.ctx, xyRatios)
+ elGraph = candleStick.draw(gl.series)
+ break
+ case 'boxPlot':
+ let boxPlot = new BoxCandleStick(this.ctx, xyRatios)
+ elGraph = boxPlot.draw(gl.series)
+ break
+ case 'rangeBar':
+ elGraph = this.ctx.rangeBar.draw(gl.series)
+ break
+ case 'heatmap':
+ let heatmap = new HeatMap(this.ctx, xyRatios)
+ elGraph = heatmap.draw(gl.series)
+ break
+ case 'treemap':
+ let treemap = new Treemap(this.ctx, xyRatios)
+ elGraph = treemap.draw(gl.series)
+ break
+ case 'pie':
+ case 'donut':
+ case 'polarArea':
+ elGraph = this.ctx.pie.draw(gl.series)
+ break
+ case 'radialBar':
+ elGraph = radialBar.draw(gl.series)
+ break
+ case 'radar':
+ elGraph = radar.draw(gl.series)
+ break
+ default:
+ elGraph = line.draw(gl.series)
+ }
+ }
+
+ return elGraph
+ }
+
+ setSVGDimensions() {
+ let gl = this.w.globals
+ let cnf = this.w.config
+
+ gl.svgWidth = cnf.chart.width
+ gl.svgHeight = cnf.chart.height
+
+ let elDim = Utils.getDimensions(this.el)
+
+ let widthUnit = cnf.chart.width
+ .toString()
+ .split(/[0-9]+/g)
+ .pop()
+
+ if (widthUnit === '%') {
+ if (Utils.isNumber(elDim[0])) {
+ if (elDim[0].width === 0) {
+ elDim = Utils.getDimensions(this.el.parentNode)
+ }
+
+ gl.svgWidth = (elDim[0] * parseInt(cnf.chart.width, 10)) / 100
+ }
+ } else if (widthUnit === 'px' || widthUnit === '') {
+ gl.svgWidth = parseInt(cnf.chart.width, 10)
+ }
+
+ let heightUnit = cnf.chart.height
+ .toString()
+ .split(/[0-9]+/g)
+ .pop()
+ if (gl.svgHeight !== 'auto' && gl.svgHeight !== '') {
+ if (heightUnit === '%') {
+ let elParentDim = Utils.getDimensions(this.el.parentNode)
+ gl.svgHeight = (elParentDim[1] * parseInt(cnf.chart.height, 10)) / 100
+ } else {
+ gl.svgHeight = parseInt(cnf.chart.height, 10)
+ }
+ } else {
+ if (gl.axisCharts) {
+ gl.svgHeight = gl.svgWidth / 1.61
+ } else {
+ gl.svgHeight = gl.svgWidth / 1.2
+ }
+ }
+
+ if (gl.svgWidth < 0) gl.svgWidth = 0
+ if (gl.svgHeight < 0) gl.svgHeight = 0
+
+ Graphics.setAttrs(gl.dom.Paper.node, {
+ width: gl.svgWidth,
+ height: gl.svgHeight
+ })
+
+ if (heightUnit !== '%') {
+ // fixes https://github.com/apexcharts/apexcharts.js/issues/2059
+ let offsetY = cnf.chart.sparkline.enabled
+ ? 0
+ : gl.axisCharts
+ ? cnf.chart.parentHeightOffset
+ : 0
+
+ gl.dom.Paper.node.parentNode.parentNode.style.minHeight =
+ gl.svgHeight + offsetY + 'px'
+ }
+
+ gl.dom.elWrap.style.width = gl.svgWidth + 'px'
+ gl.dom.elWrap.style.height = gl.svgHeight + 'px'
+ }
+
+ shiftGraphPosition() {
+ let gl = this.w.globals
+
+ let tY = gl.translateY
+ let tX = gl.translateX
+
+ let scalingAttrs = {
+ transform: 'translate(' + tX + ', ' + tY + ')'
+ }
+ Graphics.setAttrs(gl.dom.elGraphical.node, scalingAttrs)
+ }
+
+ // To prevent extra spacings in the bottom of the chart, we need to recalculate the height for pie/donut/radialbar charts
+ resizeNonAxisCharts() {
+ const w = this.w
+
+ const gl = w.globals
+
+ let legendHeight = 0
+ let offY = w.config.chart.sparkline.enabled ? 1 : 15
+ offY = offY + w.config.grid.padding.bottom
+
+ if (
+ (w.config.legend.position === 'top' ||
+ w.config.legend.position === 'bottom') &&
+ w.config.legend.show &&
+ !w.config.legend.floating
+ ) {
+ legendHeight =
+ new Legend(this.ctx).legendHelpers.getLegendBBox().clwh + 10
+ }
+
+ let el = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-radialbar, .apexcharts-pie'
+ )
+
+ let chartInnerDimensions = w.globals.radialSize * 2.05
+
+ if (
+ el &&
+ !w.config.chart.sparkline.enabled &&
+ w.config.plotOptions.radialBar.startAngle !== 0
+ ) {
+ let elRadialRect = Utils.getBoundingClientRect(el)
+ chartInnerDimensions = elRadialRect.bottom
+
+ let maxHeight = elRadialRect.bottom - elRadialRect.top
+
+ chartInnerDimensions = Math.max(w.globals.radialSize * 2.05, maxHeight)
+ }
+
+ let newHeight = chartInnerDimensions + gl.translateY + legendHeight + offY
+
+ if (gl.dom.elLegendForeign) {
+ gl.dom.elLegendForeign.setAttribute('height', newHeight)
+ }
+
+ // fix apexcharts/apexcharts.js/issues/3105 (when % is provided in height, it keeps increasing)
+ if (w.config.chart.height && String(w.config.chart.height).indexOf('%') > 0)
+ return
+
+ gl.dom.elWrap.style.height = newHeight + 'px'
+
+ Graphics.setAttrs(gl.dom.Paper.node, {
+ height: newHeight
+ })
+
+ gl.dom.Paper.node.parentNode.parentNode.style.minHeight = newHeight + 'px'
+ }
+
+ /*
+ ** All the calculations for setting range in charts will be done here
+ */
+ coreCalculations() {
+ const range = new Range(this.ctx)
+ range.init()
+ }
+
+ resetGlobals() {
+ const resetxyValues = () => {
+ return this.w.config.series.map((s) => [])
+ }
+ const globalObj = new Globals()
+
+ let gl = this.w.globals
+ globalObj.initGlobalVars(gl)
+ gl.seriesXvalues = resetxyValues()
+ gl.seriesYvalues = resetxyValues()
+ }
+
+ isMultipleY() {
+ // user has supplied an array in yaxis property. So, turn on multipleYAxis flag
+ if (
+ this.w.config.yaxis.constructor === Array &&
+ this.w.config.yaxis.length > 1
+ ) {
+ this.w.globals.isMultipleYAxis = true
+ return true
+ }
+ }
+
+ xySettings() {
+ let xyRatios = null
+ const w = this.w
+
+ if (w.globals.axisCharts) {
+ if (w.config.xaxis.crosshairs.position === 'back') {
+ const crosshairs = new Crosshairs(this.ctx)
+ crosshairs.drawXCrosshairs()
+ }
+ if (w.config.yaxis[0].crosshairs.position === 'back') {
+ const crosshairs = new Crosshairs(this.ctx)
+ crosshairs.drawYCrosshairs()
+ }
+
+ if (
+ w.config.xaxis.type === 'datetime' &&
+ w.config.xaxis.labels.formatter === undefined
+ ) {
+ this.ctx.timeScale = new TimeScale(this.ctx)
+ let formattedTimeScale = []
+ if (
+ isFinite(w.globals.minX) &&
+ isFinite(w.globals.maxX) &&
+ !w.globals.isBarHorizontal
+ ) {
+ formattedTimeScale = this.ctx.timeScale.calculateTimeScaleTicks(
+ w.globals.minX,
+ w.globals.maxX
+ )
+ } else if (w.globals.isBarHorizontal) {
+ formattedTimeScale = this.ctx.timeScale.calculateTimeScaleTicks(
+ w.globals.minY,
+ w.globals.maxY
+ )
+ }
+ this.ctx.timeScale.recalcDimensionsBasedOnFormat(formattedTimeScale)
+ }
+
+ const coreUtils = new CoreUtils(this.ctx)
+ xyRatios = coreUtils.getCalculatedRatios()
+ }
+ return xyRatios
+ }
+
+ updateSourceChart(targetChart) {
+ this.ctx.w.globals.selection = undefined
+ this.ctx.updateHelpers._updateOptions(
+ {
+ chart: {
+ selection: {
+ xaxis: {
+ min: targetChart.w.globals.minX,
+ max: targetChart.w.globals.maxX
+ }
+ }
+ }
+ },
+ false,
+ false
+ )
+ }
+
+ setupBrushHandler() {
+ const w = this.w
+
+ // only for brush charts
+ if (!w.config.chart.brush.enabled) {
+ return
+ }
+
+ // if user has not defined a custom function for selection - we handle the brush chart
+ // otherwise we leave it to the user to define the functionality for selection
+ if (typeof w.config.chart.events.selection !== 'function') {
+ let targets = w.config.chart.brush.targets || [
+ w.config.chart.brush.target
+ ]
+ // retro compatibility with single target option
+ targets.forEach((target) => {
+ let targetChart = ApexCharts.getChartByID(target)
+ targetChart.w.globals.brushSource = this.ctx
+
+ if (typeof targetChart.w.config.chart.events.zoomed !== 'function') {
+ targetChart.w.config.chart.events.zoomed = () => {
+ this.updateSourceChart(targetChart)
+ }
+ }
+ if (typeof targetChart.w.config.chart.events.scrolled !== 'function') {
+ targetChart.w.config.chart.events.scrolled = () => {
+ this.updateSourceChart(targetChart)
+ }
+ }
+ })
+
+ w.config.chart.events.selection = (chart, e) => {
+ targets.forEach((target) => {
+ let targetChart = ApexCharts.getChartByID(target)
+ let yaxis = Utils.clone(w.config.yaxis)
+
+ if (
+ w.config.chart.brush.autoScaleYaxis &&
+ targetChart.w.globals.series.length === 1
+ ) {
+ const scale = new Scales(targetChart)
+ yaxis = scale.autoScaleY(targetChart, yaxis, e)
+ }
+
+ const multipleYaxis = targetChart.w.config.yaxis.reduce(
+ (acc, curr, index) => {
+ return [
+ ...acc,
+ {
+ ...targetChart.w.config.yaxis[index],
+ min: yaxis[0].min,
+ max: yaxis[0].max
+ }
+ ]
+ },
+ []
+ )
+
+ targetChart.ctx.updateHelpers._updateOptions(
+ {
+ xaxis: {
+ min: e.xaxis.min,
+ max: e.xaxis.max
+ },
+ yaxis: multipleYaxis
+ },
+ false,
+ false,
+ false,
+ false
+ )
+ })
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/CoreUtils.js b/cao_sunyata/static/libs/apexcharts/src/modules/CoreUtils.js
new file mode 100644
index 0000000..bffc3eb
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/CoreUtils.js
@@ -0,0 +1,386 @@
+/*
+ ** Util functions which are dependent on ApexCharts instance
+ */
+
+class CoreUtils {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ static checkComboSeries(series) {
+ let comboCharts = false
+ let comboBarCount = 0
+ let comboCount = 0
+
+ // if user specified a type in series too, turn on comboCharts flag
+ if (series.length && typeof series[0].type !== 'undefined') {
+ series.forEach((s) => {
+ if (
+ s.type === 'bar' ||
+ s.type === 'column' ||
+ s.type === 'candlestick' ||
+ s.type === 'boxPlot'
+ ) {
+ comboBarCount++
+ }
+ if (typeof s.type !== 'undefined') {
+ comboCount++
+ }
+ })
+ }
+ if (comboCount > 0) {
+ comboCharts = true
+ }
+
+ return {
+ comboBarCount,
+ comboCharts
+ }
+ }
+
+ /**
+ * @memberof CoreUtils
+ * returns the sum of all individual values in a multiple stacked series
+ * Eg. w.globals.series = [[32,33,43,12], [2,3,5,1]]
+ * @return [34,36,48,13]
+ **/
+ getStackedSeriesTotals() {
+ const w = this.w
+ let total = []
+
+ if (w.globals.series.length === 0) return total
+
+ for (
+ let i = 0;
+ i < w.globals.series[w.globals.maxValsInArrayIndex].length;
+ i++
+ ) {
+ let t = 0
+ for (let j = 0; j < w.globals.series.length; j++) {
+ if (typeof w.globals.series[j][i] !== 'undefined') {
+ t += w.globals.series[j][i]
+ }
+ }
+ total.push(t)
+ }
+ w.globals.stackedSeriesTotals = total
+ return total
+ }
+
+ // get total of the all values inside all series
+ getSeriesTotalByIndex(index = null) {
+ if (index === null) {
+ // non-plot chart types - pie / donut / circle
+ return this.w.config.series.reduce((acc, cur) => acc + cur, 0)
+ } else {
+ // axis charts - supporting multiple series
+ return this.w.globals.series[index].reduce((acc, cur) => acc + cur, 0)
+ }
+ }
+
+ isSeriesNull(index = null) {
+ let r = []
+ if (index === null) {
+ // non-plot chart types - pie / donut / circle
+ r = this.w.config.series.filter((d) => d !== null)
+ } else {
+ // axis charts - supporting multiple series
+ r = this.w.config.series[index].data.filter((d) => d !== null)
+ }
+
+ return r.length === 0
+ }
+
+ seriesHaveSameValues(index) {
+ return this.w.globals.series[index].every((val, i, arr) => val === arr[0])
+ }
+
+ getCategoryLabels(labels) {
+ const w = this.w
+ let catLabels = labels.slice()
+ if (w.config.xaxis.convertedCatToNumeric) {
+ catLabels = labels.map((i, li) => {
+ return w.config.xaxis.labels.formatter(i - w.globals.minX + 1)
+ })
+ }
+ return catLabels
+ }
+ // maxValsInArrayIndex is the index of series[] which has the largest number of items
+ getLargestSeries() {
+ const w = this.w
+ w.globals.maxValsInArrayIndex = w.globals.series
+ .map((a) => a.length)
+ .indexOf(
+ Math.max.apply(
+ Math,
+ w.globals.series.map((a) => a.length)
+ )
+ )
+ }
+
+ getLargestMarkerSize() {
+ const w = this.w
+ let size = 0
+
+ w.globals.markers.size.forEach((m) => {
+ size = Math.max(size, m)
+ })
+
+ if (w.config.markers.discrete && w.config.markers.discrete.length) {
+ w.config.markers.discrete.forEach((m) => {
+ size = Math.max(size, m.size)
+ })
+ }
+
+ if (size > 0) {
+ size += w.config.markers.hover.sizeOffset + 1
+ }
+
+ w.globals.markers.largestSize = size
+
+ return size
+ }
+
+ /**
+ * @memberof Core
+ * returns the sum of all values in a series
+ * Eg. w.globals.series = [[32,33,43,12], [2,3,5,1]]
+ * @return [120, 11]
+ **/
+ getSeriesTotals() {
+ const w = this.w
+
+ w.globals.seriesTotals = w.globals.series.map((ser, index) => {
+ let total = 0
+
+ if (Array.isArray(ser)) {
+ for (let j = 0; j < ser.length; j++) {
+ total += ser[j]
+ }
+ } else {
+ // for pie/donuts/gauges
+ total += ser
+ }
+
+ return total
+ })
+ }
+
+ getSeriesTotalsXRange(minX, maxX) {
+ const w = this.w
+
+ const seriesTotalsXRange = w.globals.series.map((ser, index) => {
+ let total = 0
+
+ for (let j = 0; j < ser.length; j++) {
+ if (
+ w.globals.seriesX[index][j] > minX &&
+ w.globals.seriesX[index][j] < maxX
+ ) {
+ total += ser[j]
+ }
+ }
+
+ return total
+ })
+
+ return seriesTotalsXRange
+ }
+
+ /**
+ * @memberof CoreUtils
+ * returns the percentage value of all individual values which can be used in a 100% stacked series
+ * Eg. w.globals.series = [[32, 33, 43, 12], [2, 3, 5, 1]]
+ * @return [[94.11, 91.66, 89.58, 92.30], [5.88, 8.33, 10.41, 7.7]]
+ **/
+ getPercentSeries() {
+ const w = this.w
+
+ w.globals.seriesPercent = w.globals.series.map((ser, index) => {
+ let seriesPercent = []
+ if (Array.isArray(ser)) {
+ for (let j = 0; j < ser.length; j++) {
+ let total = w.globals.stackedSeriesTotals[j]
+ let percent = 0
+ if (total) {
+ percent = (100 * ser[j]) / total
+ }
+ seriesPercent.push(percent)
+ }
+ } else {
+ const total = w.globals.seriesTotals.reduce((acc, val) => acc + val, 0)
+ let percent = (100 * ser) / total
+ seriesPercent.push(percent)
+ }
+
+ return seriesPercent
+ })
+ }
+
+ getCalculatedRatios() {
+ let gl = this.w.globals
+
+ let yRatio = []
+ let invertedYRatio = 0
+ let xRatio = 0
+ let initialXRatio = 0
+ let invertedXRatio = 0
+ let zRatio = 0
+ let baseLineY = []
+ let baseLineInvertedY = 0.1
+ let baseLineX = 0
+
+ gl.yRange = []
+ if (gl.isMultipleYAxis) {
+ for (let i = 0; i < gl.minYArr.length; i++) {
+ gl.yRange.push(Math.abs(gl.minYArr[i] - gl.maxYArr[i]))
+ baseLineY.push(0)
+ }
+ } else {
+ gl.yRange.push(Math.abs(gl.minY - gl.maxY))
+ }
+ gl.xRange = Math.abs(gl.maxX - gl.minX)
+ gl.zRange = Math.abs(gl.maxZ - gl.minZ)
+
+ // multiple y axis
+ for (let i = 0; i < gl.yRange.length; i++) {
+ yRatio.push(gl.yRange[i] / gl.gridHeight)
+ }
+
+ xRatio = gl.xRange / gl.gridWidth
+
+ initialXRatio = Math.abs(gl.initialMaxX - gl.initialMinX) / gl.gridWidth
+
+ invertedYRatio = gl.yRange / gl.gridWidth
+ invertedXRatio = gl.xRange / gl.gridHeight
+ zRatio = (gl.zRange / gl.gridHeight) * 16
+
+ if (!zRatio) {
+ zRatio = 1
+ }
+
+ if (gl.minY !== Number.MIN_VALUE && Math.abs(gl.minY) !== 0) {
+ // Negative numbers present in series
+ gl.hasNegs = true
+ }
+
+ if (gl.isMultipleYAxis) {
+ baseLineY = []
+
+ // baseline variables is the 0 of the yaxis which will be needed when there are negatives
+ for (let i = 0; i < yRatio.length; i++) {
+ baseLineY.push(-gl.minYArr[i] / yRatio[i])
+ }
+ } else {
+ baseLineY.push(-gl.minY / yRatio[0])
+
+ if (gl.minY !== Number.MIN_VALUE && Math.abs(gl.minY) !== 0) {
+ baseLineInvertedY = -gl.minY / invertedYRatio // this is for bar chart
+ baseLineX = gl.minX / xRatio
+ }
+ }
+
+ return {
+ yRatio,
+ invertedYRatio,
+ zRatio,
+ xRatio,
+ initialXRatio,
+ invertedXRatio,
+ baseLineInvertedY,
+ baseLineY,
+ baseLineX
+ }
+ }
+
+ getLogSeries(series) {
+ const w = this.w
+
+ w.globals.seriesLog = series.map((s, i) => {
+ if (w.config.yaxis[i] && w.config.yaxis[i].logarithmic) {
+ return s.map((d) => {
+ if (d === null) return null
+ return this.getLogVal(w.config.yaxis[i].logBase, d, i)
+ })
+ } else {
+ return s
+ }
+ })
+
+ return w.globals.invalidLogScale ? series : w.globals.seriesLog
+ }
+ getBaseLog(base, value) {
+ return Math.log(value) / Math.log(base)
+ }
+ getLogVal(b, d, yIndex) {
+ if (d === 0) {
+ return 0
+ }
+ const w = this.w
+ const min_log_val =
+ w.globals.minYArr[yIndex] === 0
+ ? -1 // make sure we dont calculate log of 0
+ : this.getBaseLog(b, w.globals.minYArr[yIndex])
+ const max_log_val =
+ w.globals.maxYArr[yIndex] === 0
+ ? 0 // make sure we dont calculate log of 0
+ : this.getBaseLog(b, w.globals.maxYArr[yIndex])
+ const number_of_height_levels = max_log_val - min_log_val
+ if (d < 1) return d / number_of_height_levels
+ const log_height_value = this.getBaseLog(b, d) - min_log_val
+ return log_height_value / number_of_height_levels
+ }
+
+ getLogYRatios(yRatio) {
+ const w = this.w
+ const gl = this.w.globals
+
+ gl.yLogRatio = yRatio.slice()
+
+ gl.logYRange = gl.yRange.map((yRange, i) => {
+ if (w.config.yaxis[i] && this.w.config.yaxis[i].logarithmic) {
+ let maxY = -Number.MAX_VALUE
+ let minY = Number.MIN_VALUE
+ let range = 1
+ gl.seriesLog.forEach((s, si) => {
+ s.forEach((v) => {
+ if (w.config.yaxis[si] && w.config.yaxis[si].logarithmic) {
+ maxY = Math.max(v, maxY)
+ minY = Math.min(v, minY)
+ }
+ })
+ })
+
+ range = Math.pow(gl.yRange[i], Math.abs(minY - maxY) / gl.yRange[i])
+
+ gl.yLogRatio[i] = range / gl.gridHeight
+ return range
+ }
+ })
+
+ return gl.invalidLogScale ? yRatio.slice() : gl.yLogRatio
+ }
+
+ // Some config objects can be array - and we need to extend them correctly
+ static extendArrayProps(configInstance, options, w) {
+ if (options.yaxis) {
+ options = configInstance.extendYAxis(options, w)
+ }
+ if (options.annotations) {
+ if (options.annotations.yaxis) {
+ options = configInstance.extendYAxisAnnotations(options)
+ }
+ if (options.annotations.xaxis) {
+ options = configInstance.extendXAxisAnnotations(options)
+ }
+ if (options.annotations.points) {
+ options = configInstance.extendPointAnnotations(options)
+ }
+ }
+
+ return options
+ }
+}
+
+export default CoreUtils
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Crosshairs.js b/cao_sunyata/static/libs/apexcharts/src/modules/Crosshairs.js
new file mode 100644
index 0000000..3f77823
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Crosshairs.js
@@ -0,0 +1,138 @@
+import Graphics from './Graphics'
+import Filters from './Filters'
+import Utils from '../utils/Utils'
+
+class Crosshairs {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ drawXCrosshairs() {
+ const w = this.w
+
+ let graphics = new Graphics(this.ctx)
+ let filters = new Filters(this.ctx)
+
+ let crosshairGradient = w.config.xaxis.crosshairs.fill.gradient
+ let crosshairShadow = w.config.xaxis.crosshairs.dropShadow
+
+ let fillType = w.config.xaxis.crosshairs.fill.type
+ let gradientFrom = crosshairGradient.colorFrom
+ let gradientTo = crosshairGradient.colorTo
+ let opacityFrom = crosshairGradient.opacityFrom
+ let opacityTo = crosshairGradient.opacityTo
+ let stops = crosshairGradient.stops
+
+ let shadow = 'none'
+ let dropShadow = crosshairShadow.enabled
+ let shadowLeft = crosshairShadow.left
+ let shadowTop = crosshairShadow.top
+ let shadowBlur = crosshairShadow.blur
+ let shadowColor = crosshairShadow.color
+ let shadowOpacity = crosshairShadow.opacity
+
+ let xcrosshairsFill = w.config.xaxis.crosshairs.fill.color
+
+ if (w.config.xaxis.crosshairs.show) {
+ if (fillType === 'gradient') {
+ xcrosshairsFill = graphics.drawGradient(
+ 'vertical',
+ gradientFrom,
+ gradientTo,
+ opacityFrom,
+ opacityTo,
+ null,
+ stops,
+ null
+ )
+ }
+
+ let xcrosshairs = graphics.drawRect()
+ if (w.config.xaxis.crosshairs.width === 1) {
+ // to prevent drawing 2 lines, convert rect to line
+ xcrosshairs = graphics.drawLine()
+ }
+
+ let gridHeight = w.globals.gridHeight
+ if (!Utils.isNumber(gridHeight) || gridHeight < 0) {
+ gridHeight = 0
+ }
+ let crosshairsWidth = w.config.xaxis.crosshairs.width
+ if (!Utils.isNumber(crosshairsWidth) || crosshairsWidth < 0) {
+ crosshairsWidth = 0
+ }
+
+ xcrosshairs.attr({
+ class: 'apexcharts-xcrosshairs',
+ x: 0,
+ y: 0,
+ y2: gridHeight,
+ width: crosshairsWidth,
+ height: gridHeight,
+ fill: xcrosshairsFill,
+ filter: shadow,
+ 'fill-opacity': w.config.xaxis.crosshairs.opacity,
+ stroke: w.config.xaxis.crosshairs.stroke.color,
+ 'stroke-width': w.config.xaxis.crosshairs.stroke.width,
+ 'stroke-dasharray': w.config.xaxis.crosshairs.stroke.dashArray
+ })
+
+ if (dropShadow) {
+ xcrosshairs = filters.dropShadow(xcrosshairs, {
+ left: shadowLeft,
+ top: shadowTop,
+ blur: shadowBlur,
+ color: shadowColor,
+ opacity: shadowOpacity
+ })
+ }
+
+ w.globals.dom.elGraphical.add(xcrosshairs)
+ }
+ }
+
+ drawYCrosshairs() {
+ const w = this.w
+
+ let graphics = new Graphics(this.ctx)
+
+ let crosshair = w.config.yaxis[0].crosshairs
+ const offX = w.globals.barPadForNumericAxis
+
+ if (w.config.yaxis[0].crosshairs.show) {
+ let ycrosshairs = graphics.drawLine(
+ -offX,
+ 0,
+ w.globals.gridWidth + offX,
+ 0,
+ crosshair.stroke.color,
+ crosshair.stroke.dashArray,
+ crosshair.stroke.width
+ )
+ ycrosshairs.attr({
+ class: 'apexcharts-ycrosshairs'
+ })
+
+ w.globals.dom.elGraphical.add(ycrosshairs)
+ }
+
+ // draw an invisible crosshair to help in positioning the yaxis tooltip
+ let ycrosshairsHidden = graphics.drawLine(
+ -offX,
+ 0,
+ w.globals.gridWidth + offX,
+ 0,
+ crosshair.stroke.color,
+ 0,
+ 0
+ )
+ ycrosshairsHidden.attr({
+ class: 'apexcharts-ycrosshairs-hidden'
+ })
+
+ w.globals.dom.elGraphical.add(ycrosshairsHidden)
+ }
+}
+
+export default Crosshairs
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Data.js b/cao_sunyata/static/libs/apexcharts/src/modules/Data.js
new file mode 100644
index 0000000..98906fc
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Data.js
@@ -0,0 +1,705 @@
+import CoreUtils from './CoreUtils'
+import DateTime from './../utils/DateTime'
+import Series from './Series'
+import Utils from '../utils/Utils'
+import Defaults from './settings/Defaults'
+
+export default class Data {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.twoDSeries = []
+ this.threeDSeries = []
+ this.twoDSeriesX = []
+ this.seriesGoals = []
+ this.coreUtils = new CoreUtils(this.ctx)
+ }
+
+ isMultiFormat() {
+ return this.isFormatXY() || this.isFormat2DArray()
+ }
+
+ // given format is [{x, y}, {x, y}]
+ isFormatXY() {
+ const series = this.w.config.series.slice()
+
+ const sr = new Series(this.ctx)
+ this.activeSeriesIndex = sr.getActiveConfigSeriesIndex()
+
+ if (
+ typeof series[this.activeSeriesIndex].data !== 'undefined' &&
+ series[this.activeSeriesIndex].data.length > 0 &&
+ series[this.activeSeriesIndex].data[0] !== null &&
+ typeof series[this.activeSeriesIndex].data[0].x !== 'undefined' &&
+ series[this.activeSeriesIndex].data[0] !== null
+ ) {
+ return true
+ }
+ }
+
+ // given format is [[x, y], [x, y]]
+ isFormat2DArray() {
+ const series = this.w.config.series.slice()
+
+ const sr = new Series(this.ctx)
+ this.activeSeriesIndex = sr.getActiveConfigSeriesIndex()
+
+ if (
+ typeof series[this.activeSeriesIndex].data !== 'undefined' &&
+ series[this.activeSeriesIndex].data.length > 0 &&
+ typeof series[this.activeSeriesIndex].data[0] !== 'undefined' &&
+ series[this.activeSeriesIndex].data[0] !== null &&
+ series[this.activeSeriesIndex].data[0].constructor === Array
+ ) {
+ return true
+ }
+ }
+
+ handleFormat2DArray(ser, i) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+
+ const isBoxPlot =
+ cnf.chart.type === 'boxPlot' || cnf.series[i].type === 'boxPlot'
+
+ for (let j = 0; j < ser[i].data.length; j++) {
+ if (typeof ser[i].data[j][1] !== 'undefined') {
+ if (
+ Array.isArray(ser[i].data[j][1]) &&
+ ser[i].data[j][1].length === 4 &&
+ !isBoxPlot
+ ) {
+ // candlestick nested ohlc format
+ this.twoDSeries.push(Utils.parseNumber(ser[i].data[j][1][3]))
+ } else if (ser[i].data[j].length >= 5) {
+ // candlestick non-nested ohlc format
+ this.twoDSeries.push(Utils.parseNumber(ser[i].data[j][4]))
+ } else {
+ this.twoDSeries.push(Utils.parseNumber(ser[i].data[j][1]))
+ }
+ gl.dataFormatXNumeric = true
+ }
+ if (cnf.xaxis.type === 'datetime') {
+ // if timestamps are provided and xaxis type is datetime,
+
+ let ts = new Date(ser[i].data[j][0])
+ ts = new Date(ts).getTime()
+ this.twoDSeriesX.push(ts)
+ } else {
+ this.twoDSeriesX.push(ser[i].data[j][0])
+ }
+ }
+
+ for (let j = 0; j < ser[i].data.length; j++) {
+ if (typeof ser[i].data[j][2] !== 'undefined') {
+ this.threeDSeries.push(ser[i].data[j][2])
+ gl.isDataXYZ = true
+ }
+ }
+ }
+
+ handleFormatXY(ser, i) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+
+ const dt = new DateTime(this.ctx)
+
+ let activeI = i
+ if (gl.collapsedSeriesIndices.indexOf(i) > -1) {
+ // fix #368
+ activeI = this.activeSeriesIndex
+ }
+
+ // get series
+ for (let j = 0; j < ser[i].data.length; j++) {
+ if (typeof ser[i].data[j].y !== 'undefined') {
+ if (Array.isArray(ser[i].data[j].y)) {
+ this.twoDSeries.push(
+ Utils.parseNumber(ser[i].data[j].y[ser[i].data[j].y.length - 1])
+ )
+ } else {
+ this.twoDSeries.push(Utils.parseNumber(ser[i].data[j].y))
+ }
+ }
+
+ if (
+ typeof ser[i].data[j].goals !== 'undefined' &&
+ Array.isArray(ser[i].data[j].goals)
+ ) {
+ if (typeof this.seriesGoals[i] === 'undefined') {
+ this.seriesGoals[i] = []
+ }
+ this.seriesGoals[i].push(ser[i].data[j].goals)
+ } else {
+ if (typeof this.seriesGoals[i] === 'undefined') {
+ this.seriesGoals[i] = []
+ }
+ this.seriesGoals[i].push(null)
+ }
+ }
+
+ // get seriesX
+ for (let j = 0; j < ser[activeI].data.length; j++) {
+ const isXString = typeof ser[activeI].data[j].x === 'string'
+ const isXArr = Array.isArray(ser[activeI].data[j].x)
+ const isXDate =
+ !isXArr && !!dt.isValidDate(ser[activeI].data[j].x.toString())
+
+ if (isXString || isXDate) {
+ // user supplied '01/01/2017' or a date string (a JS date object is not supported)
+ if (isXString || cnf.xaxis.convertedCatToNumeric) {
+ const isRangeColumn = gl.isBarHorizontal && gl.isRangeData
+
+ if (cnf.xaxis.type === 'datetime' && !isRangeColumn) {
+ this.twoDSeriesX.push(dt.parseDate(ser[activeI].data[j].x))
+ } else {
+ // a category and not a numeric x value
+ this.fallbackToCategory = true
+ this.twoDSeriesX.push(ser[activeI].data[j].x)
+ }
+ } else {
+ if (cnf.xaxis.type === 'datetime') {
+ this.twoDSeriesX.push(
+ dt.parseDate(ser[activeI].data[j].x.toString())
+ )
+ } else {
+ gl.dataFormatXNumeric = true
+ gl.isXNumeric = true
+ this.twoDSeriesX.push(parseFloat(ser[activeI].data[j].x))
+ }
+ }
+ } else if (isXArr) {
+ // a multiline label described in array format
+ this.fallbackToCategory = true
+ this.twoDSeriesX.push(ser[activeI].data[j].x)
+ } else {
+ // a numeric value in x property
+ gl.isXNumeric = true
+ gl.dataFormatXNumeric = true
+ this.twoDSeriesX.push(ser[activeI].data[j].x)
+ }
+ }
+
+ if (ser[i].data[0] && typeof ser[i].data[0].z !== 'undefined') {
+ for (let t = 0; t < ser[i].data.length; t++) {
+ this.threeDSeries.push(ser[i].data[t].z)
+ }
+ gl.isDataXYZ = true
+ }
+ }
+
+ handleRangeData(ser, i) {
+ const gl = this.w.globals
+
+ let range = {}
+ if (this.isFormat2DArray()) {
+ range = this.handleRangeDataFormat('array', ser, i)
+ } else if (this.isFormatXY()) {
+ range = this.handleRangeDataFormat('xy', ser, i)
+ }
+
+ gl.seriesRangeStart.push(range.start)
+ gl.seriesRangeEnd.push(range.end)
+
+ gl.seriesRangeBar.push(range.rangeUniques)
+
+ // check for overlaps to avoid clashes in a timeline chart
+ gl.seriesRangeBar.forEach((sr, si) => {
+ if (sr) {
+ sr.forEach((sarr, sarri) => {
+ sarr.y.forEach((arr, arri) => {
+ for (let sri = 0; sri < sarr.y.length; sri++) {
+ if (arri !== sri) {
+ const range1y1 = arr.y1
+ const range1y2 = arr.y2
+ const range2y1 = sarr.y[sri].y1
+ const range2y2 = sarr.y[sri].y2
+ if (range1y1 <= range2y2 && range2y1 <= range1y2) {
+ if (sarr.overlaps.indexOf(arr.rangeName) < 0) {
+ sarr.overlaps.push(arr.rangeName)
+ }
+ if (sarr.overlaps.indexOf(sarr.y[sri].rangeName) < 0) {
+ sarr.overlaps.push(sarr.y[sri].rangeName)
+ }
+ }
+ }
+ }
+ })
+ })
+ }
+ })
+
+ return range
+ }
+
+ handleCandleStickBoxData(ser, i) {
+ const gl = this.w.globals
+
+ let ohlc = {}
+ if (this.isFormat2DArray()) {
+ ohlc = this.handleCandleStickBoxDataFormat('array', ser, i)
+ } else if (this.isFormatXY()) {
+ ohlc = this.handleCandleStickBoxDataFormat('xy', ser, i)
+ }
+
+ gl.seriesCandleO[i] = ohlc.o
+ gl.seriesCandleH[i] = ohlc.h
+ gl.seriesCandleM[i] = ohlc.m
+ gl.seriesCandleL[i] = ohlc.l
+ gl.seriesCandleC[i] = ohlc.c
+
+ return ohlc
+ }
+
+ handleRangeDataFormat(format, ser, i) {
+ const rangeStart = []
+ const rangeEnd = []
+
+ const uniqueKeys = ser[i].data
+ .filter(
+ (thing, index, self) => index === self.findIndex((t) => t.x === thing.x)
+ )
+ .map((r, index) => {
+ return {
+ x: r.x,
+ overlaps: [],
+ y: []
+ }
+ })
+
+ const err =
+ 'Please provide [Start, End] values in valid format. Read more https://apexcharts.com/docs/series/#rangecharts'
+
+ const serObj = new Series(this.ctx)
+ const activeIndex = serObj.getActiveConfigSeriesIndex()
+ if (format === 'array') {
+ if (ser[activeIndex].data[0][1].length !== 2) {
+ throw new Error(err)
+ }
+ for (let j = 0; j < ser[i].data.length; j++) {
+ rangeStart.push(ser[i].data[j][1][0])
+ rangeEnd.push(ser[i].data[j][1][1])
+ }
+ } else if (format === 'xy') {
+ if (ser[activeIndex].data[0].y.length !== 2) {
+ throw new Error(err)
+ }
+ for (let j = 0; j < ser[i].data.length; j++) {
+ const id = Utils.randomId()
+ const x = ser[i].data[j].x
+ const y = {
+ y1: ser[i].data[j].y[0],
+ y2: ser[i].data[j].y[1],
+ rangeName: id
+ }
+
+ // mutating config object by adding a new property
+ // TODO: As this is specifically for timeline rangebar charts, update the docs mentioning the series only supports xy format
+ ser[i].data[j].rangeName = id
+
+ const uI = uniqueKeys.findIndex((t) => t.x === x)
+ uniqueKeys[uI].y.push(y)
+
+ rangeStart.push(y.y1)
+ rangeEnd.push(y.y2)
+ }
+ }
+
+ return {
+ start: rangeStart,
+ end: rangeEnd,
+ rangeUniques: uniqueKeys
+ }
+ }
+
+ handleCandleStickBoxDataFormat(format, ser, i) {
+ const w = this.w
+ const isBoxPlot =
+ w.config.chart.type === 'boxPlot' || w.config.series[i].type === 'boxPlot'
+
+ const serO = []
+ const serH = []
+ const serM = []
+ const serL = []
+ const serC = []
+
+ if (format === 'array') {
+ if (
+ (isBoxPlot && ser[i].data[0].length === 6) ||
+ (!isBoxPlot && ser[i].data[0].length === 5)
+ ) {
+ for (let j = 0; j < ser[i].data.length; j++) {
+ serO.push(ser[i].data[j][1])
+ serH.push(ser[i].data[j][2])
+
+ if (isBoxPlot) {
+ serM.push(ser[i].data[j][3])
+ serL.push(ser[i].data[j][4])
+ serC.push(ser[i].data[j][5])
+ } else {
+ serL.push(ser[i].data[j][3])
+ serC.push(ser[i].data[j][4])
+ }
+ }
+ } else {
+ for (let j = 0; j < ser[i].data.length; j++) {
+ if (Array.isArray(ser[i].data[j][1])) {
+ serO.push(ser[i].data[j][1][0])
+ serH.push(ser[i].data[j][1][1])
+ if (isBoxPlot) {
+ serM.push(ser[i].data[j][1][2])
+ serL.push(ser[i].data[j][1][3])
+ serC.push(ser[i].data[j][1][4])
+ } else {
+ serL.push(ser[i].data[j][1][2])
+ serC.push(ser[i].data[j][1][3])
+ }
+ }
+ }
+ }
+ } else if (format === 'xy') {
+ for (let j = 0; j < ser[i].data.length; j++) {
+ if (Array.isArray(ser[i].data[j].y)) {
+ serO.push(ser[i].data[j].y[0])
+ serH.push(ser[i].data[j].y[1])
+ if (isBoxPlot) {
+ serM.push(ser[i].data[j].y[2])
+ serL.push(ser[i].data[j].y[3])
+ serC.push(ser[i].data[j].y[4])
+ } else {
+ serL.push(ser[i].data[j].y[2])
+ serC.push(ser[i].data[j].y[3])
+ }
+ }
+ }
+ }
+
+ return {
+ o: serO,
+ h: serH,
+ m: serM,
+ l: serL,
+ c: serC
+ }
+ }
+
+ parseDataAxisCharts(ser, ctx = this.ctx) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+
+ const dt = new DateTime(ctx)
+
+ const xlabels =
+ cnf.labels.length > 0 ? cnf.labels.slice() : cnf.xaxis.categories.slice()
+
+ gl.isRangeBar = cnf.chart.type === 'rangeBar' && gl.isBarHorizontal
+
+ gl.hasGroups =
+ cnf.xaxis.type === 'category' && cnf.xaxis.group.groups.length > 0
+ if (gl.hasGroups) {
+ gl.groups = cnf.xaxis.group.groups
+ }
+
+ const handleDates = () => {
+ for (let j = 0; j < xlabels.length; j++) {
+ if (typeof xlabels[j] === 'string') {
+ // user provided date strings
+ let isDate = dt.isValidDate(xlabels[j])
+ if (isDate) {
+ this.twoDSeriesX.push(dt.parseDate(xlabels[j]))
+ } else {
+ throw new Error(
+ 'You have provided invalid Date format. Please provide a valid JavaScript Date'
+ )
+ }
+ } else {
+ // user provided timestamps
+ this.twoDSeriesX.push(xlabels[j])
+ }
+ }
+ }
+
+ for (let i = 0; i < ser.length; i++) {
+ this.twoDSeries = []
+ this.twoDSeriesX = []
+ this.threeDSeries = []
+
+ if (typeof ser[i].data === 'undefined') {
+ console.error(
+ "It is a possibility that you may have not included 'data' property in series."
+ )
+ return
+ }
+
+ if (
+ cnf.chart.type === 'rangeBar' ||
+ cnf.chart.type === 'rangeArea' ||
+ ser[i].type === 'rangeBar' ||
+ ser[i].type === 'rangeArea'
+ ) {
+ gl.isRangeData = true
+ this.handleRangeData(ser, i)
+ }
+
+ if (this.isMultiFormat()) {
+ if (this.isFormat2DArray()) {
+ this.handleFormat2DArray(ser, i)
+ } else if (this.isFormatXY()) {
+ this.handleFormatXY(ser, i)
+ }
+
+ if (
+ cnf.chart.type === 'candlestick' ||
+ ser[i].type === 'candlestick' ||
+ cnf.chart.type === 'boxPlot' ||
+ ser[i].type === 'boxPlot'
+ ) {
+ this.handleCandleStickBoxData(ser, i)
+ }
+
+ gl.series.push(this.twoDSeries)
+ gl.labels.push(this.twoDSeriesX)
+ gl.seriesX.push(this.twoDSeriesX)
+ gl.seriesGoals = this.seriesGoals
+
+ if (i === this.activeSeriesIndex && !this.fallbackToCategory) {
+ gl.isXNumeric = true
+ }
+ } else {
+ if (cnf.xaxis.type === 'datetime') {
+ // user didn't supplied [{x,y}] or [[x,y]], but single array in data.
+ // Also labels/categories were supplied differently
+ gl.isXNumeric = true
+
+ handleDates()
+
+ gl.seriesX.push(this.twoDSeriesX)
+ } else if (cnf.xaxis.type === 'numeric') {
+ gl.isXNumeric = true
+
+ if (xlabels.length > 0) {
+ this.twoDSeriesX = xlabels
+ gl.seriesX.push(this.twoDSeriesX)
+ }
+ }
+ gl.labels.push(this.twoDSeriesX)
+ const singleArray = ser[i].data.map((d) => Utils.parseNumber(d))
+ gl.series.push(singleArray)
+ }
+
+ gl.seriesZ.push(this.threeDSeries)
+
+ if (ser[i].name !== undefined) {
+ gl.seriesNames.push(ser[i].name)
+ } else {
+ gl.seriesNames.push('series-' + parseInt(i + 1, 10))
+ }
+
+ // overrided default color if user inputs color with series data
+ if (ser[i].color !== undefined) {
+ gl.seriesColors.push(ser[i].color)
+ } else {
+ gl.seriesColors.push(undefined)
+ }
+ }
+
+ return this.w
+ }
+
+ parseDataNonAxisCharts(ser) {
+ const gl = this.w.globals
+ const cnf = this.w.config
+
+ gl.series = ser.slice()
+ gl.seriesNames = cnf.labels.slice()
+ for (let i = 0; i < gl.series.length; i++) {
+ if (gl.seriesNames[i] === undefined) {
+ gl.seriesNames.push('series-' + (i + 1))
+ }
+ }
+
+ return this.w
+ }
+
+ /** User possibly set string categories in xaxis.categories or labels prop
+ * Or didn't set xaxis labels at all - in which case we manually do it.
+ * If user passed series data as [[3, 2], [4, 5]] or [{ x: 3, y: 55 }],
+ * this shouldn't be called
+ * @param {array} ser - the series which user passed to the config
+ */
+ handleExternalLabelsData(ser) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+
+ if (cnf.xaxis.categories.length > 0) {
+ // user provided labels in xaxis.category prop
+ gl.labels = cnf.xaxis.categories
+ } else if (cnf.labels.length > 0) {
+ // user provided labels in labels props
+ gl.labels = cnf.labels.slice()
+ } else if (this.fallbackToCategory) {
+ // user provided labels in x prop in [{ x: 3, y: 55 }] data, and those labels are already stored in gl.labels[0], so just re-arrange the gl.labels array
+ gl.labels = gl.labels[0]
+
+ if (gl.seriesRangeBar.length) {
+ gl.seriesRangeBar.map((srt) => {
+ srt.forEach((sr) => {
+ if (gl.labels.indexOf(sr.x) < 0 && sr.x) {
+ gl.labels.push(sr.x)
+ }
+ })
+ })
+ gl.labels = gl.labels.filter(
+ (elem, pos, arr) => arr.indexOf(elem) === pos
+ )
+ }
+
+ if (cnf.xaxis.convertedCatToNumeric) {
+ const defaults = new Defaults(cnf)
+ defaults.convertCatToNumericXaxis(cnf, this.ctx, gl.seriesX[0])
+ this._generateExternalLabels(ser)
+ }
+ } else {
+ this._generateExternalLabels(ser)
+ }
+ }
+
+ _generateExternalLabels(ser) {
+ const gl = this.w.globals
+ const cnf = this.w.config
+ // user didn't provided any labels, fallback to 1-2-3-4-5
+ let labelArr = []
+
+ if (gl.axisCharts) {
+ if (gl.series.length > 0) {
+ if (this.isFormatXY()) {
+ // in case there is a combo chart (boxplot/scatter)
+ // and there are duplicated x values, we need to eliminate duplicates
+ const seriesDataFiltered = cnf.series.map((serie, s) => {
+ return serie.data.filter(
+ (v, i, a) => a.findIndex((t) => t.x === v.x) === i
+ )
+ })
+
+ const len = seriesDataFiltered.reduce(
+ (p, c, i, a) => (a[p].length > c.length ? p : i),
+ 0
+ )
+
+ for (let i = 0; i < seriesDataFiltered[len].length; i++) {
+ labelArr.push(i + 1)
+ }
+ } else {
+ for (let i = 0; i < gl.series[gl.maxValsInArrayIndex].length; i++) {
+ labelArr.push(i + 1)
+ }
+ }
+ }
+
+ gl.seriesX = []
+ // create gl.seriesX as it will be used in calculations of x positions
+ for (let i = 0; i < ser.length; i++) {
+ gl.seriesX.push(labelArr)
+ }
+
+ // turn on the isXNumeric flag to allow minX and maxX to function properly
+ gl.isXNumeric = true
+ }
+
+ // no series to pull labels from, put a 0-10 series
+ // possibly, user collapsed all series. Hence we can't work with above calc
+ if (labelArr.length === 0) {
+ labelArr = gl.axisCharts
+ ? []
+ : gl.series.map((gls, glsi) => {
+ return glsi + 1
+ })
+ for (let i = 0; i < ser.length; i++) {
+ gl.seriesX.push(labelArr)
+ }
+ }
+
+ // Finally, pass the labelArr in gl.labels which will be printed on x-axis
+ gl.labels = labelArr
+
+ if (cnf.xaxis.convertedCatToNumeric) {
+ gl.categoryLabels = labelArr.map((l) => {
+ return cnf.xaxis.labels.formatter(l)
+ })
+ }
+
+ // Turn on this global flag to indicate no labels were provided by user
+ gl.noLabelsProvided = true
+ }
+
+ // Segregate user provided data into appropriate vars
+ parseData(ser) {
+ let w = this.w
+ let cnf = w.config
+ let gl = w.globals
+ this.excludeCollapsedSeriesInYAxis()
+
+ // If we detected string in X prop of series, we fallback to category x-axis
+ this.fallbackToCategory = false
+
+ this.ctx.core.resetGlobals()
+ this.ctx.core.isMultipleY()
+
+ if (gl.axisCharts) {
+ // axisCharts includes line / area / column / scatter
+ this.parseDataAxisCharts(ser)
+ } else {
+ // non-axis charts are pie / donut
+ this.parseDataNonAxisCharts(ser)
+ }
+
+ this.coreUtils.getLargestSeries()
+
+ // set Null values to 0 in all series when user hides/shows some series
+ if (cnf.chart.type === 'bar' && cnf.chart.stacked) {
+ const series = new Series(this.ctx)
+ gl.series = series.setNullSeriesToZeroValues(gl.series)
+ }
+
+ this.coreUtils.getSeriesTotals()
+ if (gl.axisCharts) {
+ this.coreUtils.getStackedSeriesTotals()
+ }
+
+ this.coreUtils.getPercentSeries()
+
+ if (
+ !gl.dataFormatXNumeric &&
+ (!gl.isXNumeric ||
+ (cnf.xaxis.type === 'numeric' &&
+ cnf.labels.length === 0 &&
+ cnf.xaxis.categories.length === 0))
+ ) {
+ // x-axis labels couldn't be detected; hence try searching every option in config
+ this.handleExternalLabelsData(ser)
+ }
+
+ // check for multiline xaxis
+ const catLabels = this.coreUtils.getCategoryLabels(gl.labels)
+ for (let l = 0; l < catLabels.length; l++) {
+ if (Array.isArray(catLabels[l])) {
+ gl.isMultiLineX = true
+ break
+ }
+ }
+ }
+
+ excludeCollapsedSeriesInYAxis() {
+ const w = this.w
+ w.globals.ignoreYAxisIndexes = w.globals.collapsedSeries.map(
+ (collapsed, i) => {
+ // fix issue #1215
+ // if stacked, not returning collapsed.index to preserve yaxis
+ if (this.w.globals.isMultipleYAxis && !w.config.chart.stacked) {
+ return collapsed.index
+ }
+ }
+ )
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/DataLabels.js b/cao_sunyata/static/libs/apexcharts/src/modules/DataLabels.js
new file mode 100644
index 0000000..c0f140f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/DataLabels.js
@@ -0,0 +1,373 @@
+import Scatter from './../charts/Scatter'
+import Graphics from './Graphics'
+import Filters from './Filters'
+
+/**
+ * ApexCharts DataLabels Class for drawing dataLabels on Axes based Charts.
+ *
+ * @module DataLabels
+ **/
+
+class DataLabels {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ // When there are many datalabels to be printed, and some of them overlaps each other in the same series, this method will take care of that
+ // Also, when datalabels exceeds the drawable area and get clipped off, we need to adjust and move some pixels to make them visible again
+ dataLabelsCorrection(
+ x,
+ y,
+ val,
+ i,
+ dataPointIndex,
+ alwaysDrawDataLabel,
+ fontSize
+ ) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+ let drawnextLabel = false //
+
+ let textRects = graphics.getTextRects(val, fontSize)
+ let width = textRects.width
+ let height = textRects.height
+
+ if (y < 0) y = 0
+ if (y > w.globals.gridHeight + height) y = w.globals.gridHeight + height / 2
+
+ // first value in series, so push an empty array
+ if (typeof w.globals.dataLabelsRects[i] === 'undefined')
+ w.globals.dataLabelsRects[i] = []
+
+ // then start pushing actual rects in that sub-array
+ w.globals.dataLabelsRects[i].push({ x, y, width, height })
+
+ let len = w.globals.dataLabelsRects[i].length - 2
+ let lastDrawnIndex =
+ typeof w.globals.lastDrawnDataLabelsIndexes[i] !== 'undefined'
+ ? w.globals.lastDrawnDataLabelsIndexes[i][
+ w.globals.lastDrawnDataLabelsIndexes[i].length - 1
+ ]
+ : 0
+
+ if (typeof w.globals.dataLabelsRects[i][len] !== 'undefined') {
+ let lastDataLabelRect = w.globals.dataLabelsRects[i][lastDrawnIndex]
+ if (
+ // next label forward and x not intersecting
+ x > lastDataLabelRect.x + lastDataLabelRect.width + 2 ||
+ y > lastDataLabelRect.y + lastDataLabelRect.height + 2 ||
+ x + width < lastDataLabelRect.x // next label is going to be drawn backwards
+ ) {
+ // the 2 indexes don't override, so OK to draw next label
+ drawnextLabel = true
+ }
+ }
+
+ if (dataPointIndex === 0 || alwaysDrawDataLabel) {
+ drawnextLabel = true
+ }
+
+ return {
+ x,
+ y,
+ textRects,
+ drawnextLabel
+ }
+ }
+
+ drawDataLabel(pos, i, j, z = null, strokeWidth = 2) {
+ // this method handles line, area, bubble, scatter charts as those charts contains markers/points which have pre-defined x/y positions
+ // all other charts like radar / bars / heatmaps will define their own drawDataLabel routine
+ let w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let dataLabelsConfig = w.config.dataLabels
+
+ let x = 0
+ let y = 0
+
+ let dataPointIndex = j
+
+ let elDataLabelsWrap = null
+
+ if (!dataLabelsConfig.enabled || !Array.isArray(pos.x)) {
+ return elDataLabelsWrap
+ }
+
+ elDataLabelsWrap = graphics.group({
+ class: 'apexcharts-data-labels'
+ })
+
+ for (let q = 0; q < pos.x.length; q++) {
+ x = pos.x[q] + dataLabelsConfig.offsetX
+ y = pos.y[q] + dataLabelsConfig.offsetY + strokeWidth
+
+ if (!isNaN(x)) {
+ // a small hack as we have 2 points for the first val to connect it
+ if (j === 1 && q === 0) dataPointIndex = 0
+ if (j === 1 && q === 1) dataPointIndex = 1
+
+ let val = w.globals.series[i][dataPointIndex]
+
+ let text = ''
+
+ const getText = (v) => {
+ return w.config.dataLabels.formatter(v, {
+ ctx: this.ctx,
+ seriesIndex: i,
+ dataPointIndex,
+ w
+ })
+ }
+
+ if (w.config.chart.type === 'bubble') {
+ val = w.globals.seriesZ[i][dataPointIndex]
+ text = getText(val)
+
+ y = pos.y[q]
+ const scatter = new Scatter(this.ctx)
+ let centerTextInBubbleCoords = scatter.centerTextInBubble(
+ y,
+ i,
+ dataPointIndex
+ )
+ y = centerTextInBubbleCoords.y
+ } else {
+ if (typeof val !== 'undefined') {
+ text = getText(val)
+ }
+ }
+
+ this.plotDataLabelsText({
+ x,
+ y,
+ text,
+ i,
+ j: dataPointIndex,
+ parent: elDataLabelsWrap,
+ offsetCorrection: true,
+ dataLabelsConfig: w.config.dataLabels
+ })
+ }
+ }
+
+ return elDataLabelsWrap
+ }
+
+ plotDataLabelsText(opts) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+ let {
+ x,
+ y,
+ i,
+ j,
+ text,
+ textAnchor,
+ fontSize,
+ parent,
+ dataLabelsConfig,
+ color,
+ alwaysDrawDataLabel,
+ offsetCorrection
+ } = opts
+
+ if (Array.isArray(w.config.dataLabels.enabledOnSeries)) {
+ if (w.config.dataLabels.enabledOnSeries.indexOf(i) < 0) {
+ return
+ }
+ }
+
+ let correctedLabels = {
+ x,
+ y,
+ drawnextLabel: true,
+ textRects: null
+ }
+
+ if (offsetCorrection) {
+ correctedLabels = this.dataLabelsCorrection(
+ x,
+ y,
+ text,
+ i,
+ j,
+ alwaysDrawDataLabel,
+ parseInt(dataLabelsConfig.style.fontSize, 10)
+ )
+ }
+
+ // when zoomed, we don't need to correct labels offsets,
+ // but if normally, labels get cropped, correct them
+ if (!w.globals.zoomed) {
+ x = correctedLabels.x
+ y = correctedLabels.y
+ }
+
+ if (correctedLabels.textRects) {
+ // fixes #2264
+ if (
+ x < -10 - correctedLabels.textRects.width ||
+ x > w.globals.gridWidth + correctedLabels.textRects.width + 10
+ ) {
+ // datalabels fall outside drawing area, so draw a blank label
+ text = ''
+ }
+ }
+
+ let dataLabelColor = w.globals.dataLabels.style.colors[i]
+ if (
+ ((w.config.chart.type === 'bar' || w.config.chart.type === 'rangeBar') &&
+ w.config.plotOptions.bar.distributed) ||
+ w.config.dataLabels.distributed
+ ) {
+ dataLabelColor = w.globals.dataLabels.style.colors[j]
+ }
+ if (typeof dataLabelColor === 'function') {
+ dataLabelColor = dataLabelColor({
+ series: w.globals.series,
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+ if (color) {
+ dataLabelColor = color
+ }
+
+ let offX = dataLabelsConfig.offsetX
+ let offY = dataLabelsConfig.offsetY
+
+ if (w.config.chart.type === 'bar' || w.config.chart.type === 'rangeBar') {
+ // for certain chart types, we handle offsets while calculating datalabels pos
+ // why? because bars/column may have negative values and based on that
+ // offsets becomes reversed
+ offX = 0
+ offY = 0
+ }
+
+ if (correctedLabels.drawnextLabel) {
+ let dataLabelText = graphics.drawText({
+ width: 100,
+ height: parseInt(dataLabelsConfig.style.fontSize, 10),
+ x: x + offX,
+ y: y + offY,
+ foreColor: dataLabelColor,
+ textAnchor: textAnchor || dataLabelsConfig.textAnchor,
+ text,
+ fontSize: fontSize || dataLabelsConfig.style.fontSize,
+ fontFamily: dataLabelsConfig.style.fontFamily,
+ fontWeight: dataLabelsConfig.style.fontWeight || 'normal'
+ })
+
+ dataLabelText.attr({
+ class: 'apexcharts-datalabel',
+ cx: x,
+ cy: y
+ })
+
+ if (dataLabelsConfig.dropShadow.enabled) {
+ const textShadow = dataLabelsConfig.dropShadow
+ const filters = new Filters(this.ctx)
+ filters.dropShadow(dataLabelText, textShadow)
+ }
+
+ parent.add(dataLabelText)
+
+ if (typeof w.globals.lastDrawnDataLabelsIndexes[i] === 'undefined') {
+ w.globals.lastDrawnDataLabelsIndexes[i] = []
+ }
+
+ w.globals.lastDrawnDataLabelsIndexes[i].push(j)
+ }
+ }
+
+ addBackgroundToDataLabel(el, coords) {
+ const w = this.w
+
+ const bCnf = w.config.dataLabels.background
+
+ const paddingH = bCnf.padding
+ const paddingV = bCnf.padding / 2
+
+ const width = coords.width
+ const height = coords.height
+ const graphics = new Graphics(this.ctx)
+ const elRect = graphics.drawRect(
+ coords.x - paddingH,
+ coords.y - paddingV / 2,
+ width + paddingH * 2,
+ height + paddingV,
+ bCnf.borderRadius,
+ w.config.chart.background === 'transparent'
+ ? '#fff'
+ : w.config.chart.background,
+ bCnf.opacity,
+ bCnf.borderWidth,
+ bCnf.borderColor
+ )
+
+ if (bCnf.dropShadow.enabled) {
+ const filters = new Filters(this.ctx)
+ filters.dropShadow(elRect, bCnf.dropShadow)
+ }
+
+ return elRect
+ }
+
+ dataLabelsBackground() {
+ const w = this.w
+
+ if (w.config.chart.type === 'bubble') return
+
+ const elDataLabels = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-datalabels text'
+ )
+
+ for (let i = 0; i < elDataLabels.length; i++) {
+ const el = elDataLabels[i]
+ const coords = el.getBBox()
+ let elRect = null
+
+ if (coords.width && coords.height) {
+ elRect = this.addBackgroundToDataLabel(el, coords)
+ }
+ if (elRect) {
+ el.parentNode.insertBefore(elRect.node, el)
+ const background = el.getAttribute('fill')
+
+ const shouldAnim =
+ w.config.chart.animations.enabled &&
+ !w.globals.resized &&
+ !w.globals.dataChanged
+
+ if (shouldAnim) {
+ elRect.animate().attr({ fill: background })
+ } else {
+ elRect.attr({ fill: background })
+ }
+ el.setAttribute('fill', w.config.dataLabels.background.foreColor)
+ }
+ }
+ }
+
+ bringForward() {
+ const w = this.w
+ const elDataLabelsNodes = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-datalabels'
+ )
+
+ const elSeries = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-plot-series:last-child'
+ )
+
+ for (let i = 0; i < elDataLabelsNodes.length; i++) {
+ if (elSeries) {
+ elSeries.insertBefore(elDataLabelsNodes[i], elSeries.nextSibling)
+ }
+ }
+ }
+}
+
+export default DataLabels
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Events.js b/cao_sunyata/static/libs/apexcharts/src/modules/Events.js
new file mode 100644
index 0000000..9a6b95c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Events.js
@@ -0,0 +1,118 @@
+import Utils from '../utils/Utils'
+
+export default class Events {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.documentEvent = Utils.bind(this.documentEvent, this)
+ }
+
+ addEventListener(name, handler) {
+ const w = this.w
+
+ if (w.globals.events.hasOwnProperty(name)) {
+ w.globals.events[name].push(handler)
+ } else {
+ w.globals.events[name] = [handler]
+ }
+ }
+
+ removeEventListener(name, handler) {
+ const w = this.w
+ if (!w.globals.events.hasOwnProperty(name)) {
+ return
+ }
+
+ let index = w.globals.events[name].indexOf(handler)
+ if (index !== -1) {
+ w.globals.events[name].splice(index, 1)
+ }
+ }
+
+ fireEvent(name, args) {
+ const w = this.w
+
+ if (!w.globals.events.hasOwnProperty(name)) {
+ return
+ }
+
+ if (!args || !args.length) {
+ args = []
+ }
+
+ let evs = w.globals.events[name]
+ let l = evs.length
+
+ for (let i = 0; i < l; i++) {
+ evs[i].apply(null, args)
+ }
+ }
+
+ setupEventHandlers() {
+ const w = this.w
+ const me = this.ctx
+
+ let clickableArea = w.globals.dom.baseEl.querySelector(w.globals.chartClass)
+
+ this.ctx.eventList.forEach((event) => {
+ clickableArea.addEventListener(
+ event,
+ (e) => {
+ const opts = Object.assign({}, w, {
+ seriesIndex: w.globals.capturedSeriesIndex,
+ dataPointIndex: w.globals.capturedDataPointIndex
+ })
+
+ if (e.type === 'mousemove' || e.type === 'touchmove') {
+ if (typeof w.config.chart.events.mouseMove === 'function') {
+ w.config.chart.events.mouseMove(e, me, opts)
+ }
+ } else if (e.type === 'mouseleave' || e.type === 'touchleave') {
+ if (typeof w.config.chart.events.mouseLeave === 'function') {
+ w.config.chart.events.mouseLeave(e, me, opts)
+ }
+ } else if (
+ (e.type === 'mouseup' && e.which === 1) ||
+ e.type === 'touchend'
+ ) {
+ if (typeof w.config.chart.events.click === 'function') {
+ w.config.chart.events.click(e, me, opts)
+ }
+ me.ctx.events.fireEvent('click', [e, me, opts])
+ }
+ },
+ { capture: false, passive: true }
+ )
+ })
+
+ this.ctx.eventList.forEach((event) => {
+ w.globals.dom.baseEl.addEventListener(event, this.documentEvent, {
+ passive: true
+ })
+ })
+
+ this.ctx.core.setupBrushHandler()
+ }
+
+ documentEvent(e) {
+ const w = this.w
+ const target = e.target.className
+
+ if (e.type === 'click') {
+ let elMenu = w.globals.dom.baseEl.querySelector('.apexcharts-menu')
+ if (
+ elMenu &&
+ elMenu.classList.contains('apexcharts-menu-open') &&
+ target !== 'apexcharts-menu-icon'
+ ) {
+ elMenu.classList.remove('apexcharts-menu-open')
+ }
+ }
+
+ w.globals.clientX =
+ e.type === 'touchmove' ? e.touches[0].clientX : e.clientX
+ w.globals.clientY =
+ e.type === 'touchmove' ? e.touches[0].clientY : e.clientY
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Exports.js b/cao_sunyata/static/libs/apexcharts/src/modules/Exports.js
new file mode 100644
index 0000000..c38ce7f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Exports.js
@@ -0,0 +1,364 @@
+import Data from '../modules/Data'
+import AxesUtils from '../modules/axes/AxesUtils'
+import Series from '../modules/Series'
+import Utils from '../utils/Utils'
+
+class Exports {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ scaleSvgNode(svg, scale) {
+ // get current both width and height of the svg
+ let svgWidth = parseFloat(svg.getAttributeNS(null, 'width'))
+ let svgHeight = parseFloat(svg.getAttributeNS(null, 'height'))
+ // set new width and height based on the scale
+ svg.setAttributeNS(null, 'width', svgWidth * scale)
+ svg.setAttributeNS(null, 'height', svgHeight * scale)
+ svg.setAttributeNS(null, 'viewBox', '0 0 ' + svgWidth + ' ' + svgHeight)
+ }
+
+ fixSvgStringForIe11(svgData) {
+ // IE11 generates broken SVG that we have to fix by using regex
+ if (!Utils.isIE11()) {
+ // not IE11 - noop
+ return svgData.replace(/ /g, ' ')
+ }
+
+ // replace second occurrence of "xmlns" attribute with "xmlns:xlink" with correct url + add xmlns:svgjs
+ let nXmlnsSeen = 0
+ let result = svgData.replace(
+ /xmlns="http:\/\/www.w3.org\/2000\/svg"/g,
+ (match) => {
+ nXmlnsSeen++
+ return nXmlnsSeen === 2
+ ? 'xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svgjs="http://svgjs.dev"'
+ : match
+ }
+ )
+
+ // remove the invalid empty namespace declarations
+ result = result.replace(/xmlns:NS\d+=""/g, '')
+ // remove these broken namespaces from attributes
+ result = result.replace(/NS\d+:(\w+:\w+=")/g, '$1')
+
+ return result
+ }
+
+ getSvgString(scale) {
+ let svgString = this.w.globals.dom.Paper.svg()
+ // in case the scale is different than 1, the svg needs to be rescaled
+ if (scale !== 1) {
+ // clone the svg node so it remains intact in the UI
+ const svgNode = this.w.globals.dom.Paper.node.cloneNode(true)
+ // scale the image
+ this.scaleSvgNode(svgNode, scale)
+ // get the string representation of the svgNode
+ svgString = new XMLSerializer().serializeToString(svgNode)
+ }
+ return this.fixSvgStringForIe11(svgString)
+ }
+
+ cleanup() {
+ const w = this.w
+
+ // hide some elements to avoid printing them on exported svg
+ const xcrosshairs = w.globals.dom.baseEl.getElementsByClassName(
+ 'apexcharts-xcrosshairs'
+ )
+ const ycrosshairs = w.globals.dom.baseEl.getElementsByClassName(
+ 'apexcharts-ycrosshairs'
+ )
+ const zoomSelectionRects = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-zoom-rect, .apexcharts-selection-rect'
+ )
+ Array.prototype.forEach.call(zoomSelectionRects, (z) => {
+ z.setAttribute('width', 0)
+ })
+ if (xcrosshairs && xcrosshairs[0]) {
+ xcrosshairs[0].setAttribute('x', -500)
+ xcrosshairs[0].setAttribute('x1', -500)
+ xcrosshairs[0].setAttribute('x2', -500)
+ }
+ if (ycrosshairs && ycrosshairs[0]) {
+ ycrosshairs[0].setAttribute('y', -100)
+ ycrosshairs[0].setAttribute('y1', -100)
+ ycrosshairs[0].setAttribute('y2', -100)
+ }
+ }
+
+ svgUrl() {
+ this.cleanup()
+
+ const svgData = this.getSvgString()
+ const svgBlob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' })
+ return URL.createObjectURL(svgBlob)
+ }
+
+ dataURI(options) {
+ return new Promise((resolve) => {
+ const w = this.w
+
+ const scale = options
+ ? options.scale || options.width / w.globals.svgWidth
+ : 1
+
+ this.cleanup()
+ const canvas = document.createElement('canvas')
+ canvas.width = w.globals.svgWidth * scale
+ canvas.height = parseInt(w.globals.dom.elWrap.style.height, 10) * scale // because of resizeNonAxisCharts
+
+ const canvasBg =
+ w.config.chart.background === 'transparent'
+ ? '#fff'
+ : w.config.chart.background
+
+ let ctx = canvas.getContext('2d')
+ ctx.fillStyle = canvasBg
+ ctx.fillRect(0, 0, canvas.width * scale, canvas.height * scale)
+
+ const svgData = this.getSvgString(scale)
+
+ if (window.canvg && Utils.isIE11()) {
+ // use canvg as a polyfill to workaround ie11 considering a canvas with loaded svg 'unsafe'
+ // without ignoreClear we lose our background color; without ignoreDimensions some grid lines become invisible
+ let v = window.canvg.Canvg.fromString(ctx, svgData, {
+ ignoreClear: true,
+ ignoreDimensions: true
+ })
+ // render the svg to canvas
+ v.start()
+
+ let blob = canvas.msToBlob()
+ // dispose - missing this will cause a memory leak
+ v.stop()
+
+ resolve({ blob })
+ } else {
+ const svgUrl = 'data:image/svg+xml,' + encodeURIComponent(svgData)
+ let img = new Image()
+ img.crossOrigin = 'anonymous'
+
+ img.onload = () => {
+ ctx.drawImage(img, 0, 0)
+
+ if (canvas.msToBlob) {
+ // IE and Edge can't navigate to data urls, so we return the blob instead
+ let blob = canvas.msToBlob()
+ resolve({ blob })
+ } else {
+ let imgURI = canvas.toDataURL('image/png')
+ resolve({ imgURI })
+ }
+ }
+
+ img.src = svgUrl
+ }
+ })
+ }
+
+ exportToSVG() {
+ this.triggerDownload(
+ this.svgUrl(),
+ this.w.config.chart.toolbar.export.svg.filename,
+ '.svg'
+ )
+ }
+
+ exportToPng() {
+ this.dataURI().then(({ imgURI, blob }) => {
+ if (blob) {
+ navigator.msSaveOrOpenBlob(blob, this.w.globals.chartID + '.png')
+ } else {
+ this.triggerDownload(
+ imgURI,
+ this.w.config.chart.toolbar.export.png.filename,
+ '.png'
+ )
+ }
+ })
+ }
+
+ exportToCSV({ series, columnDelimiter, lineDelimiter = '\n' }) {
+ const w = this.w
+
+ let columns = []
+ let rows = []
+ let result = ''
+ let universalBOM = '\uFEFF'
+
+ const isTimeStamp = (num) => {
+ return w.config.xaxis.type === 'datetime' && String(num).length >= 10
+ }
+ const dataFormat = new Data(this.ctx)
+
+ const axesUtils = new AxesUtils(this.ctx)
+ const getCat = (i) => {
+ let cat = ''
+
+ // pie / donut/ radial
+ if (!w.globals.axisCharts) {
+ cat = w.config.labels[i]
+ } else {
+ // xy charts
+
+ // non datetime
+ if (
+ w.config.xaxis.type === 'category' ||
+ w.config.xaxis.convertedCatToNumeric
+ ) {
+ if (w.globals.isBarHorizontal) {
+ let lbFormatter = w.globals.yLabelFormatters[0]
+ let sr = new Series(this.ctx)
+ let activeSeries = sr.getActiveConfigSeriesIndex()
+
+ cat = lbFormatter(w.globals.labels[i], {
+ seriesIndex: activeSeries,
+ dataPointIndex: i,
+ w
+ })
+ } else {
+ cat = axesUtils.getLabel(
+ w.globals.labels,
+ w.globals.timescaleLabels,
+ 0,
+ i
+ ).text
+ }
+ }
+
+ // datetime, but labels specified in categories or labels
+ if (w.config.xaxis.type === 'datetime') {
+ if (w.config.xaxis.categories.length) {
+ cat = w.config.xaxis.categories[i]
+ } else if (w.config.labels.length) {
+ cat = w.config.labels[i]
+ }
+ }
+ }
+
+ if (Array.isArray(cat)) {
+ cat = cat.join(' ')
+ }
+
+ return Utils.isNumber(cat) ? cat : cat.split(columnDelimiter).join('')
+ }
+
+ const handleAxisRowsColumns = (s, sI) => {
+ if (columns.length && sI === 0) {
+ rows.push(columns.join(columnDelimiter))
+ }
+
+ if (s.data && s.data.length) {
+ for (let i = 0; i < s.data.length; i++) {
+ columns = []
+
+ let cat = getCat(i)
+ if (!cat) {
+ if (dataFormat.isFormatXY()) {
+ cat = series[sI].data[i].x
+ } else if (dataFormat.isFormat2DArray()) {
+ cat = series[sI].data[i] ? series[sI].data[i][0] : ''
+ }
+ }
+
+ if (sI === 0) {
+ columns.push(
+ isTimeStamp(cat)
+ ? w.config.chart.toolbar.export.csv.dateFormatter(cat)
+ : Utils.isNumber(cat)
+ ? cat
+ : cat.split(columnDelimiter).join('')
+ )
+
+ for (let ci = 0; ci < w.globals.series.length; ci++) {
+ columns.push(w.globals.series[ci][i])
+ }
+ }
+
+ if (
+ w.config.chart.type === 'candlestick' ||
+ (s.type && s.type === 'candlestick')
+ ) {
+ columns.pop()
+ columns.push(w.globals.seriesCandleO[sI][i])
+ columns.push(w.globals.seriesCandleH[sI][i])
+ columns.push(w.globals.seriesCandleL[sI][i])
+ columns.push(w.globals.seriesCandleC[sI][i])
+ }
+
+ if (
+ w.config.chart.type === 'boxPlot' ||
+ (s.type && s.type === 'boxPlot')
+ ) {
+ columns.pop()
+ columns.push(w.globals.seriesCandleO[sI][i])
+ columns.push(w.globals.seriesCandleH[sI][i])
+ columns.push(w.globals.seriesCandleM[sI][i])
+ columns.push(w.globals.seriesCandleL[sI][i])
+ columns.push(w.globals.seriesCandleC[sI][i])
+ }
+
+ if (w.config.chart.type === 'rangeBar') {
+ columns.pop()
+ columns.push(w.globals.seriesRangeStart[sI][i])
+ columns.push(w.globals.seriesRangeEnd[sI][i])
+ }
+
+ if (columns.length) {
+ rows.push(columns.join(columnDelimiter))
+ }
+ }
+ }
+ }
+
+ columns.push(w.config.chart.toolbar.export.csv.headerCategory)
+ series.map((s, sI) => {
+ const sname = s.name ? s.name : `series-${sI}`
+ if (w.globals.axisCharts) {
+ columns.push(
+ sname.split(columnDelimiter).join('')
+ ? sname.split(columnDelimiter).join('')
+ : `series-${sI}`
+ )
+ }
+ })
+
+ if (!w.globals.axisCharts) {
+ columns.push(w.config.chart.toolbar.export.csv.headerValue)
+ rows.push(columns.join(columnDelimiter))
+ }
+ series.map((s, sI) => {
+ if (w.globals.axisCharts) {
+ handleAxisRowsColumns(s, sI)
+ } else {
+ columns = []
+
+ columns.push(w.globals.labels[sI].split(columnDelimiter).join(''))
+ columns.push(w.globals.series[sI])
+ rows.push(columns.join(columnDelimiter))
+ }
+ })
+
+ result += rows.join(lineDelimiter)
+
+ this.triggerDownload(
+ 'data:text/csv; charset=utf-8,' +
+ encodeURIComponent(universalBOM + result),
+ w.config.chart.toolbar.export.csv.filename,
+ '.csv'
+ )
+ }
+
+ triggerDownload(href, filename, ext) {
+ const downloadLink = document.createElement('a')
+ downloadLink.href = href
+ downloadLink.download = (filename ? filename : this.w.globals.chartID) + ext
+ document.body.appendChild(downloadLink)
+ downloadLink.click()
+ document.body.removeChild(downloadLink)
+ }
+}
+
+export default Exports
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Fill.js b/cao_sunyata/static/libs/apexcharts/src/modules/Fill.js
new file mode 100644
index 0000000..ce8d51b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Fill.js
@@ -0,0 +1,381 @@
+import Graphics from './Graphics'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Fill Class for setting fill options of the paths.
+ *
+ * @module Fill
+ **/
+
+class Fill {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.opts = null
+ this.seriesIndex = 0
+ }
+
+ clippedImgArea(params) {
+ let w = this.w
+ let cnf = w.config
+
+ let svgW = parseInt(w.globals.gridWidth, 10)
+ let svgH = parseInt(w.globals.gridHeight, 10)
+
+ let size = svgW > svgH ? svgW : svgH
+
+ let fillImg = params.image
+
+ let imgWidth = 0
+ let imgHeight = 0
+ if (
+ typeof params.width === 'undefined' &&
+ typeof params.height === 'undefined'
+ ) {
+ if (
+ cnf.fill.image.width !== undefined &&
+ cnf.fill.image.height !== undefined
+ ) {
+ imgWidth = cnf.fill.image.width + 1
+ imgHeight = cnf.fill.image.height
+ } else {
+ imgWidth = size + 1
+ imgHeight = size
+ }
+ } else {
+ imgWidth = params.width
+ imgHeight = params.height
+ }
+
+ let elPattern = document.createElementNS(w.globals.SVGNS, 'pattern')
+
+ Graphics.setAttrs(elPattern, {
+ id: params.patternID,
+ patternUnits: params.patternUnits
+ ? params.patternUnits
+ : 'userSpaceOnUse',
+ width: imgWidth + 'px',
+ height: imgHeight + 'px'
+ })
+
+ let elImage = document.createElementNS(w.globals.SVGNS, 'image')
+ elPattern.appendChild(elImage)
+
+ elImage.setAttributeNS(window.SVG.xlink, 'href', fillImg)
+
+ Graphics.setAttrs(elImage, {
+ x: 0,
+ y: 0,
+ preserveAspectRatio: 'none',
+ width: imgWidth + 'px',
+ height: imgHeight + 'px'
+ })
+
+ elImage.style.opacity = params.opacity
+
+ w.globals.dom.elDefs.node.appendChild(elPattern)
+ }
+
+ getSeriesIndex(opts) {
+ const w = this.w
+
+ if (
+ ((w.config.chart.type === 'bar' || w.config.chart.type === 'rangeBar') &&
+ w.config.plotOptions.bar.distributed) ||
+ w.config.chart.type === 'heatmap' ||
+ w.config.chart.type === 'treemap'
+ ) {
+ this.seriesIndex = opts.seriesNumber
+ } else {
+ this.seriesIndex = opts.seriesNumber % w.globals.series.length
+ }
+
+ return this.seriesIndex
+ }
+
+ fillPath(opts) {
+ let w = this.w
+ this.opts = opts
+
+ let cnf = this.w.config
+ let pathFill
+
+ let patternFill, gradientFill
+
+ this.seriesIndex = this.getSeriesIndex(opts)
+
+ let fillColors = this.getFillColors()
+ let fillColor = fillColors[this.seriesIndex]
+
+ //override fillcolor if user inputted color with data
+ if (w.globals.seriesColors[this.seriesIndex] !== undefined) {
+ fillColor = w.globals.seriesColors[this.seriesIndex]
+ }
+
+ if (typeof fillColor === 'function') {
+ fillColor = fillColor({
+ seriesIndex: this.seriesIndex,
+ dataPointIndex: opts.dataPointIndex,
+ value: opts.value,
+ w
+ })
+ }
+ let fillType = this.getFillType(this.seriesIndex)
+ let fillOpacity = Array.isArray(cnf.fill.opacity)
+ ? cnf.fill.opacity[this.seriesIndex]
+ : cnf.fill.opacity
+
+ if (opts.color) {
+ fillColor = opts.color
+ }
+
+ let defaultColor = fillColor
+
+ if (fillColor.indexOf('rgb') === -1) {
+ if (fillColor.length < 9) {
+ // if the hex contains alpha and is of 9 digit, skip the opacity
+ defaultColor = Utils.hexToRgba(fillColor, fillOpacity)
+ }
+ } else {
+ if (fillColor.indexOf('rgba') > -1) {
+ fillOpacity = Utils.getOpacityFromRGBA(fillColor)
+ }
+ }
+ if (opts.opacity) fillOpacity = opts.opacity
+
+ if (fillType === 'pattern') {
+ patternFill = this.handlePatternFill(
+ patternFill,
+ fillColor,
+ fillOpacity,
+ defaultColor
+ )
+ }
+
+ if (fillType === 'gradient') {
+ gradientFill = this.handleGradientFill(
+ fillColor,
+ fillOpacity,
+ this.seriesIndex
+ )
+ }
+
+ if (fillType === 'image') {
+ let imgSrc = cnf.fill.image.src
+
+ let patternID = opts.patternID ? opts.patternID : ''
+ this.clippedImgArea({
+ opacity: fillOpacity,
+ image: Array.isArray(imgSrc)
+ ? opts.seriesNumber < imgSrc.length
+ ? imgSrc[opts.seriesNumber]
+ : imgSrc[0]
+ : imgSrc,
+ width: opts.width ? opts.width : undefined,
+ height: opts.height ? opts.height : undefined,
+ patternUnits: opts.patternUnits,
+ patternID: `pattern${w.globals.cuid}${opts.seriesNumber +
+ 1}${patternID}`
+ })
+ pathFill = `url(#pattern${w.globals.cuid}${opts.seriesNumber +
+ 1}${patternID})`
+ } else if (fillType === 'gradient') {
+ pathFill = gradientFill
+ } else if (fillType === 'pattern') {
+ pathFill = patternFill
+ } else {
+ pathFill = defaultColor
+ }
+
+ // override pattern/gradient if opts.solid is true
+ if (opts.solid) {
+ pathFill = defaultColor
+ }
+
+ return pathFill
+ }
+
+ getFillType(seriesIndex) {
+ const w = this.w
+
+ if (Array.isArray(w.config.fill.type)) {
+ return w.config.fill.type[seriesIndex]
+ } else {
+ return w.config.fill.type
+ }
+ }
+
+ getFillColors() {
+ const w = this.w
+ const cnf = w.config
+ const opts = this.opts
+
+ let fillColors = []
+
+ if (w.globals.comboCharts) {
+ if (w.config.series[this.seriesIndex].type === 'line') {
+ if (Array.isArray(w.globals.stroke.colors)) {
+ fillColors = w.globals.stroke.colors
+ } else {
+ fillColors.push(w.globals.stroke.colors)
+ }
+ } else {
+ if (Array.isArray(w.globals.fill.colors)) {
+ fillColors = w.globals.fill.colors
+ } else {
+ fillColors.push(w.globals.fill.colors)
+ }
+ }
+ } else {
+ if (cnf.chart.type === 'line') {
+ if (Array.isArray(w.globals.stroke.colors)) {
+ fillColors = w.globals.stroke.colors
+ } else {
+ fillColors.push(w.globals.stroke.colors)
+ }
+ } else {
+ if (Array.isArray(w.globals.fill.colors)) {
+ fillColors = w.globals.fill.colors
+ } else {
+ fillColors.push(w.globals.fill.colors)
+ }
+ }
+ }
+
+ // colors passed in arguments
+ if (typeof opts.fillColors !== 'undefined') {
+ fillColors = []
+ if (Array.isArray(opts.fillColors)) {
+ fillColors = opts.fillColors.slice()
+ } else {
+ fillColors.push(opts.fillColors)
+ }
+ }
+
+ return fillColors
+ }
+
+ handlePatternFill(patternFill, fillColor, fillOpacity, defaultColor) {
+ const cnf = this.w.config
+ const opts = this.opts
+ let graphics = new Graphics(this.ctx)
+
+ let patternStrokeWidth =
+ cnf.fill.pattern.strokeWidth === undefined
+ ? Array.isArray(cnf.stroke.width)
+ ? cnf.stroke.width[this.seriesIndex]
+ : cnf.stroke.width
+ : Array.isArray(cnf.fill.pattern.strokeWidth)
+ ? cnf.fill.pattern.strokeWidth[this.seriesIndex]
+ : cnf.fill.pattern.strokeWidth
+ let patternLineColor = fillColor
+
+ if (Array.isArray(cnf.fill.pattern.style)) {
+ if (typeof cnf.fill.pattern.style[opts.seriesNumber] !== 'undefined') {
+ let pf = graphics.drawPattern(
+ cnf.fill.pattern.style[opts.seriesNumber],
+ cnf.fill.pattern.width,
+ cnf.fill.pattern.height,
+ patternLineColor,
+ patternStrokeWidth,
+ fillOpacity
+ )
+ patternFill = pf
+ } else {
+ patternFill = defaultColor
+ }
+ } else {
+ patternFill = graphics.drawPattern(
+ cnf.fill.pattern.style,
+ cnf.fill.pattern.width,
+ cnf.fill.pattern.height,
+ patternLineColor,
+ patternStrokeWidth,
+ fillOpacity
+ )
+ }
+ return patternFill
+ }
+
+ handleGradientFill(fillColor, fillOpacity, i) {
+ const cnf = this.w.config
+ const opts = this.opts
+ let graphics = new Graphics(this.ctx)
+ let utils = new Utils()
+
+ let type = cnf.fill.gradient.type
+ let gradientFrom = fillColor
+ let gradientTo
+ let opacityFrom =
+ cnf.fill.gradient.opacityFrom === undefined
+ ? fillOpacity
+ : Array.isArray(cnf.fill.gradient.opacityFrom)
+ ? cnf.fill.gradient.opacityFrom[i]
+ : cnf.fill.gradient.opacityFrom
+
+ if (gradientFrom.indexOf('rgba') > -1) {
+ opacityFrom = Utils.getOpacityFromRGBA(gradientFrom)
+ }
+ let opacityTo =
+ cnf.fill.gradient.opacityTo === undefined
+ ? fillOpacity
+ : Array.isArray(cnf.fill.gradient.opacityTo)
+ ? cnf.fill.gradient.opacityTo[i]
+ : cnf.fill.gradient.opacityTo
+
+ if (
+ cnf.fill.gradient.gradientToColors === undefined ||
+ cnf.fill.gradient.gradientToColors.length === 0
+ ) {
+ if (cnf.fill.gradient.shade === 'dark') {
+ gradientTo = utils.shadeColor(
+ parseFloat(cnf.fill.gradient.shadeIntensity) * -1,
+ fillColor.indexOf('rgb') > -1 ? Utils.rgb2hex(fillColor) : fillColor
+ )
+ } else {
+ gradientTo = utils.shadeColor(
+ parseFloat(cnf.fill.gradient.shadeIntensity),
+ fillColor.indexOf('rgb') > -1 ? Utils.rgb2hex(fillColor) : fillColor
+ )
+ }
+ } else {
+ if (cnf.fill.gradient.gradientToColors[opts.seriesNumber]) {
+ const gToColor = cnf.fill.gradient.gradientToColors[opts.seriesNumber]
+ gradientTo = gToColor
+ if (gToColor.indexOf('rgba') > -1) {
+ opacityTo = Utils.getOpacityFromRGBA(gToColor)
+ }
+ } else {
+ gradientTo = fillColor
+ }
+ }
+
+ if (cnf.fill.gradient.inverseColors) {
+ let t = gradientFrom
+ gradientFrom = gradientTo
+ gradientTo = t
+ }
+
+ if (gradientFrom.indexOf('rgb') > -1) {
+ gradientFrom = Utils.rgb2hex(gradientFrom)
+ }
+ if (gradientTo.indexOf('rgb') > -1) {
+ gradientTo = Utils.rgb2hex(gradientTo)
+ }
+
+ return graphics.drawGradient(
+ type,
+ gradientFrom,
+ gradientTo,
+ opacityFrom,
+ opacityTo,
+ opts.size,
+ cnf.fill.gradient.stops,
+ cnf.fill.gradient.colorStops,
+ i
+ )
+ }
+}
+
+export default Fill
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Filters.js b/cao_sunyata/static/libs/apexcharts/src/modules/Filters.js
new file mode 100644
index 0000000..1aef073
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Filters.js
@@ -0,0 +1,212 @@
+import Utils from './../utils/Utils'
+
+/**
+ * ApexCharts Filters Class for setting hover/active states on the paths.
+ *
+ * @module Formatters
+ **/
+class Filters {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ // create a re-usable filter which can be appended other filter effects and applied to multiple elements
+ getDefaultFilter(el, i) {
+ const w = this.w
+ el.unfilter(true)
+
+ let filter = new window.SVG.Filter()
+ filter.size('120%', '180%', '-5%', '-40%')
+
+ if (w.config.states.normal.filter !== 'none') {
+ this.applyFilter(
+ el,
+ i,
+ w.config.states.normal.filter.type,
+ w.config.states.normal.filter.value
+ )
+ } else {
+ if (w.config.chart.dropShadow.enabled) {
+ this.dropShadow(el, w.config.chart.dropShadow, i)
+ }
+ }
+ }
+
+ addNormalFilter(el, i) {
+ const w = this.w
+
+ // revert shadow if it was there
+ // but, ignore marker as marker don't have dropshadow yet
+ if (
+ w.config.chart.dropShadow.enabled &&
+ !el.node.classList.contains('apexcharts-marker')
+ ) {
+ this.dropShadow(el, w.config.chart.dropShadow, i)
+ }
+ }
+
+ // appends dropShadow to the filter object which can be chained with other filter effects
+ addLightenFilter(el, i, attrs) {
+ const w = this.w
+ const { intensity } = attrs
+
+ el.unfilter(true)
+
+ let filter = new window.SVG.Filter()
+
+ el.filter((add) => {
+ const shadowAttr = w.config.chart.dropShadow
+ if (shadowAttr.enabled) {
+ filter = this.addShadow(add, i, shadowAttr)
+ } else {
+ filter = add
+ }
+ filter.componentTransfer({
+ rgb: { type: 'linear', slope: 1.5, intercept: intensity }
+ })
+ })
+ el.filterer.node.setAttribute('filterUnits', 'userSpaceOnUse')
+
+ this._scaleFilterSize(el.filterer.node)
+ }
+
+ // appends dropShadow to the filter object which can be chained with other filter effects
+ addDarkenFilter(el, i, attrs) {
+ const w = this.w
+ const { intensity } = attrs
+
+ el.unfilter(true)
+
+ let filter = new window.SVG.Filter()
+
+ el.filter((add) => {
+ const shadowAttr = w.config.chart.dropShadow
+ if (shadowAttr.enabled) {
+ filter = this.addShadow(add, i, shadowAttr)
+ } else {
+ filter = add
+ }
+ filter.componentTransfer({
+ rgb: { type: 'linear', slope: intensity }
+ })
+ })
+ el.filterer.node.setAttribute('filterUnits', 'userSpaceOnUse')
+ this._scaleFilterSize(el.filterer.node)
+ }
+
+ applyFilter(el, i, filter, intensity = 0.5) {
+ switch (filter) {
+ case 'none': {
+ this.addNormalFilter(el, i)
+ break
+ }
+ case 'lighten': {
+ this.addLightenFilter(el, i, {
+ intensity
+ })
+ break
+ }
+ case 'darken': {
+ this.addDarkenFilter(el, i, {
+ intensity
+ })
+ break
+ }
+ default:
+ // do nothing
+ break
+ }
+ }
+
+ // appends dropShadow to the filter object which can be chained with other filter effects
+ addShadow(add, i, attrs) {
+ const { blur, top, left, color, opacity } = attrs
+
+ let shadowBlur = add
+ .flood(Array.isArray(color) ? color[i] : color, opacity)
+ .composite(add.sourceAlpha, 'in')
+ .offset(left, top)
+ .gaussianBlur(blur)
+ .merge(add.source)
+ return add.blend(add.source, shadowBlur)
+ }
+
+ // directly adds dropShadow to the element and returns the same element.
+ // the only way it is different from the addShadow() function is that addShadow is chainable to other filters, while this function discards all filters and add dropShadow
+ dropShadow(el, attrs, i = 0) {
+ let { top, left, blur, color, opacity, noUserSpaceOnUse } = attrs
+ const w = this.w
+
+ el.unfilter(true)
+
+ if (Utils.isIE() && w.config.chart.type === 'radialBar') {
+ // in radialbar charts, dropshadow is clipping actual drawing in IE
+ return el
+ }
+
+ color = Array.isArray(color) ? color[i] : color
+
+ el.filter((add) => {
+ let shadowBlur = null
+ if (Utils.isSafari() || Utils.isFirefox() || Utils.isIE()) {
+ // safari/firefox/IE have some alternative way to use this filter
+ shadowBlur = add
+ .flood(color, opacity)
+ .composite(add.sourceAlpha, 'in')
+ .offset(left, top)
+ .gaussianBlur(blur)
+ } else {
+ shadowBlur = add
+ .flood(color, opacity)
+ .composite(add.sourceAlpha, 'in')
+ .offset(left, top)
+ .gaussianBlur(blur)
+ .merge(add.source)
+ }
+
+ add.blend(add.source, shadowBlur)
+ })
+
+ if (!noUserSpaceOnUse) {
+ el.filterer.node.setAttribute('filterUnits', 'userSpaceOnUse')
+ }
+
+ this._scaleFilterSize(el.filterer.node)
+
+ return el
+ }
+
+ setSelectionFilter(el, realIndex, dataPointIndex) {
+ const w = this.w
+ if (typeof w.globals.selectedDataPoints[realIndex] !== 'undefined') {
+ if (
+ w.globals.selectedDataPoints[realIndex].indexOf(dataPointIndex) > -1
+ ) {
+ el.node.setAttribute('selected', true)
+ let activeFilter = w.config.states.active.filter
+ if (activeFilter !== 'none') {
+ this.applyFilter(el, realIndex, activeFilter.type, activeFilter.value)
+ }
+ }
+ }
+ }
+
+ _scaleFilterSize(el) {
+ const setAttributes = (attrs) => {
+ for (let key in attrs) {
+ if (attrs.hasOwnProperty(key)) {
+ el.setAttribute(key, attrs[key])
+ }
+ }
+ }
+ setAttributes({
+ width: '200%',
+ height: '200%',
+ x: '-50%',
+ y: '-50%'
+ })
+ }
+}
+
+export default Filters
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Formatters.js b/cao_sunyata/static/libs/apexcharts/src/modules/Formatters.js
new file mode 100644
index 0000000..70d26e9
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Formatters.js
@@ -0,0 +1,182 @@
+import DateTime from '../utils/DateTime'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Formatter Class for setting value formatters for axes as well as tooltips.
+ *
+ * @module Formatters
+ **/
+
+class Formatters {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ this.tooltipKeyFormat = 'dd MMM'
+ }
+
+ xLabelFormat(fn, val, timestamp, opts) {
+ let w = this.w
+
+ if (w.config.xaxis.type === 'datetime') {
+ if (w.config.xaxis.labels.formatter === undefined) {
+ // if user has not specified a custom formatter, use the default tooltip.x.format
+ if (w.config.tooltip.x.formatter === undefined) {
+ let datetimeObj = new DateTime(this.ctx)
+ return datetimeObj.formatDate(
+ datetimeObj.getDate(val),
+ w.config.tooltip.x.format
+ )
+ }
+ }
+ }
+
+ return fn(val, timestamp, opts)
+ }
+
+ defaultGeneralFormatter(val) {
+ if (Array.isArray(val)) {
+ return val.map((v) => {
+ return v
+ })
+ } else {
+ return val
+ }
+ }
+
+ defaultYFormatter(v, yaxe, i) {
+ let w = this.w
+
+ if (Utils.isNumber(v)) {
+ if (w.globals.yValueDecimal !== 0) {
+ v = v.toFixed(
+ yaxe.decimalsInFloat !== undefined
+ ? yaxe.decimalsInFloat
+ : w.globals.yValueDecimal
+ )
+ } else if (w.globals.maxYArr[i] - w.globals.minYArr[i] < 5) {
+ v = v.toFixed(1)
+ } else {
+ v = v.toFixed(0)
+ }
+ }
+ return v
+ }
+
+ setLabelFormatters() {
+ let w = this.w
+
+ w.globals.xaxisTooltipFormatter = (val) => {
+ return this.defaultGeneralFormatter(val)
+ }
+
+ w.globals.ttKeyFormatter = (val) => {
+ return this.defaultGeneralFormatter(val)
+ }
+
+ w.globals.ttZFormatter = (val) => {
+ return val
+ }
+
+ w.globals.legendFormatter = (val) => {
+ return this.defaultGeneralFormatter(val)
+ }
+
+ // formatter function will always overwrite format property
+ if (w.config.xaxis.labels.formatter !== undefined) {
+ w.globals.xLabelFormatter = w.config.xaxis.labels.formatter
+ } else {
+ w.globals.xLabelFormatter = (val) => {
+ if (Utils.isNumber(val)) {
+ if (
+ !w.config.xaxis.convertedCatToNumeric &&
+ w.config.xaxis.type === 'numeric'
+ ) {
+ if (Utils.isNumber(w.config.xaxis.decimalsInFloat)) {
+ return val.toFixed(w.config.xaxis.decimalsInFloat)
+ } else {
+ const diff = w.globals.maxX - w.globals.minX
+ if (diff > 0 && diff < 100) {
+ return val.toFixed(1)
+ }
+ return val.toFixed(0)
+ }
+ }
+
+ if (w.globals.isBarHorizontal) {
+ const range = w.globals.maxY - w.globals.minYArr
+ if (range < 4) {
+ return val.toFixed(1)
+ }
+ }
+ return val.toFixed(0)
+ }
+ return val
+ }
+ }
+
+ if (typeof w.config.tooltip.x.formatter === 'function') {
+ w.globals.ttKeyFormatter = w.config.tooltip.x.formatter
+ } else {
+ w.globals.ttKeyFormatter = w.globals.xLabelFormatter
+ }
+
+ if (typeof w.config.xaxis.tooltip.formatter === 'function') {
+ w.globals.xaxisTooltipFormatter = w.config.xaxis.tooltip.formatter
+ }
+
+ if (Array.isArray(w.config.tooltip.y)) {
+ w.globals.ttVal = w.config.tooltip.y
+ } else {
+ if (w.config.tooltip.y.formatter !== undefined) {
+ w.globals.ttVal = w.config.tooltip.y
+ }
+ }
+
+ if (w.config.tooltip.z.formatter !== undefined) {
+ w.globals.ttZFormatter = w.config.tooltip.z.formatter
+ }
+
+ // legend formatter - if user wants to append any global values of series to legend text
+ if (w.config.legend.formatter !== undefined) {
+ w.globals.legendFormatter = w.config.legend.formatter
+ }
+
+ // formatter function will always overwrite format property
+ w.config.yaxis.forEach((yaxe, i) => {
+ if (yaxe.labels.formatter !== undefined) {
+ w.globals.yLabelFormatters[i] = yaxe.labels.formatter
+ } else {
+ w.globals.yLabelFormatters[i] = (val) => {
+ if (!w.globals.xyCharts) return val
+
+ if (Array.isArray(val)) {
+ return val.map((v) => {
+ return this.defaultYFormatter(v, yaxe, i)
+ })
+ } else {
+ return this.defaultYFormatter(val, yaxe, i)
+ }
+ }
+ }
+ })
+
+ return w.globals
+ }
+
+ heatmapLabelFormatters() {
+ const w = this.w
+ if (w.config.chart.type === 'heatmap') {
+ w.globals.yAxisScale[0].result = w.globals.seriesNames.slice()
+
+ // get the longest string from the labels array and also apply label formatter to it
+ let longest = w.globals.seriesNames.reduce(
+ (a, b) => (a.length > b.length ? a : b),
+ 0
+ )
+ w.globals.yAxisScale[0].niceMax = longest
+ w.globals.yAxisScale[0].niceMin = longest
+ }
+ }
+}
+
+export default Formatters
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Graphics.js b/cao_sunyata/static/libs/apexcharts/src/modules/Graphics.js
new file mode 100644
index 0000000..cc70d37
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Graphics.js
@@ -0,0 +1,842 @@
+import Animations from './Animations'
+import Filters from './Filters'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Graphics Class for all drawing operations.
+ *
+ * @module Graphics
+ **/
+
+class Graphics {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ drawLine(
+ x1,
+ y1,
+ x2,
+ y2,
+ lineColor = '#a8a8a8',
+ dashArray = 0,
+ strokeWidth = null,
+ strokeLineCap = 'butt'
+ ) {
+ let w = this.w
+ let line = w.globals.dom.Paper.line().attr({
+ x1,
+ y1,
+ x2,
+ y2,
+ stroke: lineColor,
+ 'stroke-dasharray': dashArray,
+ 'stroke-width': strokeWidth,
+ 'stroke-linecap': strokeLineCap
+ })
+
+ return line
+ }
+
+ drawRect(
+ x1 = 0,
+ y1 = 0,
+ x2 = 0,
+ y2 = 0,
+ radius = 0,
+ color = '#fefefe',
+ opacity = 1,
+ strokeWidth = null,
+ strokeColor = null,
+ strokeDashArray = 0
+ ) {
+ let w = this.w
+ let rect = w.globals.dom.Paper.rect()
+
+ rect.attr({
+ x: x1,
+ y: y1,
+ width: x2 > 0 ? x2 : 0,
+ height: y2 > 0 ? y2 : 0,
+ rx: radius,
+ ry: radius,
+ opacity,
+ 'stroke-width': strokeWidth !== null ? strokeWidth : 0,
+ stroke: strokeColor !== null ? strokeColor : 'none',
+ 'stroke-dasharray': strokeDashArray
+ })
+
+ // fix apexcharts.js#1410
+ rect.node.setAttribute('fill', color)
+
+ return rect
+ }
+
+ drawPolygon(
+ polygonString,
+ stroke = '#e1e1e1',
+ strokeWidth = 1,
+ fill = 'none'
+ ) {
+ const w = this.w
+ const polygon = w.globals.dom.Paper.polygon(polygonString).attr({
+ fill,
+ stroke,
+ 'stroke-width': strokeWidth
+ })
+
+ return polygon
+ }
+
+ drawCircle(radius, attrs = null) {
+ const w = this.w
+
+ if (radius < 0) radius = 0
+ const c = w.globals.dom.Paper.circle(radius * 2)
+ if (attrs !== null) {
+ c.attr(attrs)
+ }
+ return c
+ }
+
+ drawPath({
+ d = '',
+ stroke = '#a8a8a8',
+ strokeWidth = 1,
+ fill,
+ fillOpacity = 1,
+ strokeOpacity = 1,
+ classes,
+ strokeLinecap = null,
+ strokeDashArray = 0
+ }) {
+ let w = this.w
+
+ if (strokeLinecap === null) {
+ strokeLinecap = w.config.stroke.lineCap
+ }
+
+ if (d.indexOf('undefined') > -1 || d.indexOf('NaN') > -1) {
+ d = `M 0 ${w.globals.gridHeight}`
+ }
+ let p = w.globals.dom.Paper.path(d).attr({
+ fill,
+ 'fill-opacity': fillOpacity,
+ stroke,
+ 'stroke-opacity': strokeOpacity,
+ 'stroke-linecap': strokeLinecap,
+ 'stroke-width': strokeWidth,
+ 'stroke-dasharray': strokeDashArray,
+ class: classes
+ })
+
+ return p
+ }
+
+ group(attrs = null) {
+ const w = this.w
+ const g = w.globals.dom.Paper.group()
+
+ if (attrs !== null) {
+ g.attr(attrs)
+ }
+ return g
+ }
+
+ move(x, y) {
+ let move = ['M', x, y].join(' ')
+ return move
+ }
+
+ line(x, y, hORv = null) {
+ let line = null
+ if (hORv === null) {
+ line = ['L', x, y].join(' ')
+ } else if (hORv === 'H') {
+ line = ['H', x].join(' ')
+ } else if (hORv === 'V') {
+ line = ['V', y].join(' ')
+ }
+ return line
+ }
+
+ curve(x1, y1, x2, y2, x, y) {
+ let curve = ['C', x1, y1, x2, y2, x, y].join(' ')
+ return curve
+ }
+
+ quadraticCurve(x1, y1, x, y) {
+ let curve = ['Q', x1, y1, x, y].join(' ')
+ return curve
+ }
+
+ arc(rx, ry, axisRotation, largeArcFlag, sweepFlag, x, y, relative = false) {
+ let coord = 'A'
+ if (relative) coord = 'a'
+
+ let arc = [coord, rx, ry, axisRotation, largeArcFlag, sweepFlag, x, y].join(
+ ' '
+ )
+ return arc
+ }
+
+ /**
+ * @memberof Graphics
+ * @param {object}
+ * i = series's index
+ * realIndex = realIndex is series's actual index when it was drawn time. After several redraws, the iterating "i" may change in loops, but realIndex doesn't
+ * pathFrom = existing pathFrom to animateTo
+ * pathTo = new Path to which d attr will be animated from pathFrom to pathTo
+ * stroke = line Color
+ * strokeWidth = width of path Line
+ * fill = it can be gradient, single color, pattern or image
+ * animationDelay = how much to delay when starting animation (in milliseconds)
+ * dataChangeSpeed = for dynamic animations, when data changes
+ * className = class attribute to add
+ * @return {object} svg.js path object
+ **/
+ renderPaths({
+ j,
+ realIndex,
+ pathFrom,
+ pathTo,
+ stroke,
+ strokeWidth,
+ strokeLinecap,
+ fill,
+ animationDelay,
+ initialSpeed,
+ dataChangeSpeed,
+ className,
+ shouldClipToGrid = true,
+ bindEventsOnPaths = true,
+ drawShadow = true
+ }) {
+ let w = this.w
+ const filters = new Filters(this.ctx)
+ const anim = new Animations(this.ctx)
+
+ let initialAnim = this.w.config.chart.animations.enabled
+ let dynamicAnim =
+ initialAnim && this.w.config.chart.animations.dynamicAnimation.enabled
+
+ let d
+ let shouldAnimate = !!(
+ (initialAnim && !w.globals.resized) ||
+ (dynamicAnim && w.globals.dataChanged && w.globals.shouldAnimate)
+ )
+
+ if (shouldAnimate) {
+ d = pathFrom
+ } else {
+ d = pathTo
+ w.globals.animationEnded = true
+ }
+
+ let strokeDashArrayOpt = w.config.stroke.dashArray
+ let strokeDashArray = 0
+ if (Array.isArray(strokeDashArrayOpt)) {
+ strokeDashArray = strokeDashArrayOpt[realIndex]
+ } else {
+ strokeDashArray = w.config.stroke.dashArray
+ }
+
+ let el = this.drawPath({
+ d,
+ stroke,
+ strokeWidth,
+ fill,
+ fillOpacity: 1,
+ classes: className,
+ strokeLinecap,
+ strokeDashArray
+ })
+
+ el.attr('index', realIndex)
+
+ if (shouldClipToGrid) {
+ el.attr({
+ 'clip-path': `url(#gridRectMask${w.globals.cuid})`
+ })
+ }
+
+ // const defaultFilter = el.filterer
+
+ if (w.config.states.normal.filter.type !== 'none') {
+ filters.getDefaultFilter(el, realIndex)
+ } else {
+ if (w.config.chart.dropShadow.enabled && drawShadow) {
+ if (
+ !w.config.chart.dropShadow.enabledOnSeries ||
+ (w.config.chart.dropShadow.enabledOnSeries &&
+ w.config.chart.dropShadow.enabledOnSeries.indexOf(realIndex) !== -1)
+ ) {
+ const shadow = w.config.chart.dropShadow
+ filters.dropShadow(el, shadow, realIndex)
+ }
+ }
+ }
+
+ if (bindEventsOnPaths) {
+ el.node.addEventListener('mouseenter', this.pathMouseEnter.bind(this, el))
+ el.node.addEventListener('mouseleave', this.pathMouseLeave.bind(this, el))
+ el.node.addEventListener('mousedown', this.pathMouseDown.bind(this, el))
+ }
+
+ el.attr({
+ pathTo,
+ pathFrom
+ })
+
+ const defaultAnimateOpts = {
+ el,
+ j,
+ realIndex,
+ pathFrom,
+ pathTo,
+ fill,
+ strokeWidth,
+ delay: animationDelay
+ }
+
+ if (initialAnim && !w.globals.resized && !w.globals.dataChanged) {
+ anim.animatePathsGradually({
+ ...defaultAnimateOpts,
+ speed: initialSpeed
+ })
+ } else {
+ if (w.globals.resized || !w.globals.dataChanged) {
+ anim.showDelayedElements()
+ }
+ }
+
+ if (w.globals.dataChanged && dynamicAnim && shouldAnimate) {
+ anim.animatePathsGradually({
+ ...defaultAnimateOpts,
+ speed: dataChangeSpeed
+ })
+ }
+
+ return el
+ }
+
+ drawPattern(
+ style,
+ width,
+ height,
+ stroke = '#a8a8a8',
+ strokeWidth = 0,
+ opacity = 1
+ ) {
+ let w = this.w
+
+ let p = w.globals.dom.Paper.pattern(width, height, (add) => {
+ if (style === 'horizontalLines') {
+ add
+ .line(0, 0, height, 0)
+ .stroke({ color: stroke, width: strokeWidth + 1 })
+ } else if (style === 'verticalLines') {
+ add
+ .line(0, 0, 0, width)
+ .stroke({ color: stroke, width: strokeWidth + 1 })
+ } else if (style === 'slantedLines') {
+ add
+ .line(0, 0, width, height)
+ .stroke({ color: stroke, width: strokeWidth })
+ } else if (style === 'squares') {
+ add
+ .rect(width, height)
+ .fill('none')
+ .stroke({ color: stroke, width: strokeWidth })
+ } else if (style === 'circles') {
+ add
+ .circle(width)
+ .fill('none')
+ .stroke({ color: stroke, width: strokeWidth })
+ }
+ })
+
+ return p
+ }
+
+ drawGradient(
+ style,
+ gfrom,
+ gto,
+ opacityFrom,
+ opacityTo,
+ size = null,
+ stops = null,
+ colorStops = null,
+ i = 0
+ ) {
+ let w = this.w
+ let g
+
+ if (gfrom.length < 9 && gfrom.indexOf('#') === 0) {
+ // if the hex contains alpha and is of 9 digit, skip the opacity
+ gfrom = Utils.hexToRgba(gfrom, opacityFrom)
+ }
+ if (gto.length < 9 && gto.indexOf('#') === 0) {
+ gto = Utils.hexToRgba(gto, opacityTo)
+ }
+
+ let stop1 = 0
+ let stop2 = 1
+ let stop3 = 1
+ let stop4 = null
+
+ if (stops !== null) {
+ stop1 = typeof stops[0] !== 'undefined' ? stops[0] / 100 : 0
+ stop2 = typeof stops[1] !== 'undefined' ? stops[1] / 100 : 1
+ stop3 = typeof stops[2] !== 'undefined' ? stops[2] / 100 : 1
+ stop4 = typeof stops[3] !== 'undefined' ? stops[3] / 100 : null
+ }
+
+ let radial = !!(
+ w.config.chart.type === 'donut' ||
+ w.config.chart.type === 'pie' ||
+ w.config.chart.type === 'polarArea' ||
+ w.config.chart.type === 'bubble'
+ )
+
+ if (colorStops === null || colorStops.length === 0) {
+ g = w.globals.dom.Paper.gradient(radial ? 'radial' : 'linear', (stop) => {
+ stop.at(stop1, gfrom, opacityFrom)
+ stop.at(stop2, gto, opacityTo)
+ stop.at(stop3, gto, opacityTo)
+ if (stop4 !== null) {
+ stop.at(stop4, gfrom, opacityFrom)
+ }
+ })
+ } else {
+ g = w.globals.dom.Paper.gradient(radial ? 'radial' : 'linear', (stop) => {
+ let gradientStops = Array.isArray(colorStops[i])
+ ? colorStops[i]
+ : colorStops
+ gradientStops.forEach((s) => {
+ stop.at(s.offset / 100, s.color, s.opacity)
+ })
+ })
+ }
+
+ if (!radial) {
+ if (style === 'vertical') {
+ g.from(0, 0).to(0, 1)
+ } else if (style === 'diagonal') {
+ g.from(0, 0).to(1, 1)
+ } else if (style === 'horizontal') {
+ g.from(0, 1).to(1, 1)
+ } else if (style === 'diagonal2') {
+ g.from(1, 0).to(0, 1)
+ }
+ } else {
+ let offx = w.globals.gridWidth / 2
+ let offy = w.globals.gridHeight / 2
+
+ if (w.config.chart.type !== 'bubble') {
+ g.attr({
+ gradientUnits: 'userSpaceOnUse',
+ cx: offx,
+ cy: offy,
+ r: size
+ })
+ } else {
+ g.attr({
+ cx: 0.5,
+ cy: 0.5,
+ r: 0.8,
+ fx: 0.2,
+ fy: 0.2
+ })
+ }
+ }
+
+ return g
+ }
+
+ getTextBasedOnMaxWidth({ text, maxWidth, fontSize, fontFamily }) {
+ const tRects = this.getTextRects(text, fontSize, fontFamily)
+ const wordWidth = tRects.width / text.length
+ const wordsBasedOnWidth = Math.floor(maxWidth / wordWidth)
+ if (maxWidth < tRects.width) {
+ return text.slice(0, wordsBasedOnWidth - 3) + '...'
+ }
+ return text
+ }
+
+ drawText({
+ x,
+ y,
+ text,
+ textAnchor,
+ fontSize,
+ fontFamily,
+ fontWeight,
+ foreColor,
+ opacity,
+ maxWidth,
+ cssClass = '',
+ isPlainText = true
+ }) {
+ let w = this.w
+
+ if (typeof text === 'undefined') text = ''
+
+ let truncatedText = text
+ if (!textAnchor) {
+ textAnchor = 'start'
+ }
+
+ if (!foreColor || !foreColor.length) {
+ foreColor = w.config.chart.foreColor
+ }
+ fontFamily = fontFamily || w.config.chart.fontFamily
+ fontSize = fontSize || '11px'
+ fontWeight = fontWeight || 'regular'
+
+ const commonProps = {
+ maxWidth,
+ fontSize,
+ fontFamily
+ }
+ let elText
+ if (Array.isArray(text)) {
+ elText = w.globals.dom.Paper.text((add) => {
+ for (let i = 0; i < text.length; i++) {
+ if (maxWidth) {
+ truncatedText = this.getTextBasedOnMaxWidth({
+ text: text[i],
+ ...commonProps
+ })
+ }
+ i === 0
+ ? add.tspan(truncatedText)
+ : add.tspan(truncatedText).newLine()
+ }
+ })
+ } else {
+ if (maxWidth) {
+ truncatedText = this.getTextBasedOnMaxWidth({
+ text,
+ ...commonProps
+ })
+ }
+ elText = isPlainText
+ ? w.globals.dom.Paper.plain(text)
+ : w.globals.dom.Paper.text((add) => add.tspan(truncatedText))
+ }
+
+ elText.attr({
+ x,
+ y,
+ 'text-anchor': textAnchor,
+ 'dominant-baseline': 'auto',
+ 'font-size': fontSize,
+ 'font-family': fontFamily,
+ 'font-weight': fontWeight,
+ fill: foreColor,
+ class: 'apexcharts-text ' + cssClass
+ })
+
+ elText.node.style.fontFamily = fontFamily
+ elText.node.style.opacity = opacity
+
+ return elText
+ }
+
+ drawMarker(x, y, opts) {
+ x = x || 0
+ let size = opts.pSize || 0
+
+ let elPoint = null
+
+ if (opts.shape === 'square' || opts.shape === 'rect') {
+ let radius = opts.pRadius === undefined ? size / 2 : opts.pRadius
+
+ if (y === null || !size) {
+ size = 0
+ radius = 0
+ }
+
+ let nSize = size * 1.2 + radius
+
+ let p = this.drawRect(nSize, nSize, nSize, nSize, radius)
+
+ p.attr({
+ x: x - nSize / 2,
+ y: y - nSize / 2,
+ cx: x,
+ cy: y,
+ class: opts.class ? opts.class : '',
+ fill: opts.pointFillColor,
+ 'fill-opacity': opts.pointFillOpacity ? opts.pointFillOpacity : 1,
+ stroke: opts.pointStrokeColor,
+ 'stroke-width': opts.pointStrokeWidth ? opts.pointStrokeWidth : 0,
+ 'stroke-opacity': opts.pointStrokeOpacity ? opts.pointStrokeOpacity : 1
+ })
+
+ elPoint = p
+ } else if (opts.shape === 'circle' || !opts.shape) {
+ if (!Utils.isNumber(y)) {
+ size = 0
+ y = 0
+ }
+
+ // let nSize = size - opts.pRadius / 2 < 0 ? 0 : size - opts.pRadius / 2
+
+ elPoint = this.drawCircle(size, {
+ cx: x,
+ cy: y,
+ class: opts.class ? opts.class : '',
+ stroke: opts.pointStrokeColor,
+ fill: opts.pointFillColor,
+ 'fill-opacity': opts.pointFillOpacity ? opts.pointFillOpacity : 1,
+ 'stroke-width': opts.pointStrokeWidth ? opts.pointStrokeWidth : 0,
+ 'stroke-opacity': opts.pointStrokeOpacity ? opts.pointStrokeOpacity : 1
+ })
+ }
+
+ return elPoint
+ }
+
+ pathMouseEnter(path, e) {
+ let w = this.w
+ const filters = new Filters(this.ctx)
+
+ const i = parseInt(path.node.getAttribute('index'), 10)
+ const j = parseInt(path.node.getAttribute('j'), 10)
+
+ if (typeof w.config.chart.events.dataPointMouseEnter === 'function') {
+ w.config.chart.events.dataPointMouseEnter(e, this.ctx, {
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+ this.ctx.events.fireEvent('dataPointMouseEnter', [
+ e,
+ this.ctx,
+ { seriesIndex: i, dataPointIndex: j, w }
+ ])
+
+ if (w.config.states.active.filter.type !== 'none') {
+ if (path.node.getAttribute('selected') === 'true') {
+ return
+ }
+ }
+
+ if (w.config.states.hover.filter.type !== 'none') {
+ if (!w.globals.isTouchDevice) {
+ let hoverFilter = w.config.states.hover.filter
+ filters.applyFilter(path, i, hoverFilter.type, hoverFilter.value)
+ }
+ }
+ }
+
+ pathMouseLeave(path, e) {
+ let w = this.w
+ const filters = new Filters(this.ctx)
+
+ const i = parseInt(path.node.getAttribute('index'), 10)
+ const j = parseInt(path.node.getAttribute('j'), 10)
+
+ if (typeof w.config.chart.events.dataPointMouseLeave === 'function') {
+ w.config.chart.events.dataPointMouseLeave(e, this.ctx, {
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+ this.ctx.events.fireEvent('dataPointMouseLeave', [
+ e,
+ this.ctx,
+ { seriesIndex: i, dataPointIndex: j, w }
+ ])
+
+ if (w.config.states.active.filter.type !== 'none') {
+ if (path.node.getAttribute('selected') === 'true') {
+ return
+ }
+ }
+
+ if (w.config.states.hover.filter.type !== 'none') {
+ filters.getDefaultFilter(path, i)
+ }
+ }
+
+ pathMouseDown(path, e) {
+ let w = this.w
+ const filters = new Filters(this.ctx)
+
+ const i = parseInt(path.node.getAttribute('index'), 10)
+ const j = parseInt(path.node.getAttribute('j'), 10)
+
+ let selected = 'false'
+ if (path.node.getAttribute('selected') === 'true') {
+ path.node.setAttribute('selected', 'false')
+
+ if (w.globals.selectedDataPoints[i].indexOf(j) > -1) {
+ let index = w.globals.selectedDataPoints[i].indexOf(j)
+ w.globals.selectedDataPoints[i].splice(index, 1)
+ }
+ } else {
+ if (
+ !w.config.states.active.allowMultipleDataPointsSelection &&
+ w.globals.selectedDataPoints.length > 0
+ ) {
+ w.globals.selectedDataPoints = []
+ const elPaths = w.globals.dom.Paper.select('.apexcharts-series path')
+ .members
+ const elCircles = w.globals.dom.Paper.select(
+ '.apexcharts-series circle, .apexcharts-series rect'
+ ).members
+
+ const deSelect = (els) => {
+ Array.prototype.forEach.call(els, (el) => {
+ el.node.setAttribute('selected', 'false')
+ filters.getDefaultFilter(el, i)
+ })
+ }
+ deSelect(elPaths)
+ deSelect(elCircles)
+ }
+
+ path.node.setAttribute('selected', 'true')
+ selected = 'true'
+
+ if (typeof w.globals.selectedDataPoints[i] === 'undefined') {
+ w.globals.selectedDataPoints[i] = []
+ }
+ w.globals.selectedDataPoints[i].push(j)
+ }
+
+ if (selected === 'true') {
+ let activeFilter = w.config.states.active.filter
+ if (activeFilter !== 'none') {
+ filters.applyFilter(path, i, activeFilter.type, activeFilter.value)
+ } else {
+ // Reapply the hover filter in case it was removed by `deselect`when there is no active filter and it is not a touch device
+ if (w.config.states.hover.filter !== 'none') {
+ if (!w.globals.isTouchDevice) {
+ var hoverFilter = w.config.states.hover.filter
+ filters.applyFilter(path, i, hoverFilter.type, hoverFilter.value)
+ }
+ }
+ }
+ } else {
+ // If the item was deselected, apply hover state filter if it is not a touch device
+ if (w.config.states.active.filter.type !== 'none') {
+ if (
+ w.config.states.hover.filter.type !== 'none' &&
+ !w.globals.isTouchDevice
+ ) {
+ var hoverFilter = w.config.states.hover.filter
+ filters.applyFilter(path, i, hoverFilter.type, hoverFilter.value)
+ } else {
+ filters.getDefaultFilter(path, i)
+ }
+ }
+ }
+
+ if (typeof w.config.chart.events.dataPointSelection === 'function') {
+ w.config.chart.events.dataPointSelection(e, this.ctx, {
+ selectedDataPoints: w.globals.selectedDataPoints,
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+
+ if (e) {
+ this.ctx.events.fireEvent('dataPointSelection', [
+ e,
+ this.ctx,
+ {
+ selectedDataPoints: w.globals.selectedDataPoints,
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ }
+ ])
+ }
+ }
+
+ rotateAroundCenter(el) {
+ let coord = {}
+ if (el && typeof el.getBBox === 'function') {
+ coord = el.getBBox()
+ }
+ let x = coord.x + coord.width / 2
+ let y = coord.y + coord.height / 2
+
+ return {
+ x,
+ y
+ }
+ }
+
+ static setAttrs(el, attrs) {
+ for (let key in attrs) {
+ if (attrs.hasOwnProperty(key)) {
+ el.setAttribute(key, attrs[key])
+ }
+ }
+ }
+
+ getTextRects(text, fontSize, fontFamily, transform, useBBox = true) {
+ let w = this.w
+ let virtualText = this.drawText({
+ x: -200,
+ y: -200,
+ text,
+ textAnchor: 'start',
+ fontSize,
+ fontFamily,
+ foreColor: '#fff',
+ opacity: 0
+ })
+
+ if (transform) {
+ virtualText.attr('transform', transform)
+ }
+ w.globals.dom.Paper.add(virtualText)
+
+ let rect = virtualText.bbox()
+ if (!useBBox) {
+ rect = virtualText.node.getBoundingClientRect()
+ }
+
+ virtualText.remove()
+
+ return {
+ width: rect.width,
+ height: rect.height
+ }
+ }
+
+ /**
+ * append ... to long text
+ * http://stackoverflow.com/questions/9241315/trimming-text-to-a-given-pixel-width-in-svg
+ * @memberof Graphics
+ **/
+ placeTextWithEllipsis(textObj, textString, width) {
+ if (typeof textObj.getComputedTextLength !== 'function') return
+ textObj.textContent = textString
+ if (textString.length > 0) {
+ // ellipsis is needed
+ if (textObj.getComputedTextLength() >= width / 1.1) {
+ for (let x = textString.length - 3; x > 0; x -= 3) {
+ if (textObj.getSubStringLength(0, x) <= width / 1.1) {
+ textObj.textContent = textString.substring(0, x) + '...'
+ return
+ }
+ }
+ textObj.textContent = '.' // can't place at all
+ }
+ }
+ }
+}
+
+export default Graphics
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Markers.js b/cao_sunyata/static/libs/apexcharts/src/modules/Markers.js
new file mode 100644
index 0000000..0a098a1
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Markers.js
@@ -0,0 +1,245 @@
+import Filters from './Filters'
+import Graphics from './Graphics'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Markers Class for drawing points on y values in axes charts.
+ *
+ * @module Markers
+ **/
+
+export default class Markers {
+ constructor(ctx, opts) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ setGlobalMarkerSize() {
+ const w = this.w
+
+ w.globals.markers.size = Array.isArray(w.config.markers.size)
+ ? w.config.markers.size
+ : [w.config.markers.size]
+
+ if (w.globals.markers.size.length > 0) {
+ if (w.globals.markers.size.length < w.globals.series.length + 1) {
+ for (let i = 0; i <= w.globals.series.length; i++) {
+ if (typeof w.globals.markers.size[i] === 'undefined') {
+ w.globals.markers.size.push(w.globals.markers.size[0])
+ }
+ }
+ }
+ } else {
+ w.globals.markers.size = w.config.series.map((s) => w.config.markers.size)
+ }
+ }
+
+ plotChartMarkers(pointsPos, seriesIndex, j, pSize, alwaysDrawMarker = false) {
+ let w = this.w
+
+ let i = seriesIndex
+ let p = pointsPos
+ let elPointsWrap = null
+
+ let graphics = new Graphics(this.ctx)
+
+ let point
+
+ const hasDiscreteMarkers =
+ w.config.markers.discrete && w.config.markers.discrete.length
+
+ if (
+ w.globals.markers.size[seriesIndex] > 0 ||
+ alwaysDrawMarker ||
+ hasDiscreteMarkers
+ ) {
+ elPointsWrap = graphics.group({
+ class:
+ alwaysDrawMarker || hasDiscreteMarkers
+ ? ''
+ : 'apexcharts-series-markers'
+ })
+
+ elPointsWrap.attr(
+ 'clip-path',
+ `url(#gridRectMarkerMask${w.globals.cuid})`
+ )
+ }
+
+ if (Array.isArray(p.x)) {
+ for (let q = 0; q < p.x.length; q++) {
+ let dataPointIndex = j
+
+ // a small hack as we have 2 points for the first val to connect it
+ if (j === 1 && q === 0) dataPointIndex = 0
+ if (j === 1 && q === 1) dataPointIndex = 1
+
+ let PointClasses = 'apexcharts-marker'
+ if (
+ (w.config.chart.type === 'line' || w.config.chart.type === 'area') &&
+ !w.globals.comboCharts &&
+ !w.config.tooltip.intersect
+ ) {
+ PointClasses += ' no-pointer-events'
+ }
+
+ const shouldMarkerDraw = Array.isArray(w.config.markers.size)
+ ? w.globals.markers.size[seriesIndex] > 0
+ : w.config.markers.size > 0
+
+ if (shouldMarkerDraw || alwaysDrawMarker || hasDiscreteMarkers) {
+ if (Utils.isNumber(p.y[q])) {
+ PointClasses += ` w${Utils.randomId()}`
+ } else {
+ PointClasses = 'apexcharts-nullpoint'
+ }
+
+ let opts = this.getMarkerConfig({
+ cssClass: PointClasses,
+ seriesIndex,
+ dataPointIndex
+ })
+
+ if (w.config.series[i].data[dataPointIndex]) {
+ if (w.config.series[i].data[dataPointIndex].fillColor) {
+ opts.pointFillColor =
+ w.config.series[i].data[dataPointIndex].fillColor
+ }
+
+ if (w.config.series[i].data[dataPointIndex].strokeColor) {
+ opts.pointStrokeColor =
+ w.config.series[i].data[dataPointIndex].strokeColor
+ }
+ }
+
+ if (pSize) {
+ opts.pSize = pSize
+ }
+ point = graphics.drawMarker(p.x[q], p.y[q], opts)
+
+ point.attr('rel', dataPointIndex)
+ point.attr('j', dataPointIndex)
+ point.attr('index', seriesIndex)
+ point.node.setAttribute('default-marker-size', opts.pSize)
+
+ const filters = new Filters(this.ctx)
+ filters.setSelectionFilter(point, seriesIndex, dataPointIndex)
+ this.addEvents(point)
+
+ if (elPointsWrap) {
+ elPointsWrap.add(point)
+ }
+ } else {
+ // dynamic array creation - multidimensional
+ if (typeof w.globals.pointsArray[seriesIndex] === 'undefined')
+ w.globals.pointsArray[seriesIndex] = []
+
+ w.globals.pointsArray[seriesIndex].push([p.x[q], p.y[q]])
+ }
+ }
+ }
+
+ return elPointsWrap
+ }
+
+ getMarkerConfig({
+ cssClass,
+ seriesIndex,
+ dataPointIndex = null,
+ finishRadius = null
+ }) {
+ const w = this.w
+ let pStyle = this.getMarkerStyle(seriesIndex)
+ let pSize = w.globals.markers.size[seriesIndex]
+
+ const m = w.config.markers
+
+ // discrete markers is an option where user can specify a particular marker with different shape, size and color
+
+ if (dataPointIndex !== null && m.discrete.length) {
+ m.discrete.map((marker) => {
+ if (
+ marker.seriesIndex === seriesIndex &&
+ marker.dataPointIndex === dataPointIndex
+ ) {
+ pStyle.pointStrokeColor = marker.strokeColor
+ pStyle.pointFillColor = marker.fillColor
+ pSize = marker.size
+ pStyle.pointShape = marker.shape
+ }
+ })
+ }
+
+ return {
+ pSize: finishRadius === null ? pSize : finishRadius,
+ pRadius: m.radius,
+ width: Array.isArray(m.width) ? m.width[seriesIndex] : m.width,
+ height: Array.isArray(m.height) ? m.height[seriesIndex] : m.height,
+ pointStrokeWidth: Array.isArray(m.strokeWidth)
+ ? m.strokeWidth[seriesIndex]
+ : m.strokeWidth,
+ pointStrokeColor: pStyle.pointStrokeColor,
+ pointFillColor: pStyle.pointFillColor,
+ shape:
+ pStyle.pointShape ||
+ (Array.isArray(m.shape) ? m.shape[seriesIndex] : m.shape),
+ class: cssClass,
+ pointStrokeOpacity: Array.isArray(m.strokeOpacity)
+ ? m.strokeOpacity[seriesIndex]
+ : m.strokeOpacity,
+ pointStrokeDashArray: Array.isArray(m.strokeDashArray)
+ ? m.strokeDashArray[seriesIndex]
+ : m.strokeDashArray,
+ pointFillOpacity: Array.isArray(m.fillOpacity)
+ ? m.fillOpacity[seriesIndex]
+ : m.fillOpacity,
+ seriesIndex
+ }
+ }
+
+ addEvents(circle) {
+ const w = this.w
+
+ const graphics = new Graphics(this.ctx)
+ circle.node.addEventListener(
+ 'mouseenter',
+ graphics.pathMouseEnter.bind(this.ctx, circle)
+ )
+ circle.node.addEventListener(
+ 'mouseleave',
+ graphics.pathMouseLeave.bind(this.ctx, circle)
+ )
+
+ circle.node.addEventListener(
+ 'mousedown',
+ graphics.pathMouseDown.bind(this.ctx, circle)
+ )
+
+ circle.node.addEventListener('click', w.config.markers.onClick)
+ circle.node.addEventListener('dblclick', w.config.markers.onDblClick)
+
+ circle.node.addEventListener(
+ 'touchstart',
+ graphics.pathMouseDown.bind(this.ctx, circle),
+ { passive: true }
+ )
+ }
+
+ getMarkerStyle(seriesIndex) {
+ let w = this.w
+
+ let colors = w.globals.markers.colors
+ let strokeColors =
+ w.config.markers.strokeColor || w.config.markers.strokeColors
+
+ let pointStrokeColor = Array.isArray(strokeColors)
+ ? strokeColors[seriesIndex]
+ : strokeColors
+ let pointFillColor = Array.isArray(colors) ? colors[seriesIndex] : colors
+
+ return {
+ pointStrokeColor,
+ pointFillColor
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Range.js b/cao_sunyata/static/libs/apexcharts/src/modules/Range.js
new file mode 100644
index 0000000..f0a0b97
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Range.js
@@ -0,0 +1,548 @@
+import Utils from '../utils/Utils'
+import DateTime from '../utils/DateTime'
+import Scales from './Scales'
+
+/**
+ * Range is used to generates values between min and max.
+ *
+ * @module Range
+ **/
+
+class Range {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.scales = new Scales(ctx)
+ }
+
+ init() {
+ this.setYRange()
+ this.setXRange()
+ this.setZRange()
+ }
+
+ getMinYMaxY(
+ startingIndex,
+ lowestY = Number.MAX_VALUE,
+ highestY = -Number.MAX_VALUE,
+ len = null
+ ) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+ let maxY = -Number.MAX_VALUE
+ let minY = Number.MIN_VALUE
+
+ if (len === null) {
+ len = startingIndex + 1
+ }
+ const series = gl.series
+ let seriesMin = series
+ let seriesMax = series
+
+ if (cnf.chart.type === 'candlestick') {
+ seriesMin = gl.seriesCandleL
+ seriesMax = gl.seriesCandleH
+ } else if (cnf.chart.type === 'boxPlot') {
+ seriesMin = gl.seriesCandleO
+ seriesMax = gl.seriesCandleC
+ } else if (gl.isRangeData) {
+ seriesMin = gl.seriesRangeStart
+ seriesMax = gl.seriesRangeEnd
+ }
+
+ for (let i = startingIndex; i < len; i++) {
+ gl.dataPoints = Math.max(gl.dataPoints, series[i].length)
+
+ if (gl.categoryLabels.length) {
+ gl.dataPoints = gl.categoryLabels.filter(
+ (label) => typeof label !== 'undefined'
+ ).length
+ }
+ for (let j = 0; j < gl.series[i].length; j++) {
+ let val = series[i][j]
+ if (val !== null && Utils.isNumber(val)) {
+ if (typeof seriesMax[i][j] !== 'undefined') {
+ maxY = Math.max(maxY, seriesMax[i][j])
+ lowestY = Math.min(lowestY, seriesMax[i][j])
+ }
+ if (typeof seriesMin[i][j] !== 'undefined') {
+ lowestY = Math.min(lowestY, seriesMin[i][j])
+ highestY = Math.max(highestY, seriesMin[i][j])
+ }
+
+ if (
+ this.w.config.chart.type === 'candlestick' ||
+ this.w.config.chart.type === 'boxPlot'
+ ) {
+ if (typeof gl.seriesCandleC[i][j] !== 'undefined') {
+ maxY = Math.max(maxY, gl.seriesCandleO[i][j])
+ maxY = Math.max(maxY, gl.seriesCandleH[i][j])
+ maxY = Math.max(maxY, gl.seriesCandleL[i][j])
+ maxY = Math.max(maxY, gl.seriesCandleC[i][j])
+ if (this.w.config.chart.type === 'boxPlot') {
+ maxY = Math.max(maxY, gl.seriesCandleM[i][j])
+ }
+ }
+
+ // there is a combo chart and the specified series in not either candlestick or boxplot, find the max there
+ if (
+ cnf.series[i].type &&
+ (cnf.series[i].type !== 'candlestick' ||
+ cnf.series[i].type !== 'boxPlot')
+ ) {
+ maxY = Math.max(maxY, gl.series[i][j])
+ lowestY = Math.min(lowestY, gl.series[i][j])
+ }
+
+ highestY = maxY
+ }
+
+ if (
+ gl.seriesGoals[i] &&
+ gl.seriesGoals[i][j] &&
+ Array.isArray(gl.seriesGoals[i][j])
+ ) {
+ gl.seriesGoals[i][j].forEach((g) => {
+ if (minY !== Number.MIN_VALUE) {
+ minY = Math.min(minY, g.value)
+ lowestY = minY
+ }
+ maxY = Math.max(maxY, g.value)
+ highestY = maxY
+ })
+ }
+
+ if (Utils.isFloat(val)) {
+ val = Utils.noExponents(val)
+ gl.yValueDecimal = Math.max(
+ gl.yValueDecimal,
+ val.toString().split('.')[1].length
+ )
+ }
+ if (minY > seriesMin[i][j] && seriesMin[i][j] < 0) {
+ minY = seriesMin[i][j]
+ }
+ } else {
+ gl.hasNullValues = true
+ }
+ }
+ }
+
+ if (
+ cnf.chart.type === 'rangeBar' &&
+ gl.seriesRangeStart.length &&
+ gl.isBarHorizontal
+ ) {
+ minY = lowestY
+ }
+
+ if (cnf.chart.type === 'bar') {
+ if (minY < 0 && maxY < 0) {
+ // all negative values in a bar chart, hence make the max to 0
+ maxY = 0
+ }
+ if (minY === Number.MIN_VALUE) {
+ minY = 0
+ }
+ }
+
+ return {
+ minY,
+ maxY,
+ lowestY,
+ highestY
+ }
+ }
+
+ setYRange() {
+ let gl = this.w.globals
+ let cnf = this.w.config
+ gl.maxY = -Number.MAX_VALUE
+ gl.minY = Number.MIN_VALUE
+
+ let lowestYInAllSeries = Number.MAX_VALUE
+
+ if (gl.isMultipleYAxis) {
+ // we need to get minY and maxY for multiple y axis
+ for (let i = 0; i < gl.series.length; i++) {
+ const minYMaxYArr = this.getMinYMaxY(i, lowestYInAllSeries, null, i + 1)
+ gl.minYArr.push(minYMaxYArr.minY)
+ gl.maxYArr.push(minYMaxYArr.maxY)
+ lowestYInAllSeries = minYMaxYArr.lowestY
+ }
+ }
+
+ // and then, get the minY and maxY from all series
+ const minYMaxY = this.getMinYMaxY(
+ 0,
+ lowestYInAllSeries,
+ null,
+ gl.series.length
+ )
+ gl.minY = minYMaxY.minY
+ gl.maxY = minYMaxY.maxY
+ lowestYInAllSeries = minYMaxY.lowestY
+
+ if (cnf.chart.stacked) {
+ this._setStackedMinMax()
+ }
+
+ // if the numbers are too big, reduce the range
+ // for eg, if number is between 100000-110000, putting 0 as the lowest value is not so good idea. So change the gl.minY for line/area/candlesticks/boxPlot
+ if (
+ cnf.chart.type === 'line' ||
+ cnf.chart.type === 'area' ||
+ cnf.chart.type === 'candlestick' ||
+ cnf.chart.type === 'boxPlot' ||
+ (cnf.chart.type === 'rangeBar' && !gl.isBarHorizontal)
+ ) {
+ if (
+ gl.minY === Number.MIN_VALUE &&
+ lowestYInAllSeries !== -Number.MAX_VALUE &&
+ lowestYInAllSeries !== gl.maxY // single value possibility
+ ) {
+ let diff = gl.maxY - lowestYInAllSeries
+ if (
+ (lowestYInAllSeries >= 0 && lowestYInAllSeries <= 10) ||
+ cnf.yaxis[0].min !== undefined ||
+ cnf.yaxis[0].max !== undefined
+ ) {
+ // if minY is already 0/low value, we don't want to go negatives here - so this check is essential.
+ diff = 0
+ }
+
+ gl.minY = lowestYInAllSeries - (diff * 5) / 100
+
+ /* fix https://github.com/apexcharts/apexcharts.js/issues/614 */
+ /* fix https://github.com/apexcharts/apexcharts.js/issues/968 */
+ if (lowestYInAllSeries > 0 && gl.minY < 0) {
+ gl.minY = 0
+ }
+
+ /* fix https://github.com/apexcharts/apexcharts.js/issues/426 */
+ gl.maxY = gl.maxY + (diff * 5) / 100
+ }
+ }
+
+ cnf.yaxis.forEach((yaxe, index) => {
+ // override all min/max values by user defined values (y axis)
+ if (yaxe.max !== undefined) {
+ if (typeof yaxe.max === 'number') {
+ gl.maxYArr[index] = yaxe.max
+ } else if (typeof yaxe.max === 'function') {
+ // fixes apexcharts.js/issues/2098
+ gl.maxYArr[index] = yaxe.max(
+ gl.isMultipleYAxis ? gl.maxYArr[index] : gl.maxY
+ )
+ }
+
+ // gl.maxY is for single y-axis chart, it will be ignored in multi-yaxis
+ gl.maxY = gl.maxYArr[index]
+ }
+ if (yaxe.min !== undefined) {
+ if (typeof yaxe.min === 'number') {
+ gl.minYArr[index] = yaxe.min
+ } else if (typeof yaxe.min === 'function') {
+ // fixes apexcharts.js/issues/2098
+ gl.minYArr[index] = yaxe.min(
+ gl.isMultipleYAxis
+ ? gl.minYArr[index] === Number.MIN_VALUE
+ ? 0
+ : gl.minYArr[index]
+ : gl.minY
+ )
+ }
+ // gl.minY is for single y-axis chart, it will be ignored in multi-yaxis
+ gl.minY = gl.minYArr[index]
+ }
+ })
+
+ // for horizontal bar charts, we need to check xaxis min/max as user may have specified there
+ if (gl.isBarHorizontal) {
+ const minmax = ['min', 'max']
+ minmax.forEach((m) => {
+ if (cnf.xaxis[m] !== undefined && typeof cnf.xaxis[m] === 'number') {
+ m === 'min' ? (gl.minY = cnf.xaxis[m]) : (gl.maxY = cnf.xaxis[m])
+ }
+ })
+ }
+
+ // for multi y-axis we need different scales for each
+ if (gl.isMultipleYAxis) {
+ this.scales.setMultipleYScales()
+ gl.minY = lowestYInAllSeries
+ gl.yAxisScale.forEach((scale, i) => {
+ gl.minYArr[i] = scale.niceMin
+ gl.maxYArr[i] = scale.niceMax
+ })
+ } else {
+ this.scales.setYScaleForIndex(0, gl.minY, gl.maxY)
+ gl.minY = gl.yAxisScale[0].niceMin
+ gl.maxY = gl.yAxisScale[0].niceMax
+ gl.minYArr[0] = gl.yAxisScale[0].niceMin
+ gl.maxYArr[0] = gl.yAxisScale[0].niceMax
+ }
+
+ return {
+ minY: gl.minY,
+ maxY: gl.maxY,
+ minYArr: gl.minYArr,
+ maxYArr: gl.maxYArr,
+ yAxisScale: gl.yAxisScale
+ }
+ }
+
+ setXRange() {
+ let gl = this.w.globals
+ let cnf = this.w.config
+
+ const isXNumeric =
+ cnf.xaxis.type === 'numeric' ||
+ cnf.xaxis.type === 'datetime' ||
+ (cnf.xaxis.type === 'category' && !gl.noLabelsProvided) ||
+ gl.noLabelsProvided ||
+ gl.isXNumeric
+
+ const getInitialMinXMaxX = () => {
+ for (let i = 0; i < gl.series.length; i++) {
+ if (gl.labels[i]) {
+ for (let j = 0; j < gl.labels[i].length; j++) {
+ if (gl.labels[i][j] !== null && Utils.isNumber(gl.labels[i][j])) {
+ gl.maxX = Math.max(gl.maxX, gl.labels[i][j])
+ gl.initialMaxX = Math.max(gl.maxX, gl.labels[i][j])
+ gl.minX = Math.min(gl.minX, gl.labels[i][j])
+ gl.initialMinX = Math.min(gl.minX, gl.labels[i][j])
+ }
+ }
+ }
+ }
+ }
+ // minX maxX starts here
+ if (gl.isXNumeric) {
+ getInitialMinXMaxX()
+ }
+
+ if (gl.noLabelsProvided) {
+ if (cnf.xaxis.categories.length === 0) {
+ gl.maxX = gl.labels[gl.labels.length - 1]
+ gl.initialMaxX = gl.labels[gl.labels.length - 1]
+ gl.minX = 1
+ gl.initialMinX = 1
+ }
+ }
+
+ if (gl.isXNumeric || gl.noLabelsProvided || gl.dataFormatXNumeric) {
+ let ticks
+
+ if (cnf.xaxis.tickAmount === undefined) {
+ ticks = Math.round(gl.svgWidth / 150)
+
+ // no labels provided and total number of dataPoints is less than 30
+ if (cnf.xaxis.type === 'numeric' && gl.dataPoints < 30) {
+ ticks = gl.dataPoints - 1
+ }
+
+ // this check is for when ticks exceeds total datapoints and that would result in duplicate labels
+ if (ticks > gl.dataPoints && gl.dataPoints !== 0) {
+ ticks = gl.dataPoints - 1
+ }
+ } else if (cnf.xaxis.tickAmount === 'dataPoints') {
+ if (gl.series.length > 1) {
+ ticks = gl.series[gl.maxValsInArrayIndex].length - 1
+ }
+ if (gl.isXNumeric) {
+ ticks = gl.maxX - gl.minX - 1
+ }
+ } else {
+ ticks = cnf.xaxis.tickAmount
+ }
+ gl.xTickAmount = ticks
+
+ // override all min/max values by user defined values (x axis)
+ if (cnf.xaxis.max !== undefined && typeof cnf.xaxis.max === 'number') {
+ gl.maxX = cnf.xaxis.max
+ }
+ if (cnf.xaxis.min !== undefined && typeof cnf.xaxis.min === 'number') {
+ gl.minX = cnf.xaxis.min
+ }
+
+ // if range is provided, adjust the new minX
+ if (cnf.xaxis.range !== undefined) {
+ gl.minX = gl.maxX - cnf.xaxis.range
+ }
+
+ if (gl.minX !== Number.MAX_VALUE && gl.maxX !== -Number.MAX_VALUE) {
+ if (cnf.xaxis.convertedCatToNumeric && !gl.dataFormatXNumeric) {
+ let catScale = []
+ for (let i = gl.minX - 1; i < gl.maxX; i++) {
+ catScale.push(i + 1)
+ }
+ gl.xAxisScale = {
+ result: catScale,
+ niceMin: catScale[0],
+ niceMax: catScale[catScale.length - 1]
+ }
+ } else {
+ gl.xAxisScale = this.scales.setXScale(gl.minX, gl.maxX)
+ }
+ } else {
+ gl.xAxisScale = this.scales.linearScale(1, ticks, ticks)
+ if (gl.noLabelsProvided && gl.labels.length > 0) {
+ gl.xAxisScale = this.scales.linearScale(
+ 1,
+ gl.labels.length,
+ ticks - 1
+ )
+
+ // this is the only place seriesX is again mutated
+ gl.seriesX = gl.labels.slice()
+ }
+ }
+ // we will still store these labels as the count for this will be different (to draw grid and labels placement)
+ if (isXNumeric) {
+ gl.labels = gl.xAxisScale.result.slice()
+ }
+ }
+
+ if (gl.isBarHorizontal && gl.labels.length) {
+ gl.xTickAmount = gl.labels.length
+ }
+
+ // single dataPoint
+ this._handleSingleDataPoint()
+
+ // minimum x difference to calculate bar width in numeric bars
+ this._getMinXDiff()
+
+ return {
+ minX: gl.minX,
+ maxX: gl.maxX
+ }
+ }
+
+ setZRange() {
+ // minZ, maxZ starts here
+ let gl = this.w.globals
+
+ if (!gl.isDataXYZ) return
+ for (let i = 0; i < gl.series.length; i++) {
+ if (typeof gl.seriesZ[i] !== 'undefined') {
+ for (let j = 0; j < gl.seriesZ[i].length; j++) {
+ if (gl.seriesZ[i][j] !== null && Utils.isNumber(gl.seriesZ[i][j])) {
+ gl.maxZ = Math.max(gl.maxZ, gl.seriesZ[i][j])
+ gl.minZ = Math.min(gl.minZ, gl.seriesZ[i][j])
+ }
+ }
+ }
+ }
+ }
+
+ _handleSingleDataPoint() {
+ const gl = this.w.globals
+ const cnf = this.w.config
+
+ if (gl.minX === gl.maxX) {
+ let datetimeObj = new DateTime(this.ctx)
+
+ if (cnf.xaxis.type === 'datetime') {
+ const newMinX = datetimeObj.getDate(gl.minX)
+ if (cnf.xaxis.labels.datetimeUTC) {
+ newMinX.setUTCDate(newMinX.getUTCDate() - 2)
+ } else {
+ newMinX.setDate(newMinX.getDate() - 2)
+ }
+
+ gl.minX = new Date(newMinX).getTime()
+
+ const newMaxX = datetimeObj.getDate(gl.maxX)
+ if (cnf.xaxis.labels.datetimeUTC) {
+ newMaxX.setUTCDate(newMaxX.getUTCDate() + 2)
+ } else {
+ newMaxX.setDate(newMaxX.getDate() + 2)
+ }
+ gl.maxX = new Date(newMaxX).getTime()
+ } else if (
+ cnf.xaxis.type === 'numeric' ||
+ (cnf.xaxis.type === 'category' && !gl.noLabelsProvided)
+ ) {
+ gl.minX = gl.minX - 2
+ gl.initialMinX = gl.minX
+ gl.maxX = gl.maxX + 2
+ gl.initialMaxX = gl.maxX
+ }
+ }
+ }
+
+ _getMinXDiff() {
+ const gl = this.w.globals
+
+ if (gl.isXNumeric) {
+ // get the least x diff if numeric x axis is present
+ gl.seriesX.forEach((sX, i) => {
+ if (sX.length === 1) {
+ // a small hack to prevent overlapping multiple bars when there is just 1 datapoint in bar series.
+ // fix #811
+ sX.push(
+ gl.seriesX[gl.maxValsInArrayIndex][
+ gl.seriesX[gl.maxValsInArrayIndex].length - 1
+ ]
+ )
+ }
+
+ // fix #983 (clone the array to avoid side effects)
+ const seriesX = sX.slice()
+ seriesX.sort((a, b) => a - b)
+
+ seriesX.forEach((s, j) => {
+ if (j > 0) {
+ let xDiff = s - seriesX[j - 1]
+ if (xDiff > 0) {
+ gl.minXDiff = Math.min(xDiff, gl.minXDiff)
+ }
+ }
+ })
+ if (gl.dataPoints === 1 || gl.minXDiff === Number.MAX_VALUE) {
+ // fixes apexcharts.js #1221
+ gl.minXDiff = 0.5
+ }
+ })
+ }
+ }
+
+ _setStackedMinMax() {
+ const gl = this.w.globals
+ // for stacked charts, we calculate each series's parallel values. i.e, series[0][j] + series[1][j] .... [series[i.length][j]] and get the max out of it
+ let stackedPoss = []
+ let stackedNegs = []
+
+ if (gl.series.length) {
+ for (let j = 0; j < gl.series[gl.maxValsInArrayIndex].length; j++) {
+ let poss = 0
+ let negs = 0
+ for (let i = 0; i < gl.series.length; i++) {
+ if (gl.series[i][j] !== null && Utils.isNumber(gl.series[i][j])) {
+ // 0.0001 fixes #185 when values are very small
+ gl.series[i][j] > 0
+ ? (poss = poss + parseFloat(gl.series[i][j]) + 0.0001)
+ : (negs = negs + parseFloat(gl.series[i][j]))
+ }
+
+ if (i === gl.series.length - 1) {
+ // push all the totals to the array for future use
+ stackedPoss.push(poss)
+ stackedNegs.push(negs)
+ }
+ }
+ }
+ }
+
+ // get the max/min out of the added parallel values
+ for (let z = 0; z < stackedPoss.length; z++) {
+ gl.maxY = Math.max(gl.maxY, stackedPoss[z])
+ gl.minY = Math.min(gl.minY, stackedNegs[z])
+ }
+ }
+}
+
+export default Range
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Responsive.js b/cao_sunyata/static/libs/apexcharts/src/modules/Responsive.js
new file mode 100644
index 0000000..2081a02
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Responsive.js
@@ -0,0 +1,73 @@
+import Config from './settings/Config'
+import Utils from '../utils/Utils'
+import CoreUtils from './CoreUtils'
+
+/**
+ * ApexCharts Responsive Class to override options for different screen sizes.
+ *
+ * @module Responsive
+ **/
+
+export default class Responsive {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ // the opts parameter if not null has to be set overriding everything
+ // as the opts is set by user externally
+ checkResponsiveConfig(opts) {
+ const w = this.w
+ const cnf = w.config
+
+ // check if responsive config exists
+ if (cnf.responsive.length === 0) return
+
+ let res = cnf.responsive.slice()
+ res
+ .sort((a, b) =>
+ a.breakpoint > b.breakpoint ? 1 : b.breakpoint > a.breakpoint ? -1 : 0
+ )
+ .reverse()
+
+ let config = new Config({})
+
+ const iterateResponsiveOptions = (newOptions = {}) => {
+ let largestBreakpoint = res[0].breakpoint
+ const width = window.innerWidth > 0 ? window.innerWidth : screen.width
+
+ if (width > largestBreakpoint) {
+ let options = CoreUtils.extendArrayProps(
+ config,
+ w.globals.initialConfig,
+ w
+ )
+ newOptions = Utils.extend(options, newOptions)
+ newOptions = Utils.extend(w.config, newOptions)
+ this.overrideResponsiveOptions(newOptions)
+ } else {
+ for (let i = 0; i < res.length; i++) {
+ if (width < res[i].breakpoint) {
+ newOptions = CoreUtils.extendArrayProps(config, res[i].options, w)
+ newOptions = Utils.extend(w.config, newOptions)
+ this.overrideResponsiveOptions(newOptions)
+ }
+ }
+ }
+ }
+
+ if (opts) {
+ let options = CoreUtils.extendArrayProps(config, opts, w)
+ options = Utils.extend(w.config, options)
+ options = Utils.extend(options, opts)
+ iterateResponsiveOptions(options)
+ } else {
+ iterateResponsiveOptions({})
+ }
+ }
+
+ overrideResponsiveOptions(newOptions) {
+ let newConfig = new Config(newOptions).init({ responsiveOverride: true })
+ this.w.config = newConfig
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Scales.js b/cao_sunyata/static/libs/apexcharts/src/modules/Scales.js
new file mode 100644
index 0000000..617424d
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Scales.js
@@ -0,0 +1,586 @@
+import Utils from '../utils/Utils'
+
+export default class Range {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ // http://stackoverflow.com/questions/326679/choosing-an-attractive-linear-scale-for-a-graphs-y-axiss
+ // This routine creates the Y axis values for a graph.
+ niceScale(yMin, yMax, ticks = 10, index = 0, NO_MIN_MAX_PROVIDED) {
+ const w = this.w
+ // Determine Range
+ let range = Math.abs(yMax - yMin)
+
+ ticks = this._adjustTicksForSmallRange(ticks, index, range)
+
+ if (ticks === 'dataPoints') {
+ ticks = w.globals.dataPoints - 1
+ }
+
+ if (
+ (yMin === Number.MIN_VALUE && yMax === 0) ||
+ (!Utils.isNumber(yMin) && !Utils.isNumber(yMax)) ||
+ (yMin === Number.MIN_VALUE && yMax === -Number.MAX_VALUE)
+ ) {
+ // when all values are 0
+ yMin = 0
+ yMax = ticks
+ let linearScale = this.linearScale(yMin, yMax, ticks)
+ return linearScale
+ }
+
+ if (yMin > yMax) {
+ // if somehow due to some wrong config, user sent max less than min,
+ // adjust the min/max again
+ console.warn('axis.min cannot be greater than axis.max')
+ yMax = yMin + 0.1
+ } else if (yMin === yMax) {
+ // If yMin and yMax are identical, then
+ // adjust the yMin and yMax values to actually
+ // make a graph. Also avoids division by zero errors.
+ yMin = yMin === 0 ? 0 : yMin - 0.5 // some small value
+ yMax = yMax === 0 ? 2 : yMax + 0.5 // some small value
+ }
+
+ // Calculate Min amd Max graphical labels and graph
+ // increments. The number of ticks defaults to
+ // 10 which is the SUGGESTED value. Any tick value
+ // entered is used as a suggested value which is
+ // adjusted to be a 'pretty' value.
+ //
+ // Output will be an array of the Y axis values that
+ // encompass the Y values.
+ let result = []
+
+ if (
+ range < 1 &&
+ NO_MIN_MAX_PROVIDED &&
+ (w.config.chart.type === 'candlestick' ||
+ w.config.series[index].type === 'candlestick' ||
+ w.config.chart.type === 'boxPlot' ||
+ w.config.series[index].type === 'boxPlot' ||
+ w.globals.isRangeData)
+ ) {
+ /* fix https://github.com/apexcharts/apexcharts.js/issues/430 */
+ yMax = yMax * 1.01
+ }
+
+ let tiks = ticks + 1
+ // Adjust ticks if needed
+ if (tiks < 2) {
+ tiks = 2
+ } else if (tiks > 2) {
+ tiks -= 2
+ }
+
+ // Get raw step value
+ let tempStep = range / tiks
+ // Calculate pretty step value
+
+ let mag = Math.floor(Utils.log10(tempStep))
+ let magPow = Math.pow(10, mag)
+ let magMsd = Math.round(tempStep / magPow)
+ if (magMsd < 1) {
+ magMsd = 1
+ }
+ let stepSize = magMsd * magPow
+
+ // build Y label array.
+ // Lower and upper bounds calculations
+ let lb = stepSize * Math.floor(yMin / stepSize)
+ let ub = stepSize * Math.ceil(yMax / stepSize)
+ // Build array
+ let val = lb
+
+ if (NO_MIN_MAX_PROVIDED && range > 2) {
+ while (1) {
+ result.push(val)
+ val += stepSize
+ if (val > ub) {
+ break
+ }
+ }
+
+ return {
+ result,
+ niceMin: result[0],
+ niceMax: result[result.length - 1]
+ }
+ } else {
+ result = []
+ let v = yMin
+ result.push(v)
+ let valuesDivider = Math.abs(yMax - yMin) / ticks
+ for (let i = 0; i <= ticks; i++) {
+ v = v + valuesDivider
+ result.push(v)
+ }
+
+ if (result[result.length - 2] >= yMax) {
+ result.pop()
+ }
+
+ return {
+ result,
+ niceMin: result[0],
+ niceMax: result[result.length - 1]
+ }
+ }
+ }
+
+ linearScale(yMin, yMax, ticks = 10, index) {
+ let range = Math.abs(yMax - yMin)
+
+ ticks = this._adjustTicksForSmallRange(ticks, index, range)
+
+ if (ticks === 'dataPoints') {
+ ticks = this.w.globals.dataPoints - 1
+ }
+
+ let step = range / ticks
+ if (ticks === Number.MAX_VALUE) {
+ ticks = 10
+ step = 1
+ }
+
+ let result = []
+ let v = yMin
+
+ while (ticks >= 0) {
+ result.push(v)
+ v = v + step
+ ticks -= 1
+ }
+
+ return {
+ result,
+ niceMin: result[0],
+ niceMax: result[result.length - 1]
+ }
+ }
+
+ logarithmicScaleNice(yMin, yMax, base) {
+ // Basic validation to avoid for loop starting at -inf.
+ if (yMax <= 0) yMax = Math.max(yMin, base)
+ if (yMin <= 0) yMin = Math.min(yMax, base)
+
+ const logs = []
+
+ const logMax = Math.ceil(Math.log(yMax) / Math.log(base) + 1) // Get powers of base for our max and min
+ const logMin = Math.floor(Math.log(yMin) / Math.log(base))
+
+ for (let i = logMin; i < logMax; i++) {
+ logs.push(Math.pow(base, i))
+ }
+
+ return {
+ result: logs,
+ niceMin: logs[0],
+ niceMax: logs[logs.length - 1]
+ }
+ }
+
+ logarithmicScale(yMin, yMax, base) {
+ // Basic validation to avoid for loop starting at -inf.
+ if (yMax <= 0) yMax = Math.max(yMin, base)
+ if (yMin <= 0) yMin = Math.min(yMax, base)
+
+ const logs = []
+
+ // Get the logarithmic range.
+ const logMax = Math.log(yMax) / Math.log(base)
+ const logMin = Math.log(yMin) / Math.log(base)
+
+ // Get the exact logarithmic range.
+ // (This is the exact number of multiples of the base there are between yMin and yMax).
+ const logRange = logMax - logMin
+
+ // Round the logarithmic range to get the number of ticks we will create.
+ // If the chosen min/max values are multiples of each other WRT the base, this will be neat.
+ // If the chosen min/max aren't, we will at least still provide USEFUL ticks.
+ const ticks = Math.round(logRange)
+
+ // Get the logarithmic spacing between ticks.
+ const logTickSpacing = logRange / ticks
+
+ // Create as many ticks as there is range in the logs.
+ for (let i = 0, logTick = logMin; i < ticks; i++, logTick += logTickSpacing) {
+ logs.push(Math.pow(base, logTick))
+ }
+
+ // Add a final tick at the yMax.
+ logs.push(Math.pow(base, logMax))
+
+ return {
+ result: logs,
+ niceMin: yMin,
+ niceMax: yMax
+ }
+ }
+
+ _adjustTicksForSmallRange(ticks, index, range) {
+ let newTicks = ticks
+ if (
+ typeof index !== 'undefined' &&
+ this.w.config.yaxis[index].labels.formatter &&
+ this.w.config.yaxis[index].tickAmount === undefined
+ ) {
+ const formattedVal = this.w.config.yaxis[index].labels.formatter(1)
+ if (
+ Utils.isNumber(Number(formattedVal)) &&
+ !Utils.isFloat(formattedVal)
+ ) {
+ newTicks = Math.ceil(range)
+ }
+ }
+ return newTicks < ticks ? newTicks : ticks
+ }
+
+ setYScaleForIndex(index, minY, maxY) {
+ const gl = this.w.globals
+ const cnf = this.w.config
+
+ let y = gl.isBarHorizontal ? cnf.xaxis : cnf.yaxis[index]
+
+ if (typeof gl.yAxisScale[index] === 'undefined') {
+ gl.yAxisScale[index] = []
+ }
+
+ let diff = Math.abs(maxY - minY)
+
+ if (y.logarithmic && diff <= 5) {
+ gl.invalidLogScale = true
+ }
+
+ if (y.logarithmic && diff > 5) {
+ gl.allSeriesCollapsed = false
+ gl.yAxisScale[index] = this.logarithmicScale(minY, maxY, y.logBase)
+ gl.yAxisScale[index] = y.forceNiceScale
+ ? this.logarithmicScaleNice(minY, maxY, y.logBase)
+ : this.logarithmicScale(minY, maxY, y.logBase)
+ } else {
+ if (maxY === -Number.MAX_VALUE || !Utils.isNumber(maxY)) {
+ // no data in the chart. Either all series collapsed or user passed a blank array
+ gl.yAxisScale[index] = this.linearScale(0, 5, 5)
+ } else {
+ // there is some data. Turn off the allSeriesCollapsed flag
+ gl.allSeriesCollapsed = false
+
+ if ((y.min !== undefined || y.max !== undefined) && !y.forceNiceScale) {
+ // fix https://github.com/apexcharts/apexcharts.js/issues/492
+ gl.yAxisScale[index] = this.linearScale(
+ minY,
+ maxY,
+ y.tickAmount,
+ index
+ )
+ } else {
+ const noMinMaxProvided =
+ (cnf.yaxis[index].max === undefined &&
+ cnf.yaxis[index].min === undefined) ||
+ cnf.yaxis[index].forceNiceScale
+ gl.yAxisScale[index] = this.niceScale(
+ minY,
+ maxY,
+ y.tickAmount ? y.tickAmount : diff < 5 && diff > 1 ? diff + 1 : 5,
+ index,
+ // fix https://github.com/apexcharts/apexcharts.js/issues/397
+ noMinMaxProvided
+ )
+ }
+ }
+ }
+ }
+
+ setXScale(minX, maxX) {
+ const w = this.w
+ const gl = w.globals
+ const x = w.config.xaxis
+ let diff = Math.abs(maxX - minX)
+ if (maxX === -Number.MAX_VALUE || !Utils.isNumber(maxX)) {
+ // no data in the chart. Either all series collapsed or user passed a blank array
+ gl.xAxisScale = this.linearScale(0, 5, 5)
+ } else {
+ gl.xAxisScale = this.linearScale(
+ minX,
+ maxX,
+ x.tickAmount ? x.tickAmount : diff < 5 && diff > 1 ? diff + 1 : 5,
+ 0
+ )
+ }
+ return gl.xAxisScale
+ }
+
+ setMultipleYScales() {
+ const gl = this.w.globals
+ const cnf = this.w.config
+
+ const minYArr = gl.minYArr.concat([])
+ const maxYArr = gl.maxYArr.concat([])
+
+ let scalesIndices = []
+ // here, we loop through the yaxis array and find the item which has "seriesName" property
+ cnf.yaxis.forEach((yaxe, i) => {
+ let index = i
+ cnf.series.forEach((s, si) => {
+ // if seriesName matches and that series is not collapsed, we use that scale
+ // fix issue #1215
+ // proceed even if si is in gl.collapsedSeriesIndices
+ if (s.name === yaxe.seriesName) {
+ index = si
+
+ if (i !== si) {
+ scalesIndices.push({
+ index: si,
+ similarIndex: i,
+ alreadyExists: true
+ })
+ } else {
+ scalesIndices.push({
+ index: si
+ })
+ }
+ }
+ })
+
+ let minY = minYArr[index]
+ let maxY = maxYArr[index]
+
+ this.setYScaleForIndex(i, minY, maxY)
+ })
+
+ this.sameScaleInMultipleAxes(minYArr, maxYArr, scalesIndices)
+ }
+
+ sameScaleInMultipleAxes(minYArr, maxYArr, scalesIndices) {
+ const cnf = this.w.config
+ const gl = this.w.globals
+
+ // we got the scalesIndices array in the above code, but we need to filter out the items which doesn't have same scales
+ let similarIndices = []
+ scalesIndices.forEach((scale) => {
+ if (scale.alreadyExists) {
+ if (typeof similarIndices[scale.index] === 'undefined') {
+ similarIndices[scale.index] = []
+ }
+ similarIndices[scale.index].push(scale.index)
+ similarIndices[scale.index].push(scale.similarIndex)
+ }
+ })
+
+ function intersect(a, b) {
+ return a.filter((value) => b.indexOf(value) !== -1)
+ }
+
+ gl.yAxisSameScaleIndices = similarIndices
+
+ similarIndices.forEach((si, i) => {
+ similarIndices.forEach((sj, j) => {
+ if (i !== j) {
+ if (intersect(si, sj).length > 0) {
+ similarIndices[i] = similarIndices[i].concat(similarIndices[j])
+ }
+ }
+ })
+ })
+
+ // then, we remove duplicates from the similarScale array
+ let uniqueSimilarIndices = similarIndices.map((item) => {
+ return item.filter((i, pos) => item.indexOf(i) === pos)
+ })
+
+ // sort further to remove whole duplicate arrays later
+ let sortedIndices = uniqueSimilarIndices.map((s) => s.sort())
+
+ // remove undefined items
+ similarIndices = similarIndices.filter((s) => !!s)
+
+ let indices = sortedIndices.slice()
+ let stringIndices = indices.map((ind) => JSON.stringify(ind))
+ indices = indices.filter(
+ (ind, p) => stringIndices.indexOf(JSON.stringify(ind)) === p
+ )
+
+ let sameScaleMinYArr = []
+ let sameScaleMaxYArr = []
+ minYArr.forEach((minYValue, yi) => {
+ indices.forEach((scale, i) => {
+ // we compare only the yIndex which exists in the indices array
+ if (scale.indexOf(yi) > -1) {
+ if (typeof sameScaleMinYArr[i] === 'undefined') {
+ sameScaleMinYArr[i] = []
+ sameScaleMaxYArr[i] = []
+ }
+ sameScaleMinYArr[i].push({
+ key: yi,
+ value: minYValue
+ })
+ sameScaleMaxYArr[i].push({
+ key: yi,
+ value: maxYArr[yi]
+ })
+ }
+ })
+ })
+
+ let sameScaleMin = Array.apply(null, Array(indices.length)).map(
+ Number.prototype.valueOf,
+ Number.MIN_VALUE
+ )
+ let sameScaleMax = Array.apply(null, Array(indices.length)).map(
+ Number.prototype.valueOf,
+ -Number.MAX_VALUE
+ )
+
+ sameScaleMinYArr.forEach((s, i) => {
+ s.forEach((sc, j) => {
+ sameScaleMin[i] = Math.min(sc.value, sameScaleMin[i])
+ })
+ })
+
+ sameScaleMaxYArr.forEach((s, i) => {
+ s.forEach((sc, j) => {
+ sameScaleMax[i] = Math.max(sc.value, sameScaleMax[i])
+ })
+ })
+
+ minYArr.forEach((min, i) => {
+ sameScaleMaxYArr.forEach((s, si) => {
+ let minY = sameScaleMin[si]
+ let maxY = sameScaleMax[si]
+
+ if (cnf.chart.stacked) {
+ // for stacked charts, we need to add the values
+ maxY = 0
+
+ s.forEach((ind, k) => {
+ // fix incorrectly adjust y scale issue #1215
+ if (ind.value !== -Number.MAX_VALUE) {
+ maxY += ind.value
+ }
+ if (minY !== Number.MIN_VALUE) {
+ minY += sameScaleMinYArr[si][k].value
+ }
+ })
+ }
+
+ s.forEach((ind, k) => {
+ if (s[k].key === i) {
+ if (cnf.yaxis[i].min !== undefined) {
+ if (typeof cnf.yaxis[i].min === 'function') {
+ minY = cnf.yaxis[i].min(gl.minY)
+ } else {
+ minY = cnf.yaxis[i].min
+ }
+ }
+ if (cnf.yaxis[i].max !== undefined) {
+ if (typeof cnf.yaxis[i].max === 'function') {
+ maxY = cnf.yaxis[i].max(gl.maxY)
+ } else {
+ maxY = cnf.yaxis[i].max
+ }
+ }
+
+ this.setYScaleForIndex(i, minY, maxY)
+ }
+ })
+ })
+ })
+ }
+
+ // experimental feature which scales the y-axis to a min/max based on x-axis range
+ autoScaleY(ctx, yaxis, e) {
+ if (!ctx) {
+ ctx = this
+ }
+
+ const w = ctx.w
+
+ if (w.globals.isMultipleYAxis || w.globals.collapsedSeries.length) {
+ // The autoScale option for multiple y-axis is turned off as it leads to buggy behavior.
+ // Also, when a series is collapsed, it results in incorrect behavior. Hence turned it off for that too - fixes apexcharts.js#795
+ console.warn('autoScaleYaxis is not supported in a multi-yaxis chart.')
+ return yaxis
+ }
+
+ const seriesX = w.globals.seriesX[0]
+
+ let isStacked = w.config.chart.stacked
+
+ yaxis.forEach((yaxe, yi) => {
+ let firstXIndex = 0
+
+ for (let xi = 0; xi < seriesX.length; xi++) {
+ if (seriesX[xi] >= e.xaxis.min) {
+ firstXIndex = xi
+ break
+ }
+ }
+
+ let initialMin = w.globals.minYArr[yi]
+ let initialMax = w.globals.maxYArr[yi]
+ let min, max
+
+ let stackedSer = w.globals.stackedSeriesTotals
+
+ w.globals.series.forEach((serie, sI) => {
+ let firstValue = serie[firstXIndex]
+
+ if (isStacked) {
+ firstValue = stackedSer[firstXIndex]
+ min = max = firstValue
+
+ stackedSer.forEach((y, yI) => {
+ if (seriesX[yI] <= e.xaxis.max && seriesX[yI] >= e.xaxis.min) {
+ if (y > max && y !== null) max = y
+ if (serie[yI] < min && serie[yI] !== null) min = serie[yI]
+ }
+ })
+ } else {
+ min = max = firstValue
+
+ serie.forEach((y, yI) => {
+ if (seriesX[yI] <= e.xaxis.max && seriesX[yI] >= e.xaxis.min) {
+ let valMin = y
+ let valMax = y
+ w.globals.series.forEach((wS, wSI) => {
+ if (y !== null) {
+ valMin = Math.min(wS[yI], valMin)
+ valMax = Math.max(wS[yI], valMax)
+ }
+ })
+ if (valMax > max && valMax !== null) max = valMax
+ if (valMin < min && valMin !== null) min = valMin
+ }
+ })
+ }
+
+ if (min === undefined && max === undefined) {
+ min = initialMin
+ max = initialMax
+ }
+ min *= min < 0 ? 1.1 : 0.9
+ max *= max < 0 ? 0.9 : 1.1
+
+ if (max < 0 && max < initialMax) {
+ max = initialMax
+ }
+ if (min < 0 && min > initialMin) {
+ min = initialMin
+ }
+
+ if (yaxis.length > 1) {
+ yaxis[sI].min = yaxe.min === undefined ? min : yaxe.min
+ yaxis[sI].max = yaxe.max === undefined ? max : yaxe.max
+ } else {
+ yaxis[0].min = yaxe.min === undefined ? min : yaxe.min
+ yaxis[0].max = yaxe.max === undefined ? max : yaxe.max
+ }
+ })
+ })
+
+ return yaxis
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Series.js b/cao_sunyata/static/libs/apexcharts/src/modules/Series.js
new file mode 100644
index 0000000..73e487d
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Series.js
@@ -0,0 +1,453 @@
+import Graphics from './Graphics'
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Series Class for interaction with the Series of the chart.
+ *
+ * @module Series
+ **/
+
+export default class Series {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.legendInactiveClass = 'legend-mouseover-inactive'
+ }
+
+ getAllSeriesEls() {
+ return this.w.globals.dom.baseEl.getElementsByClassName(`apexcharts-series`)
+ }
+
+ getSeriesByName(seriesName) {
+ return this.w.globals.dom.baseEl.querySelector(
+ `.apexcharts-inner .apexcharts-series[seriesName='${Utils.escapeString(
+ seriesName
+ )}']`
+ )
+ }
+
+ isSeriesHidden(seriesName) {
+ const targetElement = this.getSeriesByName(seriesName)
+ let realIndex = parseInt(targetElement.getAttribute('data:realIndex'), 10)
+ let isHidden = targetElement.classList.contains(
+ 'apexcharts-series-collapsed'
+ )
+
+ return { isHidden, realIndex }
+ }
+
+ addCollapsedClassToSeries(elSeries, index) {
+ const w = this.w
+ function iterateOnAllCollapsedSeries(series) {
+ for (let cs = 0; cs < series.length; cs++) {
+ if (series[cs].index === index) {
+ elSeries.node.classList.add('apexcharts-series-collapsed')
+ }
+ }
+ }
+
+ iterateOnAllCollapsedSeries(w.globals.collapsedSeries)
+ iterateOnAllCollapsedSeries(w.globals.ancillaryCollapsedSeries)
+ }
+
+ toggleSeries(seriesName) {
+ let isSeriesHidden = this.isSeriesHidden(seriesName)
+
+ this.ctx.legend.legendHelpers.toggleDataSeries(
+ isSeriesHidden.realIndex,
+ isSeriesHidden.isHidden
+ )
+
+ return isSeriesHidden.isHidden
+ }
+
+ showSeries(seriesName) {
+ let isSeriesHidden = this.isSeriesHidden(seriesName)
+
+ if (isSeriesHidden.isHidden) {
+ this.ctx.legend.legendHelpers.toggleDataSeries(
+ isSeriesHidden.realIndex,
+ true
+ )
+ }
+ }
+
+ hideSeries(seriesName) {
+ let isSeriesHidden = this.isSeriesHidden(seriesName)
+
+ if (!isSeriesHidden.isHidden) {
+ this.ctx.legend.legendHelpers.toggleDataSeries(
+ isSeriesHidden.realIndex,
+ false
+ )
+ }
+ }
+
+ resetSeries(
+ shouldUpdateChart = true,
+ shouldResetZoom = true,
+ shouldResetCollapsed = true
+ ) {
+ const w = this.w
+
+ let series = Utils.clone(w.globals.initialSeries)
+
+ w.globals.previousPaths = []
+
+ if (shouldResetCollapsed) {
+ w.globals.collapsedSeries = []
+ w.globals.ancillaryCollapsedSeries = []
+ w.globals.collapsedSeriesIndices = []
+ w.globals.ancillaryCollapsedSeriesIndices = []
+ } else {
+ series = this.emptyCollapsedSeries(series)
+ }
+
+ w.config.series = series
+
+ if (shouldUpdateChart) {
+ if (shouldResetZoom) {
+ w.globals.zoomed = false
+ this.ctx.updateHelpers.revertDefaultAxisMinMax()
+ }
+ this.ctx.updateHelpers._updateSeries(
+ series,
+ w.config.chart.animations.dynamicAnimation.enabled
+ )
+ }
+ }
+
+ emptyCollapsedSeries(series) {
+ const w = this.w
+ for (let i = 0; i < series.length; i++) {
+ if (w.globals.collapsedSeriesIndices.indexOf(i) > -1) {
+ series[i].data = []
+ }
+ }
+ return series
+ }
+ toggleSeriesOnHover(e, targetElement) {
+ const w = this.w
+
+ if (!targetElement) targetElement = e.target
+
+ let allSeriesEls = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-series, .apexcharts-datalabels`
+ )
+
+ if (e.type === 'mousemove') {
+ let seriesCnt = parseInt(targetElement.getAttribute('rel'), 10) - 1
+
+ let seriesEl = null
+ let dataLabelEl = null
+ if (w.globals.axisCharts || w.config.chart.type === 'radialBar') {
+ if (w.globals.axisCharts) {
+ seriesEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[data\\:realIndex='${seriesCnt}']`
+ )
+ dataLabelEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-datalabels[data\\:realIndex='${seriesCnt}']`
+ )
+ } else {
+ seriesEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[rel='${seriesCnt + 1}']`
+ )
+ }
+ } else {
+ seriesEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[rel='${seriesCnt + 1}'] path`
+ )
+ }
+
+ for (let se = 0; se < allSeriesEls.length; se++) {
+ allSeriesEls[se].classList.add(this.legendInactiveClass)
+ }
+
+ if (seriesEl !== null) {
+ if (!w.globals.axisCharts) {
+ seriesEl.parentNode.classList.remove(this.legendInactiveClass)
+ }
+ seriesEl.classList.remove(this.legendInactiveClass)
+
+ if (dataLabelEl !== null) {
+ dataLabelEl.classList.remove(this.legendInactiveClass)
+ }
+ }
+ } else if (e.type === 'mouseout') {
+ for (let se = 0; se < allSeriesEls.length; se++) {
+ allSeriesEls[se].classList.remove(this.legendInactiveClass)
+ }
+ }
+ }
+
+ highlightRangeInSeries(e, targetElement) {
+ const w = this.w
+ const allHeatMapElements = w.globals.dom.baseEl.getElementsByClassName(
+ 'apexcharts-heatmap-rect'
+ )
+
+ const activeInactive = (action) => {
+ for (let i = 0; i < allHeatMapElements.length; i++) {
+ allHeatMapElements[i].classList[action](this.legendInactiveClass)
+ }
+ }
+
+ const removeInactiveClassFromHoveredRange = (range) => {
+ for (let i = 0; i < allHeatMapElements.length; i++) {
+ const val = parseInt(allHeatMapElements[i].getAttribute('val'), 10)
+ if (val >= range.from && val <= range.to) {
+ allHeatMapElements[i].classList.remove(this.legendInactiveClass)
+ }
+ }
+ }
+
+ if (e.type === 'mousemove') {
+ let seriesCnt = parseInt(targetElement.getAttribute('rel'), 10) - 1
+ activeInactive('add')
+
+ const range = w.config.plotOptions.heatmap.colorScale.ranges[seriesCnt]
+
+ removeInactiveClassFromHoveredRange(range)
+ } else if (e.type === 'mouseout') {
+ activeInactive('remove')
+ }
+ }
+
+ getActiveConfigSeriesIndex(ignoreBars = false, order = 'asc') {
+ const w = this.w
+ let activeIndex = 0
+
+ if (w.config.series.length > 1) {
+ // active series flag is required to know if user has not deactivated via legend click
+ let activeSeriesIndex = w.config.series.map((s, index) => {
+ let hasBars = false
+ if (ignoreBars) {
+ hasBars =
+ w.config.series[index].type === 'bar' ||
+ w.config.series[index].type === 'column'
+ }
+ return s.data && s.data.length > 0 && !hasBars ? index : -1
+ })
+
+ for (
+ let a = order === 'asc' ? 0 : activeSeriesIndex.length - 1;
+ order === 'asc' ? a < activeSeriesIndex.length : a >= 0;
+ order === 'asc' ? a++ : a--
+ ) {
+ if (activeSeriesIndex[a] !== -1) {
+ activeIndex = activeSeriesIndex[a]
+ break
+ }
+ }
+ }
+
+ return activeIndex
+ }
+
+ getPreviousPaths() {
+ let w = this.w
+
+ w.globals.previousPaths = []
+
+ function pushPaths(seriesEls, i, type) {
+ let paths = seriesEls[i].childNodes
+ let dArr = {
+ type,
+ paths: [],
+ realIndex: seriesEls[i].getAttribute('data:realIndex')
+ }
+
+ for (let j = 0; j < paths.length; j++) {
+ if (paths[j].hasAttribute('pathTo')) {
+ let d = paths[j].getAttribute('pathTo')
+ dArr.paths.push({
+ d
+ })
+ }
+ }
+
+ w.globals.previousPaths.push(dArr)
+ }
+
+ const getPaths = (chartType) => {
+ return w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-${chartType}-series .apexcharts-series`
+ )
+ }
+
+ const chartTypes = [
+ 'line',
+ 'area',
+ 'bar',
+ 'rangebar',
+ 'candlestick',
+ 'radar'
+ ]
+ chartTypes.forEach((type) => {
+ const paths = getPaths(type)
+ for (let p = 0; p < paths.length; p++) {
+ pushPaths(paths, p, type)
+ }
+ })
+
+ this.handlePrevBubbleScatterPaths('bubble')
+ this.handlePrevBubbleScatterPaths('scatter')
+
+ let heatTreeSeries = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-${w.config.chart.type} .apexcharts-series`
+ )
+
+ if (heatTreeSeries.length > 0) {
+ for (let h = 0; h < heatTreeSeries.length; h++) {
+ let seriesEls = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-${w.config.chart.type} .apexcharts-series[data\\:realIndex='${h}'] rect`
+ )
+
+ let dArr = []
+
+ for (let i = 0; i < seriesEls.length; i++) {
+ const getAttr = (x) => {
+ return seriesEls[i].getAttribute(x)
+ }
+ const rect = {
+ x: parseFloat(getAttr('x')),
+ y: parseFloat(getAttr('y')),
+ width: parseFloat(getAttr('width')),
+ height: parseFloat(getAttr('height'))
+ }
+ dArr.push({
+ rect,
+ color: seriesEls[i].getAttribute('color')
+ })
+ }
+ w.globals.previousPaths.push(dArr)
+ }
+ }
+
+ if (!w.globals.axisCharts) {
+ // for non-axis charts (i.e., circular charts, pathFrom is not usable. We need whole series)
+ w.globals.previousPaths = w.globals.series
+ }
+ }
+
+ handlePrevBubbleScatterPaths(type) {
+ const w = this.w
+ let paths = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-${type}-series .apexcharts-series`
+ )
+ if (paths.length > 0) {
+ for (let s = 0; s < paths.length; s++) {
+ let seriesEls = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-${type}-series .apexcharts-series[data\\:realIndex='${s}'] circle`
+ )
+ let dArr = []
+
+ for (let i = 0; i < seriesEls.length; i++) {
+ dArr.push({
+ x: seriesEls[i].getAttribute('cx'),
+ y: seriesEls[i].getAttribute('cy'),
+ r: seriesEls[i].getAttribute('r')
+ })
+ }
+ w.globals.previousPaths.push(dArr)
+ }
+ }
+ }
+
+ clearPreviousPaths() {
+ const w = this.w
+ w.globals.previousPaths = []
+ w.globals.allSeriesCollapsed = false
+ }
+
+ handleNoData() {
+ const w = this.w
+ const me = this
+
+ const noDataOpts = w.config.noData
+ const graphics = new Graphics(me.ctx)
+
+ let x = w.globals.svgWidth / 2
+ let y = w.globals.svgHeight / 2
+ let textAnchor = 'middle'
+
+ w.globals.noData = true
+ w.globals.animationEnded = true
+
+ if (noDataOpts.align === 'left') {
+ x = 10
+ textAnchor = 'start'
+ } else if (noDataOpts.align === 'right') {
+ x = w.globals.svgWidth - 10
+ textAnchor = 'end'
+ }
+
+ if (noDataOpts.verticalAlign === 'top') {
+ y = 50
+ } else if (noDataOpts.verticalAlign === 'bottom') {
+ y = w.globals.svgHeight - 50
+ }
+
+ x = x + noDataOpts.offsetX
+ y = y + parseInt(noDataOpts.style.fontSize, 10) + 2 + noDataOpts.offsetY
+
+ if (noDataOpts.text !== undefined && noDataOpts.text !== '') {
+ let titleText = graphics.drawText({
+ x,
+ y,
+ text: noDataOpts.text,
+ textAnchor,
+ fontSize: noDataOpts.style.fontSize,
+ fontFamily: noDataOpts.style.fontFamily,
+ foreColor: noDataOpts.style.color,
+ opacity: 1,
+ class: 'apexcharts-text-nodata'
+ })
+
+ w.globals.dom.Paper.add(titleText)
+ }
+ }
+
+ // When user clicks on legends, the collapsed series is filled with [0,0,0,...,0]
+ // This is because we don't want to alter the series' length as it is used at many places
+ setNullSeriesToZeroValues(series) {
+ let w = this.w
+ for (let sl = 0; sl < series.length; sl++) {
+ if (series[sl].length === 0) {
+ for (let j = 0; j < series[w.globals.maxValsInArrayIndex].length; j++) {
+ series[sl].push(0)
+ }
+ }
+ }
+ return series
+ }
+
+ hasAllSeriesEqualX() {
+ let equalLen = true
+ const w = this.w
+
+ const filteredSerX = this.filteredSeriesX()
+
+ for (let i = 0; i < filteredSerX.length - 1; i++) {
+ if (filteredSerX[i][0] !== filteredSerX[i + 1][0]) {
+ equalLen = false
+ break
+ }
+ }
+
+ w.globals.allSeriesHasEqualX = equalLen
+
+ return equalLen
+ }
+
+ filteredSeriesX() {
+ const w = this.w
+
+ const filteredSeriesX = w.globals.seriesX.map((ser) =>
+ ser.length > 0 ? ser : []
+ )
+
+ return filteredSeriesX
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Theme.js b/cao_sunyata/static/libs/apexcharts/src/modules/Theme.js
new file mode 100644
index 0000000..f7138aa
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Theme.js
@@ -0,0 +1,239 @@
+import Utils from '../utils/Utils'
+
+/**
+ * ApexCharts Theme Class for setting the colors and palettes.
+ *
+ * @module Theme
+ **/
+
+export default class Theme {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.colors = []
+ this.w = ctx.w
+ const w = this.w
+
+ this.isColorFn = false
+ this.isHeatmapDistributed =
+ (w.config.chart.type === 'treemap' &&
+ w.config.plotOptions.treemap.distributed) ||
+ (w.config.chart.type === 'heatmap' &&
+ w.config.plotOptions.heatmap.distributed)
+ this.isBarDistributed =
+ w.config.plotOptions.bar.distributed &&
+ (w.config.chart.type === 'bar' || w.config.chart.type === 'rangeBar')
+ }
+
+ init() {
+ this.setDefaultColors()
+ }
+
+ setDefaultColors() {
+ let w = this.w
+ let utils = new Utils()
+
+ w.globals.dom.elWrap.classList.add(
+ `apexcharts-theme-${w.config.theme.mode}`
+ )
+
+ if (w.config.colors === undefined) {
+ w.globals.colors = this.predefined()
+ } else {
+ w.globals.colors = w.config.colors
+
+ // if user provided a function in colors, we need to eval here
+ if (
+ Array.isArray(w.config.colors) &&
+ w.config.colors.length > 0 &&
+ typeof w.config.colors[0] === 'function'
+ ) {
+ w.globals.colors = w.config.series.map((s, i) => {
+ let c = w.config.colors[i]
+ if (!c) c = w.config.colors[0]
+ if (typeof c === 'function') {
+ this.isColorFn = true
+ return c({
+ value: w.globals.axisCharts
+ ? w.globals.series[i][0]
+ ? w.globals.series[i][0]
+ : 0
+ : w.globals.series[i],
+ seriesIndex: i,
+ dataPointIndex: i,
+ w
+ })
+ }
+ return c
+ })
+ }
+ }
+
+ // user defined colors in series array
+ w.globals.seriesColors.map((c, i) => {
+ if (c) {
+ w.globals.colors[i] = c
+ }
+ })
+
+ if (w.config.theme.monochrome.enabled) {
+ let monoArr = []
+ let glsCnt = w.globals.series.length
+ if (this.isBarDistributed || this.isHeatmapDistributed) {
+ glsCnt = w.globals.series[0].length * w.globals.series.length
+ }
+
+ let mainColor = w.config.theme.monochrome.color
+ let part = 1 / (glsCnt / w.config.theme.monochrome.shadeIntensity)
+ let shade = w.config.theme.monochrome.shadeTo
+ let percent = 0
+
+ for (let gsl = 0; gsl < glsCnt; gsl++) {
+ let newColor
+
+ if (shade === 'dark') {
+ newColor = utils.shadeColor(percent * -1, mainColor)
+ percent = percent + part
+ } else {
+ newColor = utils.shadeColor(percent, mainColor)
+ percent = percent + part
+ }
+
+ monoArr.push(newColor)
+ }
+ w.globals.colors = monoArr.slice()
+ }
+ const defaultColors = w.globals.colors.slice()
+
+ // if user specified fewer colors than no. of series, push the same colors again
+ this.pushExtraColors(w.globals.colors)
+
+ const colorTypes = ['fill', 'stroke']
+ colorTypes.forEach((c) => {
+ if (w.config[c].colors === undefined) {
+ w.globals[c].colors = this.isColorFn ? w.config.colors : defaultColors
+ } else {
+ w.globals[c].colors = w.config[c].colors.slice()
+ }
+ this.pushExtraColors(w.globals[c].colors)
+ })
+
+ if (w.config.dataLabels.style.colors === undefined) {
+ w.globals.dataLabels.style.colors = defaultColors
+ } else {
+ w.globals.dataLabels.style.colors = w.config.dataLabels.style.colors.slice()
+ }
+ this.pushExtraColors(w.globals.dataLabels.style.colors, 50)
+
+ if (w.config.plotOptions.radar.polygons.fill.colors === undefined) {
+ w.globals.radarPolygons.fill.colors = [
+ w.config.theme.mode === 'dark' ? '#424242' : 'none'
+ ]
+ } else {
+ w.globals.radarPolygons.fill.colors = w.config.plotOptions.radar.polygons.fill.colors.slice()
+ }
+ this.pushExtraColors(w.globals.radarPolygons.fill.colors, 20)
+
+ // The point colors
+ if (w.config.markers.colors === undefined) {
+ w.globals.markers.colors = defaultColors
+ } else {
+ w.globals.markers.colors = w.config.markers.colors.slice()
+ }
+ this.pushExtraColors(w.globals.markers.colors)
+ }
+
+ // When the number of colors provided is less than the number of series, this method
+ // will push same colors to the list
+ // params:
+ // distributed is only valid for distributed column/bar charts
+ pushExtraColors(colorSeries, length, distributed = null) {
+ let w = this.w
+
+ let len = length || w.globals.series.length
+
+ if (distributed === null) {
+ distributed =
+ this.isBarDistributed ||
+ this.isHeatmapDistributed ||
+ (w.config.chart.type === 'heatmap' &&
+ w.config.plotOptions.heatmap.colorScale.inverse)
+ }
+
+ if (distributed && w.globals.series.length) {
+ len =
+ w.globals.series[w.globals.maxValsInArrayIndex].length *
+ w.globals.series.length
+ }
+
+ if (colorSeries.length < len) {
+ let diff = len - colorSeries.length
+ for (let i = 0; i < diff; i++) {
+ colorSeries.push(colorSeries[i])
+ }
+ }
+ }
+
+ updateThemeOptions(options) {
+ options.chart = options.chart || {}
+ options.tooltip = options.tooltip || {}
+ const mode = options.theme.mode || 'light'
+ const palette = options.theme.palette
+ ? options.theme.palette
+ : mode === 'dark'
+ ? 'palette4'
+ : 'palette1'
+ const foreColor = options.chart.foreColor
+ ? options.chart.foreColor
+ : mode === 'dark'
+ ? '#f6f7f8'
+ : '#373d3f'
+
+ options.tooltip.theme = mode
+ options.chart.foreColor = foreColor
+ options.theme.palette = palette
+
+ return options
+ }
+
+ predefined() {
+ let palette = this.w.config.theme.palette
+
+ // D6E3F8, FCEFEF, DCE0D9, A5978B, EDDDD4, D6E3F8, FEF5EF
+ switch (palette) {
+ case 'palette1':
+ this.colors = ['#008FFB', '#00E396', '#FEB019', '#FF4560', '#775DD0']
+ break
+ case 'palette2':
+ this.colors = ['#3f51b5', '#03a9f4', '#4caf50', '#f9ce1d', '#FF9800']
+ break
+ case 'palette3':
+ this.colors = ['#33b2df', '#546E7A', '#d4526e', '#13d8aa', '#A5978B']
+ break
+ case 'palette4':
+ this.colors = ['#4ecdc4', '#c7f464', '#81D4FA', '#fd6a6a', '#546E7A']
+ break
+ case 'palette5':
+ this.colors = ['#2b908f', '#f9a3a4', '#90ee7e', '#fa4443', '#69d2e7']
+ break
+ case 'palette6':
+ this.colors = ['#449DD1', '#F86624', '#EA3546', '#662E9B', '#C5D86D']
+ break
+ case 'palette7':
+ this.colors = ['#D7263D', '#1B998B', '#2E294E', '#F46036', '#E2C044']
+ break
+ case 'palette8':
+ this.colors = ['#662E9B', '#F86624', '#F9C80E', '#EA3546', '#43BCCD']
+ break
+ case 'palette9':
+ this.colors = ['#5C4742', '#A5978B', '#8D5B4C', '#5A2A27', '#C4BBAF']
+ break
+ case 'palette10':
+ this.colors = ['#A300D6', '#7D02EB', '#5653FE', '#2983FF', '#00B1F2']
+ break
+ default:
+ this.colors = ['#008FFB', '#00E396', '#FEB019', '#FF4560', '#775DD0']
+ break
+ }
+ return this.colors
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/TimeScale.js b/cao_sunyata/static/libs/apexcharts/src/modules/TimeScale.js
new file mode 100644
index 0000000..92e5aa3
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/TimeScale.js
@@ -0,0 +1,917 @@
+import DateTime from '../utils/DateTime'
+import Dimensions from './dimensions/Dimensions'
+import Graphics from './Graphics'
+import Utils from '../utils/Utils'
+
+const MINUTES_IN_DAY = 24 * 60
+const SECONDS_IN_DAY = MINUTES_IN_DAY * 60
+const MIN_ZOOM_DAYS = 10 / SECONDS_IN_DAY
+
+/**
+ * ApexCharts TimeScale Class for generating time ticks for x-axis.
+ *
+ * @module TimeScale
+ **/
+
+class TimeScale {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ this.timeScaleArray = []
+ this.utc = this.w.config.xaxis.labels.datetimeUTC
+ }
+
+ calculateTimeScaleTicks(minX, maxX) {
+ let w = this.w
+
+ // null check when no series to show
+ if (w.globals.allSeriesCollapsed) {
+ w.globals.labels = []
+ w.globals.timescaleLabels = []
+ return []
+ }
+
+ let dt = new DateTime(this.ctx)
+
+ const daysDiff = (maxX - minX) / (1000 * SECONDS_IN_DAY)
+ this.determineInterval(daysDiff)
+
+ w.globals.disableZoomIn = false
+ w.globals.disableZoomOut = false
+
+ if (daysDiff < MIN_ZOOM_DAYS) {
+ w.globals.disableZoomIn = true
+ } else if (daysDiff > 50000) {
+ w.globals.disableZoomOut = true
+ }
+
+ const timeIntervals = dt.getTimeUnitsfromTimestamp(minX, maxX, this.utc)
+
+ const daysWidthOnXAxis = w.globals.gridWidth / daysDiff
+ const hoursWidthOnXAxis = daysWidthOnXAxis / 24
+ const minutesWidthOnXAxis = hoursWidthOnXAxis / 60
+ const secondsWidthOnXAxis = minutesWidthOnXAxis / 60
+
+ let numberOfHours = Math.floor(daysDiff * 24)
+ let numberOfMinutes = Math.floor(daysDiff * MINUTES_IN_DAY)
+ let numberOfSeconds = Math.floor(daysDiff * SECONDS_IN_DAY)
+ let numberOfDays = Math.floor(daysDiff)
+ let numberOfMonths = Math.floor(daysDiff / 30)
+ let numberOfYears = Math.floor(daysDiff / 365)
+
+ const firstVal = {
+ minMillisecond: timeIntervals.minMillisecond,
+ minSecond: timeIntervals.minSecond,
+ minMinute: timeIntervals.minMinute,
+ minHour: timeIntervals.minHour,
+ minDate: timeIntervals.minDate,
+ minMonth: timeIntervals.minMonth,
+ minYear: timeIntervals.minYear
+ }
+
+ let currentMillisecond = firstVal.minMillisecond
+ let currentSecond = firstVal.minSecond
+ let currentMinute = firstVal.minMinute
+ let currentHour = firstVal.minHour
+ let currentMonthDate = firstVal.minDate
+ let currentDate = firstVal.minDate
+ let currentMonth = firstVal.minMonth
+ let currentYear = firstVal.minYear
+
+ const params = {
+ firstVal,
+ currentMillisecond,
+ currentSecond,
+ currentMinute,
+ currentHour,
+ currentMonthDate,
+ currentDate,
+ currentMonth,
+ currentYear,
+ daysWidthOnXAxis,
+ hoursWidthOnXAxis,
+ minutesWidthOnXAxis,
+ secondsWidthOnXAxis,
+ numberOfSeconds,
+ numberOfMinutes,
+ numberOfHours,
+ numberOfDays,
+ numberOfMonths,
+ numberOfYears
+ }
+
+ switch (this.tickInterval) {
+ case 'years': {
+ this.generateYearScale(params)
+ break
+ }
+ case 'months':
+ case 'half_year': {
+ this.generateMonthScale(params)
+ break
+ }
+ case 'months_days':
+ case 'months_fortnight':
+ case 'days':
+ case 'week_days': {
+ this.generateDayScale(params)
+ break
+ }
+ case 'hours': {
+ this.generateHourScale(params)
+ break
+ }
+ case 'minutes_fives':
+ case 'minutes':
+ this.generateMinuteScale(params)
+ break
+ case 'seconds_tens':
+ case 'seconds_fives':
+ case 'seconds':
+ this.generateSecondScale(params)
+ break
+ }
+
+ // first, we will adjust the month values index
+ // as in the upper function, it is starting from 0
+ // we will start them from 1
+ const adjustedMonthInTimeScaleArray = this.timeScaleArray.map((ts) => {
+ let defaultReturn = {
+ position: ts.position,
+ unit: ts.unit,
+ year: ts.year,
+ day: ts.day ? ts.day : 1,
+ hour: ts.hour ? ts.hour : 0,
+ month: ts.month + 1
+ }
+ if (ts.unit === 'month') {
+ return {
+ ...defaultReturn,
+ day: 1,
+ value: ts.value + 1
+ }
+ } else if (ts.unit === 'day' || ts.unit === 'hour') {
+ return {
+ ...defaultReturn,
+ value: ts.value
+ }
+ } else if (ts.unit === 'minute') {
+ return {
+ ...defaultReturn,
+ value: ts.value,
+ minute: ts.value
+ }
+ } else if (ts.unit === 'second') {
+ return {
+ ...defaultReturn,
+ value: ts.value,
+ minute: ts.minute,
+ second: ts.second
+ }
+ }
+
+ return ts
+ })
+
+ const filteredTimeScale = adjustedMonthInTimeScaleArray.filter((ts) => {
+ let modulo = 1
+ let ticks = Math.ceil(w.globals.gridWidth / 120)
+ let value = ts.value
+ if (w.config.xaxis.tickAmount !== undefined) {
+ ticks = w.config.xaxis.tickAmount
+ }
+ if (adjustedMonthInTimeScaleArray.length > ticks) {
+ modulo = Math.floor(adjustedMonthInTimeScaleArray.length / ticks)
+ }
+
+ let shouldNotSkipUnit = false // there is a big change in unit i.e days to months
+ let shouldNotPrint = false // should skip these values
+
+ switch (this.tickInterval) {
+ case 'years':
+ // make years label denser
+ if (ts.unit === 'year') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'half_year':
+ modulo = 7
+ if (ts.unit === 'year') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'months':
+ modulo = 1
+ if (ts.unit === 'year') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'months_fortnight':
+ modulo = 15
+ if (ts.unit === 'year' || ts.unit === 'month') {
+ shouldNotSkipUnit = true
+ }
+ if (value === 30) {
+ shouldNotPrint = true
+ }
+ break
+ case 'months_days':
+ modulo = 10
+ if (ts.unit === 'month') {
+ shouldNotSkipUnit = true
+ }
+ if (value === 30) {
+ shouldNotPrint = true
+ }
+ break
+ case 'week_days':
+ modulo = 8
+ if (ts.unit === 'month') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'days':
+ modulo = 1
+ if (ts.unit === 'month') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'hours':
+ if (ts.unit === 'day') {
+ shouldNotSkipUnit = true
+ }
+ break
+ case 'minutes_fives':
+ if (value % 5 !== 0) {
+ shouldNotPrint = true
+ }
+ break
+ case 'seconds_tens':
+ if (value % 10 !== 0) {
+ shouldNotPrint = true
+ }
+ break
+ case 'seconds_fives':
+ if (value % 5 !== 0) {
+ shouldNotPrint = true
+ }
+ break
+ }
+
+ if (
+ this.tickInterval === 'hours' ||
+ this.tickInterval === 'minutes_fives' ||
+ this.tickInterval === 'seconds_tens' ||
+ this.tickInterval === 'seconds_fives'
+ ) {
+ if (!shouldNotPrint) {
+ return true
+ }
+ } else {
+ if ((value % modulo === 0 || shouldNotSkipUnit) && !shouldNotPrint) {
+ return true
+ }
+ }
+ })
+
+ return filteredTimeScale
+ }
+
+ recalcDimensionsBasedOnFormat(filteredTimeScale, inverted) {
+ const w = this.w
+ const reformattedTimescaleArray = this.formatDates(filteredTimeScale)
+
+ const removedOverlappingTS = this.removeOverlappingTS(
+ reformattedTimescaleArray
+ )
+
+ w.globals.timescaleLabels = removedOverlappingTS.slice()
+
+ // at this stage, we need to re-calculate coords of the grid as timeline labels may have altered the xaxis labels coords
+ // The reason we can't do this prior to this stage is because timeline labels depends on gridWidth, and as the ticks are calculated based on available gridWidth, there can be unknown number of ticks generated for different minX and maxX
+ // Dependency on Dimensions(), need to refactor correctly
+ // TODO - find an alternate way to avoid calling this Heavy method twice
+ let dimensions = new Dimensions(this.ctx)
+ dimensions.plotCoords()
+ }
+
+ determineInterval(daysDiff) {
+ const yearsDiff = daysDiff / 365
+ const hoursDiff = daysDiff * 24
+ const minutesDiff = hoursDiff * 60
+ const secondsDiff = minutesDiff * 60
+ switch (true) {
+ case yearsDiff > 5:
+ this.tickInterval = 'years'
+ break
+ case daysDiff > 800:
+ this.tickInterval = 'half_year'
+ break
+ case daysDiff > 180:
+ this.tickInterval = 'months'
+ break
+ case daysDiff > 90:
+ this.tickInterval = 'months_fortnight'
+ break
+ case daysDiff > 60:
+ this.tickInterval = 'months_days'
+ break
+ case daysDiff > 30:
+ this.tickInterval = 'week_days'
+ break
+ case daysDiff > 2:
+ this.tickInterval = 'days'
+ break
+ case hoursDiff > 2.4:
+ this.tickInterval = 'hours'
+ break
+ case minutesDiff > 15:
+ this.tickInterval = 'minutes_fives'
+ break
+ case minutesDiff > 5:
+ this.tickInterval = 'minutes'
+ break
+ case minutesDiff > 1:
+ this.tickInterval = 'seconds_tens'
+ break
+ case secondsDiff > 20:
+ this.tickInterval = 'seconds_fives'
+ break
+ default:
+ this.tickInterval = 'seconds'
+ break
+ }
+ }
+
+ generateYearScale({
+ firstVal,
+ currentMonth,
+ currentYear,
+ daysWidthOnXAxis,
+ numberOfYears
+ }) {
+ let firstTickValue = firstVal.minYear
+ let firstTickPosition = 0
+ const dt = new DateTime(this.ctx)
+
+ let unit = 'year'
+
+ if (firstVal.minDate > 1 || firstVal.minMonth > 0) {
+ let remainingDays = dt.determineRemainingDaysOfYear(
+ firstVal.minYear,
+ firstVal.minMonth,
+ firstVal.minDate
+ )
+
+ // remainingDaysofFirstMonth is used to reacht the 2nd tick position
+ let remainingDaysOfFirstYear =
+ dt.determineDaysOfYear(firstVal.minYear) - remainingDays + 1
+
+ // calculate the first tick position
+ firstTickPosition = remainingDaysOfFirstYear * daysWidthOnXAxis
+ firstTickValue = firstVal.minYear + 1
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value: firstTickValue,
+ unit,
+ year: firstTickValue,
+ month: Utils.monthMod(currentMonth + 1)
+ })
+ } else if (firstVal.minDate === 1 && firstVal.minMonth === 0) {
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value: firstTickValue,
+ unit,
+ year: currentYear,
+ month: Utils.monthMod(currentMonth + 1)
+ })
+ }
+
+ let year = firstTickValue
+ let pos = firstTickPosition
+
+ // keep drawing rest of the ticks
+ for (let i = 0; i < numberOfYears; i++) {
+ year++
+ pos = dt.determineDaysOfYear(year - 1) * daysWidthOnXAxis + pos
+ this.timeScaleArray.push({
+ position: pos,
+ value: year,
+ unit,
+ year,
+ month: 1
+ })
+ }
+ }
+
+ generateMonthScale({
+ firstVal,
+ currentMonthDate,
+ currentMonth,
+ currentYear,
+ daysWidthOnXAxis,
+ numberOfMonths
+ }) {
+ let firstTickValue = currentMonth
+ let firstTickPosition = 0
+ const dt = new DateTime(this.ctx)
+ let unit = 'month'
+ let yrCounter = 0
+
+ if (firstVal.minDate > 1) {
+ // remainingDaysofFirstMonth is used to reacht the 2nd tick position
+ let remainingDaysOfFirstMonth =
+ dt.determineDaysOfMonths(currentMonth + 1, firstVal.minYear) -
+ currentMonthDate +
+ 1
+
+ // calculate the first tick position
+ firstTickPosition = remainingDaysOfFirstMonth * daysWidthOnXAxis
+ firstTickValue = Utils.monthMod(currentMonth + 1)
+
+ let year = currentYear + yrCounter
+ let month = Utils.monthMod(firstTickValue)
+ let value = firstTickValue
+ // it's Jan, so update the year
+ if (firstTickValue === 0) {
+ unit = 'year'
+ value = year
+ month = 1
+ yrCounter += 1
+ year = year + yrCounter
+ }
+
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value,
+ unit,
+ year,
+ month
+ })
+ } else {
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value: firstTickValue,
+ unit,
+ year: currentYear,
+ month: Utils.monthMod(currentMonth)
+ })
+ }
+
+ let month = firstTickValue + 1
+ let pos = firstTickPosition
+
+ // keep drawing rest of the ticks
+ for (let i = 0, j = 1; i < numberOfMonths; i++, j++) {
+ month = Utils.monthMod(month)
+
+ if (month === 0) {
+ unit = 'year'
+ yrCounter += 1
+ } else {
+ unit = 'month'
+ }
+ let year = this._getYear(currentYear, month, yrCounter)
+
+ pos = dt.determineDaysOfMonths(month, year) * daysWidthOnXAxis + pos
+ let monthVal = month === 0 ? year : month
+ this.timeScaleArray.push({
+ position: pos,
+ value: monthVal,
+ unit,
+ year,
+ month: month === 0 ? 1 : month
+ })
+ month++
+ }
+ }
+
+ generateDayScale({
+ firstVal,
+ currentMonth,
+ currentYear,
+ hoursWidthOnXAxis,
+ numberOfDays
+ }) {
+ const dt = new DateTime(this.ctx)
+ let unit = 'day'
+ let firstTickValue = firstVal.minDate + 1
+ let date = firstTickValue
+
+ const changeMonth = (dateVal, month, year) => {
+ let monthdays = dt.determineDaysOfMonths(month + 1, year)
+
+ if (dateVal > monthdays) {
+ month = month + 1
+ date = 1
+ unit = 'month'
+ val = month
+ return month
+ }
+
+ return month
+ }
+
+ let remainingHours = 24 - firstVal.minHour
+ let yrCounter = 0
+
+ // calculate the first tick position
+ let firstTickPosition = remainingHours * hoursWidthOnXAxis
+
+ let val = firstTickValue
+ let month = changeMonth(date, currentMonth, currentYear)
+
+ if (firstVal.minHour === 0 && firstVal.minDate === 1) {
+ // the first value is the first day of month
+ firstTickPosition = 0
+ val = Utils.monthMod(firstVal.minMonth)
+ unit = 'month'
+ date = firstVal.minDate
+ numberOfDays++
+ } else if (
+ firstVal.minDate !== 1 &&
+ firstVal.minHour === 0 &&
+ firstVal.minMinute === 0
+ ) {
+ // fixes apexcharts/apexcharts.js/issues/1730
+ firstTickPosition = 0
+ firstTickValue = firstVal.minDate
+ date = firstTickValue
+ val = firstTickValue
+ // in case it's the last date of month, we need to check it
+ month = changeMonth(date, currentMonth, currentYear)
+ }
+
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value: val,
+ unit,
+ year: this._getYear(currentYear, month, yrCounter),
+ month: Utils.monthMod(month),
+ day: date
+ })
+
+ let pos = firstTickPosition
+ // keep drawing rest of the ticks
+ for (let i = 0; i < numberOfDays; i++) {
+ date += 1
+ unit = 'day'
+ month = changeMonth(
+ date,
+ month,
+ this._getYear(currentYear, month, yrCounter)
+ )
+
+ let year = this._getYear(currentYear, month, yrCounter)
+
+ pos = 24 * hoursWidthOnXAxis + pos
+ let value = date === 1 ? Utils.monthMod(month) : date
+ this.timeScaleArray.push({
+ position: pos,
+ value,
+ unit,
+ year,
+ month: Utils.monthMod(month),
+ day: value
+ })
+ }
+ }
+
+ generateHourScale({
+ firstVal,
+ currentDate,
+ currentMonth,
+ currentYear,
+ minutesWidthOnXAxis,
+ numberOfHours
+ }) {
+ const dt = new DateTime(this.ctx)
+
+ let yrCounter = 0
+ let unit = 'hour'
+
+ const changeDate = (dateVal, month) => {
+ let monthdays = dt.determineDaysOfMonths(month + 1, currentYear)
+ if (dateVal > monthdays) {
+ date = 1
+ month = month + 1
+ }
+ return { month, date }
+ }
+
+ const changeMonth = (dateVal, month) => {
+ let monthdays = dt.determineDaysOfMonths(month + 1, currentYear)
+ if (dateVal > monthdays) {
+ month = month + 1
+ return month
+ }
+
+ return month
+ }
+
+ // factor in minSeconds as well
+ let remainingMins = 60 - (firstVal.minMinute + firstVal.minSecond / 60.0)
+
+ let firstTickPosition = remainingMins * minutesWidthOnXAxis
+ let firstTickValue = firstVal.minHour + 1
+ let hour = firstTickValue + 1
+
+ if (remainingMins === 60) {
+ firstTickPosition = 0
+ firstTickValue = firstVal.minHour
+ hour = firstTickValue + 1
+ }
+
+ let date = currentDate
+
+ let month = changeMonth(date, currentMonth)
+
+ // push the first tick in the array
+ this.timeScaleArray.push({
+ position: firstTickPosition,
+ value: firstTickValue,
+ unit,
+ day: date,
+ hour,
+ year: currentYear,
+ month: Utils.monthMod(month)
+ })
+
+ let pos = firstTickPosition
+ // keep drawing rest of the ticks
+ for (let i = 0; i < numberOfHours; i++) {
+ unit = 'hour'
+
+ if (hour >= 24) {
+ hour = 0
+ date += 1
+ unit = 'day'
+
+ const checkNextMonth = changeDate(date, month)
+
+ month = checkNextMonth.month
+ month = changeMonth(date, month)
+ }
+
+ let year = this._getYear(currentYear, month, yrCounter)
+ pos =
+ hour === 0 && i === 0
+ ? remainingMins * minutesWidthOnXAxis
+ : 60 * minutesWidthOnXAxis + pos
+ let val = hour === 0 ? date : hour
+ this.timeScaleArray.push({
+ position: pos,
+ value: val,
+ unit,
+ hour,
+ day: date,
+ year,
+ month: Utils.monthMod(month)
+ })
+
+ hour++
+ }
+ }
+
+ generateMinuteScale({
+ currentMillisecond,
+ currentSecond,
+ currentMinute,
+ currentHour,
+ currentDate,
+ currentMonth,
+ currentYear,
+ minutesWidthOnXAxis,
+ secondsWidthOnXAxis,
+ numberOfMinutes
+ }) {
+ let yrCounter = 0
+ let unit = 'minute'
+
+ let remainingSecs = 60 - currentSecond
+ let firstTickPosition =
+ (remainingSecs - currentMillisecond / 1000) * secondsWidthOnXAxis
+ let minute = currentMinute + 1
+
+ let date = currentDate
+ let month = currentMonth
+ let year = currentYear
+ let hour = currentHour
+
+ let pos = firstTickPosition
+ for (let i = 0; i < numberOfMinutes; i++) {
+ if (minute >= 60) {
+ minute = 0
+ hour += 1
+ if (hour === 24) {
+ hour = 0
+ }
+ }
+
+ this.timeScaleArray.push({
+ position: pos,
+ value: minute,
+ unit,
+ hour,
+ minute,
+ day: date,
+ year: this._getYear(year, month, yrCounter),
+ month: Utils.monthMod(month)
+ })
+
+ pos += minutesWidthOnXAxis
+ minute++
+ }
+ }
+
+ generateSecondScale({
+ currentMillisecond,
+ currentSecond,
+ currentMinute,
+ currentHour,
+ currentDate,
+ currentMonth,
+ currentYear,
+ secondsWidthOnXAxis,
+ numberOfSeconds
+ }) {
+ let yrCounter = 0
+ let unit = 'second'
+
+ const remainingMillisecs = 1000 - currentMillisecond
+ let firstTickPosition = (remainingMillisecs / 1000) * secondsWidthOnXAxis
+
+ let second = currentSecond + 1
+ let minute = currentMinute
+ let date = currentDate
+ let month = currentMonth
+ let year = currentYear
+ let hour = currentHour
+
+ let pos = firstTickPosition
+ for (let i = 0; i < numberOfSeconds; i++) {
+ if (second >= 60) {
+ minute++
+ second = 0
+ if (minute >= 60) {
+ hour++
+ minute = 0
+ if (hour === 24) {
+ hour = 0
+ }
+ }
+ }
+
+ this.timeScaleArray.push({
+ position: pos,
+ value: second,
+ unit,
+ hour,
+ minute,
+ second,
+ day: date,
+ year: this._getYear(year, month, yrCounter),
+ month: Utils.monthMod(month)
+ })
+
+ pos += secondsWidthOnXAxis
+ second++
+ }
+ }
+
+ createRawDateString(ts, value) {
+ let raw = ts.year
+
+ if (ts.month === 0) {
+ // invalid month, correct it
+ ts.month = 1
+ }
+ raw += '-' + ('0' + ts.month.toString()).slice(-2)
+
+ // unit is day
+ if (ts.unit === 'day') {
+ raw += ts.unit === 'day' ? '-' + ('0' + value).slice(-2) : '-01'
+ } else {
+ raw += '-' + ('0' + (ts.day ? ts.day : '1')).slice(-2)
+ }
+
+ // unit is hour
+ if (ts.unit === 'hour') {
+ raw += ts.unit === 'hour' ? 'T' + ('0' + value).slice(-2) : 'T00'
+ } else {
+ raw += 'T' + ('0' + (ts.hour ? ts.hour : '0')).slice(-2)
+ }
+
+ if (ts.unit === 'minute') {
+ raw += ':' + ('0' + value).slice(-2)
+ } else {
+ raw += ':' + (ts.minute ? ('0' + ts.minute).slice(-2) : '00')
+ }
+
+ if (ts.unit === 'second') {
+ raw += ':' + ('0' + value).slice(-2)
+ } else {
+ raw += ':00'
+ }
+
+ if (this.utc) {
+ raw += '.000Z'
+ }
+ return raw
+ }
+
+ formatDates(filteredTimeScale) {
+ const w = this.w
+
+ const reformattedTimescaleArray = filteredTimeScale.map((ts) => {
+ let value = ts.value.toString()
+
+ let dt = new DateTime(this.ctx)
+
+ const raw = this.createRawDateString(ts, value)
+
+ let dateToFormat = dt.getDate(dt.parseDate(raw))
+ if (!this.utc) {
+ // Fixes #1726, #1544, #1485, #1255
+ dateToFormat = dt.getDate(dt.parseDateWithTimezone(raw))
+ }
+
+ if (w.config.xaxis.labels.format === undefined) {
+ let customFormat = 'dd MMM'
+ const dtFormatter = w.config.xaxis.labels.datetimeFormatter
+ if (ts.unit === 'year') customFormat = dtFormatter.year
+ if (ts.unit === 'month') customFormat = dtFormatter.month
+ if (ts.unit === 'day') customFormat = dtFormatter.day
+ if (ts.unit === 'hour') customFormat = dtFormatter.hour
+ if (ts.unit === 'minute') customFormat = dtFormatter.minute
+ if (ts.unit === 'second') customFormat = dtFormatter.second
+
+ value = dt.formatDate(dateToFormat, customFormat)
+ } else {
+ value = dt.formatDate(dateToFormat, w.config.xaxis.labels.format)
+ }
+
+ return {
+ dateString: raw,
+ position: ts.position,
+ value,
+ unit: ts.unit,
+ year: ts.year,
+ month: ts.month
+ }
+ })
+
+ return reformattedTimescaleArray
+ }
+
+ removeOverlappingTS(arr) {
+ const graphics = new Graphics(this.ctx)
+
+ let equalLabelLengthFlag = false // These labels got same length?
+ let constantLabelWidth // If true, what is the constant length to use
+ if (
+ arr.length > 0 && // check arr length
+ arr[0].value && // check arr[0] contains value
+ arr.every((lb) => lb.value.length === arr[0].value.length) // check every arr label value is the same as the first one
+ ) {
+ equalLabelLengthFlag = true // These labels got same length
+ constantLabelWidth = graphics.getTextRects(arr[0].value).width // The constant label width to use
+ }
+
+ let lastDrawnIndex = 0
+
+ let filteredArray = arr.map((item, index) => {
+ if (index > 0 && this.w.config.xaxis.labels.hideOverlappingLabels) {
+ const prevLabelWidth = !equalLabelLengthFlag // if vary in label length
+ ? graphics.getTextRects(arr[lastDrawnIndex].value).width // get individual length
+ : constantLabelWidth // else: use constant length
+ const prevPos = arr[lastDrawnIndex].position
+ const pos = item.position
+
+ if (pos > prevPos + prevLabelWidth + 10) {
+ lastDrawnIndex = index
+ return item
+ } else {
+ return null
+ }
+ } else {
+ return item
+ }
+ })
+
+ filteredArray = filteredArray.filter((f) => f !== null)
+
+ return filteredArray
+ }
+
+ _getYear(currentYear, month, yrCounter) {
+ return currentYear + Math.floor(month / 12) + yrCounter
+ }
+}
+
+export default TimeScale
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/TitleSubtitle.js b/cao_sunyata/static/libs/apexcharts/src/modules/TitleSubtitle.js
new file mode 100644
index 0000000..2b3f88e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/TitleSubtitle.js
@@ -0,0 +1,52 @@
+import Graphics from './Graphics'
+
+export default class TitleSubtitle {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ draw() {
+ this.drawTitleSubtitle('title')
+ this.drawTitleSubtitle('subtitle')
+ }
+
+ drawTitleSubtitle(type) {
+ let w = this.w
+ const tsConfig = type === 'title' ? w.config.title : w.config.subtitle
+
+ let x = w.globals.svgWidth / 2
+ let y = tsConfig.offsetY
+ let textAnchor = 'middle'
+
+ if (tsConfig.align === 'left') {
+ x = 10
+ textAnchor = 'start'
+ } else if (tsConfig.align === 'right') {
+ x = w.globals.svgWidth - 10
+ textAnchor = 'end'
+ }
+
+ x = x + tsConfig.offsetX
+ y = y + parseInt(tsConfig.style.fontSize, 10) + tsConfig.margin / 2
+
+ if (tsConfig.text !== undefined) {
+ let graphics = new Graphics(this.ctx)
+ let titleText = graphics.drawText({
+ x,
+ y,
+ text: tsConfig.text,
+ textAnchor,
+ fontSize: tsConfig.style.fontSize,
+ fontFamily: tsConfig.style.fontFamily,
+ fontWeight: tsConfig.style.fontWeight,
+ foreColor: tsConfig.style.color,
+ opacity: 1
+ })
+
+ titleText.node.setAttribute('class', `apexcharts-${type}-text`)
+
+ w.globals.dom.Paper.add(titleText)
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/Toolbar.js b/cao_sunyata/static/libs/apexcharts/src/modules/Toolbar.js
new file mode 100644
index 0000000..edfef1b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/Toolbar.js
@@ -0,0 +1,532 @@
+import Graphics from './Graphics'
+import Exports from './Exports'
+import Scales from './Scales'
+import Utils from './../utils/Utils'
+import icoPan from './../assets/ico-pan-hand.svg'
+import icoZoom from './../assets/ico-zoom-in.svg'
+import icoReset from './../assets/ico-home.svg'
+import icoZoomIn from './../assets/ico-plus.svg'
+import icoZoomOut from './../assets/ico-minus.svg'
+import icoSelect from './../assets/ico-select.svg'
+import icoMenu from './../assets/ico-menu.svg'
+
+/**
+ * ApexCharts Toolbar Class for creating toolbar in axis based charts.
+ *
+ * @module Toolbar
+ **/
+
+export default class Toolbar {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ const w = this.w
+
+ this.ev = this.w.config.chart.events
+ this.selectedClass = 'apexcharts-selected'
+
+ this.localeValues = this.w.globals.locale.toolbar
+
+ this.minX = w.globals.minX
+ this.maxX = w.globals.maxX
+ }
+
+ createToolbar() {
+ let w = this.w
+
+ const createDiv = () => {
+ return document.createElement('div')
+ }
+ const elToolbarWrap = createDiv()
+ elToolbarWrap.setAttribute('class', 'apexcharts-toolbar')
+ elToolbarWrap.style.top = w.config.chart.toolbar.offsetY + 'px'
+ elToolbarWrap.style.right = -w.config.chart.toolbar.offsetX + 3 + 'px'
+ w.globals.dom.elWrap.appendChild(elToolbarWrap)
+
+ this.elZoom = createDiv()
+ this.elZoomIn = createDiv()
+ this.elZoomOut = createDiv()
+ this.elPan = createDiv()
+ this.elSelection = createDiv()
+ this.elZoomReset = createDiv()
+ this.elMenuIcon = createDiv()
+ this.elMenu = createDiv()
+ this.elCustomIcons = []
+
+ this.t = w.config.chart.toolbar.tools
+
+ if (Array.isArray(this.t.customIcons)) {
+ for (let i = 0; i < this.t.customIcons.length; i++) {
+ this.elCustomIcons.push(createDiv())
+ }
+ }
+
+ let toolbarControls = []
+
+ const appendZoomControl = (type, el, ico) => {
+ const tool = type.toLowerCase()
+ if (this.t[tool] && w.config.chart.zoom.enabled) {
+ toolbarControls.push({
+ el,
+ icon: typeof this.t[tool] === 'string' ? this.t[tool] : ico,
+ title: this.localeValues[type],
+ class: `apexcharts-${tool}-icon`
+ })
+ }
+ }
+
+ appendZoomControl('zoomIn', this.elZoomIn, icoZoomIn)
+ appendZoomControl('zoomOut', this.elZoomOut, icoZoomOut)
+
+ const zoomSelectionCtrls = (z) => {
+ if (this.t[z] && w.config.chart[z].enabled) {
+ toolbarControls.push({
+ el: z === 'zoom' ? this.elZoom : this.elSelection,
+ icon:
+ typeof this.t[z] === 'string'
+ ? this.t[z]
+ : z === 'zoom'
+ ? icoZoom
+ : icoSelect,
+ title: this.localeValues[
+ z === 'zoom' ? 'selectionZoom' : 'selection'
+ ],
+ class: w.globals.isTouchDevice
+ ? 'apexcharts-element-hidden'
+ : `apexcharts-${z}-icon`
+ })
+ }
+ }
+ zoomSelectionCtrls('zoom')
+ zoomSelectionCtrls('selection')
+
+ if (this.t.pan && w.config.chart.zoom.enabled) {
+ toolbarControls.push({
+ el: this.elPan,
+ icon: typeof this.t.pan === 'string' ? this.t.pan : icoPan,
+ title: this.localeValues.pan,
+ class: w.globals.isTouchDevice
+ ? 'apexcharts-element-hidden'
+ : 'apexcharts-pan-icon'
+ })
+ }
+
+ appendZoomControl('reset', this.elZoomReset, icoReset)
+
+ if (this.t.download) {
+ toolbarControls.push({
+ el: this.elMenuIcon,
+ icon: typeof this.t.download === 'string' ? this.t.download : icoMenu,
+ title: this.localeValues.menu,
+ class: 'apexcharts-menu-icon'
+ })
+ }
+
+ for (let i = 0; i < this.elCustomIcons.length; i++) {
+ toolbarControls.push({
+ el: this.elCustomIcons[i],
+ icon: this.t.customIcons[i].icon,
+ title: this.t.customIcons[i].title,
+ index: this.t.customIcons[i].index,
+ class: 'apexcharts-toolbar-custom-icon ' + this.t.customIcons[i].class
+ })
+ }
+
+ toolbarControls.forEach((t, index) => {
+ if (t.index) {
+ Utils.moveIndexInArray(toolbarControls, index, t.index)
+ }
+ })
+
+ for (let i = 0; i < toolbarControls.length; i++) {
+ Graphics.setAttrs(toolbarControls[i].el, {
+ class: toolbarControls[i].class,
+ title: toolbarControls[i].title
+ })
+
+ toolbarControls[i].el.innerHTML = toolbarControls[i].icon
+ elToolbarWrap.appendChild(toolbarControls[i].el)
+ }
+
+ this._createHamburgerMenu(elToolbarWrap)
+
+ if (w.globals.zoomEnabled) {
+ this.elZoom.classList.add(this.selectedClass)
+ } else if (w.globals.panEnabled) {
+ this.elPan.classList.add(this.selectedClass)
+ } else if (w.globals.selectionEnabled) {
+ this.elSelection.classList.add(this.selectedClass)
+ }
+
+ this.addToolbarEventListeners()
+ }
+
+ _createHamburgerMenu(parent) {
+ this.elMenuItems = []
+ parent.appendChild(this.elMenu)
+
+ Graphics.setAttrs(this.elMenu, {
+ class: 'apexcharts-menu'
+ })
+
+ const menuItems = [
+ {
+ name: 'exportSVG',
+ title: this.localeValues.exportToSVG
+ },
+ {
+ name: 'exportPNG',
+ title: this.localeValues.exportToPNG
+ },
+ {
+ name: 'exportCSV',
+ title: this.localeValues.exportToCSV
+ }
+ ]
+
+ if (!this.w.globals.allSeriesHasEqualX) {
+ // if it is a multi series, and all series have variable x values, export CSV won't work
+ menuItems.splice(2, 1)
+ }
+ for (let i = 0; i < menuItems.length; i++) {
+ this.elMenuItems.push(document.createElement('div'))
+ this.elMenuItems[i].innerHTML = menuItems[i].title
+ Graphics.setAttrs(this.elMenuItems[i], {
+ class: `apexcharts-menu-item ${menuItems[i].name}`,
+ title: menuItems[i].title
+ })
+ this.elMenu.appendChild(this.elMenuItems[i])
+ }
+ }
+
+ addToolbarEventListeners() {
+ this.elZoomReset.addEventListener('click', this.handleZoomReset.bind(this))
+ this.elSelection.addEventListener(
+ 'click',
+ this.toggleZoomSelection.bind(this, 'selection')
+ )
+ this.elZoom.addEventListener(
+ 'click',
+ this.toggleZoomSelection.bind(this, 'zoom')
+ )
+ this.elZoomIn.addEventListener('click', this.handleZoomIn.bind(this))
+ this.elZoomOut.addEventListener('click', this.handleZoomOut.bind(this))
+ this.elPan.addEventListener('click', this.togglePanning.bind(this))
+ this.elMenuIcon.addEventListener('click', this.toggleMenu.bind(this))
+ this.elMenuItems.forEach((m) => {
+ if (m.classList.contains('exportSVG')) {
+ m.addEventListener('click', this.handleDownload.bind(this, 'svg'))
+ } else if (m.classList.contains('exportPNG')) {
+ m.addEventListener('click', this.handleDownload.bind(this, 'png'))
+ } else if (m.classList.contains('exportCSV')) {
+ m.addEventListener('click', this.handleDownload.bind(this, 'csv'))
+ }
+ })
+ for (let i = 0; i < this.t.customIcons.length; i++) {
+ this.elCustomIcons[i].addEventListener(
+ 'click',
+ this.t.customIcons[i].click.bind(this, this.ctx, this.ctx.w)
+ )
+ }
+ }
+
+ toggleZoomSelection(type) {
+ const charts = this.ctx.getSyncedCharts()
+
+ charts.forEach((ch) => {
+ ch.ctx.toolbar.toggleOtherControls()
+
+ let el =
+ type === 'selection'
+ ? ch.ctx.toolbar.elSelection
+ : ch.ctx.toolbar.elZoom
+ let enabledType =
+ type === 'selection' ? 'selectionEnabled' : 'zoomEnabled'
+
+ ch.w.globals[enabledType] = !ch.w.globals[enabledType]
+
+ if (!el.classList.contains(ch.ctx.toolbar.selectedClass)) {
+ el.classList.add(ch.ctx.toolbar.selectedClass)
+ } else {
+ el.classList.remove(ch.ctx.toolbar.selectedClass)
+ }
+ })
+ }
+
+ getToolbarIconsReference() {
+ const w = this.w
+ if (!this.elZoom) {
+ this.elZoom = w.globals.dom.baseEl.querySelector('.apexcharts-zoom-icon')
+ }
+ if (!this.elPan) {
+ this.elPan = w.globals.dom.baseEl.querySelector('.apexcharts-pan-icon')
+ }
+ if (!this.elSelection) {
+ this.elSelection = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-selection-icon'
+ )
+ }
+ }
+
+ enableZoomPanFromToolbar(type) {
+ this.toggleOtherControls()
+
+ type === 'pan'
+ ? (this.w.globals.panEnabled = true)
+ : (this.w.globals.zoomEnabled = true)
+
+ const el = type === 'pan' ? this.elPan : this.elZoom
+ const el2 = type === 'pan' ? this.elZoom : this.elPan
+ if (el) {
+ el.classList.add(this.selectedClass)
+ }
+ if (el2) {
+ el2.classList.remove(this.selectedClass)
+ }
+ }
+
+ togglePanning() {
+ const charts = this.ctx.getSyncedCharts()
+
+ charts.forEach((ch) => {
+ ch.ctx.toolbar.toggleOtherControls()
+ ch.w.globals.panEnabled = !ch.w.globals.panEnabled
+
+ if (
+ !ch.ctx.toolbar.elPan.classList.contains(ch.ctx.toolbar.selectedClass)
+ ) {
+ ch.ctx.toolbar.elPan.classList.add(ch.ctx.toolbar.selectedClass)
+ } else {
+ ch.ctx.toolbar.elPan.classList.remove(ch.ctx.toolbar.selectedClass)
+ }
+ })
+ }
+
+ toggleOtherControls() {
+ const w = this.w
+ w.globals.panEnabled = false
+ w.globals.zoomEnabled = false
+ w.globals.selectionEnabled = false
+
+ this.getToolbarIconsReference()
+
+ const toggleEls = [this.elPan, this.elSelection, this.elZoom]
+ toggleEls.forEach((el) => {
+ if (el) {
+ el.classList.remove(this.selectedClass)
+ }
+ })
+ }
+
+ handleZoomIn() {
+ const w = this.w
+
+ if (w.globals.isRangeBar) {
+ this.minX = w.globals.minY
+ this.maxX = w.globals.maxY
+ }
+
+ const centerX = (this.minX + this.maxX) / 2
+ let newMinX = (this.minX + centerX) / 2
+ let newMaxX = (this.maxX + centerX) / 2
+
+ const newMinXMaxX = this._getNewMinXMaxX(newMinX, newMaxX)
+
+ if (!w.globals.disableZoomIn) {
+ this.zoomUpdateOptions(newMinXMaxX.minX, newMinXMaxX.maxX)
+ }
+ }
+
+ handleZoomOut() {
+ const w = this.w
+
+ if (w.globals.isRangeBar) {
+ this.minX = w.globals.minY
+ this.maxX = w.globals.maxY
+ }
+
+ // avoid zooming out beyond 1000 which may result in NaN values being printed on x-axis
+ if (
+ w.config.xaxis.type === 'datetime' &&
+ new Date(this.minX).getUTCFullYear() < 1000
+ ) {
+ return
+ }
+
+ const centerX = (this.minX + this.maxX) / 2
+ let newMinX = this.minX - (centerX - this.minX)
+ let newMaxX = this.maxX - (centerX - this.maxX)
+
+ const newMinXMaxX = this._getNewMinXMaxX(newMinX, newMaxX)
+
+ if (!w.globals.disableZoomOut) {
+ this.zoomUpdateOptions(newMinXMaxX.minX, newMinXMaxX.maxX)
+ }
+ }
+
+ _getNewMinXMaxX(newMinX, newMaxX) {
+ const shouldFloor = this.w.config.xaxis.convertedCatToNumeric
+ return {
+ minX: shouldFloor ? Math.floor(newMinX) : newMinX,
+ maxX: shouldFloor ? Math.floor(newMaxX) : newMaxX
+ }
+ }
+
+ zoomUpdateOptions(newMinX, newMaxX) {
+ const w = this.w
+
+ if (newMinX === undefined && newMaxX === undefined) {
+ this.handleZoomReset()
+ return
+ }
+
+ if (w.config.xaxis.convertedCatToNumeric) {
+ // in category charts, avoid zooming out beyond min and max
+ if (newMinX < 1) {
+ newMinX = 1
+ newMaxX = w.globals.dataPoints
+ }
+
+ if (newMaxX - newMinX < 2) {
+ return
+ }
+ }
+
+ let xaxis = {
+ min: newMinX,
+ max: newMaxX
+ }
+
+ const beforeZoomRange = this.getBeforeZoomRange(xaxis)
+ if (beforeZoomRange) {
+ xaxis = beforeZoomRange.xaxis
+ }
+
+ let options = {
+ xaxis
+ }
+
+ let yaxis = Utils.clone(w.globals.initialConfig.yaxis)
+ if (w.config.chart.zoom.autoScaleYaxis) {
+ const scale = new Scales(this.ctx)
+ yaxis = scale.autoScaleY(this.ctx, yaxis, {
+ xaxis
+ })
+ }
+
+ if (!w.config.chart.group) {
+ // if chart in a group, prevent yaxis update here
+ // fix issue #650
+ options.yaxis = yaxis
+ }
+
+ this.w.globals.zoomed = true
+
+ this.ctx.updateHelpers._updateOptions(
+ options,
+ false,
+ this.w.config.chart.animations.dynamicAnimation.enabled
+ )
+
+ this.zoomCallback(xaxis, yaxis)
+ }
+
+ zoomCallback(xaxis, yaxis) {
+ if (typeof this.ev.zoomed === 'function') {
+ this.ev.zoomed(this.ctx, { xaxis, yaxis })
+ }
+ }
+
+ getBeforeZoomRange(xaxis, yaxis) {
+ let newRange = null
+ if (typeof this.ev.beforeZoom === 'function') {
+ newRange = this.ev.beforeZoom(this, { xaxis, yaxis })
+ }
+
+ return newRange
+ }
+
+ toggleMenu() {
+ window.setTimeout(() => {
+ if (this.elMenu.classList.contains('apexcharts-menu-open')) {
+ this.elMenu.classList.remove('apexcharts-menu-open')
+ } else {
+ this.elMenu.classList.add('apexcharts-menu-open')
+ }
+ }, 0)
+ }
+
+ handleDownload(type) {
+ const w = this.w
+ const exprt = new Exports(this.ctx)
+ switch (type) {
+ case 'svg':
+ exprt.exportToSVG(this.ctx)
+ break
+ case 'png':
+ exprt.exportToPng(this.ctx)
+ break
+ case 'csv':
+ exprt.exportToCSV({
+ series: w.config.series,
+ columnDelimiter: w.config.chart.toolbar.export.csv.columnDelimiter
+ })
+ break
+ }
+ }
+
+ handleZoomReset(e) {
+ const charts = this.ctx.getSyncedCharts()
+
+ charts.forEach((ch) => {
+ let w = ch.w
+
+ // forget lastXAxis min/max as reset button isn't resetting the x-axis completely if zoomX is called before
+ w.globals.lastXAxis.min = undefined
+ w.globals.lastXAxis.max = undefined
+
+ ch.updateHelpers.revertDefaultAxisMinMax()
+
+ if (typeof w.config.chart.events.beforeResetZoom === 'function') {
+ // here, user get an option to control xaxis and yaxis when resetZoom is called
+ // at this point, whatever is returned from w.config.chart.events.beforeResetZoom
+ // is set as the new xaxis/yaxis min/max
+ const resetZoomRange = w.config.chart.events.beforeResetZoom(ch, w)
+
+ if (resetZoomRange) {
+ ch.updateHelpers.revertDefaultAxisMinMax(resetZoomRange)
+ }
+ }
+
+ if (typeof w.config.chart.events.zoomed === 'function') {
+ ch.ctx.toolbar.zoomCallback({
+ min: w.config.xaxis.min,
+ max: w.config.xaxis.max
+ })
+ }
+
+ w.globals.zoomed = false
+
+ // if user has some series collapsed before hitting zoom reset button,
+ // those series should stay collapsed
+ let series = ch.ctx.series.emptyCollapsedSeries(
+ Utils.clone(w.globals.initialSeries)
+ )
+
+ ch.updateHelpers._updateSeries(
+ series,
+ w.config.chart.animations.dynamicAnimation.enabled
+ )
+ })
+ }
+
+ destroy() {
+ this.elZoom = null
+ this.elZoomIn = null
+ this.elZoomOut = null
+ this.elPan = null
+ this.elSelection = null
+ this.elZoomReset = null
+ this.elMenuIcon = null
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/ZoomPanSelection.js b/cao_sunyata/static/libs/apexcharts/src/modules/ZoomPanSelection.js
new file mode 100644
index 0000000..5a280b4
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/ZoomPanSelection.js
@@ -0,0 +1,777 @@
+import Graphics from './Graphics'
+import Utils from './../utils/Utils'
+import Toolbar from './Toolbar'
+import Scales from './Scales'
+
+/**
+ * ApexCharts Zoom Class for handling zooming and panning on axes based charts.
+ *
+ * @module ZoomPanSelection
+ **/
+
+export default class ZoomPanSelection extends Toolbar {
+ constructor(ctx) {
+ super(ctx)
+
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.dragged = false
+ this.graphics = new Graphics(this.ctx)
+
+ this.eventList = [
+ 'mousedown',
+ 'mouseleave',
+ 'mousemove',
+ 'touchstart',
+ 'touchmove',
+ 'mouseup',
+ 'touchend'
+ ]
+
+ this.clientX = 0
+ this.clientY = 0
+ this.startX = 0
+ this.endX = 0
+ this.dragX = 0
+ this.startY = 0
+ this.endY = 0
+ this.dragY = 0
+ this.moveDirection = 'none'
+ }
+
+ init({ xyRatios }) {
+ let w = this.w
+ let me = this
+
+ this.xyRatios = xyRatios
+
+ this.zoomRect = this.graphics.drawRect(0, 0, 0, 0)
+ this.selectionRect = this.graphics.drawRect(0, 0, 0, 0)
+ this.gridRect = w.globals.dom.baseEl.querySelector('.apexcharts-grid')
+
+ this.zoomRect.node.classList.add('apexcharts-zoom-rect')
+ this.selectionRect.node.classList.add('apexcharts-selection-rect')
+ w.globals.dom.elGraphical.add(this.zoomRect)
+ w.globals.dom.elGraphical.add(this.selectionRect)
+
+ if (w.config.chart.selection.type === 'x') {
+ this.slDraggableRect = this.selectionRect
+ .draggable({
+ minX: 0,
+ minY: 0,
+ maxX: w.globals.gridWidth,
+ maxY: w.globals.gridHeight
+ })
+ .on('dragmove', this.selectionDragging.bind(this, 'dragging'))
+ } else if (w.config.chart.selection.type === 'y') {
+ this.slDraggableRect = this.selectionRect
+ .draggable({
+ minX: 0,
+ maxX: w.globals.gridWidth
+ })
+ .on('dragmove', this.selectionDragging.bind(this, 'dragging'))
+ } else {
+ this.slDraggableRect = this.selectionRect
+ .draggable()
+ .on('dragmove', this.selectionDragging.bind(this, 'dragging'))
+ }
+ this.preselectedSelection()
+
+ this.hoverArea = w.globals.dom.baseEl.querySelector(
+ `${w.globals.chartClass} .apexcharts-svg`
+ )
+ this.hoverArea.classList.add('apexcharts-zoomable')
+
+ this.eventList.forEach((event) => {
+ this.hoverArea.addEventListener(
+ event,
+ me.svgMouseEvents.bind(me, xyRatios),
+ {
+ capture: false,
+ passive: true
+ }
+ )
+ })
+ }
+
+ // remove the event listeners which were previously added on hover area
+ destroy() {
+ if (this.slDraggableRect) {
+ this.slDraggableRect.draggable(false)
+ this.slDraggableRect.off()
+ this.selectionRect.off()
+ }
+
+ this.selectionRect = null
+ this.zoomRect = null
+ this.gridRect = null
+ }
+
+ svgMouseEvents(xyRatios, e) {
+ let w = this.w
+ let me = this
+ const toolbar = this.ctx.toolbar
+
+ let zoomtype = w.globals.zoomEnabled
+ ? w.config.chart.zoom.type
+ : w.config.chart.selection.type
+
+ const autoSelected = w.config.chart.toolbar.autoSelected
+
+ if (e.shiftKey) {
+ this.shiftWasPressed = true
+ toolbar.enableZoomPanFromToolbar(autoSelected === 'pan' ? 'zoom' : 'pan')
+ } else {
+ if (this.shiftWasPressed) {
+ toolbar.enableZoomPanFromToolbar(autoSelected)
+ this.shiftWasPressed = false
+ }
+ }
+
+ if (!e.target) return
+
+ const tc = e.target.classList
+ let pc
+ if (e.target.parentNode && e.target.parentNode !== null) {
+ pc = e.target.parentNode.classList
+ }
+ const falsePositives =
+ tc.contains('apexcharts-selection-rect') ||
+ tc.contains('apexcharts-legend-marker') ||
+ tc.contains('apexcharts-legend-text') ||
+ (pc && pc.contains('apexcharts-toolbar'))
+
+ if (falsePositives) return
+
+ me.clientX =
+ e.type === 'touchmove' || e.type === 'touchstart'
+ ? e.touches[0].clientX
+ : e.type === 'touchend'
+ ? e.changedTouches[0].clientX
+ : e.clientX
+ me.clientY =
+ e.type === 'touchmove' || e.type === 'touchstart'
+ ? e.touches[0].clientY
+ : e.type === 'touchend'
+ ? e.changedTouches[0].clientY
+ : e.clientY
+
+ if (e.type === 'mousedown' && e.which === 1) {
+ let gridRectDim = me.gridRect.getBoundingClientRect()
+
+ me.startX = me.clientX - gridRectDim.left
+ me.startY = me.clientY - gridRectDim.top
+
+ me.dragged = false
+ me.w.globals.mousedown = true
+ }
+
+ if ((e.type === 'mousemove' && e.which === 1) || e.type === 'touchmove') {
+ me.dragged = true
+
+ if (w.globals.panEnabled) {
+ w.globals.selection = null
+ if (me.w.globals.mousedown) {
+ me.panDragging({
+ context: me,
+ zoomtype,
+ xyRatios
+ })
+ }
+ } else {
+ if (
+ (me.w.globals.mousedown && w.globals.zoomEnabled) ||
+ (me.w.globals.mousedown && w.globals.selectionEnabled)
+ ) {
+ me.selection = me.selectionDrawing({
+ context: me,
+ zoomtype
+ })
+ }
+ }
+ }
+
+ if (
+ e.type === 'mouseup' ||
+ e.type === 'touchend' ||
+ e.type === 'mouseleave'
+ ) {
+ // we will be calling getBoundingClientRect on each mousedown/mousemove/mouseup
+ let gridRectDim = me.gridRect.getBoundingClientRect()
+
+ if (me.w.globals.mousedown) {
+ // user released the drag, now do all the calculations
+ me.endX = me.clientX - gridRectDim.left
+ me.endY = me.clientY - gridRectDim.top
+ me.dragX = Math.abs(me.endX - me.startX)
+ me.dragY = Math.abs(me.endY - me.startY)
+
+ if (w.globals.zoomEnabled || w.globals.selectionEnabled) {
+ me.selectionDrawn({
+ context: me,
+ zoomtype
+ })
+ }
+
+ if (w.globals.panEnabled && w.config.xaxis.convertedCatToNumeric) {
+ me.delayedPanScrolled()
+ }
+ }
+
+ if (w.globals.zoomEnabled) {
+ me.hideSelectionRect(this.selectionRect)
+ }
+
+ me.dragged = false
+ me.w.globals.mousedown = false
+ }
+
+ this.makeSelectionRectDraggable()
+ }
+
+ makeSelectionRectDraggable() {
+ const w = this.w
+
+ if (!this.selectionRect) return
+
+ const rectDim = this.selectionRect.node.getBoundingClientRect()
+ if (rectDim.width > 0 && rectDim.height > 0) {
+ this.slDraggableRect
+ .selectize({
+ points: 'l, r',
+ pointSize: 8,
+ pointType: 'rect'
+ })
+ .resize({
+ constraint: {
+ minX: 0,
+ minY: 0,
+ maxX: w.globals.gridWidth,
+ maxY: w.globals.gridHeight
+ }
+ })
+ .on('resizing', this.selectionDragging.bind(this, 'resizing'))
+ }
+ }
+
+ preselectedSelection() {
+ const w = this.w
+ const xyRatios = this.xyRatios
+
+ if (!w.globals.zoomEnabled) {
+ if (
+ typeof w.globals.selection !== 'undefined' &&
+ w.globals.selection !== null
+ ) {
+ this.drawSelectionRect(w.globals.selection)
+ } else {
+ if (
+ w.config.chart.selection.xaxis.min !== undefined &&
+ w.config.chart.selection.xaxis.max !== undefined
+ ) {
+ const x =
+ (w.config.chart.selection.xaxis.min - w.globals.minX) /
+ xyRatios.xRatio
+ const width =
+ w.globals.gridWidth -
+ (w.globals.maxX - w.config.chart.selection.xaxis.max) /
+ xyRatios.xRatio -
+ x
+ let selectionRect = {
+ x,
+ y: 0,
+ width,
+ height: w.globals.gridHeight,
+ translateX: 0,
+ translateY: 0,
+ selectionEnabled: true
+ }
+ this.drawSelectionRect(selectionRect)
+ this.makeSelectionRectDraggable()
+ if (typeof w.config.chart.events.selection === 'function') {
+ w.config.chart.events.selection(this.ctx, {
+ xaxis: {
+ min: w.config.chart.selection.xaxis.min,
+ max: w.config.chart.selection.xaxis.max
+ },
+ yaxis: {}
+ })
+ }
+ }
+ }
+ }
+ }
+
+ drawSelectionRect({ x, y, width, height, translateX = 0, translateY = 0 }) {
+ const w = this.w
+ const zoomRect = this.zoomRect
+ const selectionRect = this.selectionRect
+ if (this.dragged || w.globals.selection !== null) {
+ let scalingAttrs = {
+ transform: 'translate(' + translateX + ', ' + translateY + ')'
+ }
+
+ // change styles based on zoom or selection
+ // zoom is Enabled and user has dragged, so draw blue rect
+ if (w.globals.zoomEnabled && this.dragged) {
+ if (width < 0) width = 1 // fixes apexcharts.js#1168
+ zoomRect.attr({
+ x,
+ y,
+ width,
+ height,
+ fill: w.config.chart.zoom.zoomedArea.fill.color,
+ 'fill-opacity': w.config.chart.zoom.zoomedArea.fill.opacity,
+ stroke: w.config.chart.zoom.zoomedArea.stroke.color,
+ 'stroke-width': w.config.chart.zoom.zoomedArea.stroke.width,
+ 'stroke-opacity': w.config.chart.zoom.zoomedArea.stroke.opacity
+ })
+ Graphics.setAttrs(zoomRect.node, scalingAttrs)
+ }
+
+ // selection is enabled
+ if (w.globals.selectionEnabled) {
+ selectionRect.attr({
+ x,
+ y,
+ width: width > 0 ? width : 0,
+ height: height > 0 ? height : 0,
+ fill: w.config.chart.selection.fill.color,
+ 'fill-opacity': w.config.chart.selection.fill.opacity,
+ stroke: w.config.chart.selection.stroke.color,
+ 'stroke-width': w.config.chart.selection.stroke.width,
+ 'stroke-dasharray': w.config.chart.selection.stroke.dashArray,
+ 'stroke-opacity': w.config.chart.selection.stroke.opacity
+ })
+
+ Graphics.setAttrs(selectionRect.node, scalingAttrs)
+ }
+ }
+ }
+
+ hideSelectionRect(rect) {
+ if (rect) {
+ rect.attr({
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0
+ })
+ }
+ }
+
+ selectionDrawing({ context, zoomtype }) {
+ const w = this.w
+ let me = context
+
+ let gridRectDim = this.gridRect.getBoundingClientRect()
+
+ let startX = me.startX - 1
+ let startY = me.startY
+ let inversedX = false
+ let inversedY = false
+
+ let selectionWidth = me.clientX - gridRectDim.left - startX
+ let selectionHeight = me.clientY - gridRectDim.top - startY
+
+ let selectionRect = {}
+
+ if (Math.abs(selectionWidth + startX) > w.globals.gridWidth) {
+ // user dragged the mouse outside drawing area to the right
+ selectionWidth = w.globals.gridWidth - startX
+ } else if (me.clientX - gridRectDim.left < 0) {
+ // user dragged the mouse outside drawing area to the left
+ selectionWidth = startX
+ }
+
+ // inverse selection X
+ if (startX > me.clientX - gridRectDim.left) {
+ inversedX = true
+ selectionWidth = Math.abs(selectionWidth)
+ }
+
+ // inverse selection Y
+ if (startY > me.clientY - gridRectDim.top) {
+ inversedY = true
+ selectionHeight = Math.abs(selectionHeight)
+ }
+
+ if (zoomtype === 'x') {
+ selectionRect = {
+ x: inversedX ? startX - selectionWidth : startX,
+ y: 0,
+ width: selectionWidth,
+ height: w.globals.gridHeight
+ }
+ } else if (zoomtype === 'y') {
+ selectionRect = {
+ x: 0,
+ y: inversedY ? startY - selectionHeight : startY,
+ width: w.globals.gridWidth,
+ height: selectionHeight
+ }
+ } else {
+ selectionRect = {
+ x: inversedX ? startX - selectionWidth : startX,
+ y: inversedY ? startY - selectionHeight : startY,
+ width: selectionWidth,
+ height: selectionHeight
+ }
+ }
+
+ me.drawSelectionRect(selectionRect)
+ me.selectionDragging('resizing')
+ return selectionRect
+ }
+
+ selectionDragging(type, e) {
+ const w = this.w
+ const xyRatios = this.xyRatios
+
+ const selRect = this.selectionRect
+
+ let timerInterval = 0
+
+ if (type === 'resizing') {
+ timerInterval = 30
+ }
+
+ // update selection when selection rect is dragged
+ const getSelAttr = (attr) => {
+ return parseFloat(selRect.node.getAttribute(attr))
+ }
+ const draggedProps = {
+ x: getSelAttr('x'),
+ y: getSelAttr('y'),
+ width: getSelAttr('width'),
+ height: getSelAttr('height')
+ }
+ w.globals.selection = draggedProps
+ // update selection ends
+
+ if (
+ typeof w.config.chart.events.selection === 'function' &&
+ w.globals.selectionEnabled
+ ) {
+ // a small debouncer is required when resizing to avoid freezing the chart
+ clearTimeout(this.w.globals.selectionResizeTimer)
+ this.w.globals.selectionResizeTimer = window.setTimeout(() => {
+ const gridRectDim = this.gridRect.getBoundingClientRect()
+ const selectionRect = selRect.node.getBoundingClientRect()
+
+ const minX =
+ w.globals.xAxisScale.niceMin +
+ (selectionRect.left - gridRectDim.left) * xyRatios.xRatio
+ const maxX =
+ w.globals.xAxisScale.niceMin +
+ (selectionRect.right - gridRectDim.left) * xyRatios.xRatio
+
+ const minY =
+ w.globals.yAxisScale[0].niceMin +
+ (gridRectDim.bottom - selectionRect.bottom) * xyRatios.yRatio[0]
+ const maxY =
+ w.globals.yAxisScale[0].niceMax -
+ (selectionRect.top - gridRectDim.top) * xyRatios.yRatio[0]
+
+ const xyAxis = {
+ xaxis: {
+ min: minX,
+ max: maxX
+ },
+ yaxis: {
+ min: minY,
+ max: maxY
+ }
+ }
+ w.config.chart.events.selection(this.ctx, xyAxis)
+
+ if (
+ w.config.chart.brush.enabled &&
+ w.config.chart.events.brushScrolled !== undefined
+ ) {
+ w.config.chart.events.brushScrolled(this.ctx, xyAxis)
+ }
+ }, timerInterval)
+ }
+ }
+
+ selectionDrawn({ context, zoomtype }) {
+ const w = this.w
+ const me = context
+ const xyRatios = this.xyRatios
+ const toolbar = this.ctx.toolbar
+
+ if (me.startX > me.endX) {
+ let tempX = me.startX
+ me.startX = me.endX
+ me.endX = tempX
+ }
+ if (me.startY > me.endY) {
+ let tempY = me.startY
+ me.startY = me.endY
+ me.endY = tempY
+ }
+
+ let xLowestValue = undefined
+ let xHighestValue = undefined
+
+ if (!w.globals.isRangeBar) {
+ xLowestValue = w.globals.xAxisScale.niceMin + me.startX * xyRatios.xRatio
+ xHighestValue = w.globals.xAxisScale.niceMin + me.endX * xyRatios.xRatio
+ } else {
+ xLowestValue =
+ w.globals.yAxisScale[0].niceMin + me.startX * xyRatios.invertedYRatio
+ xHighestValue =
+ w.globals.yAxisScale[0].niceMin + me.endX * xyRatios.invertedYRatio
+ }
+
+ // TODO: we will consider the 1st y axis values here for getting highest and lowest y
+ let yHighestValue = []
+ let yLowestValue = []
+
+ w.config.yaxis.forEach((yaxe, index) => {
+ yHighestValue.push(
+ w.globals.yAxisScale[index].niceMax - xyRatios.yRatio[index] * me.startY
+ )
+ yLowestValue.push(
+ w.globals.yAxisScale[index].niceMax - xyRatios.yRatio[index] * me.endY
+ )
+ })
+
+ if (
+ me.dragged &&
+ (me.dragX > 10 || me.dragY > 10) &&
+ xLowestValue !== xHighestValue
+ ) {
+ if (w.globals.zoomEnabled) {
+ let yaxis = Utils.clone(w.globals.initialConfig.yaxis)
+ let xaxis = Utils.clone(w.globals.initialConfig.xaxis)
+
+ w.globals.zoomed = true
+
+ if (w.config.xaxis.convertedCatToNumeric) {
+ xLowestValue = Math.floor(xLowestValue)
+ xHighestValue = Math.floor(xHighestValue)
+
+ if (xLowestValue < 1) {
+ xLowestValue = 1
+ xHighestValue = w.globals.dataPoints
+ }
+
+ if (xHighestValue - xLowestValue < 2) {
+ xHighestValue = xLowestValue + 1
+ }
+ }
+
+ if (zoomtype === 'xy' || zoomtype === 'x') {
+ xaxis = {
+ min: xLowestValue,
+ max: xHighestValue
+ }
+ }
+
+ if (zoomtype === 'xy' || zoomtype === 'y') {
+ yaxis.forEach((yaxe, index) => {
+ yaxis[index].min = yLowestValue[index]
+ yaxis[index].max = yHighestValue[index]
+ })
+ }
+
+ if (w.config.chart.zoom.autoScaleYaxis) {
+ const scale = new Scales(me.ctx)
+ yaxis = scale.autoScaleY(me.ctx, yaxis, {
+ xaxis
+ })
+ }
+
+ if (toolbar) {
+ let beforeZoomRange = toolbar.getBeforeZoomRange(xaxis, yaxis)
+ if (beforeZoomRange) {
+ xaxis = beforeZoomRange.xaxis ? beforeZoomRange.xaxis : xaxis
+ yaxis = beforeZoomRange.yaxis ? beforeZoomRange.yaxis : yaxis
+ }
+ }
+
+ let options = {
+ xaxis
+ }
+
+ if (!w.config.chart.group) {
+ // if chart in a group, prevent yaxis update here
+ // fix issue #650
+ options.yaxis = yaxis
+ }
+ me.ctx.updateHelpers._updateOptions(
+ options,
+ false,
+ me.w.config.chart.animations.dynamicAnimation.enabled
+ )
+
+ if (typeof w.config.chart.events.zoomed === 'function') {
+ toolbar.zoomCallback(xaxis, yaxis)
+ }
+ } else if (w.globals.selectionEnabled) {
+ let yaxis = null
+ let xaxis = null
+ xaxis = {
+ min: xLowestValue,
+ max: xHighestValue
+ }
+ if (zoomtype === 'xy' || zoomtype === 'y') {
+ yaxis = Utils.clone(w.config.yaxis)
+ yaxis.forEach((yaxe, index) => {
+ yaxis[index].min = yLowestValue[index]
+ yaxis[index].max = yHighestValue[index]
+ })
+ }
+
+ w.globals.selection = me.selection
+ if (typeof w.config.chart.events.selection === 'function') {
+ w.config.chart.events.selection(me.ctx, {
+ xaxis,
+ yaxis
+ })
+ }
+ }
+ }
+ }
+
+ panDragging({ context }) {
+ const w = this.w
+ let me = context
+
+ // check to make sure there is data to compare against
+ if (typeof w.globals.lastClientPosition.x !== 'undefined') {
+ // get the change from last position to this position
+ const deltaX = w.globals.lastClientPosition.x - me.clientX
+ const deltaY = w.globals.lastClientPosition.y - me.clientY
+
+ // check which direction had the highest amplitude and then figure out direction by checking if the value is greater or less than zero
+ if (Math.abs(deltaX) > Math.abs(deltaY) && deltaX > 0) {
+ this.moveDirection = 'left'
+ } else if (Math.abs(deltaX) > Math.abs(deltaY) && deltaX < 0) {
+ this.moveDirection = 'right'
+ } else if (Math.abs(deltaY) > Math.abs(deltaX) && deltaY > 0) {
+ this.moveDirection = 'up'
+ } else if (Math.abs(deltaY) > Math.abs(deltaX) && deltaY < 0) {
+ this.moveDirection = 'down'
+ }
+ }
+
+ // set the new last position to the current for next time (to get the position of drag)
+ w.globals.lastClientPosition = {
+ x: me.clientX,
+ y: me.clientY
+ }
+
+ let xLowestValue = w.globals.isRangeBar ? w.globals.minY : w.globals.minX
+
+ let xHighestValue = w.globals.isRangeBar ? w.globals.maxY : w.globals.maxX
+
+ // on a category, we don't pan continuosly as it causes bugs
+ if (!w.config.xaxis.convertedCatToNumeric) {
+ me.panScrolled(xLowestValue, xHighestValue)
+ }
+ }
+
+ delayedPanScrolled() {
+ const w = this.w
+
+ let newMinX = w.globals.minX
+ let newMaxX = w.globals.maxX
+ const centerX = (w.globals.maxX - w.globals.minX) / 2
+
+ if (this.moveDirection === 'left') {
+ newMinX = w.globals.minX + centerX
+ newMaxX = w.globals.maxX + centerX
+ } else if (this.moveDirection === 'right') {
+ newMinX = w.globals.minX - centerX
+ newMaxX = w.globals.maxX - centerX
+ }
+
+ newMinX = Math.floor(newMinX)
+ newMaxX = Math.floor(newMaxX)
+ this.updateScrolledChart(
+ { xaxis: { min: newMinX, max: newMaxX } },
+ newMinX,
+ newMaxX
+ )
+ }
+
+ panScrolled(xLowestValue, xHighestValue) {
+ const w = this.w
+
+ const xyRatios = this.xyRatios
+ let yaxis = Utils.clone(w.globals.initialConfig.yaxis)
+
+ let xRatio = xyRatios.xRatio
+ let minX = w.globals.minX
+ let maxX = w.globals.maxX
+ if (w.globals.isRangeBar) {
+ xRatio = xyRatios.invertedYRatio
+ minX = w.globals.minY
+ maxX = w.globals.maxY
+ }
+
+ if (this.moveDirection === 'left') {
+ xLowestValue = minX + (w.globals.gridWidth / 15) * xRatio
+ xHighestValue = maxX + (w.globals.gridWidth / 15) * xRatio
+ } else if (this.moveDirection === 'right') {
+ xLowestValue = minX - (w.globals.gridWidth / 15) * xRatio
+ xHighestValue = maxX - (w.globals.gridWidth / 15) * xRatio
+ }
+
+ if (!w.globals.isRangeBar) {
+ if (
+ xLowestValue < w.globals.initialMinX ||
+ xHighestValue > w.globals.initialMaxX
+ ) {
+ xLowestValue = minX
+ xHighestValue = maxX
+ }
+ }
+
+ let xaxis = {
+ min: xLowestValue,
+ max: xHighestValue
+ }
+
+ if (w.config.chart.zoom.autoScaleYaxis) {
+ const scale = new Scales(this.ctx)
+ yaxis = scale.autoScaleY(this.ctx, yaxis, {
+ xaxis
+ })
+ }
+
+ let options = {
+ xaxis: {
+ min: xLowestValue,
+ max: xHighestValue
+ }
+ }
+
+ if (!w.config.chart.group) {
+ // if chart in a group, prevent yaxis update here
+ // fix issue #650
+ options.yaxis = yaxis
+ }
+
+ this.updateScrolledChart(options, xLowestValue, xHighestValue)
+ }
+
+ updateScrolledChart(options, xLowestValue, xHighestValue) {
+ const w = this.w
+
+ this.ctx.updateHelpers._updateOptions(options, false, false)
+
+ if (typeof w.config.chart.events.scrolled === 'function') {
+ w.config.chart.events.scrolled(this.ctx, {
+ xaxis: {
+ min: xLowestValue,
+ max: xHighestValue
+ }
+ })
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Annotations.js b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Annotations.js
new file mode 100644
index 0000000..6157714
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Annotations.js
@@ -0,0 +1,321 @@
+import Graphics from '../../modules/Graphics'
+import Utils from '../../utils/Utils'
+import Helpers from './Helpers'
+import XAxisAnnotations from './XAxisAnnotations'
+import YAxisAnnotations from './YAxisAnnotations'
+import PointsAnnotations from './PointsAnnotations'
+import Options from './../settings/Options'
+
+/**
+ * ApexCharts Annotations Class for drawing lines/rects on both xaxis and yaxis.
+ *
+ * @module Annotations
+ **/
+export default class Annotations {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ this.graphics = new Graphics(this.ctx)
+
+ if (this.w.globals.isBarHorizontal) {
+ this.invertAxis = true
+ }
+
+ this.helpers = new Helpers(this)
+ this.xAxisAnnotations = new XAxisAnnotations(this)
+ this.yAxisAnnotations = new YAxisAnnotations(this)
+ this.pointsAnnotations = new PointsAnnotations(this)
+
+ if (this.w.globals.isBarHorizontal && this.w.config.yaxis[0].reversed) {
+ this.inversedReversedAxis = true
+ }
+
+ this.xDivision = this.w.globals.gridWidth / this.w.globals.dataPoints
+ }
+
+ drawAxesAnnotations() {
+ const w = this.w
+ if (w.globals.axisCharts) {
+ let yAnnotations = this.yAxisAnnotations.drawYAxisAnnotations()
+ let xAnnotations = this.xAxisAnnotations.drawXAxisAnnotations()
+ let pointAnnotations = this.pointsAnnotations.drawPointAnnotations()
+
+ const initialAnim = w.config.chart.animations.enabled
+
+ const annoArray = [yAnnotations, xAnnotations, pointAnnotations]
+ const annoElArray = [
+ xAnnotations.node,
+ yAnnotations.node,
+ pointAnnotations.node
+ ]
+ for (let i = 0; i < 3; i++) {
+ w.globals.dom.elGraphical.add(annoArray[i])
+ if (initialAnim && !w.globals.resized && !w.globals.dataChanged) {
+ // fixes apexcharts/apexcharts.js#685
+ if (
+ w.config.chart.type !== 'scatter' &&
+ w.config.chart.type !== 'bubble' &&
+ w.globals.dataPoints > 1
+ ) {
+ annoElArray[i].classList.add('apexcharts-element-hidden')
+ }
+ }
+ w.globals.delayedElements.push({ el: annoElArray[i], index: 0 })
+ }
+
+ // background sizes needs to be calculated after text is drawn, so calling them last
+ this.helpers.annotationsBackground()
+ }
+ }
+
+ drawImageAnnos() {
+ const w = this.w
+
+ w.config.annotations.images.map((s, index) => {
+ this.addImage(s, index)
+ })
+ }
+
+ drawTextAnnos() {
+ const w = this.w
+
+ w.config.annotations.texts.map((t, index) => {
+ this.addText(t, index)
+ })
+ }
+
+ addXaxisAnnotation(anno, parent, index) {
+ this.xAxisAnnotations.addXaxisAnnotation(anno, parent, index)
+ }
+
+ addYaxisAnnotation(anno, parent, index) {
+ this.yAxisAnnotations.addYaxisAnnotation(anno, parent, index)
+ }
+
+ addPointAnnotation(anno, parent, index) {
+ this.pointsAnnotations.addPointAnnotation(anno, parent, index)
+ }
+
+ addText(params, index) {
+ const {
+ x,
+ y,
+ text,
+ textAnchor,
+ foreColor,
+ fontSize,
+ fontFamily,
+ fontWeight,
+ cssClass,
+ backgroundColor,
+ borderWidth,
+ strokeDashArray,
+ borderRadius,
+ borderColor,
+ appendTo = '.apexcharts-annotations',
+ paddingLeft = 4,
+ paddingRight = 4,
+ paddingBottom = 2,
+ paddingTop = 2
+ } = params
+
+ const w = this.w
+
+ let elText = this.graphics.drawText({
+ x,
+ y,
+ text,
+ textAnchor: textAnchor || 'start',
+ fontSize: fontSize || '12px',
+ fontWeight: fontWeight || 'regular',
+ fontFamily: fontFamily || w.config.chart.fontFamily,
+ foreColor: foreColor || w.config.chart.foreColor,
+ cssClass: 'apexcharts-text ' + cssClass ? cssClass : ''
+ })
+
+ const parent = w.globals.dom.baseEl.querySelector(appendTo)
+ if (parent) {
+ parent.appendChild(elText.node)
+ }
+
+ const textRect = elText.bbox()
+
+ if (text) {
+ const elRect = this.graphics.drawRect(
+ textRect.x - paddingLeft,
+ textRect.y - paddingTop,
+ textRect.width + paddingLeft + paddingRight,
+ textRect.height + paddingBottom + paddingTop,
+ borderRadius,
+ backgroundColor ? backgroundColor : 'transparent',
+ 1,
+ borderWidth,
+ borderColor,
+ strokeDashArray
+ )
+
+ parent.insertBefore(elRect.node, elText.node)
+ }
+ }
+
+ addImage(params, index) {
+ const w = this.w
+
+ const {
+ path,
+ x = 0,
+ y = 0,
+ width = 20,
+ height = 20,
+ appendTo = '.apexcharts-annotations'
+ } = params
+
+ let img = w.globals.dom.Paper.image(path)
+ img.size(width, height).move(x, y)
+
+ const parent = w.globals.dom.baseEl.querySelector(appendTo)
+ if (parent) {
+ parent.appendChild(img.node)
+ }
+
+ return img
+ }
+
+ // The addXaxisAnnotation method requires a parent class, and user calling this method externally on the chart instance may not specify parent, hence a different method
+ addXaxisAnnotationExternal(params, pushToMemory, context) {
+ this.addAnnotationExternal({
+ params,
+ pushToMemory,
+ context,
+ type: 'xaxis',
+ contextMethod: context.addXaxisAnnotation
+ })
+ return context
+ }
+
+ addYaxisAnnotationExternal(params, pushToMemory, context) {
+ this.addAnnotationExternal({
+ params,
+ pushToMemory,
+ context,
+ type: 'yaxis',
+ contextMethod: context.addYaxisAnnotation
+ })
+ return context
+ }
+
+ addPointAnnotationExternal(params, pushToMemory, context) {
+ if (typeof this.invertAxis === 'undefined') {
+ this.invertAxis = context.w.globals.isBarHorizontal
+ }
+
+ this.addAnnotationExternal({
+ params,
+ pushToMemory,
+ context,
+ type: 'point',
+ contextMethod: context.addPointAnnotation
+ })
+ return context
+ }
+
+ addAnnotationExternal({
+ params,
+ pushToMemory,
+ context,
+ type,
+ contextMethod
+ }) {
+ const me = context
+ const w = me.w
+ const parent = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-${type}-annotations`
+ )
+ const index = parent.childNodes.length + 1
+
+ const options = new Options()
+ const axesAnno = Object.assign(
+ {},
+ type === 'xaxis'
+ ? options.xAxisAnnotation
+ : type === 'yaxis'
+ ? options.yAxisAnnotation
+ : options.pointAnnotation
+ )
+
+ const anno = Utils.extend(axesAnno, params)
+
+ switch (type) {
+ case 'xaxis':
+ this.addXaxisAnnotation(anno, parent, index)
+ break
+ case 'yaxis':
+ this.addYaxisAnnotation(anno, parent, index)
+ break
+ case 'point':
+ this.addPointAnnotation(anno, parent, index)
+ break
+ }
+
+ // add background
+ let axesAnnoLabel = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-${type}-annotations .apexcharts-${type}-annotation-label[rel='${index}']`
+ )
+ const elRect = this.helpers.addBackgroundToAnno(axesAnnoLabel, anno)
+ if (elRect) {
+ parent.insertBefore(elRect.node, axesAnnoLabel)
+ }
+
+ if (pushToMemory) {
+ w.globals.memory.methodsToExec.push({
+ context: me,
+ id: anno.id ? anno.id : Utils.randomId(),
+ method: contextMethod,
+ label: 'addAnnotation',
+ params
+ })
+ }
+
+ return context
+ }
+
+ clearAnnotations(ctx) {
+ const w = ctx.w
+ let annos = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-yaxis-annotations, .apexcharts-xaxis-annotations, .apexcharts-point-annotations'
+ )
+
+ // annotations added externally should be cleared out too
+ w.globals.memory.methodsToExec.map((m, i) => {
+ if (m.label === 'addText' || m.label === 'addAnnotation') {
+ w.globals.memory.methodsToExec.splice(i, 1)
+ }
+ })
+
+ annos = Utils.listToArray(annos)
+
+ // delete the DOM elements
+ Array.prototype.forEach.call(annos, (a) => {
+ while (a.firstChild) {
+ a.removeChild(a.firstChild)
+ }
+ })
+ }
+
+ removeAnnotation(ctx, id) {
+ const w = ctx.w
+ let annos = w.globals.dom.baseEl.querySelectorAll(`.${id}`)
+
+ if (annos) {
+ w.globals.memory.methodsToExec.map((m, i) => {
+ if (m.id === id) {
+ w.globals.memory.methodsToExec.splice(i, 1)
+ }
+ })
+
+ Array.prototype.forEach.call(annos, (a) => {
+ a.parentElement.removeChild(a)
+ })
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Helpers.js
new file mode 100644
index 0000000..75ef5aa
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/Helpers.js
@@ -0,0 +1,245 @@
+import CoreUtils from '../CoreUtils'
+
+export default class Helpers {
+ constructor(annoCtx) {
+ this.w = annoCtx.w
+ this.annoCtx = annoCtx
+ }
+
+ setOrientations(anno, annoIndex = null) {
+ let w = this.w
+
+ if (anno.label.orientation === 'vertical') {
+ const i = annoIndex !== null ? annoIndex : 0
+ let xAnno = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-xaxis-annotations .apexcharts-xaxis-annotation-label[rel='${i}']`
+ )
+
+ if (xAnno !== null) {
+ const xAnnoCoord = xAnno.getBoundingClientRect()
+ xAnno.setAttribute(
+ 'x',
+ parseFloat(xAnno.getAttribute('x')) - xAnnoCoord.height + 4
+ )
+
+ if (anno.label.position === 'top') {
+ xAnno.setAttribute(
+ 'y',
+ parseFloat(xAnno.getAttribute('y')) + xAnnoCoord.width
+ )
+ } else {
+ xAnno.setAttribute(
+ 'y',
+ parseFloat(xAnno.getAttribute('y')) - xAnnoCoord.width
+ )
+ }
+
+ let annoRotatingCenter = this.annoCtx.graphics.rotateAroundCenter(xAnno)
+ const x = annoRotatingCenter.x
+ const y = annoRotatingCenter.y
+
+ xAnno.setAttribute('transform', `rotate(-90 ${x} ${y})`)
+ }
+ }
+ }
+
+ addBackgroundToAnno(annoEl, anno) {
+ const w = this.w
+
+ if (
+ !annoEl ||
+ typeof anno.label.text === 'undefined' ||
+ (typeof anno.label.text !== 'undefined' &&
+ !String(anno.label.text).trim())
+ )
+ return null
+
+ const elGridRect = w.globals.dom.baseEl
+ .querySelector('.apexcharts-grid')
+ .getBoundingClientRect()
+
+ const coords = annoEl.getBoundingClientRect()
+
+ let pleft = anno.label.style.padding.left
+ let pright = anno.label.style.padding.right
+ let ptop = anno.label.style.padding.top
+ let pbottom = anno.label.style.padding.bottom
+
+ if (anno.label.orientation === 'vertical') {
+ ptop = anno.label.style.padding.left
+ pbottom = anno.label.style.padding.right
+ pleft = anno.label.style.padding.top
+ pright = anno.label.style.padding.bottom
+ }
+
+ const x1 = coords.left - elGridRect.left - pleft
+ const y1 = coords.top - elGridRect.top - ptop
+ const elRect = this.annoCtx.graphics.drawRect(
+ x1 - w.globals.barPadForNumericAxis,
+ y1,
+ coords.width + pleft + pright,
+ coords.height + ptop + pbottom,
+ anno.label.borderRadius,
+ anno.label.style.background,
+ 1,
+ anno.label.borderWidth,
+ anno.label.borderColor,
+ 0
+ )
+
+ if (anno.id) {
+ // don't escapeString for this ID as it causes duplicate rects
+ elRect.node.classList.add(anno.id)
+ }
+
+ return elRect
+ }
+
+ annotationsBackground() {
+ const w = this.w
+
+ const add = (anno, i, type) => {
+ let annoLabel = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-${type}-annotations .apexcharts-${type}-annotation-label[rel='${i}']`
+ )
+
+ if (annoLabel) {
+ const parent = annoLabel.parentNode
+ const elRect = this.addBackgroundToAnno(annoLabel, anno)
+
+ if (elRect) {
+ parent.insertBefore(elRect.node, annoLabel)
+
+ if (anno.label.mouseEnter) {
+ elRect.node.addEventListener(
+ 'mouseenter',
+ anno.label.mouseEnter.bind(this, anno)
+ )
+ }
+ if (anno.label.mouseLeave) {
+ elRect.node.addEventListener(
+ 'mouseleave',
+ anno.label.mouseLeave.bind(this, anno)
+ )
+ }
+ }
+ }
+ }
+
+ w.config.annotations.xaxis.map((anno, i) => {
+ add(anno, i, 'xaxis')
+ })
+
+ w.config.annotations.yaxis.map((anno, i) => {
+ add(anno, i, 'yaxis')
+ })
+
+ w.config.annotations.points.map((anno, i) => {
+ add(anno, i, 'point')
+ })
+ }
+
+ getY1Y2(type, anno) {
+ let y = type === 'y1' ? anno.y : anno.y2
+ let yP
+
+ const w = this.w
+ if (this.annoCtx.invertAxis) {
+ let catIndex = w.globals.labels.indexOf(y)
+ if (w.config.xaxis.convertedCatToNumeric) {
+ catIndex = w.globals.categoryLabels.indexOf(y)
+ }
+ const xLabel = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-yaxis-texts-g text:nth-child(' + (catIndex + 1) + ')'
+ )
+ if (xLabel) {
+ yP = parseFloat(xLabel.getAttribute('y'))
+ }
+ } else {
+ let yPos
+ if (w.config.yaxis[anno.yAxisIndex].logarithmic) {
+ const coreUtils = new CoreUtils(this.annoCtx.ctx)
+ y = coreUtils.getLogVal(y, anno.yAxisIndex)
+ yPos = y / w.globals.yLogRatio[anno.yAxisIndex]
+ } else {
+ yPos =
+ (y - w.globals.minYArr[anno.yAxisIndex]) /
+ (w.globals.yRange[anno.yAxisIndex] / w.globals.gridHeight)
+ }
+ yP = w.globals.gridHeight - yPos
+
+ if (
+ w.config.yaxis[anno.yAxisIndex] &&
+ w.config.yaxis[anno.yAxisIndex].reversed
+ ) {
+ yP = yPos
+ }
+ }
+
+ return yP
+ }
+
+ getX1X2(type, anno) {
+ const w = this.w
+ let min = this.annoCtx.invertAxis ? w.globals.minY : w.globals.minX
+ let max = this.annoCtx.invertAxis ? w.globals.maxY : w.globals.maxX
+ const range = this.annoCtx.invertAxis
+ ? w.globals.yRange[0]
+ : w.globals.xRange
+
+ let x1 = (anno.x - min) / (range / w.globals.gridWidth)
+
+ if (this.annoCtx.inversedReversedAxis) {
+ x1 = (max - anno.x) / (range / w.globals.gridWidth)
+ }
+
+ if (
+ (w.config.xaxis.type === 'category' ||
+ w.config.xaxis.convertedCatToNumeric) &&
+ !this.annoCtx.invertAxis &&
+ !w.globals.dataFormatXNumeric
+ ) {
+ x1 = this.getStringX(anno.x)
+ }
+
+ let x2 = (anno.x2 - min) / (range / w.globals.gridWidth)
+
+ if (this.annoCtx.inversedReversedAxis) {
+ x2 = (max - anno.x2) / (range / w.globals.gridWidth)
+ }
+ if (
+ (w.config.xaxis.type === 'category' ||
+ w.config.xaxis.convertedCatToNumeric) &&
+ !this.annoCtx.invertAxis &&
+ !w.globals.dataFormatXNumeric
+ ) {
+ x2 = this.getStringX(anno.x2)
+ }
+
+ return type === 'x1' ? x1 : x2
+ }
+
+ getStringX(x) {
+ const w = this.w
+ let rX = x
+
+ if (
+ w.config.xaxis.convertedCatToNumeric &&
+ w.globals.categoryLabels.length
+ ) {
+ x = w.globals.categoryLabels.indexOf(x) + 1
+ }
+
+ let catIndex = w.globals.labels.indexOf(x)
+
+ const xLabel = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-xaxis-texts-g text:nth-child(' + (catIndex + 1) + ')'
+ )
+
+ if (xLabel) {
+ rX = parseFloat(xLabel.getAttribute('x'))
+ }
+
+ return rX
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/annotations/PointsAnnotations.js b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/PointsAnnotations.js
new file mode 100644
index 0000000..dc32420
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/PointsAnnotations.js
@@ -0,0 +1,122 @@
+import Utils from '../../utils/Utils'
+import Helpers from './Helpers'
+
+export default class PointAnnotations {
+ constructor(annoCtx) {
+ this.w = annoCtx.w
+ this.annoCtx = annoCtx
+ this.helpers = new Helpers(this.annoCtx)
+ }
+
+ addPointAnnotation(anno, parent, index) {
+ const w = this.w
+
+ let x = this.helpers.getX1X2('x1', anno)
+ let y = this.helpers.getY1Y2('y1', anno)
+
+ if (!Utils.isNumber(x)) return
+
+ let optsPoints = {
+ pSize: anno.marker.size,
+ pointStrokeWidth: anno.marker.strokeWidth,
+ pointFillColor: anno.marker.fillColor,
+ pointStrokeColor: anno.marker.strokeColor,
+ shape: anno.marker.shape,
+ pRadius: anno.marker.radius,
+ class: `apexcharts-point-annotation-marker ${anno.marker.cssClass} ${
+ anno.id ? anno.id : ''
+ }`
+ }
+
+ let point = this.annoCtx.graphics.drawMarker(
+ x + anno.marker.offsetX,
+ y + anno.marker.offsetY,
+ optsPoints
+ )
+
+ parent.appendChild(point.node)
+
+ const text = anno.label.text ? anno.label.text : ''
+
+ let elText = this.annoCtx.graphics.drawText({
+ x: x + anno.label.offsetX,
+ y:
+ y +
+ anno.label.offsetY -
+ anno.marker.size -
+ parseFloat(anno.label.style.fontSize) / 1.6,
+ text,
+ textAnchor: anno.label.textAnchor,
+ fontSize: anno.label.style.fontSize,
+ fontFamily: anno.label.style.fontFamily,
+ fontWeight: anno.label.style.fontWeight,
+ foreColor: anno.label.style.color,
+ cssClass: `apexcharts-point-annotation-label ${
+ anno.label.style.cssClass
+ } ${anno.id ? anno.id : ''}`
+ })
+
+ elText.attr({
+ rel: index
+ })
+
+ parent.appendChild(elText.node)
+
+ // TODO: deprecate this as we will use custom
+ if (anno.customSVG.SVG) {
+ let g = this.annoCtx.graphics.group({
+ class:
+ 'apexcharts-point-annotations-custom-svg ' + anno.customSVG.cssClass
+ })
+
+ g.attr({
+ transform: `translate(${x + anno.customSVG.offsetX}, ${y +
+ anno.customSVG.offsetY})`
+ })
+
+ g.node.innerHTML = anno.customSVG.SVG
+ parent.appendChild(g.node)
+ }
+
+ if (anno.image.path) {
+ let imgWidth = anno.image.width ? anno.image.width : 20
+ let imgHeight = anno.image.height ? anno.image.height : 20
+
+ point = this.annoCtx.addImage({
+ x: x + anno.image.offsetX - imgWidth / 2,
+ y: y + anno.image.offsetY - imgHeight / 2,
+ width: imgWidth,
+ height: imgHeight,
+ path: anno.image.path,
+ appendTo: '.apexcharts-point-annotations'
+ })
+ }
+
+ if (anno.mouseEnter) {
+ point.node.addEventListener(
+ 'mouseenter',
+ anno.mouseEnter.bind(this, anno)
+ )
+ }
+ if (anno.mouseLeave) {
+ point.node.addEventListener(
+ 'mouseleave',
+ anno.mouseLeave.bind(this, anno)
+ )
+ }
+ }
+
+ drawPointAnnotations() {
+ let w = this.w
+
+ let elg = this.annoCtx.graphics.group({
+ class: 'apexcharts-point-annotations'
+ })
+
+ w.config.annotations.points.map((anno, index) => {
+ this.addPointAnnotation(anno, elg.node, index)
+ })
+
+ return elg
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/annotations/XAxisAnnotations.js b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/XAxisAnnotations.js
new file mode 100644
index 0000000..ff16c93
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/XAxisAnnotations.js
@@ -0,0 +1,118 @@
+import Utils from '../../utils/Utils'
+import Helpers from './Helpers'
+
+export default class XAnnotations {
+ constructor(annoCtx) {
+ this.w = annoCtx.w
+ this.annoCtx = annoCtx
+
+ this.invertAxis = this.annoCtx.invertAxis
+
+ this.helpers = new Helpers(this.annoCtx)
+ }
+
+ addXaxisAnnotation(anno, parent, index) {
+ let w = this.w
+
+ let x1 = this.helpers.getX1X2('x1', anno)
+ let x2
+
+ const text = anno.label.text
+
+ let strokeDashArray = anno.strokeDashArray
+
+ if (!Utils.isNumber(x1)) return
+
+ if (anno.x2 === null || typeof anno.x2 === 'undefined') {
+ let line = this.annoCtx.graphics.drawLine(
+ x1 + anno.offsetX, // x1
+ 0 + anno.offsetY, // y1
+ x1 + anno.offsetX, // x2
+ w.globals.gridHeight + anno.offsetY, // y2
+ anno.borderColor, // lineColor
+ strokeDashArray, //dashArray
+ anno.borderWidth
+ )
+ parent.appendChild(line.node)
+ if (anno.id) {
+ line.node.classList.add(anno.id)
+ }
+ } else {
+ x2 = this.helpers.getX1X2('x2', anno)
+
+ if (x2 < x1) {
+ let temp = x1
+ x1 = x2
+ x2 = temp
+ }
+
+ let rect = this.annoCtx.graphics.drawRect(
+ x1 + anno.offsetX, // x1
+ 0 + anno.offsetY, // y1
+ x2 - x1, // x2
+ w.globals.gridHeight + anno.offsetY, // y2
+ 0, // radius
+ anno.fillColor, // color
+ anno.opacity, // opacity,
+ 1, // strokeWidth
+ anno.borderColor, // strokeColor
+ strokeDashArray // stokeDashArray
+ )
+ rect.node.classList.add('apexcharts-annotation-rect')
+ rect.attr('clip-path', `url(#gridRectMask${w.globals.cuid})`)
+ parent.appendChild(rect.node)
+ if (anno.id) {
+ rect.node.classList.add(anno.id)
+ }
+ }
+ let textY = anno.label.position === 'top' ? 4 : w.globals.gridHeight
+
+ let textRects = this.annoCtx.graphics.getTextRects(
+ text,
+ parseFloat(anno.label.style.fontSize)
+ )
+
+ let elText = this.annoCtx.graphics.drawText({
+ x: x1 + anno.label.offsetX,
+ y:
+ textY +
+ anno.label.offsetY -
+ (anno.label.orientation === 'vertical'
+ ? anno.label.position === 'top'
+ ? textRects.width / 2 - 12
+ : -textRects.width / 2
+ : 0),
+ text,
+ textAnchor: anno.label.textAnchor,
+ fontSize: anno.label.style.fontSize,
+ fontFamily: anno.label.style.fontFamily,
+ fontWeight: anno.label.style.fontWeight,
+ foreColor: anno.label.style.color,
+ cssClass: `apexcharts-xaxis-annotation-label ${
+ anno.label.style.cssClass
+ } ${anno.id ? anno.id : ''}`
+ })
+
+ elText.attr({
+ rel: index
+ })
+
+ parent.appendChild(elText.node)
+
+ // after placing the annotations on svg, set any vertically placed annotations
+ this.annoCtx.helpers.setOrientations(anno, index)
+ }
+ drawXAxisAnnotations() {
+ let w = this.w
+
+ let elg = this.annoCtx.graphics.group({
+ class: 'apexcharts-xaxis-annotations'
+ })
+
+ w.config.annotations.xaxis.map((anno, index) => {
+ this.addXaxisAnnotation(anno, elg.node, index)
+ })
+
+ return elg
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/annotations/YAxisAnnotations.js b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/YAxisAnnotations.js
new file mode 100644
index 0000000..0ee2c6c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/annotations/YAxisAnnotations.js
@@ -0,0 +1,112 @@
+import Helpers from './Helpers'
+
+export default class YAnnotations {
+ constructor(annoCtx) {
+ this.w = annoCtx.w
+ this.annoCtx = annoCtx
+
+ this.helpers = new Helpers(this.annoCtx)
+ }
+
+ addYaxisAnnotation(anno, parent, index) {
+ let w = this.w
+
+ let strokeDashArray = anno.strokeDashArray
+
+ let y1 = this.helpers.getY1Y2('y1', anno)
+ let y2
+
+ const text = anno.label.text
+
+ if (anno.y2 === null || typeof anno.y2 === 'undefined') {
+ let line = this.annoCtx.graphics.drawLine(
+ 0 + anno.offsetX, // x1
+ y1 + anno.offsetY, // y1
+ this._getYAxisAnnotationWidth(anno), // x2
+ y1 + anno.offsetY, // y2
+ anno.borderColor, // lineColor
+ strokeDashArray, // dashArray
+ anno.borderWidth
+ )
+ parent.appendChild(line.node)
+ if (anno.id) {
+ line.node.classList.add(anno.id)
+ }
+ } else {
+ y2 = this.helpers.getY1Y2('y2', anno)
+
+ if (y2 > y1) {
+ let temp = y1
+ y1 = y2
+ y2 = temp
+ }
+
+ let rect = this.annoCtx.graphics.drawRect(
+ 0 + anno.offsetX, // x1
+ y2 + anno.offsetY, // y1
+ this._getYAxisAnnotationWidth(anno), // x2
+ y1 - y2, // y2
+ 0, // radius
+ anno.fillColor, // color
+ anno.opacity, // opacity,
+ 1, // strokeWidth
+ anno.borderColor, // strokeColor
+ strokeDashArray // stokeDashArray
+ )
+ rect.node.classList.add('apexcharts-annotation-rect')
+ rect.attr('clip-path', `url(#gridRectMask${w.globals.cuid})`)
+
+ parent.appendChild(rect.node)
+ if (anno.id) {
+ rect.node.classList.add(anno.id)
+ }
+ }
+ let textX = anno.label.position === 'right' ? w.globals.gridWidth : 0
+
+ let elText = this.annoCtx.graphics.drawText({
+ x: textX + anno.label.offsetX,
+ y: (y2 != null ? y2 : y1) + anno.label.offsetY - 3,
+ text,
+ textAnchor: anno.label.textAnchor,
+ fontSize: anno.label.style.fontSize,
+ fontFamily: anno.label.style.fontFamily,
+ fontWeight: anno.label.style.fontWeight,
+ foreColor: anno.label.style.color,
+ cssClass: `apexcharts-yaxis-annotation-label ${
+ anno.label.style.cssClass
+ } ${anno.id ? anno.id : ''}`
+ })
+
+ elText.attr({
+ rel: index
+ })
+
+ parent.appendChild(elText.node)
+ }
+
+ _getYAxisAnnotationWidth(anno) {
+ // issue apexcharts.js#2009
+ const w = this.w
+ let width = w.globals.gridWidth
+ if (anno.width.indexOf('%') > -1) {
+ width = (w.globals.gridWidth * parseInt(anno.width, 10)) / 100
+ } else {
+ width = parseInt(anno.width, 10)
+ }
+ return width + anno.offsetX
+ }
+
+ drawYAxisAnnotations() {
+ let w = this.w
+
+ let elg = this.annoCtx.graphics.group({
+ class: 'apexcharts-yaxis-annotations'
+ })
+
+ w.config.annotations.yaxis.map((anno, index) => {
+ this.addYaxisAnnotation(anno, elg.node, index)
+ })
+
+ return elg
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/axes/Axes.js b/cao_sunyata/static/libs/apexcharts/src/modules/axes/Axes.js
new file mode 100644
index 0000000..0ecfcbd
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/axes/Axes.js
@@ -0,0 +1,39 @@
+import XAxis from './XAxis'
+import YAxis from './YAxis'
+
+export default class Axes {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ drawAxis(type, xyRatios) {
+ let gl = this.w.globals
+ let cnf = this.w.config
+
+ let xAxis = new XAxis(this.ctx)
+ let yAxis = new YAxis(this.ctx)
+
+ if (gl.axisCharts && type !== 'radar') {
+ let elXaxis, elYaxis
+
+ if (gl.isBarHorizontal) {
+ elYaxis = yAxis.drawYaxisInversed(0)
+ elXaxis = xAxis.drawXaxisInversed(0)
+
+ gl.dom.elGraphical.add(elXaxis)
+ gl.dom.elGraphical.add(elYaxis)
+ } else {
+ elXaxis = xAxis.drawXaxis()
+ gl.dom.elGraphical.add(elXaxis)
+
+ cnf.yaxis.map((yaxe, index) => {
+ if (gl.ignoreYAxisIndexes.indexOf(index) === -1) {
+ elYaxis = yAxis.drawYaxis(index)
+ gl.dom.Paper.add(elYaxis)
+ }
+ })
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/axes/AxesUtils.js b/cao_sunyata/static/libs/apexcharts/src/modules/axes/AxesUtils.js
new file mode 100644
index 0000000..60c8307
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/axes/AxesUtils.js
@@ -0,0 +1,247 @@
+import Formatters from '../Formatters'
+import Graphics from '../Graphics'
+import CoreUtils from '../CoreUtils'
+import DateTime from '../../utils/DateTime'
+
+export default class AxesUtils {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ // Based on the formatter function, get the label text and position
+ getLabel(
+ labels,
+ timescaleLabels,
+ x,
+ i,
+ drawnLabels = [],
+ fontSize = '12px',
+ isLeafGroup = true
+ ) {
+ const w = this.w
+ let rawLabel = typeof labels[i] === 'undefined' ? '' : labels[i]
+ let label = rawLabel
+
+ let xlbFormatter = w.globals.xLabelFormatter
+ let customFormatter = w.config.xaxis.labels.formatter
+
+ let isBold = false
+
+ let xFormat = new Formatters(this.ctx)
+ let timestamp = rawLabel
+
+ if (isLeafGroup) {
+ label = xFormat.xLabelFormat(xlbFormatter, rawLabel, timestamp, {
+ i,
+ dateFormatter: new DateTime(this.ctx).formatDate,
+ w
+ })
+
+ if (customFormatter !== undefined) {
+ label = customFormatter(rawLabel, labels[i], {
+ i,
+ dateFormatter: new DateTime(this.ctx).formatDate,
+ w
+ })
+ }
+ }
+
+ const determineHighestUnit = (unit) => {
+ let highestUnit = null
+ timescaleLabels.forEach((t) => {
+ if (t.unit === 'month') {
+ highestUnit = 'year'
+ } else if (t.unit === 'day') {
+ highestUnit = 'month'
+ } else if (t.unit === 'hour') {
+ highestUnit = 'day'
+ } else if (t.unit === 'minute') {
+ highestUnit = 'hour'
+ }
+ })
+
+ return highestUnit === unit
+ }
+ if (timescaleLabels.length > 0) {
+ isBold = determineHighestUnit(timescaleLabels[i].unit)
+ x = timescaleLabels[i].position
+ label = timescaleLabels[i].value
+ } else {
+ if (w.config.xaxis.type === 'datetime' && customFormatter === undefined) {
+ label = ''
+ }
+ }
+
+ if (typeof label === 'undefined') label = ''
+
+ label = Array.isArray(label) ? label : label.toString()
+
+ let graphics = new Graphics(this.ctx)
+ let textRect = {}
+ if (w.globals.rotateXLabels && isLeafGroup) {
+ textRect = graphics.getTextRects(
+ label,
+ parseInt(fontSize, 10),
+ null,
+ `rotate(${w.config.xaxis.labels.rotate} 0 0)`,
+ false
+ )
+ } else {
+ textRect = graphics.getTextRects(label, parseInt(fontSize, 10))
+ }
+
+ const allowDuplicatesInTimeScale =
+ !w.config.xaxis.labels.showDuplicates && this.ctx.timeScale
+
+ if (
+ !Array.isArray(label) &&
+ (label.indexOf('NaN') === 0 ||
+ label.toLowerCase().indexOf('invalid') === 0 ||
+ label.toLowerCase().indexOf('infinity') >= 0 ||
+ (drawnLabels.indexOf(label) >= 0 && allowDuplicatesInTimeScale))
+ ) {
+ label = ''
+ }
+
+ return {
+ x,
+ text: label,
+ textRect,
+ isBold
+ }
+ }
+
+ checkLabelBasedOnTickamount(i, label, labelsLen) {
+ const w = this.w
+
+ let ticks = w.config.xaxis.tickAmount
+ if (ticks === 'dataPoints') ticks = Math.round(w.globals.gridWidth / 120)
+
+ if (ticks > labelsLen) return label
+ let tickMultiple = Math.round(labelsLen / (ticks + 1))
+
+ if (i % tickMultiple === 0) {
+ return label
+ } else {
+ label.text = ''
+ }
+
+ return label
+ }
+
+ checkForOverflowingLabels(
+ i,
+ label,
+ labelsLen,
+ drawnLabels,
+ drawnLabelsRects
+ ) {
+ const w = this.w
+
+ if (i === 0) {
+ // check if first label is being truncated
+ if (w.globals.skipFirstTimelinelabel) {
+ label.text = ''
+ }
+ }
+
+ if (i === labelsLen - 1) {
+ // check if last label is being truncated
+ if (w.globals.skipLastTimelinelabel) {
+ label.text = ''
+ }
+ }
+
+ if (w.config.xaxis.labels.hideOverlappingLabels && drawnLabels.length > 0) {
+ const prev = drawnLabelsRects[drawnLabelsRects.length - 1]
+ if (
+ label.x <
+ prev.textRect.width /
+ (w.globals.rotateXLabels
+ ? Math.abs(w.config.xaxis.labels.rotate) / 12
+ : 1.01) +
+ prev.x
+ ) {
+ label.text = ''
+ }
+ }
+
+ return label
+ }
+
+ checkForReversedLabels(i, labels) {
+ const w = this.w
+ if (w.config.yaxis[i] && w.config.yaxis[i].reversed) {
+ labels.reverse()
+ }
+ return labels
+ }
+
+ isYAxisHidden(index) {
+ const w = this.w
+ const coreUtils = new CoreUtils(this.ctx)
+
+ return (
+ !w.config.yaxis[index].show ||
+ (!w.config.yaxis[index].showForNullSeries &&
+ coreUtils.isSeriesNull(index) &&
+ w.globals.collapsedSeriesIndices.indexOf(index) === -1)
+ )
+ }
+
+ // get the label color for y-axis
+ // realIndex is the actual series index, while i is the tick Index
+ getYAxisForeColor(yColors, realIndex) {
+ const w = this.w
+ if (Array.isArray(yColors) && w.globals.yAxisScale[realIndex]) {
+ this.ctx.theme.pushExtraColors(
+ yColors,
+ w.globals.yAxisScale[realIndex].result.length,
+ false
+ )
+ }
+ return yColors
+ }
+
+ drawYAxisTicks(
+ x,
+ tickAmount,
+ axisBorder,
+ axisTicks,
+ realIndex,
+ labelsDivider,
+ elYaxis
+ ) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ // initial label position = 0;
+ let t = w.globals.translateY
+
+ if (axisTicks.show && tickAmount > 0) {
+ if (w.config.yaxis[realIndex].opposite === true) x = x + axisTicks.width
+
+ for (let i = tickAmount; i >= 0; i--) {
+ let tY =
+ t + tickAmount / 10 + w.config.yaxis[realIndex].labels.offsetY - 1
+ if (w.globals.isBarHorizontal) {
+ tY = labelsDivider * i
+ }
+
+ if (w.config.chart.type === 'heatmap') {
+ tY = tY + labelsDivider / 2
+ }
+ let elTick = graphics.drawLine(
+ x + axisBorder.offsetX - axisTicks.width + axisTicks.offsetX,
+ tY + axisTicks.offsetY,
+ x + axisBorder.offsetX + axisTicks.offsetX,
+ tY + axisTicks.offsetY,
+ axisTicks.color
+ )
+ elYaxis.add(elTick)
+ t = t + labelsDivider
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/axes/Grid.js b/cao_sunyata/static/libs/apexcharts/src/modules/axes/Grid.js
new file mode 100644
index 0000000..1711405
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/axes/Grid.js
@@ -0,0 +1,521 @@
+import CoreUtils from '../CoreUtils'
+import Graphics from '../Graphics'
+import XAxis from './XAxis'
+import AxesUtils from './AxesUtils'
+
+/**
+ * ApexCharts Grid Class for drawing Cartesian Grid.
+ *
+ * @module Grid
+ **/
+
+class Grid {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ const w = this.w
+ this.xaxisLabels = w.globals.labels.slice()
+ this.axesUtils = new AxesUtils(ctx)
+
+ this.isRangeBar = w.globals.seriesRangeBar.length
+
+ if (w.globals.timescaleLabels.length > 0) {
+ // timescaleLabels labels are there
+ this.xaxisLabels = w.globals.timescaleLabels.slice()
+ }
+ }
+
+ // when using sparklines or when showing no grid, we need to have a grid area which is reused at many places for other calculations as well
+ drawGridArea(elGrid = null) {
+ let w = this.w
+
+ let graphics = new Graphics(this.ctx)
+
+ if (elGrid === null) {
+ elGrid = graphics.group({
+ class: 'apexcharts-grid'
+ })
+ }
+
+ let elVerticalLine = graphics.drawLine(
+ w.globals.padHorizontal,
+ 1,
+ w.globals.padHorizontal,
+ w.globals.gridHeight,
+ 'transparent'
+ )
+
+ let elHorzLine = graphics.drawLine(
+ w.globals.padHorizontal,
+ w.globals.gridHeight,
+ w.globals.gridWidth,
+ w.globals.gridHeight,
+ 'transparent'
+ )
+
+ elGrid.add(elHorzLine)
+ elGrid.add(elVerticalLine)
+
+ return elGrid
+ }
+
+ drawGrid() {
+ let gl = this.w.globals
+
+ let elgrid = null
+
+ if (gl.axisCharts) {
+ // grid is drawn after xaxis and yaxis are drawn
+ elgrid = this.renderGrid()
+
+ this.drawGridArea(elgrid.el)
+ }
+ return elgrid
+ }
+
+ // This mask will clip off overflowing graphics from the drawable area
+ createGridMask() {
+ let w = this.w
+ let gl = w.globals
+ const graphics = new Graphics(this.ctx)
+
+ let strokeSize = Array.isArray(w.config.stroke.width)
+ ? 0
+ : w.config.stroke.width
+
+ if (Array.isArray(w.config.stroke.width)) {
+ let strokeMaxSize = 0
+ w.config.stroke.width.forEach((m) => {
+ strokeMaxSize = Math.max(strokeMaxSize, m)
+ })
+ strokeSize = strokeMaxSize
+ }
+
+ gl.dom.elGridRectMask = document.createElementNS(gl.SVGNS, 'clipPath')
+ gl.dom.elGridRectMask.setAttribute('id', `gridRectMask${gl.cuid}`)
+
+ gl.dom.elGridRectMarkerMask = document.createElementNS(gl.SVGNS, 'clipPath')
+ gl.dom.elGridRectMarkerMask.setAttribute(
+ 'id',
+ `gridRectMarkerMask${gl.cuid}`
+ )
+
+ gl.dom.elForecastMask = document.createElementNS(gl.SVGNS, 'clipPath')
+ gl.dom.elForecastMask.setAttribute('id', `forecastMask${gl.cuid}`)
+
+ gl.dom.elNonForecastMask = document.createElementNS(gl.SVGNS, 'clipPath')
+ gl.dom.elNonForecastMask.setAttribute('id', `nonForecastMask${gl.cuid}`)
+
+ // let barHalfWidth = 0
+
+ const type = w.config.chart.type
+ const hasBar =
+ type === 'bar' ||
+ type === 'rangeBar' ||
+ type === 'candlestick' ||
+ type === 'boxPlot' ||
+ w.globals.comboBarCount > 0
+
+ let barWidthLeft = 0
+ let barWidthRight = 0
+ if (hasBar && w.globals.isXNumeric && !w.globals.isBarHorizontal) {
+ barWidthLeft = w.config.grid.padding.left
+ barWidthRight = w.config.grid.padding.right
+
+ if (gl.barPadForNumericAxis > barWidthLeft) {
+ barWidthLeft = gl.barPadForNumericAxis
+ barWidthRight = gl.barPadForNumericAxis
+ }
+ }
+ gl.dom.elGridRect = graphics.drawRect(
+ -strokeSize / 2 - barWidthLeft - 2,
+ -strokeSize / 2,
+ gl.gridWidth + strokeSize + barWidthRight + barWidthLeft + 4,
+ gl.gridHeight + strokeSize,
+ 0,
+ '#fff'
+ )
+
+ let markerSize = w.globals.markers.largestSize + 1
+
+ gl.dom.elGridRectMarker = graphics.drawRect(
+ -markerSize * 2,
+ -markerSize * 2,
+ gl.gridWidth + markerSize * 4,
+ gl.gridHeight + markerSize * 4,
+ 0,
+ '#fff'
+ )
+ gl.dom.elGridRectMask.appendChild(gl.dom.elGridRect.node)
+ gl.dom.elGridRectMarkerMask.appendChild(gl.dom.elGridRectMarker.node)
+
+ let defs = gl.dom.baseEl.querySelector('defs')
+ defs.appendChild(gl.dom.elGridRectMask)
+ defs.appendChild(gl.dom.elForecastMask)
+ defs.appendChild(gl.dom.elNonForecastMask)
+ defs.appendChild(gl.dom.elGridRectMarkerMask)
+ }
+
+ _drawGridLines({ i, x1, y1, x2, y2, xCount, parent }) {
+ const w = this.w
+
+ const shouldDraw = () => {
+ if (i === 0 && w.globals.skipFirstTimelinelabel) {
+ return false
+ }
+
+ if (
+ i === xCount - 1 &&
+ w.globals.skipLastTimelinelabel &&
+ !w.config.xaxis.labels.formatter
+ ) {
+ return false
+ }
+ if (w.config.chart.type === 'radar') {
+ return false
+ }
+ return true
+ }
+
+ if (shouldDraw()) {
+ if (w.config.grid.xaxis.lines.show) {
+ this._drawGridLine({ x1, y1, x2, y2, parent })
+ }
+ let y_2 = 0
+ if (w.globals.hasGroups && w.config.xaxis.tickPlacement === 'between') {
+ const groups = w.globals.groups
+ if (groups) {
+ let gacc = 0
+ for (let gi = 0; gacc < i && gi < groups.length; gi++) {
+ gacc += groups[gi].cols
+ }
+ if (gacc === i) {
+ y_2 = w.globals.xAxisLabelsHeight * 0.6
+ }
+ }
+ }
+
+ let xAxis = new XAxis(this.ctx)
+ xAxis.drawXaxisTicks(x1, y_2, this.elg)
+ }
+ }
+
+ _drawGridLine({ x1, y1, x2, y2, parent }) {
+ const w = this.w
+
+ const isHorzLine = parent.node.classList.contains(
+ 'apexcharts-gridlines-horizontal'
+ )
+
+ let strokeDashArray = w.config.grid.strokeDashArray
+ const offX = w.globals.barPadForNumericAxis
+
+ const graphics = new Graphics(this)
+ let line = graphics.drawLine(
+ x1 - (isHorzLine ? offX : 0),
+ y1,
+ x2 + (isHorzLine ? offX : 0),
+ y2,
+ w.config.grid.borderColor,
+ strokeDashArray
+ )
+ line.node.classList.add('apexcharts-gridline')
+ parent.add(line)
+ }
+
+ _drawGridBandRect({ c, x1, y1, x2, y2, type }) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+ const offX = w.globals.barPadForNumericAxis
+
+ if (type === 'column' && w.config.xaxis.type === 'datetime') return
+
+ const color = w.config.grid[type].colors[c]
+
+ let rect = graphics.drawRect(
+ x1 - (type === 'row' ? offX : 0),
+ y1,
+ x2 + (type === 'row' ? offX * 2 : 0),
+ y2,
+ 0,
+ color,
+ w.config.grid[type].opacity
+ )
+ this.elg.add(rect)
+ rect.attr('clip-path', `url(#gridRectMask${w.globals.cuid})`)
+ rect.node.classList.add(`apexcharts-grid-${type}`)
+ }
+
+ _drawXYLines({ xCount, tickAmount }) {
+ const w = this.w
+
+ const datetimeLines = ({ xC, x1, y1, x2, y2 }) => {
+ for (let i = 0; i < xC; i++) {
+ x1 = this.xaxisLabels[i].position
+ x2 = this.xaxisLabels[i].position
+
+ this._drawGridLines({
+ i,
+ x1,
+ y1,
+ x2,
+ y2,
+ xCount,
+ parent: this.elgridLinesV
+ })
+ }
+ }
+
+ const categoryLines = ({ xC, x1, y1, x2, y2 }) => {
+ if (
+ typeof w.config.xaxis.tickAmount !== 'undefined' &&
+ w.config.xaxis.tickAmount !== 'dataPoints' &&
+ w.config.xaxis.tickPlacement === 'on'
+ ) {
+ // user has specified tickamount in a category x-axis chart
+ const visibleLabels = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-text.apexcharts-xaxis-label tspan:not(:empty)'
+ )
+
+ visibleLabels.forEach((d, i) => {
+ const textRect = d.getBBox()
+
+ this._drawGridLines({
+ i,
+ x1: textRect.x + textRect.width / 2,
+ y1,
+ x2: textRect.x + textRect.width / 2,
+ y2,
+ xCount,
+ parent: this.elgridLinesV
+ })
+ })
+ } else {
+ for (let i = 0; i < xC + (w.globals.isXNumeric ? 0 : 1); i++) {
+ if (i === 0 && xC === 1 && w.globals.dataPoints === 1) {
+ // single datapoint
+ x1 = w.globals.gridWidth / 2
+ x2 = x1
+ }
+ this._drawGridLines({
+ i,
+ x1,
+ y1,
+ x2,
+ y2,
+ xCount,
+ parent: this.elgridLinesV
+ })
+
+ x1 = x1 + w.globals.gridWidth / (w.globals.isXNumeric ? xC - 1 : xC)
+ x2 = x1
+ }
+ }
+ }
+
+ // draw vertical lines
+ if (w.config.grid.xaxis.lines.show || w.config.xaxis.axisTicks.show) {
+ let x1 = w.globals.padHorizontal
+ let y1 = 0
+ let x2
+ let y2 = w.globals.gridHeight
+
+ if (w.globals.timescaleLabels.length) {
+ datetimeLines({ xC: xCount, x1, y1, x2, y2 })
+ } else {
+ if (w.globals.isXNumeric) {
+ xCount = w.globals.xAxisScale.result.length
+ }
+ if (w.config.xaxis.convertedCatToNumeric) {
+ // in case of a convertedCatToNumeric, some labels might be skipped due to hideOverLapping labels, hence use this var to get the visible ticks
+ xCount = w.globals.xaxisLabelsCount
+ }
+ categoryLines({ xC: xCount, x1, y1, x2, y2 })
+ }
+ }
+
+ // draw horizontal lines
+ if (w.config.grid.yaxis.lines.show) {
+ let x1 = 0
+ let y1 = 0
+ let y2 = 0
+ let x2 = w.globals.gridWidth
+ let tA = tickAmount + 1
+
+ if (this.isRangeBar) {
+ tA = w.globals.labels.length
+ }
+
+ for (let i = 0; i < tA + (this.isRangeBar ? 1 : 0); i++) {
+ this._drawGridLine({ x1, y1, x2, y2, parent: this.elgridLinesH })
+
+ y1 = y1 + w.globals.gridHeight / (this.isRangeBar ? tA : tickAmount)
+
+ y2 = y1
+ }
+ }
+ }
+
+ _drawInvertedXYLines({ xCount }) {
+ const w = this.w
+
+ // draw vertical lines
+ if (w.config.grid.xaxis.lines.show || w.config.xaxis.axisTicks.show) {
+ let x1 = w.globals.padHorizontal
+ let y1 = 0
+ let x2
+ let y2 = w.globals.gridHeight
+ for (let i = 0; i < xCount + 1; i++) {
+ if (w.config.grid.xaxis.lines.show) {
+ this._drawGridLine({ x1, y1, x2, y2, parent: this.elgridLinesV })
+ }
+
+ let xAxis = new XAxis(this.ctx)
+ xAxis.drawXaxisTicks(x1, 0, this.elg)
+ x1 = x1 + w.globals.gridWidth / xCount + 0.3
+ x2 = x1
+ }
+ }
+
+ // draw horizontal lines
+ if (w.config.grid.yaxis.lines.show) {
+ let x1 = 0
+ let y1 = 0
+ let y2 = 0
+ let x2 = w.globals.gridWidth
+
+ for (let i = 0; i < w.globals.dataPoints + 1; i++) {
+ this._drawGridLine({ x1, y1, x2, y2, parent: this.elgridLinesH })
+
+ y1 = y1 + w.globals.gridHeight / w.globals.dataPoints
+ y2 = y1
+ }
+ }
+ }
+
+ // actual grid rendering
+ renderGrid() {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ this.elg = graphics.group({
+ class: 'apexcharts-grid'
+ })
+ this.elgridLinesH = graphics.group({
+ class: 'apexcharts-gridlines-horizontal'
+ })
+ this.elgridLinesV = graphics.group({
+ class: 'apexcharts-gridlines-vertical'
+ })
+
+ this.elg.add(this.elgridLinesH)
+ this.elg.add(this.elgridLinesV)
+
+ if (!w.config.grid.show) {
+ this.elgridLinesV.hide()
+ this.elgridLinesH.hide()
+ }
+
+ let yTickAmount = w.globals.yAxisScale.length
+ ? w.globals.yAxisScale[0].result.length - 1
+ : 5
+ for (let i = 0; i < w.globals.series.length; i++) {
+ if (typeof w.globals.yAxisScale[i] !== 'undefined') {
+ yTickAmount = w.globals.yAxisScale[i].result.length - 1
+ }
+ if (yTickAmount > 2) break
+ }
+
+ let xCount
+
+ if (!w.globals.isBarHorizontal || this.isRangeBar) {
+ xCount = this.xaxisLabels.length
+
+ if (this.isRangeBar) {
+ yTickAmount = w.globals.labels.length
+ if (w.config.xaxis.tickAmount && w.config.xaxis.labels.formatter) {
+ xCount = w.config.xaxis.tickAmount
+ }
+ }
+ this._drawXYLines({ xCount, tickAmount: yTickAmount })
+ } else {
+ xCount = yTickAmount
+
+ // for horizontal bar chart, get the xaxis tickamount
+ yTickAmount = w.globals.xTickAmount
+ this._drawInvertedXYLines({ xCount, tickAmount: yTickAmount })
+ }
+
+ this.drawGridBands(xCount, yTickAmount)
+ return {
+ el: this.elg,
+ xAxisTickWidth: w.globals.gridWidth / xCount
+ }
+ }
+
+ drawGridBands(xCount, tickAmount) {
+ const w = this.w
+
+ // rows background bands
+ if (
+ w.config.grid.row.colors !== undefined &&
+ w.config.grid.row.colors.length > 0
+ ) {
+ let x1 = 0
+ let y1 = 0
+ let y2 = w.globals.gridHeight / tickAmount
+ let x2 = w.globals.gridWidth
+
+ for (let i = 0, c = 0; i < tickAmount; i++, c++) {
+ if (c >= w.config.grid.row.colors.length) {
+ c = 0
+ }
+ this._drawGridBandRect({
+ c,
+ x1,
+ y1,
+ x2,
+ y2,
+ type: 'row'
+ })
+
+ y1 = y1 + w.globals.gridHeight / tickAmount
+ }
+ }
+
+ // columns background bands
+ if (
+ w.config.grid.column.colors !== undefined &&
+ w.config.grid.column.colors.length > 0
+ ) {
+ const xc =
+ !w.globals.isBarHorizontal &&
+ (w.config.xaxis.type === 'category' ||
+ w.config.xaxis.convertedCatToNumeric)
+ ? xCount - 1
+ : xCount
+ let x1 = w.globals.padHorizontal
+ let y1 = 0
+ let x2 = w.globals.padHorizontal + w.globals.gridWidth / xc
+ let y2 = w.globals.gridHeight
+ for (let i = 0, c = 0; i < xCount; i++, c++) {
+ if (c >= w.config.grid.column.colors.length) {
+ c = 0
+ }
+ this._drawGridBandRect({
+ c,
+ x1,
+ y1,
+ x2,
+ y2,
+ type: 'column'
+ })
+
+ x1 = x1 + w.globals.gridWidth / xc
+ }
+ }
+ }
+}
+
+export default Grid
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/axes/XAxis.js b/cao_sunyata/static/libs/apexcharts/src/modules/axes/XAxis.js
new file mode 100644
index 0000000..29bef23
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/axes/XAxis.js
@@ -0,0 +1,633 @@
+import Graphics from '../Graphics'
+import AxesUtils from './AxesUtils'
+
+/**
+ * ApexCharts XAxis Class for drawing X-Axis.
+ *
+ * @module XAxis
+ **/
+
+export default class XAxis {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ const w = this.w
+ this.axesUtils = new AxesUtils(ctx)
+
+ this.xaxisLabels = w.globals.labels.slice()
+ if (w.globals.timescaleLabels.length > 0 && !w.globals.isBarHorizontal) {
+ // timeline labels are there and chart is not rangeabr timeline
+ this.xaxisLabels = w.globals.timescaleLabels.slice()
+ }
+
+ if (w.config.xaxis.overwriteCategories) {
+ this.xaxisLabels = w.config.xaxis.overwriteCategories
+ }
+ this.drawnLabels = []
+ this.drawnLabelsRects = []
+
+ if (w.config.xaxis.position === 'top') {
+ this.offY = 0
+ } else {
+ this.offY = w.globals.gridHeight + 1
+ }
+ this.offY = this.offY + w.config.xaxis.axisBorder.offsetY
+ this.isCategoryBarHorizontal =
+ w.config.chart.type === 'bar' && w.config.plotOptions.bar.horizontal
+
+ this.xaxisFontSize = w.config.xaxis.labels.style.fontSize
+ this.xaxisFontFamily = w.config.xaxis.labels.style.fontFamily
+ this.xaxisForeColors = w.config.xaxis.labels.style.colors
+ this.xaxisBorderWidth = w.config.xaxis.axisBorder.width
+ if (this.isCategoryBarHorizontal) {
+ this.xaxisBorderWidth = w.config.yaxis[0].axisBorder.width.toString()
+ }
+
+ if (this.xaxisBorderWidth.indexOf('%') > -1) {
+ this.xaxisBorderWidth =
+ (w.globals.gridWidth * parseInt(this.xaxisBorderWidth, 10)) / 100
+ } else {
+ this.xaxisBorderWidth = parseInt(this.xaxisBorderWidth, 10)
+ }
+ this.xaxisBorderHeight = w.config.xaxis.axisBorder.height
+
+ // For bars, we will only consider single y xais,
+ // as we are not providing multiple yaxis for bar charts
+ this.yaxis = w.config.yaxis[0]
+ }
+
+ drawXaxis() {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let elXaxis = graphics.group({
+ class: 'apexcharts-xaxis',
+ transform: `translate(${w.config.xaxis.offsetX}, ${w.config.xaxis.offsetY})`
+ })
+
+ let elXaxisTexts = graphics.group({
+ class: 'apexcharts-xaxis-texts-g',
+ transform: `translate(${w.globals.translateXAxisX}, ${w.globals.translateXAxisY})`
+ })
+
+ elXaxis.add(elXaxisTexts)
+
+ let labels = []
+
+ for (let i = 0; i < this.xaxisLabels.length; i++) {
+ labels.push(this.xaxisLabels[i])
+ }
+
+ this.drawXAxisLabelAndGroup(
+ true,
+ graphics,
+ elXaxisTexts,
+ labels,
+ w.globals.isXNumeric,
+ (i, colWidth) => colWidth
+ )
+
+ if (w.globals.hasGroups) {
+ let labelsGroup = w.globals.groups
+
+ labels = []
+ for (let i = 0; i < labelsGroup.length; i++) {
+ labels.push(labelsGroup[i].title)
+ }
+
+ let overwriteStyles = {}
+ if (w.config.xaxis.group.style) {
+ overwriteStyles.xaxisFontSize = w.config.xaxis.group.style.fontSize
+ overwriteStyles.xaxisFontFamily = w.config.xaxis.group.style.fontFamily
+ overwriteStyles.xaxisForeColors = w.config.xaxis.group.style.colors
+ overwriteStyles.fontWeight = w.config.xaxis.group.style.fontWeight
+ overwriteStyles.cssClass = w.config.xaxis.group.style.cssClass
+ }
+
+ this.drawXAxisLabelAndGroup(
+ false,
+ graphics,
+ elXaxisTexts,
+ labels,
+ false,
+ (i, colWidth) => labelsGroup[i].cols * colWidth,
+ overwriteStyles
+ )
+ }
+
+ if (w.config.xaxis.title.text !== undefined) {
+ let elXaxisTitle = graphics.group({
+ class: 'apexcharts-xaxis-title'
+ })
+
+ let elXAxisTitleText = graphics.drawText({
+ x: w.globals.gridWidth / 2 + w.config.xaxis.title.offsetX,
+ y:
+ this.offY +
+ parseFloat(this.xaxisFontSize) +
+ w.globals.xAxisLabelsHeight +
+ w.config.xaxis.title.offsetY,
+ text: w.config.xaxis.title.text,
+ textAnchor: 'middle',
+ fontSize: w.config.xaxis.title.style.fontSize,
+ fontFamily: w.config.xaxis.title.style.fontFamily,
+ fontWeight: w.config.xaxis.title.style.fontWeight,
+ foreColor: w.config.xaxis.title.style.color,
+ cssClass:
+ 'apexcharts-xaxis-title-text ' + w.config.xaxis.title.style.cssClass
+ })
+
+ elXaxisTitle.add(elXAxisTitleText)
+
+ elXaxis.add(elXaxisTitle)
+ }
+
+ if (w.config.xaxis.axisBorder.show) {
+ const offX = w.globals.barPadForNumericAxis
+ let elHorzLine = graphics.drawLine(
+ w.globals.padHorizontal + w.config.xaxis.axisBorder.offsetX - offX,
+ this.offY,
+ this.xaxisBorderWidth + offX,
+ this.offY,
+ w.config.xaxis.axisBorder.color,
+ 0,
+ this.xaxisBorderHeight
+ )
+
+ elXaxis.add(elHorzLine)
+ }
+
+ return elXaxis
+ }
+
+ drawXAxisLabelAndGroup(
+ isLeafGroup,
+ graphics,
+ elXaxisTexts,
+ labels,
+ isXNumeric,
+ colWidthCb,
+ overwriteStyles = {}
+ ) {
+ let drawnLabels = []
+ let drawnLabelsRects = []
+ let w = this.w
+
+ const xaxisFontSize = overwriteStyles.xaxisFontSize || this.xaxisFontSize
+ const xaxisFontFamily =
+ overwriteStyles.xaxisFontFamily || this.xaxisFontFamily
+ const xaxisForeColors =
+ overwriteStyles.xaxisForeColors || this.xaxisForeColors
+ const fontWeight =
+ overwriteStyles.fontWeight || w.config.xaxis.labels.style.fontWeight
+ const cssClass =
+ overwriteStyles.cssClass || w.config.xaxis.labels.style.cssClass
+
+ let colWidth
+
+ // initial x Position (keep adding column width in the loop)
+ let xPos = w.globals.padHorizontal
+
+ let labelsLen = labels.length
+
+ /**
+ * labelsLen can be different (whether you are drawing x-axis labels or x-axis group labels)
+ * hence, we introduce dataPoints to be consistent.
+ * Also, in datetime/numeric xaxis, dataPoints can be misleading, so we resort to labelsLen for such xaxis type
+ */
+ let dataPoints =
+ w.config.xaxis.type === 'category' ? w.globals.dataPoints : labelsLen
+
+ if (isXNumeric) {
+ let len = dataPoints > 1 ? dataPoints - 1 : dataPoints
+ colWidth = w.globals.gridWidth / len
+ xPos = xPos + colWidthCb(0, colWidth) / 2 + w.config.xaxis.labels.offsetX
+ } else {
+ colWidth = w.globals.gridWidth / dataPoints
+ xPos = xPos + colWidthCb(0, colWidth) + w.config.xaxis.labels.offsetX
+ }
+
+ for (let i = 0; i <= labelsLen - 1; i++) {
+ let x = xPos - colWidthCb(i, colWidth) / 2 + w.config.xaxis.labels.offsetX
+
+ if (
+ i === 0 &&
+ labelsLen === 1 &&
+ colWidth / 2 === xPos &&
+ dataPoints === 1
+ ) {
+ // single datapoint
+ x = w.globals.gridWidth / 2
+ }
+ let label = this.axesUtils.getLabel(
+ labels,
+ w.globals.timescaleLabels,
+ x,
+ i,
+ drawnLabels,
+ xaxisFontSize,
+ isLeafGroup
+ )
+
+ let offsetYCorrection = 28
+ if (w.globals.rotateXLabels && isLeafGroup) {
+ offsetYCorrection = 22
+ }
+
+ if (!isLeafGroup) {
+ offsetYCorrection =
+ offsetYCorrection +
+ parseFloat(xaxisFontSize) +
+ (w.globals.xAxisLabelsHeight - w.globals.xAxisGroupLabelsHeight) +
+ (w.globals.rotateXLabels ? 10 : 0)
+ }
+
+ const isCategoryTickAmounts =
+ typeof w.config.xaxis.tickAmount !== 'undefined' &&
+ w.config.xaxis.tickAmount !== 'dataPoints' &&
+ w.config.xaxis.type !== 'datetime'
+
+ if (isCategoryTickAmounts) {
+ label = this.axesUtils.checkLabelBasedOnTickamount(i, label, labelsLen)
+ } else {
+ label = this.axesUtils.checkForOverflowingLabels(
+ i,
+ label,
+ labelsLen,
+ drawnLabels,
+ drawnLabelsRects
+ )
+ }
+
+ const getCatForeColor = () => {
+ return isLeafGroup && w.config.xaxis.convertedCatToNumeric
+ ? xaxisForeColors[w.globals.minX + i - 1]
+ : xaxisForeColors[i]
+ }
+
+ if (isLeafGroup && label.text) {
+ w.globals.xaxisLabelsCount++
+ }
+
+ if (w.config.xaxis.labels.show) {
+ let elText = graphics.drawText({
+ x: label.x,
+ y:
+ this.offY +
+ w.config.xaxis.labels.offsetY +
+ offsetYCorrection -
+ (w.config.xaxis.position === 'top'
+ ? w.globals.xAxisHeight + w.config.xaxis.axisTicks.height - 2
+ : 0),
+ text: label.text,
+ textAnchor: 'middle',
+ fontWeight: label.isBold ? 600 : fontWeight,
+ fontSize: xaxisFontSize,
+ fontFamily: xaxisFontFamily,
+ foreColor: Array.isArray(xaxisForeColors)
+ ? getCatForeColor()
+ : xaxisForeColors,
+ isPlainText: false,
+ cssClass:
+ (isLeafGroup
+ ? 'apexcharts-xaxis-label '
+ : 'apexcharts-xaxis-group-label ') + cssClass
+ })
+ elXaxisTexts.add(elText)
+
+ if (isLeafGroup) {
+ let elTooltipTitle = document.createElementNS(
+ w.globals.SVGNS,
+ 'title'
+ )
+ elTooltipTitle.textContent = Array.isArray(label.text)
+ ? label.text.join(' ')
+ : label.text
+ elText.node.appendChild(elTooltipTitle)
+ if (label.text !== '') {
+ drawnLabels.push(label.text)
+ drawnLabelsRects.push(label)
+ }
+ }
+ }
+ if (i < labelsLen - 1) {
+ xPos = xPos + colWidthCb(i + 1, colWidth)
+ }
+ }
+ }
+
+ // this actually becomes the vertical axis (for bar charts)
+ drawXaxisInversed(realIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let translateYAxisX = w.config.yaxis[0].opposite
+ ? w.globals.translateYAxisX[realIndex]
+ : 0
+
+ let elYaxis = graphics.group({
+ class: 'apexcharts-yaxis apexcharts-xaxis-inversed',
+ rel: realIndex
+ })
+
+ let elYaxisTexts = graphics.group({
+ class: 'apexcharts-yaxis-texts-g apexcharts-xaxis-inversed-texts-g',
+ transform: 'translate(' + translateYAxisX + ', 0)'
+ })
+
+ elYaxis.add(elYaxisTexts)
+
+ let colHeight
+
+ // initial x Position (keep adding column width in the loop)
+ let yPos
+ let labels = []
+
+ if (w.config.yaxis[realIndex].show) {
+ for (let i = 0; i < this.xaxisLabels.length; i++) {
+ labels.push(this.xaxisLabels[i])
+ }
+ }
+
+ colHeight = w.globals.gridHeight / labels.length
+ yPos = -(colHeight / 2.2)
+
+ let lbFormatter = w.globals.yLabelFormatters[0]
+
+ const ylabels = w.config.yaxis[0].labels
+
+ if (ylabels.show) {
+ for (let i = 0; i <= labels.length - 1; i++) {
+ let label = typeof labels[i] === 'undefined' ? '' : labels[i]
+
+ label = lbFormatter(label, {
+ seriesIndex: realIndex,
+ dataPointIndex: i,
+ w
+ })
+
+ const yColors = this.axesUtils.getYAxisForeColor(
+ ylabels.style.colors,
+ realIndex
+ )
+ const getForeColor = () => {
+ return Array.isArray(yColors) ? yColors[i] : yColors
+ }
+
+ let multiY = 0
+ if (Array.isArray(label)) {
+ multiY = (label.length / 2) * parseInt(ylabels.style.fontSize, 10)
+ }
+ let elLabel = graphics.drawText({
+ x: ylabels.offsetX - 15,
+ y: yPos + colHeight + ylabels.offsetY - multiY,
+ text: label,
+ textAnchor: this.yaxis.opposite ? 'start' : 'end',
+ foreColor: getForeColor(),
+ fontSize: ylabels.style.fontSize,
+ fontFamily: ylabels.style.fontFamily,
+ fontWeight: ylabels.style.fontWeight,
+ isPlainText: false,
+ cssClass: 'apexcharts-yaxis-label ' + ylabels.style.cssClass
+ })
+
+ elYaxisTexts.add(elLabel)
+
+ let elTooltipTitle = document.createElementNS(w.globals.SVGNS, 'title')
+ elTooltipTitle.textContent = Array.isArray(label)
+ ? label.join(' ')
+ : label
+ elLabel.node.appendChild(elTooltipTitle)
+
+ if (w.config.yaxis[realIndex].labels.rotate !== 0) {
+ let labelRotatingCenter = graphics.rotateAroundCenter(elLabel.node)
+ elLabel.node.setAttribute(
+ 'transform',
+ `rotate(${w.config.yaxis[realIndex].labels.rotate} 0 ${labelRotatingCenter.y})`
+ )
+ }
+ yPos = yPos + colHeight
+ }
+ }
+
+ if (w.config.yaxis[0].title.text !== undefined) {
+ let elXaxisTitle = graphics.group({
+ class: 'apexcharts-yaxis-title apexcharts-xaxis-title-inversed',
+ transform: 'translate(' + translateYAxisX + ', 0)'
+ })
+
+ let elXAxisTitleText = graphics.drawText({
+ x: 0,
+ y: w.globals.gridHeight / 2,
+ text: w.config.yaxis[0].title.text,
+ textAnchor: 'middle',
+ foreColor: w.config.yaxis[0].title.style.color,
+ fontSize: w.config.yaxis[0].title.style.fontSize,
+ fontWeight: w.config.yaxis[0].title.style.fontWeight,
+ fontFamily: w.config.yaxis[0].title.style.fontFamily,
+ cssClass:
+ 'apexcharts-yaxis-title-text ' +
+ w.config.yaxis[0].title.style.cssClass
+ })
+
+ elXaxisTitle.add(elXAxisTitleText)
+
+ elYaxis.add(elXaxisTitle)
+ }
+
+ let offX = 0
+ if (this.isCategoryBarHorizontal && w.config.yaxis[0].opposite) {
+ offX = w.globals.gridWidth
+ }
+ const axisBorder = w.config.xaxis.axisBorder
+ if (axisBorder.show) {
+ let elVerticalLine = graphics.drawLine(
+ w.globals.padHorizontal + axisBorder.offsetX + offX,
+ 1 + axisBorder.offsetY,
+ w.globals.padHorizontal + axisBorder.offsetX + offX,
+ w.globals.gridHeight + axisBorder.offsetY,
+ axisBorder.color,
+ 0
+ )
+
+ elYaxis.add(elVerticalLine)
+ }
+
+ if (w.config.yaxis[0].axisTicks.show) {
+ this.axesUtils.drawYAxisTicks(
+ offX,
+ labels.length,
+ w.config.yaxis[0].axisBorder,
+ w.config.yaxis[0].axisTicks,
+ 0,
+ colHeight,
+ elYaxis
+ )
+ }
+
+ return elYaxis
+ }
+
+ drawXaxisTicks(x1, y2, appendToElement) {
+ let w = this.w
+ let x2 = x1
+
+ if (x1 < 0 || x1 - 2 > w.globals.gridWidth) return
+
+ let y1 = this.offY + w.config.xaxis.axisTicks.offsetY
+ y2 = y2 + y1 + w.config.xaxis.axisTicks.height
+ if (w.config.xaxis.position === 'top') {
+ y2 = y1 - w.config.xaxis.axisTicks.height
+ }
+
+ if (w.config.xaxis.axisTicks.show) {
+ let graphics = new Graphics(this.ctx)
+
+ let line = graphics.drawLine(
+ x1 + w.config.xaxis.axisTicks.offsetX,
+ y1 + w.config.xaxis.offsetY,
+ x2 + w.config.xaxis.axisTicks.offsetX,
+ y2 + w.config.xaxis.offsetY,
+ w.config.xaxis.axisTicks.color
+ )
+
+ // we are not returning anything, but appending directly to the element passed in param
+ appendToElement.add(line)
+ line.node.classList.add('apexcharts-xaxis-tick')
+ }
+ }
+
+ getXAxisTicksPositions() {
+ const w = this.w
+ let xAxisTicksPositions = []
+
+ const xCount = this.xaxisLabels.length
+ let x1 = w.globals.padHorizontal
+
+ if (w.globals.timescaleLabels.length > 0) {
+ for (let i = 0; i < xCount; i++) {
+ x1 = this.xaxisLabels[i].position
+ xAxisTicksPositions.push(x1)
+ }
+ } else {
+ let xCountForCategoryCharts = xCount
+ for (let i = 0; i < xCountForCategoryCharts; i++) {
+ let x1Count = xCountForCategoryCharts
+ if (w.globals.isXNumeric && w.config.chart.type !== 'bar') {
+ x1Count -= 1
+ }
+ x1 = x1 + w.globals.gridWidth / x1Count
+ xAxisTicksPositions.push(x1)
+ }
+ }
+
+ return xAxisTicksPositions
+ }
+
+ // to rotate x-axis labels or to put ... for longer text in xaxis
+ xAxisLabelCorrections() {
+ let w = this.w
+
+ let graphics = new Graphics(this.ctx)
+
+ let xAxis = w.globals.dom.baseEl.querySelector('.apexcharts-xaxis-texts-g')
+
+ let xAxisTexts = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-xaxis-texts-g text:not(.apexcharts-xaxis-group-label)'
+ )
+ let yAxisTextsInversed = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-yaxis-inversed text'
+ )
+ let xAxisTextsInversed = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-xaxis-inversed-texts-g text tspan'
+ )
+
+ if (w.globals.rotateXLabels || w.config.xaxis.labels.rotateAlways) {
+ for (let xat = 0; xat < xAxisTexts.length; xat++) {
+ let textRotatingCenter = graphics.rotateAroundCenter(xAxisTexts[xat])
+ textRotatingCenter.y = textRotatingCenter.y - 1 // + tickWidth/4;
+ textRotatingCenter.x = textRotatingCenter.x + 1
+
+ xAxisTexts[xat].setAttribute(
+ 'transform',
+ `rotate(${w.config.xaxis.labels.rotate} ${textRotatingCenter.x} ${textRotatingCenter.y})`
+ )
+
+ xAxisTexts[xat].setAttribute('text-anchor', `end`)
+
+ let offsetHeight = 10
+
+ xAxis.setAttribute('transform', `translate(0, ${-offsetHeight})`)
+
+ let tSpan = xAxisTexts[xat].childNodes
+
+ if (w.config.xaxis.labels.trim) {
+ Array.prototype.forEach.call(tSpan, (ts) => {
+ graphics.placeTextWithEllipsis(
+ ts,
+ ts.textContent,
+ w.globals.xAxisLabelsHeight -
+ (w.config.legend.position === 'bottom' ? 20 : 10)
+ )
+ })
+ }
+ }
+ } else {
+ let width = w.globals.gridWidth / (w.globals.labels.length + 1)
+
+ for (let xat = 0; xat < xAxisTexts.length; xat++) {
+ let tSpan = xAxisTexts[xat].childNodes
+
+ if (w.config.xaxis.labels.trim && w.config.xaxis.type !== 'datetime') {
+ Array.prototype.forEach.call(tSpan, (ts) => {
+ graphics.placeTextWithEllipsis(ts, ts.textContent, width)
+ })
+ }
+ }
+ }
+
+ if (yAxisTextsInversed.length > 0) {
+ // truncate rotated y axis in bar chart (x axis)
+ let firstLabelPosX = yAxisTextsInversed[
+ yAxisTextsInversed.length - 1
+ ].getBBox()
+ let lastLabelPosX = yAxisTextsInversed[0].getBBox()
+
+ if (firstLabelPosX.x < -20) {
+ yAxisTextsInversed[
+ yAxisTextsInversed.length - 1
+ ].parentNode.removeChild(
+ yAxisTextsInversed[yAxisTextsInversed.length - 1]
+ )
+ }
+
+ if (
+ lastLabelPosX.x + lastLabelPosX.width > w.globals.gridWidth &&
+ !w.globals.isBarHorizontal
+ ) {
+ yAxisTextsInversed[0].parentNode.removeChild(yAxisTextsInversed[0])
+ }
+
+ // truncate rotated x axis in bar chart (y axis)
+ for (let xat = 0; xat < xAxisTextsInversed.length; xat++) {
+ graphics.placeTextWithEllipsis(
+ xAxisTextsInversed[xat],
+ xAxisTextsInversed[xat].textContent,
+ w.config.yaxis[0].labels.maxWidth -
+ (w.config.yaxis[0].title.text
+ ? parseFloat(w.config.yaxis[0].title.style.fontSize) * 2
+ : 0) -
+ 15
+ )
+ }
+ }
+ }
+
+ // renderXAxisBands() {
+ // let w = this.w;
+
+ // let plotBand = document.createElementNS(w.globals.SVGNS, 'rect')
+ // w.globals.dom.elGraphical.add(plotBand)
+ // }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/axes/YAxis.js b/cao_sunyata/static/libs/apexcharts/src/modules/axes/YAxis.js
new file mode 100644
index 0000000..d8effd2
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/axes/YAxis.js
@@ -0,0 +1,558 @@
+import Graphics from '../Graphics'
+import Utils from '../../utils/Utils'
+import AxesUtils from './AxesUtils'
+
+/**
+ * ApexCharts YAxis Class for drawing Y-Axis.
+ *
+ * @module YAxis
+ **/
+
+export default class YAxis {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ const w = this.w
+
+ this.xaxisFontSize = w.config.xaxis.labels.style.fontSize
+ this.axisFontFamily = w.config.xaxis.labels.style.fontFamily
+
+ this.xaxisForeColors = w.config.xaxis.labels.style.colors
+ this.isCategoryBarHorizontal =
+ w.config.chart.type === 'bar' && w.config.plotOptions.bar.horizontal
+
+ this.xAxisoffX = 0
+ if (w.config.xaxis.position === 'bottom') {
+ this.xAxisoffX = w.globals.gridHeight
+ }
+ this.drawnLabels = []
+ this.axesUtils = new AxesUtils(ctx)
+ }
+
+ drawYaxis(realIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ const yaxisStyle = w.config.yaxis[realIndex].labels.style
+ let yaxisFontSize = yaxisStyle.fontSize
+ let yaxisFontFamily = yaxisStyle.fontFamily
+ let yaxisFontWeight = yaxisStyle.fontWeight
+
+ let elYaxis = graphics.group({
+ class: 'apexcharts-yaxis',
+ rel: realIndex,
+ transform: 'translate(' + w.globals.translateYAxisX[realIndex] + ', 0)'
+ })
+
+ if (this.axesUtils.isYAxisHidden(realIndex)) {
+ return elYaxis
+ }
+
+ let elYaxisTexts = graphics.group({
+ class: 'apexcharts-yaxis-texts-g'
+ })
+
+ elYaxis.add(elYaxisTexts)
+
+ let tickAmount = w.globals.yAxisScale[realIndex].result.length - 1
+
+ // labelsDivider is simply svg height/number of ticks
+ let labelsDivider = w.globals.gridHeight / tickAmount
+
+ // initial label position = 0;
+ let l = w.globals.translateY
+ let lbFormatter = w.globals.yLabelFormatters[realIndex]
+
+ let labels = w.globals.yAxisScale[realIndex].result.slice()
+
+ labels = this.axesUtils.checkForReversedLabels(realIndex, labels)
+
+ let firstLabel = ''
+ if (w.config.yaxis[realIndex].labels.show) {
+ for (let i = tickAmount; i >= 0; i--) {
+ let val = labels[i]
+
+ val = lbFormatter(val, i, w)
+
+ let xPad = w.config.yaxis[realIndex].labels.padding
+ if (w.config.yaxis[realIndex].opposite && w.config.yaxis.length !== 0) {
+ xPad = xPad * -1
+ }
+
+ const yColors = this.axesUtils.getYAxisForeColor(
+ yaxisStyle.colors,
+ realIndex
+ )
+ const getForeColor = () => {
+ return Array.isArray(yColors) ? yColors[i] : yColors
+ }
+
+ let label = graphics.drawText({
+ x: xPad,
+ y: l + tickAmount / 10 + w.config.yaxis[realIndex].labels.offsetY + 1,
+ text: val,
+ textAnchor: w.config.yaxis[realIndex].opposite ? 'start' : 'end',
+ fontSize: yaxisFontSize,
+ fontFamily: yaxisFontFamily,
+ fontWeight: yaxisFontWeight,
+ maxWidth: w.config.yaxis[realIndex].labels.maxWidth,
+ foreColor: getForeColor(),
+ isPlainText: false,
+ cssClass: 'apexcharts-yaxis-label ' + yaxisStyle.cssClass
+ })
+ if (i === tickAmount) {
+ firstLabel = label
+ }
+ elYaxisTexts.add(label)
+
+ let elTooltipTitle = document.createElementNS(w.globals.SVGNS, 'title')
+ elTooltipTitle.textContent = Array.isArray(val) ? val.join(' ') : val
+ label.node.appendChild(elTooltipTitle)
+
+ if (w.config.yaxis[realIndex].labels.rotate !== 0) {
+ let firstabelRotatingCenter = graphics.rotateAroundCenter(
+ firstLabel.node
+ )
+ let labelRotatingCenter = graphics.rotateAroundCenter(label.node)
+ label.node.setAttribute(
+ 'transform',
+ `rotate(${w.config.yaxis[realIndex].labels.rotate} ${firstabelRotatingCenter.x} ${labelRotatingCenter.y})`
+ )
+ }
+ l = l + labelsDivider
+ }
+ }
+
+ if (w.config.yaxis[realIndex].title.text !== undefined) {
+ let elYaxisTitle = graphics.group({
+ class: 'apexcharts-yaxis-title'
+ })
+
+ let x = 0
+ if (w.config.yaxis[realIndex].opposite) {
+ x = w.globals.translateYAxisX[realIndex]
+ }
+ let elYAxisTitleText = graphics.drawText({
+ x,
+ y:
+ w.globals.gridHeight / 2 +
+ w.globals.translateY +
+ w.config.yaxis[realIndex].title.offsetY,
+ text: w.config.yaxis[realIndex].title.text,
+ textAnchor: 'end',
+ foreColor: w.config.yaxis[realIndex].title.style.color,
+ fontSize: w.config.yaxis[realIndex].title.style.fontSize,
+ fontWeight: w.config.yaxis[realIndex].title.style.fontWeight,
+ fontFamily: w.config.yaxis[realIndex].title.style.fontFamily,
+ cssClass:
+ 'apexcharts-yaxis-title-text ' +
+ w.config.yaxis[realIndex].title.style.cssClass
+ })
+
+ elYaxisTitle.add(elYAxisTitleText)
+
+ elYaxis.add(elYaxisTitle)
+ }
+
+ let axisBorder = w.config.yaxis[realIndex].axisBorder
+
+ let x = 31 + axisBorder.offsetX
+ if (w.config.yaxis[realIndex].opposite) {
+ x = -31 - axisBorder.offsetX
+ }
+
+ if (axisBorder.show) {
+ let elVerticalLine = graphics.drawLine(
+ x,
+ w.globals.translateY + axisBorder.offsetY - 2,
+ x,
+ w.globals.gridHeight + w.globals.translateY + axisBorder.offsetY + 2,
+ axisBorder.color,
+ 0,
+ axisBorder.width
+ )
+
+ elYaxis.add(elVerticalLine)
+ }
+ if (w.config.yaxis[realIndex].axisTicks.show) {
+ this.axesUtils.drawYAxisTicks(
+ x,
+ tickAmount,
+ axisBorder,
+ w.config.yaxis[realIndex].axisTicks,
+ realIndex,
+ labelsDivider,
+ elYaxis
+ )
+ }
+
+ return elYaxis
+ }
+
+ // This actually becomes horizontal axis (for bar charts)
+ drawYaxisInversed(realIndex) {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let elXaxis = graphics.group({
+ class: 'apexcharts-xaxis apexcharts-yaxis-inversed'
+ })
+
+ let elXaxisTexts = graphics.group({
+ class: 'apexcharts-xaxis-texts-g',
+ transform: `translate(${w.globals.translateXAxisX}, ${w.globals.translateXAxisY})`
+ })
+
+ elXaxis.add(elXaxisTexts)
+
+ let tickAmount = w.globals.yAxisScale[realIndex].result.length - 1
+
+ // labelsDivider is simply svg width/number of ticks
+ let labelsDivider = w.globals.gridWidth / tickAmount + 0.1
+
+ // initial label position;
+ let l = labelsDivider + w.config.xaxis.labels.offsetX
+
+ let lbFormatter = w.globals.xLabelFormatter
+
+ let labels = w.globals.yAxisScale[realIndex].result.slice()
+
+ let timescaleLabels = w.globals.timescaleLabels
+ if (timescaleLabels.length > 0) {
+ this.xaxisLabels = timescaleLabels.slice()
+ labels = timescaleLabels.slice()
+ tickAmount = labels.length
+ }
+
+ labels = this.axesUtils.checkForReversedLabels(realIndex, labels)
+
+ const tl = timescaleLabels.length
+
+ if (w.config.xaxis.labels.show) {
+ for (let i = tl ? 0 : tickAmount; tl ? i < tl : i >= 0; tl ? i++ : i--) {
+ let val = labels[i]
+ val = lbFormatter(val, i, w)
+
+ let x =
+ w.globals.gridWidth +
+ w.globals.padHorizontal -
+ (l - labelsDivider + w.config.xaxis.labels.offsetX)
+
+ if (timescaleLabels.length) {
+ let label = this.axesUtils.getLabel(
+ labels,
+ timescaleLabels,
+ x,
+ i,
+ this.drawnLabels,
+ this.xaxisFontSize
+ )
+ x = label.x
+ val = label.text
+ this.drawnLabels.push(label.text)
+
+ if (i === 0 && w.globals.skipFirstTimelinelabel) {
+ val = ''
+ }
+ if (i === labels.length - 1 && w.globals.skipLastTimelinelabel) {
+ val = ''
+ }
+ }
+ let elTick = graphics.drawText({
+ x,
+ y:
+ this.xAxisoffX +
+ w.config.xaxis.labels.offsetY +
+ 30 -
+ (w.config.xaxis.position === 'top'
+ ? w.globals.xAxisHeight + w.config.xaxis.axisTicks.height - 2
+ : 0),
+ text: val,
+ textAnchor: 'middle',
+ foreColor: Array.isArray(this.xaxisForeColors)
+ ? this.xaxisForeColors[realIndex]
+ : this.xaxisForeColors,
+ fontSize: this.xaxisFontSize,
+ fontFamily: this.xaxisFontFamily,
+ fontWeight: w.config.xaxis.labels.style.fontWeight,
+ isPlainText: false,
+ cssClass:
+ 'apexcharts-xaxis-label ' + w.config.xaxis.labels.style.cssClass
+ })
+
+ elXaxisTexts.add(elTick)
+
+ elTick.tspan(val)
+
+ let elTooltipTitle = document.createElementNS(w.globals.SVGNS, 'title')
+ elTooltipTitle.textContent = val
+ elTick.node.appendChild(elTooltipTitle)
+
+ l = l + labelsDivider
+ }
+ }
+
+ this.inversedYAxisTitleText(elXaxis)
+ this.inversedYAxisBorder(elXaxis)
+
+ return elXaxis
+ }
+
+ inversedYAxisBorder(parent) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+
+ let axisBorder = w.config.xaxis.axisBorder
+ if (axisBorder.show) {
+ let lineCorrection = 0
+ if (w.config.chart.type === 'bar' && w.globals.isXNumeric) {
+ lineCorrection = lineCorrection - 15
+ }
+ let elHorzLine = graphics.drawLine(
+ w.globals.padHorizontal + lineCorrection + axisBorder.offsetX,
+ this.xAxisoffX,
+ w.globals.gridWidth,
+ this.xAxisoffX,
+ axisBorder.color,
+ 0,
+ axisBorder.height
+ )
+
+ parent.add(elHorzLine)
+ }
+ }
+
+ inversedYAxisTitleText(parent) {
+ const w = this.w
+ const graphics = new Graphics(this.ctx)
+ if (w.config.xaxis.title.text !== undefined) {
+ let elYaxisTitle = graphics.group({
+ class: 'apexcharts-xaxis-title apexcharts-yaxis-title-inversed'
+ })
+
+ let elYAxisTitleText = graphics.drawText({
+ x: w.globals.gridWidth / 2 + w.config.xaxis.title.offsetX,
+ y:
+ this.xAxisoffX +
+ parseFloat(this.xaxisFontSize) +
+ parseFloat(w.config.xaxis.title.style.fontSize) +
+ w.config.xaxis.title.offsetY +
+ 20,
+ text: w.config.xaxis.title.text,
+ textAnchor: 'middle',
+ fontSize: w.config.xaxis.title.style.fontSize,
+ fontFamily: w.config.xaxis.title.style.fontFamily,
+ fontWeight: w.config.xaxis.title.style.fontWeight,
+ foreColor: w.config.xaxis.title.style.color,
+ cssClass:
+ 'apexcharts-xaxis-title-text ' + w.config.xaxis.title.style.cssClass
+ })
+
+ elYaxisTitle.add(elYAxisTitleText)
+
+ parent.add(elYaxisTitle)
+ }
+ }
+
+ yAxisTitleRotate(realIndex, yAxisOpposite) {
+ let w = this.w
+
+ let graphics = new Graphics(this.ctx)
+
+ let yAxisLabelsCoord = {
+ width: 0,
+ height: 0
+ }
+ let yAxisTitleCoord = {
+ width: 0,
+ height: 0
+ }
+
+ let elYAxisLabelsWrap = w.globals.dom.baseEl.querySelector(
+ ` .apexcharts-yaxis[rel='${realIndex}'] .apexcharts-yaxis-texts-g`
+ )
+
+ if (elYAxisLabelsWrap !== null) {
+ yAxisLabelsCoord = elYAxisLabelsWrap.getBoundingClientRect()
+ }
+
+ let yAxisTitle = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-yaxis[rel='${realIndex}'] .apexcharts-yaxis-title text`
+ )
+
+ if (yAxisTitle !== null) {
+ yAxisTitleCoord = yAxisTitle.getBoundingClientRect()
+ }
+
+ if (yAxisTitle !== null) {
+ let x = this.xPaddingForYAxisTitle(
+ realIndex,
+ yAxisLabelsCoord,
+ yAxisTitleCoord,
+ yAxisOpposite
+ )
+
+ yAxisTitle.setAttribute('x', x.xPos - (yAxisOpposite ? 10 : 0))
+ }
+
+ if (yAxisTitle !== null) {
+ let titleRotatingCenter = graphics.rotateAroundCenter(yAxisTitle)
+ yAxisTitle.setAttribute(
+ 'transform',
+ `rotate(${
+ yAxisOpposite
+ ? w.config.yaxis[realIndex].title.rotate * -1
+ : w.config.yaxis[realIndex].title.rotate
+ } ${titleRotatingCenter.x} ${titleRotatingCenter.y})`
+ )
+ }
+ }
+
+ xPaddingForYAxisTitle(
+ realIndex,
+ yAxisLabelsCoord,
+ yAxisTitleCoord,
+ yAxisOpposite
+ ) {
+ let w = this.w
+ let oppositeAxisCount = 0
+
+ let x = 0
+ let padd = 10
+
+ if (w.config.yaxis[realIndex].title.text === undefined || realIndex < 0) {
+ return {
+ xPos: x,
+ padd: 0
+ }
+ }
+
+ if (yAxisOpposite) {
+ x =
+ yAxisLabelsCoord.width +
+ w.config.yaxis[realIndex].title.offsetX +
+ yAxisTitleCoord.width / 2 +
+ padd / 2
+
+ oppositeAxisCount += 1
+
+ if (oppositeAxisCount === 0) {
+ x = x - padd / 2
+ }
+ } else {
+ x =
+ yAxisLabelsCoord.width * -1 +
+ w.config.yaxis[realIndex].title.offsetX +
+ padd / 2 +
+ yAxisTitleCoord.width / 2
+
+ if (w.globals.isBarHorizontal) {
+ padd = 25
+ x =
+ yAxisLabelsCoord.width * -1 -
+ w.config.yaxis[realIndex].title.offsetX -
+ padd
+ }
+ }
+
+ return {
+ xPos: x,
+ padd
+ }
+ }
+
+ // sets the x position of the y-axis by counting the labels width, title width and any offset
+ setYAxisXPosition(yaxisLabelCoords, yTitleCoords) {
+ let w = this.w
+
+ let xLeft = 0
+ let xRight = 0
+ let leftOffsetX = 18
+ let rightOffsetX = 1
+
+ if (w.config.yaxis.length > 1) {
+ this.multipleYs = true
+ }
+
+ w.config.yaxis.map((yaxe, index) => {
+ let shouldNotDrawAxis =
+ w.globals.ignoreYAxisIndexes.indexOf(index) > -1 ||
+ !yaxe.show ||
+ yaxe.floating ||
+ yaxisLabelCoords[index].width === 0
+
+ let axisWidth = yaxisLabelCoords[index].width + yTitleCoords[index].width
+
+ if (!yaxe.opposite) {
+ xLeft = w.globals.translateX - leftOffsetX
+
+ if (!shouldNotDrawAxis) {
+ leftOffsetX = leftOffsetX + axisWidth + 20
+ }
+
+ w.globals.translateYAxisX[index] = xLeft + yaxe.labels.offsetX
+ } else {
+ if (w.globals.isBarHorizontal) {
+ xRight = w.globals.gridWidth + w.globals.translateX - 1
+
+ w.globals.translateYAxisX[index] = xRight - yaxe.labels.offsetX
+ } else {
+ xRight = w.globals.gridWidth + w.globals.translateX + rightOffsetX
+
+ if (!shouldNotDrawAxis) {
+ rightOffsetX = rightOffsetX + axisWidth + 20
+ }
+
+ w.globals.translateYAxisX[index] = xRight - yaxe.labels.offsetX + 20
+ }
+ }
+ })
+ }
+
+ setYAxisTextAlignments() {
+ const w = this.w
+
+ let yaxis = w.globals.dom.baseEl.getElementsByClassName(`apexcharts-yaxis`)
+ yaxis = Utils.listToArray(yaxis)
+ yaxis.forEach((y, index) => {
+ const yaxe = w.config.yaxis[index]
+ // proceed only if user has specified alignment
+ if (yaxe && yaxe.labels.align !== undefined) {
+ const yAxisInner = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-yaxis[rel='${index}'] .apexcharts-yaxis-texts-g`
+ )
+ let yAxisTexts = w.globals.dom.baseEl.querySelectorAll(
+ `.apexcharts-yaxis[rel='${index}'] .apexcharts-yaxis-label`
+ )
+
+ yAxisTexts = Utils.listToArray(yAxisTexts)
+
+ const rect = yAxisInner.getBoundingClientRect()
+
+ if (yaxe.labels.align === 'left') {
+ yAxisTexts.forEach((label, lI) => {
+ label.setAttribute('text-anchor', 'start')
+ })
+ if (!yaxe.opposite) {
+ yAxisInner.setAttribute('transform', `translate(-${rect.width}, 0)`)
+ }
+ } else if (yaxe.labels.align === 'center') {
+ yAxisTexts.forEach((label, lI) => {
+ label.setAttribute('text-anchor', 'middle')
+ })
+ yAxisInner.setAttribute(
+ 'transform',
+ `translate(${(rect.width / 2) * (!yaxe.opposite ? -1 : 1)}, 0)`
+ )
+ } else if (yaxe.labels.align === 'right') {
+ yAxisTexts.forEach((label, lI) => {
+ label.setAttribute('text-anchor', 'end')
+ })
+ if (yaxe.opposite) {
+ yAxisInner.setAttribute('transform', `translate(${rect.width}, 0)`)
+ }
+ }
+ }
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Dimensions.js b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Dimensions.js
new file mode 100644
index 0000000..8e6eab9
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Dimensions.js
@@ -0,0 +1,336 @@
+import YAxis from '../axes/YAxis'
+import Helpers from './Helpers'
+import DimXAxis from './XAxis'
+import DimYAxis from './YAxis'
+import Grid from './Grid'
+
+/**
+ * ApexCharts Dimensions Class for calculating rects of all elements that are drawn and will be drawn.
+ *
+ * @module Dimensions
+ **/
+
+export default class Dimensions {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ this.lgRect = {}
+ this.yAxisWidth = 0
+ this.yAxisWidthLeft = 0
+ this.yAxisWidthRight = 0
+ this.xAxisHeight = 0
+ this.isSparkline = this.w.config.chart.sparkline.enabled
+
+ this.dimHelpers = new Helpers(this)
+ this.dimYAxis = new DimYAxis(this)
+ this.dimXAxis = new DimXAxis(this)
+ this.dimGrid = new Grid(this)
+ this.lgWidthForSideLegends = 0
+ this.gridPad = this.w.config.grid.padding
+ this.xPadRight = 0
+ this.xPadLeft = 0
+ }
+
+ /**
+ * @memberof Dimensions
+ * @param {object} w - chart context
+ **/
+ plotCoords() {
+ let w = this.w
+ let gl = w.globals
+
+ this.lgRect = this.dimHelpers.getLegendsRect()
+
+ if (
+ this.isSparkline &&
+ (w.config.markers.discrete.length > 0 || w.config.markers.size > 0)
+ ) {
+ Object.entries(this.gridPad).forEach(([k, v]) => {
+ this.gridPad[k] = Math.max(v, this.w.globals.markers.largestSize / 1.5)
+ })
+ }
+
+ if (gl.axisCharts) {
+ // for line / area / scatter / column
+ this.setDimensionsForAxisCharts()
+ } else {
+ // for pie / donuts / circle
+ this.setDimensionsForNonAxisCharts()
+ }
+
+ this.dimGrid.gridPadFortitleSubtitle()
+
+ // after calculating everything, apply padding set by user
+ gl.gridHeight = gl.gridHeight - this.gridPad.top - this.gridPad.bottom
+
+ gl.gridWidth =
+ gl.gridWidth -
+ this.gridPad.left -
+ this.gridPad.right -
+ this.xPadRight -
+ this.xPadLeft
+
+ let barWidth = this.dimGrid.gridPadForColumnsInNumericAxis(gl.gridWidth)
+
+ gl.gridWidth = gl.gridWidth - barWidth * 2
+
+ gl.translateX =
+ gl.translateX +
+ this.gridPad.left +
+ this.xPadLeft +
+ (barWidth > 0 ? barWidth + 4 : 0)
+ gl.translateY = gl.translateY + this.gridPad.top
+ }
+
+ setDimensionsForAxisCharts() {
+ let w = this.w
+ let gl = w.globals
+
+ let yaxisLabelCoords = this.dimYAxis.getyAxisLabelsCoords()
+ let yTitleCoords = this.dimYAxis.getyAxisTitleCoords()
+
+ w.globals.yLabelsCoords = []
+ w.globals.yTitleCoords = []
+ w.config.yaxis.map((yaxe, index) => {
+ // store the labels and titles coords in global vars
+ w.globals.yLabelsCoords.push({
+ width: yaxisLabelCoords[index].width,
+ index
+ })
+ w.globals.yTitleCoords.push({
+ width: yTitleCoords[index].width,
+ index
+ })
+ })
+
+ this.yAxisWidth = this.dimYAxis.getTotalYAxisWidth()
+
+ let xaxisLabelCoords = this.dimXAxis.getxAxisLabelsCoords()
+ let xaxisGroupLabelCoords = this.dimXAxis.getxAxisGroupLabelsCoords()
+ let xtitleCoords = this.dimXAxis.getxAxisTitleCoords()
+
+ this.conditionalChecksForAxisCoords(
+ xaxisLabelCoords,
+ xtitleCoords,
+ xaxisGroupLabelCoords
+ )
+
+ gl.translateXAxisY = w.globals.rotateXLabels ? this.xAxisHeight / 8 : -4
+ gl.translateXAxisX =
+ w.globals.rotateXLabels &&
+ w.globals.isXNumeric &&
+ w.config.xaxis.labels.rotate <= -45
+ ? -this.xAxisWidth / 4
+ : 0
+
+ if (w.globals.isBarHorizontal) {
+ gl.rotateXLabels = false
+ gl.translateXAxisY =
+ -1 * (parseInt(w.config.xaxis.labels.style.fontSize, 10) / 1.5)
+ }
+
+ gl.translateXAxisY = gl.translateXAxisY + w.config.xaxis.labels.offsetY
+ gl.translateXAxisX = gl.translateXAxisX + w.config.xaxis.labels.offsetX
+
+ let yAxisWidth = this.yAxisWidth
+ let xAxisHeight = this.xAxisHeight
+ gl.xAxisLabelsHeight = this.xAxisHeight - xtitleCoords.height
+ gl.xAxisGroupLabelsHeight = gl.xAxisLabelsHeight - xaxisLabelCoords.height
+ gl.xAxisLabelsWidth = this.xAxisWidth
+ gl.xAxisHeight = this.xAxisHeight
+ let translateY = 10
+
+ if (w.config.chart.type === 'radar' || this.isSparkline) {
+ yAxisWidth = 0
+ xAxisHeight = gl.goldenPadding
+ }
+
+ if (this.isSparkline) {
+ this.lgRect = {
+ height: 0,
+ width: 0
+ }
+ }
+
+ if (this.isSparkline || w.config.chart.type === 'treemap') {
+ yAxisWidth = 0
+ xAxisHeight = 0
+ translateY = 0
+ }
+
+ if (!this.isSparkline) {
+ this.dimXAxis.additionalPaddingXLabels(xaxisLabelCoords)
+ }
+
+ const legendTopBottom = () => {
+ gl.translateX = yAxisWidth
+ gl.gridHeight =
+ gl.svgHeight -
+ this.lgRect.height -
+ xAxisHeight -
+ (!this.isSparkline && w.config.chart.type !== 'treemap'
+ ? w.globals.rotateXLabels
+ ? 10
+ : 15
+ : 0)
+ gl.gridWidth = gl.svgWidth - yAxisWidth
+ }
+
+ if (w.config.xaxis.position === 'top')
+ translateY = gl.xAxisHeight - w.config.xaxis.axisTicks.height - 5
+
+ switch (w.config.legend.position) {
+ case 'bottom':
+ gl.translateY = translateY
+ legendTopBottom()
+ break
+ case 'top':
+ gl.translateY = this.lgRect.height + translateY
+ legendTopBottom()
+ break
+ case 'left':
+ gl.translateY = translateY
+ gl.translateX = this.lgRect.width + yAxisWidth
+ gl.gridHeight = gl.svgHeight - xAxisHeight - 12
+ gl.gridWidth = gl.svgWidth - this.lgRect.width - yAxisWidth
+ break
+ case 'right':
+ gl.translateY = translateY
+ gl.translateX = yAxisWidth
+ gl.gridHeight = gl.svgHeight - xAxisHeight - 12
+ gl.gridWidth = gl.svgWidth - this.lgRect.width - yAxisWidth - 5
+ break
+ default:
+ throw new Error('Legend position not supported')
+ }
+
+ this.dimGrid.setGridXPosForDualYAxis(yTitleCoords, yaxisLabelCoords)
+
+ // after drawing everything, set the Y axis positions
+ let objyAxis = new YAxis(this.ctx)
+ objyAxis.setYAxisXPosition(yaxisLabelCoords, yTitleCoords)
+ }
+
+ setDimensionsForNonAxisCharts() {
+ let w = this.w
+ let gl = w.globals
+ let cnf = w.config
+ let xPad = 0
+
+ if (w.config.legend.show && !w.config.legend.floating) {
+ xPad = 20
+ }
+
+ const type =
+ cnf.chart.type === 'pie' ||
+ cnf.chart.type === 'polarArea' ||
+ cnf.chart.type === 'donut'
+ ? 'pie'
+ : 'radialBar'
+
+ let offY = cnf.plotOptions[type].offsetY
+ let offX = cnf.plotOptions[type].offsetX
+
+ if (!cnf.legend.show || cnf.legend.floating) {
+ gl.gridHeight =
+ gl.svgHeight - cnf.grid.padding.left + cnf.grid.padding.right
+ gl.gridWidth = gl.gridHeight
+
+ gl.translateY = offY
+ gl.translateX = offX + (gl.svgWidth - gl.gridWidth) / 2
+
+ return
+ }
+
+ switch (cnf.legend.position) {
+ case 'bottom':
+ gl.gridHeight = gl.svgHeight - this.lgRect.height - gl.goldenPadding
+ gl.gridWidth = gl.svgWidth
+ gl.translateY = offY - 10
+ gl.translateX = offX + (gl.svgWidth - gl.gridWidth) / 2
+ break
+ case 'top':
+ gl.gridHeight = gl.svgHeight - this.lgRect.height - gl.goldenPadding
+ gl.gridWidth = gl.svgWidth
+ gl.translateY = this.lgRect.height + offY + 10
+ gl.translateX = offX + (gl.svgWidth - gl.gridWidth) / 2
+ break
+ case 'left':
+ gl.gridWidth = gl.svgWidth - this.lgRect.width - xPad
+ gl.gridHeight =
+ cnf.chart.height !== 'auto' ? gl.svgHeight : gl.gridWidth
+ gl.translateY = offY
+ gl.translateX = offX + this.lgRect.width + xPad
+ break
+ case 'right':
+ gl.gridWidth = gl.svgWidth - this.lgRect.width - xPad - 5
+ gl.gridHeight =
+ cnf.chart.height !== 'auto' ? gl.svgHeight : gl.gridWidth
+ gl.translateY = offY
+ gl.translateX = offX + 10
+ break
+ default:
+ throw new Error('Legend position not supported')
+ }
+ }
+
+ conditionalChecksForAxisCoords(
+ xaxisLabelCoords,
+ xtitleCoords,
+ xaxisGroupLabelCoords
+ ) {
+ const w = this.w
+
+ const xAxisNum = w.globals.hasGroups ? 2 : 1
+
+ const baseXAxisHeight =
+ xaxisGroupLabelCoords.height +
+ xaxisLabelCoords.height +
+ xtitleCoords.height
+ const xAxisHeightMultiplicate = w.globals.isMultiLineX
+ ? 1.2
+ : w.globals.LINE_HEIGHT_RATIO
+ const rotatedXAxisOffset = w.globals.rotateXLabels ? 22 : 10
+ const rotatedXAxisLegendOffset =
+ w.globals.rotateXLabels && w.config.legend.position === 'bottom'
+ const additionalOffset = rotatedXAxisLegendOffset ? 10 : 0
+
+ this.xAxisHeight =
+ baseXAxisHeight * xAxisHeightMultiplicate +
+ xAxisNum * rotatedXAxisOffset +
+ additionalOffset
+
+ this.xAxisWidth = xaxisLabelCoords.width
+
+ if (
+ this.xAxisHeight - xtitleCoords.height >
+ w.config.xaxis.labels.maxHeight
+ ) {
+ this.xAxisHeight = w.config.xaxis.labels.maxHeight
+ }
+
+ if (
+ w.config.xaxis.labels.minHeight &&
+ this.xAxisHeight < w.config.xaxis.labels.minHeight
+ ) {
+ this.xAxisHeight = w.config.xaxis.labels.minHeight
+ }
+
+ if (w.config.xaxis.floating) {
+ this.xAxisHeight = 0
+ }
+
+ let minYAxisWidth = 0
+ let maxYAxisWidth = 0
+ w.config.yaxis.forEach((y) => {
+ minYAxisWidth += y.labels.minWidth
+ maxYAxisWidth += y.labels.maxWidth
+ })
+ if (this.yAxisWidth < minYAxisWidth) {
+ this.yAxisWidth = minYAxisWidth
+ }
+ if (this.yAxisWidth > maxYAxisWidth) {
+ this.yAxisWidth = maxYAxisWidth
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Grid.js b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Grid.js
new file mode 100644
index 0000000..0dcb808
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Grid.js
@@ -0,0 +1,151 @@
+import AxesUtils from '../axes/AxesUtils'
+
+export default class DimGrid {
+ constructor(dCtx) {
+ this.w = dCtx.w
+ this.dCtx = dCtx
+ }
+
+ gridPadForColumnsInNumericAxis(gridWidth) {
+ const w = this.w
+
+ if (w.globals.noData || w.globals.allSeriesCollapsed) {
+ return 0
+ }
+
+ const hasBar = (type) => {
+ return (
+ type === 'bar' ||
+ type === 'rangeBar' ||
+ type === 'candlestick' ||
+ type === 'boxPlot'
+ )
+ }
+
+ const type = w.config.chart.type
+
+ let barWidth = 0
+ let seriesLen = hasBar(type) ? w.config.series.length : 1
+
+ if (w.globals.comboBarCount > 0) {
+ seriesLen = w.globals.comboBarCount
+ }
+ w.globals.collapsedSeries.forEach((c) => {
+ if (hasBar(c.type)) {
+ seriesLen = seriesLen - 1
+ }
+ })
+ if (w.config.chart.stacked) {
+ seriesLen = 1
+ }
+
+ const barsPresent = hasBar(type) || w.globals.comboBarCount > 0
+
+ if (
+ barsPresent &&
+ w.globals.isXNumeric &&
+ !w.globals.isBarHorizontal &&
+ seriesLen > 0
+ ) {
+ let xRatio = 0
+ let xRange = Math.abs(w.globals.initialMaxX - w.globals.initialMinX)
+
+ if (xRange <= 3) {
+ xRange = w.globals.dataPoints
+ }
+
+ xRatio = xRange / gridWidth
+
+ let xDivision
+ // max barwidth should be equal to minXDiff to avoid overlap
+ if (w.globals.minXDiff && w.globals.minXDiff / xRatio > 0) {
+ xDivision = w.globals.minXDiff / xRatio
+ }
+
+ if (xDivision > gridWidth / 2) {
+ xDivision = xDivision / 2
+ }
+ barWidth =
+ ((xDivision / seriesLen) *
+ parseInt(w.config.plotOptions.bar.columnWidth, 10)) /
+ 100
+
+ if (barWidth < 1) {
+ barWidth = 1
+ }
+
+ barWidth = barWidth / (seriesLen > 1 ? 1 : 1.5) + 5
+
+ w.globals.barPadForNumericAxis = barWidth
+ }
+ return barWidth
+ }
+
+ gridPadFortitleSubtitle() {
+ const w = this.w
+ const gl = w.globals
+ let gridShrinkOffset =
+ this.dCtx.isSparkline || !w.globals.axisCharts ? 0 : 10
+
+ const titleSubtitle = ['title', 'subtitle']
+
+ titleSubtitle.forEach((t) => {
+ if (w.config[t].text !== undefined) {
+ gridShrinkOffset += w.config[t].margin
+ } else {
+ gridShrinkOffset +=
+ this.dCtx.isSparkline || !w.globals.axisCharts ? 0 : 5
+ }
+ })
+
+ if (
+ w.config.legend.show &&
+ w.config.legend.position === 'bottom' &&
+ !w.config.legend.floating &&
+ !w.globals.axisCharts
+ ) {
+ gridShrinkOffset += 10
+ }
+
+ let titleCoords = this.dCtx.dimHelpers.getTitleSubtitleCoords('title')
+ let subtitleCoords = this.dCtx.dimHelpers.getTitleSubtitleCoords('subtitle')
+
+ gl.gridHeight =
+ gl.gridHeight -
+ titleCoords.height -
+ subtitleCoords.height -
+ gridShrinkOffset
+
+ gl.translateY =
+ gl.translateY +
+ titleCoords.height +
+ subtitleCoords.height +
+ gridShrinkOffset
+ }
+
+ setGridXPosForDualYAxis(yTitleCoords, yaxisLabelCoords) {
+ let w = this.w
+ const axesUtils = new AxesUtils(this.dCtx.ctx)
+
+ w.config.yaxis.map((yaxe, index) => {
+ if (
+ w.globals.ignoreYAxisIndexes.indexOf(index) === -1 &&
+ !yaxe.floating &&
+ !axesUtils.isYAxisHidden(index)
+ ) {
+ if (yaxe.opposite) {
+ w.globals.translateX =
+ w.globals.translateX -
+ (yaxisLabelCoords[index].width + yTitleCoords[index].width) -
+ parseInt(w.config.yaxis[index].labels.style.fontSize, 10) / 1.2 -
+ 12
+ }
+
+ // fixes apexcharts.js#1599
+ if (w.globals.translateX < 2) {
+ w.globals.translateX = 2
+ }
+ }
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Helpers.js
new file mode 100644
index 0000000..0404bf5
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/Helpers.js
@@ -0,0 +1,100 @@
+import Utils from '../../utils/Utils'
+
+export default class Helpers {
+ constructor(dCtx) {
+ this.w = dCtx.w
+ this.dCtx = dCtx
+ }
+
+ /**
+ * Get Chart Title/Subtitle Dimensions
+ * @memberof Dimensions
+ * @return {{width, height}}
+ **/
+ getTitleSubtitleCoords(type) {
+ let w = this.w
+ let width = 0
+ let height = 0
+
+ const floating =
+ type === 'title' ? w.config.title.floating : w.config.subtitle.floating
+
+ let el = w.globals.dom.baseEl.querySelector(`.apexcharts-${type}-text`)
+
+ if (el !== null && !floating) {
+ let coord = el.getBoundingClientRect()
+ width = coord.width
+ height = w.globals.axisCharts ? coord.height + 5 : coord.height
+ }
+
+ return {
+ width,
+ height
+ }
+ }
+
+ getLegendsRect() {
+ let w = this.w
+
+ let elLegendWrap = w.globals.dom.baseEl.querySelector('.apexcharts-legend')
+
+ if (
+ !w.config.legend.height &&
+ (w.config.legend.position === 'top' ||
+ w.config.legend.position === 'bottom')
+ ) {
+ // avoid legend to take up all the space
+ elLegendWrap.style.maxHeight = w.globals.svgHeight / 2 + 'px'
+ }
+
+ let lgRect = Object.assign({}, Utils.getBoundingClientRect(elLegendWrap))
+
+ if (
+ elLegendWrap !== null &&
+ !w.config.legend.floating &&
+ w.config.legend.show
+ ) {
+ this.dCtx.lgRect = {
+ x: lgRect.x,
+ y: lgRect.y,
+ height: lgRect.height,
+ width: lgRect.height === 0 ? 0 : lgRect.width
+ }
+ } else {
+ this.dCtx.lgRect = {
+ x: 0,
+ y: 0,
+ height: 0,
+ width: 0
+ }
+ }
+
+ // if legend takes up all of the chart space, we need to restrict it.
+ if (
+ w.config.legend.position === 'left' ||
+ w.config.legend.position === 'right'
+ ) {
+ if (this.dCtx.lgRect.width * 1.5 > w.globals.svgWidth) {
+ this.dCtx.lgRect.width = w.globals.svgWidth / 1.5
+ }
+ }
+
+ return this.dCtx.lgRect
+ }
+
+ getLargestStringFromMultiArr(val, arr) {
+ const w = this.w
+ let valArr = val
+ if (w.globals.isMultiLineX) {
+ // if the xaxis labels has multiline texts (array)
+ let maxArrs = arr.map((xl, idx) => {
+ return Array.isArray(xl) ? xl.length : 1
+ })
+ let maxArrLen = Math.max(...maxArrs)
+ let maxArrIndex = maxArrs.indexOf(maxArrLen)
+ valArr = arr[maxArrIndex]
+ }
+
+ return valArr
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/XAxis.js b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/XAxis.js
new file mode 100644
index 0000000..c247910
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/XAxis.js
@@ -0,0 +1,385 @@
+import Formatters from '../Formatters'
+import Graphics from '../Graphics'
+import Utils from '../../utils/Utils'
+import DateTime from '../../utils/DateTime'
+
+export default class DimXAxis {
+ constructor(dCtx) {
+ this.w = dCtx.w
+ this.dCtx = dCtx
+ }
+
+ /**
+ * Get X Axis Dimensions
+ * @memberof Dimensions
+ * @return {{width, height}}
+ **/
+ getxAxisLabelsCoords() {
+ let w = this.w
+
+ let xaxisLabels = w.globals.labels.slice()
+ if (w.config.xaxis.convertedCatToNumeric && xaxisLabels.length === 0) {
+ xaxisLabels = w.globals.categoryLabels
+ }
+
+ let rect
+
+ if (w.globals.timescaleLabels.length > 0) {
+ const coords = this.getxAxisTimeScaleLabelsCoords()
+ rect = {
+ width: coords.width,
+ height: coords.height
+ }
+ w.globals.rotateXLabels = false
+ } else {
+ this.dCtx.lgWidthForSideLegends =
+ (w.config.legend.position === 'left' ||
+ w.config.legend.position === 'right') &&
+ !w.config.legend.floating
+ ? this.dCtx.lgRect.width
+ : 0
+
+ // get the longest string from the labels array and also apply label formatter
+ let xlbFormatter = w.globals.xLabelFormatter
+ // prevent changing xaxisLabels to avoid issues in multi-yaxes - fix #522
+ let val = Utils.getLargestStringFromArr(xaxisLabels)
+ let valArr = this.dCtx.dimHelpers.getLargestStringFromMultiArr(
+ val,
+ xaxisLabels
+ )
+
+ // the labels gets changed for bar charts
+ if (w.globals.isBarHorizontal) {
+ val = w.globals.yAxisScale[0].result.reduce(
+ (a, b) => (a.length > b.length ? a : b),
+ 0
+ )
+ valArr = val
+ }
+
+ let xFormat = new Formatters(this.dCtx.ctx)
+ let timestamp = val
+ val = xFormat.xLabelFormat(xlbFormatter, val, timestamp, {
+ i: undefined,
+ dateFormatter: new DateTime(this.dCtx.ctx).formatDate,
+ w
+ })
+ valArr = xFormat.xLabelFormat(xlbFormatter, valArr, timestamp, {
+ i: undefined,
+ dateFormatter: new DateTime(this.dCtx.ctx).formatDate,
+ w
+ })
+
+ if (
+ (w.config.xaxis.convertedCatToNumeric && typeof val === 'undefined') ||
+ String(val).trim() === ''
+ ) {
+ val = '1'
+ valArr = val
+ }
+
+ let graphics = new Graphics(this.dCtx.ctx)
+ let xLabelrect = graphics.getTextRects(
+ val,
+ w.config.xaxis.labels.style.fontSize
+ )
+ let xArrLabelrect = xLabelrect
+ if (val !== valArr) {
+ xArrLabelrect = graphics.getTextRects(
+ valArr,
+ w.config.xaxis.labels.style.fontSize
+ )
+ }
+
+ rect = {
+ width:
+ xLabelrect.width >= xArrLabelrect.width
+ ? xLabelrect.width
+ : xArrLabelrect.width,
+ height:
+ xLabelrect.height >= xArrLabelrect.height
+ ? xLabelrect.height
+ : xArrLabelrect.height
+ }
+
+ if (
+ (rect.width * xaxisLabels.length >
+ w.globals.svgWidth -
+ this.dCtx.lgWidthForSideLegends -
+ this.dCtx.yAxisWidth -
+ this.dCtx.gridPad.left -
+ this.dCtx.gridPad.right &&
+ w.config.xaxis.labels.rotate !== 0) ||
+ w.config.xaxis.labels.rotateAlways
+ ) {
+ if (!w.globals.isBarHorizontal) {
+ w.globals.rotateXLabels = true
+ const getRotatedTextRects = (text) => {
+ return graphics.getTextRects(
+ text,
+ w.config.xaxis.labels.style.fontSize,
+ w.config.xaxis.labels.style.fontFamily,
+ `rotate(${w.config.xaxis.labels.rotate} 0 0)`,
+ false
+ )
+ }
+ xLabelrect = getRotatedTextRects(val)
+ if (val !== valArr) {
+ xArrLabelrect = getRotatedTextRects(valArr)
+ }
+
+ rect.height =
+ (xLabelrect.height > xArrLabelrect.height
+ ? xLabelrect.height
+ : xArrLabelrect.height) / 1.5
+ rect.width =
+ xLabelrect.width > xArrLabelrect.width
+ ? xLabelrect.width
+ : xArrLabelrect.width
+ }
+ } else {
+ w.globals.rotateXLabels = false
+ }
+ }
+
+ if (!w.config.xaxis.labels.show) {
+ rect = {
+ width: 0,
+ height: 0
+ }
+ }
+
+ return {
+ width: rect.width,
+ height: rect.height
+ }
+ }
+
+ /**
+ * Get X Axis Label Group height
+ * @memberof Dimensions
+ * @return {{width, height}}
+ */
+ getxAxisGroupLabelsCoords() {
+ let w = this.w
+
+ if (!w.globals.hasGroups) {
+ return { width: 0, height: 0 }
+ }
+
+ const fontSize =
+ w.config.xaxis.group.style?.fontSize ||
+ w.config.xaxis.labels.style.fontSize
+
+ let xaxisLabels = w.globals.groups.map((g) => g.title)
+
+ let rect
+
+ // prevent changing xaxisLabels to avoid issues in multi-yaxes - fix #522
+ let val = Utils.getLargestStringFromArr(xaxisLabels)
+ let valArr = this.dCtx.dimHelpers.getLargestStringFromMultiArr(
+ val,
+ xaxisLabels
+ )
+
+ let graphics = new Graphics(this.dCtx.ctx)
+ let xLabelrect = graphics.getTextRects(val, fontSize)
+ let xArrLabelrect = xLabelrect
+ if (val !== valArr) {
+ xArrLabelrect = graphics.getTextRects(valArr, fontSize)
+ }
+
+ rect = {
+ width:
+ xLabelrect.width >= xArrLabelrect.width
+ ? xLabelrect.width
+ : xArrLabelrect.width,
+ height:
+ xLabelrect.height >= xArrLabelrect.height
+ ? xLabelrect.height
+ : xArrLabelrect.height
+ }
+
+ if (!w.config.xaxis.labels.show) {
+ rect = {
+ width: 0,
+ height: 0
+ }
+ }
+
+ return {
+ width: rect.width,
+ height: rect.height
+ }
+ }
+
+ /**
+ * Get X Axis Title Dimensions
+ * @memberof Dimensions
+ * @return {{width, height}}
+ **/
+ getxAxisTitleCoords() {
+ let w = this.w
+ let width = 0
+ let height = 0
+
+ if (w.config.xaxis.title.text !== undefined) {
+ let graphics = new Graphics(this.dCtx.ctx)
+
+ let rect = graphics.getTextRects(
+ w.config.xaxis.title.text,
+ w.config.xaxis.title.style.fontSize
+ )
+
+ width = rect.width
+ height = rect.height
+ }
+
+ return {
+ width,
+ height
+ }
+ }
+
+ getxAxisTimeScaleLabelsCoords() {
+ let w = this.w
+ let rect
+
+ this.dCtx.timescaleLabels = w.globals.timescaleLabels.slice()
+
+ let labels = this.dCtx.timescaleLabels.map((label) => label.value)
+
+ // get the longest string from the labels array and also apply label formatter to it
+ let val = labels.reduce((a, b) => {
+ // if undefined, maybe user didn't pass the datetime(x) values
+ if (typeof a === 'undefined') {
+ console.error(
+ 'You have possibly supplied invalid Date format. Please supply a valid JavaScript Date'
+ )
+ return 0
+ } else {
+ return a.length > b.length ? a : b
+ }
+ }, 0)
+
+ let graphics = new Graphics(this.dCtx.ctx)
+ rect = graphics.getTextRects(val, w.config.xaxis.labels.style.fontSize)
+
+ let totalWidthRotated = rect.width * 1.05 * labels.length
+
+ if (
+ totalWidthRotated > w.globals.gridWidth &&
+ w.config.xaxis.labels.rotate !== 0
+ ) {
+ w.globals.overlappingXLabels = true
+ }
+
+ return rect
+ }
+
+ // In certain cases, the last labels gets cropped in xaxis.
+ // Hence, we add some additional padding based on the label length to avoid the last label being cropped or we don't draw it at all
+ additionalPaddingXLabels(xaxisLabelCoords) {
+ const w = this.w
+ const gl = w.globals
+ const cnf = w.config
+ const xtype = cnf.xaxis.type
+
+ let lbWidth = xaxisLabelCoords.width
+
+ gl.skipLastTimelinelabel = false
+ gl.skipFirstTimelinelabel = false
+ const isBarOpposite =
+ w.config.yaxis[0].opposite && w.globals.isBarHorizontal
+
+ const isCollapsed = (i) => gl.collapsedSeriesIndices.indexOf(i) !== -1
+
+ const rightPad = (yaxe) => {
+ if (this.dCtx.timescaleLabels && this.dCtx.timescaleLabels.length) {
+ // for timeline labels, we take the last label and check if it exceeds gridWidth
+ const firstimescaleLabel = this.dCtx.timescaleLabels[0]
+ const lastTimescaleLabel = this.dCtx.timescaleLabels[
+ this.dCtx.timescaleLabels.length - 1
+ ]
+
+ const lastLabelPosition =
+ lastTimescaleLabel.position +
+ lbWidth / 1.75 -
+ this.dCtx.yAxisWidthRight
+
+ const firstLabelPosition =
+ firstimescaleLabel.position -
+ lbWidth / 1.75 +
+ this.dCtx.yAxisWidthLeft
+
+ let lgRightRectWidth =
+ w.config.legend.position === 'right' && this.dCtx.lgRect.width > 0
+ ? this.dCtx.lgRect.width
+ : 0
+ if (
+ lastLabelPosition >
+ gl.svgWidth - gl.translateX - lgRightRectWidth
+ ) {
+ gl.skipLastTimelinelabel = true
+ }
+
+ if (
+ firstLabelPosition <
+ -((!yaxe.show || yaxe.floating) &&
+ (cnf.chart.type === 'bar' ||
+ cnf.chart.type === 'candlestick' ||
+ cnf.chart.type === 'rangeBar' ||
+ cnf.chart.type === 'boxPlot')
+ ? lbWidth / 1.75
+ : 10)
+ ) {
+ gl.skipFirstTimelinelabel = true
+ }
+ } else if (xtype === 'datetime') {
+ // If user has enabled DateTime, but uses own's formatter
+ if (this.dCtx.gridPad.right < lbWidth && !gl.rotateXLabels) {
+ gl.skipLastTimelinelabel = true
+ }
+ } else if (xtype !== 'datetime') {
+ if (
+ this.dCtx.gridPad.right < lbWidth / 2 - this.dCtx.yAxisWidthRight &&
+ !gl.rotateXLabels &&
+ !w.config.xaxis.labels.trim &&
+ (w.config.xaxis.tickPlacement !== 'between' ||
+ w.globals.isBarHorizontal)
+ ) {
+ this.dCtx.xPadRight = lbWidth / 2 + 1
+ }
+ }
+ }
+
+ const padYAxe = (yaxe, i) => {
+ if (isCollapsed(i)) return
+
+ // the code below causes issue apexcharts.js#1989
+ // after testing with other use-cases, this has no actual value, hence commented
+ // if (xtype !== 'datetime') {
+ // if (
+ // this.dCtx.gridPad.left < lbWidth / 2 - this.dCtx.yAxisWidthLeft &&
+ // !gl.rotateXLabels &&
+ // !cnf.xaxis.labels.trim
+ // ) {
+ // this.dCtx.xPadLeft = lbWidth / 2 + 1
+ // }
+ // }
+
+ rightPad(yaxe)
+ }
+
+ cnf.yaxis.forEach((yaxe, i) => {
+ if (isBarOpposite) {
+ if (this.dCtx.gridPad.left < lbWidth) {
+ this.dCtx.xPadLeft = lbWidth / 2 + 1
+ }
+ this.dCtx.xPadRight = lbWidth / 2 + 1
+ } else {
+ padYAxe(yaxe, i)
+ }
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/YAxis.js b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/YAxis.js
new file mode 100644
index 0000000..8adf715
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/dimensions/YAxis.js
@@ -0,0 +1,205 @@
+import Graphics from '../Graphics'
+import Utils from '../../utils/Utils'
+import AxesUtils from '../axes/AxesUtils'
+
+export default class DimYAxis {
+ constructor(dCtx) {
+ this.w = dCtx.w
+ this.dCtx = dCtx
+ }
+
+ /**
+ * Get Y Axis Dimensions
+ * @memberof Dimensions
+ * @return {{width, height}}
+ **/
+ getyAxisLabelsCoords() {
+ let w = this.w
+
+ let width = 0
+ let height = 0
+ let ret = []
+ let labelPad = 10
+ const axesUtils = new AxesUtils(this.dCtx.ctx)
+
+ w.config.yaxis.map((yaxe, index) => {
+ const yS = w.globals.yAxisScale[index]
+ let yAxisMinWidth = 0
+ if (
+ !axesUtils.isYAxisHidden(index) &&
+ yaxe.labels.show &&
+ yaxe.labels.minWidth !== undefined
+ )
+ yAxisMinWidth = yaxe.labels.minWidth
+
+ if (
+ !axesUtils.isYAxisHidden(index) &&
+ yaxe.labels.show &&
+ yS.result.length
+ ) {
+ let lbFormatter = w.globals.yLabelFormatters[index]
+ let minV = yS.niceMin === Number.MIN_VALUE ? 0 : yS.niceMin
+ const longestStr =
+ String(minV).length > String(yS.niceMax).length ? minV : yS.niceMax
+
+ // the second parameter -1 is the index of tick which user can use in the formatter
+ let val = lbFormatter(longestStr, {
+ seriesIndex: index,
+ dataPointIndex: -1,
+ w
+ })
+ let valArr = val
+
+ // if user has specified a custom formatter, and the result is null or empty, we need to discard the formatter and take the value as it is.
+ if (typeof val === 'undefined' || val.length === 0) {
+ val = longestStr
+ }
+
+ if (w.globals.isBarHorizontal) {
+ labelPad = 0
+
+ let barYaxisLabels = w.globals.labels.slice()
+
+ // get the longest string from the labels array and also apply label formatter to it
+ val = Utils.getLargestStringFromArr(barYaxisLabels)
+
+ val = lbFormatter(val, { seriesIndex: index, dataPointIndex: -1, w })
+ valArr = this.dCtx.dimHelpers.getLargestStringFromMultiArr(
+ val,
+ barYaxisLabels
+ )
+ }
+
+ let graphics = new Graphics(this.dCtx.ctx)
+
+ let rotateStr = 'rotate('.concat(yaxe.labels.rotate, ' 0 0)')
+ let rect = graphics.getTextRects(
+ val,
+ yaxe.labels.style.fontSize,
+ yaxe.labels.style.fontFamily,
+ rotateStr,
+ false
+ )
+
+ let arrLabelrect = rect
+
+ if (val !== valArr) {
+ arrLabelrect = graphics.getTextRects(
+ valArr,
+ yaxe.labels.style.fontSize,
+ yaxe.labels.style.fontFamily,
+ rotateStr,
+ false
+ )
+ }
+
+ ret.push({
+ width:
+ (yAxisMinWidth > arrLabelrect.width || yAxisMinWidth > rect.width
+ ? yAxisMinWidth
+ : arrLabelrect.width > rect.width
+ ? arrLabelrect.width
+ : rect.width) + labelPad,
+ height:
+ arrLabelrect.height > rect.height
+ ? arrLabelrect.height
+ : rect.height
+ })
+ } else {
+ ret.push({
+ width,
+ height
+ })
+ }
+ })
+
+ return ret
+ }
+
+ /**
+ * Get Y Axis Dimensions
+ * @memberof Dimensions
+ * @return {{width, height}}
+ **/
+ getyAxisTitleCoords() {
+ let w = this.w
+ let ret = []
+
+ w.config.yaxis.map((yaxe, index) => {
+ if (yaxe.show && yaxe.title.text !== undefined) {
+ let graphics = new Graphics(this.dCtx.ctx)
+ let rotateStr = 'rotate('.concat(yaxe.title.rotate, ' 0 0)')
+ let rect = graphics.getTextRects(
+ yaxe.title.text,
+ yaxe.title.style.fontSize,
+ yaxe.title.style.fontFamily,
+ rotateStr,
+ false
+ )
+
+ ret.push({
+ width: rect.width,
+ height: rect.height
+ })
+ } else {
+ ret.push({
+ width: 0,
+ height: 0
+ })
+ }
+ })
+
+ return ret
+ }
+
+ getTotalYAxisWidth() {
+ let w = this.w
+ let yAxisWidth = 0
+ let yAxisWidthLeft = 0
+ let yAxisWidthRight = 0
+ let padding = w.globals.yAxisScale.length > 1 ? 10 : 0
+ const axesUtils = new AxesUtils(this.dCtx.ctx)
+
+ const isHiddenYAxis = function(index) {
+ return w.globals.ignoreYAxisIndexes.indexOf(index) > -1
+ }
+
+ const padForLabelTitle = (coord, index) => {
+ let floating = w.config.yaxis[index].floating
+ let width = 0
+
+ if (coord.width > 0 && !floating) {
+ width = coord.width + padding
+ if (isHiddenYAxis(index)) {
+ width = width - coord.width - padding
+ }
+ } else {
+ width = floating || axesUtils.isYAxisHidden(index) ? 0 : 5
+ }
+
+ w.config.yaxis[index].opposite
+ ? (yAxisWidthRight = yAxisWidthRight + width)
+ : (yAxisWidthLeft = yAxisWidthLeft + width)
+
+ yAxisWidth = yAxisWidth + width
+ }
+
+ w.globals.yLabelsCoords.map((yLabelCoord, index) => {
+ padForLabelTitle(yLabelCoord, index)
+ })
+
+ w.globals.yTitleCoords.map((yTitleCoord, index) => {
+ padForLabelTitle(yTitleCoord, index)
+ })
+
+ if (w.globals.isBarHorizontal && !w.config.yaxis[0].floating) {
+ yAxisWidth =
+ w.globals.yLabelsCoords[0].width + w.globals.yTitleCoords[0].width + 15
+ }
+
+ this.dCtx.yAxisWidthLeft = yAxisWidthLeft
+ this.dCtx.yAxisWidthRight = yAxisWidthRight
+
+ return yAxisWidth
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Destroy.js b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Destroy.js
new file mode 100644
index 0000000..578e3ce
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Destroy.js
@@ -0,0 +1,88 @@
+export default class Destroy {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ clear({ isUpdating }) {
+ if (this.ctx.zoomPanSelection) {
+ this.ctx.zoomPanSelection.destroy()
+ }
+ if (this.ctx.toolbar) {
+ this.ctx.toolbar.destroy()
+ }
+
+ this.ctx.animations = null
+ this.ctx.axes = null
+ this.ctx.annotations = null
+ this.ctx.core = null
+ this.ctx.data = null
+ this.ctx.grid = null
+ this.ctx.series = null
+ this.ctx.responsive = null
+ this.ctx.theme = null
+ this.ctx.formatters = null
+ this.ctx.titleSubtitle = null
+ this.ctx.legend = null
+ this.ctx.dimensions = null
+ this.ctx.options = null
+ this.ctx.crosshairs = null
+ this.ctx.zoomPanSelection = null
+ this.ctx.updateHelpers = null
+ this.ctx.toolbar = null
+ this.ctx.localization = null
+ this.ctx.w.globals.tooltip = null
+ this.clearDomElements({ isUpdating })
+ }
+
+ killSVG(draw) {
+ draw.each(function(i, children) {
+ this.removeClass('*')
+ this.off()
+ this.stop()
+ }, true)
+ draw.ungroup()
+ draw.clear()
+ }
+
+ clearDomElements({ isUpdating }) {
+ const elSVG = this.w.globals.dom.Paper.node
+ // fixes apexcharts.js#1654 & vue-apexcharts#256
+ if (elSVG.parentNode && elSVG.parentNode.parentNode && !isUpdating) {
+ elSVG.parentNode.parentNode.style.minHeight = 'unset'
+ }
+
+ // detach root event
+ const baseEl = this.w.globals.dom.baseEl
+ if (baseEl) {
+ // see https://github.com/apexcharts/vue-apexcharts/issues/275
+ this.ctx.eventList.forEach((event) => {
+ baseEl.removeEventListener(event, this.ctx.events.documentEvent)
+ })
+ }
+
+ const domEls = this.w.globals.dom
+
+ if (this.ctx.el !== null) {
+ // remove all child elements - resetting the whole chart
+ while (this.ctx.el.firstChild) {
+ this.ctx.el.removeChild(this.ctx.el.firstChild)
+ }
+ }
+
+ this.killSVG(domEls.Paper)
+ domEls.Paper.remove()
+
+ domEls.elWrap = null
+ domEls.elGraphical = null
+ domEls.elAnnotations = null
+ domEls.elLegendWrap = null
+ domEls.baseEl = null
+ domEls.elGridRect = null
+ domEls.elGridRectMask = null
+ domEls.elGridRectMarkerMask = null
+ domEls.elForecastMask = null
+ domEls.elNonForecastMask = null
+ domEls.elDefs = null
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/helpers/InitCtxVariables.js b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/InitCtxVariables.js
new file mode 100644
index 0000000..b86e9a7
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/InitCtxVariables.js
@@ -0,0 +1,104 @@
+import Events from '../Events'
+import Localization from './Localization'
+import Animations from '../Animations'
+import Axes from '../axes/Axes'
+import Config from '../settings/Config'
+import CoreUtils from '../CoreUtils'
+import Crosshairs from '../Crosshairs'
+import Grid from '../axes/Grid'
+import Graphics from '../Graphics'
+import Exports from '../Exports'
+import Options from '../settings/Options'
+import Responsive from '../Responsive'
+import Series from '../Series'
+import Theme from '../Theme'
+import Formatters from '../Formatters'
+import TitleSubtitle from '../TitleSubtitle'
+import Legend from '../legend/Legend'
+import Toolbar from '../Toolbar'
+import Dimensions from '../dimensions/Dimensions'
+import ZoomPanSelection from '../ZoomPanSelection'
+import Tooltip from '../tooltip/Tooltip'
+import Core from '../Core'
+import Data from '../Data'
+import UpdateHelpers from './UpdateHelpers'
+
+import '../../svgjs/svg.js'
+import 'svg.filter.js'
+import 'svg.pathmorphing.js'
+import 'svg.draggable.js'
+import 'svg.select.js'
+import 'svg.resize.js'
+
+// global Apex object which user can use to override chart's defaults globally
+if (typeof window.Apex === 'undefined') {
+ window.Apex = {}
+}
+
+export default class InitCtxVariables {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ initModules() {
+ this.ctx.publicMethods = [
+ 'updateOptions',
+ 'updateSeries',
+ 'appendData',
+ 'appendSeries',
+ 'toggleSeries',
+ 'showSeries',
+ 'hideSeries',
+ 'setLocale',
+ 'resetSeries',
+ 'zoomX',
+ 'toggleDataPointSelection',
+ 'dataURI',
+ 'addXaxisAnnotation',
+ 'addYaxisAnnotation',
+ 'addPointAnnotation',
+ 'clearAnnotations',
+ 'removeAnnotation',
+ 'paper',
+ 'destroy'
+ ]
+
+ this.ctx.eventList = [
+ 'click',
+ 'mousedown',
+ 'mousemove',
+ 'mouseleave',
+ 'touchstart',
+ 'touchmove',
+ 'touchleave',
+ 'mouseup',
+ 'touchend'
+ ]
+
+ this.ctx.animations = new Animations(this.ctx)
+ this.ctx.axes = new Axes(this.ctx)
+ this.ctx.core = new Core(this.ctx.el, this.ctx)
+ this.ctx.config = new Config({})
+ this.ctx.data = new Data(this.ctx)
+ this.ctx.grid = new Grid(this.ctx)
+ this.ctx.graphics = new Graphics(this.ctx)
+ this.ctx.coreUtils = new CoreUtils(this.ctx)
+ this.ctx.crosshairs = new Crosshairs(this.ctx)
+ this.ctx.events = new Events(this.ctx)
+ this.ctx.exports = new Exports(this.ctx)
+ this.ctx.localization = new Localization(this.ctx)
+ this.ctx.options = new Options()
+ this.ctx.responsive = new Responsive(this.ctx)
+ this.ctx.series = new Series(this.ctx)
+ this.ctx.theme = new Theme(this.ctx)
+ this.ctx.formatters = new Formatters(this.ctx)
+ this.ctx.titleSubtitle = new TitleSubtitle(this.ctx)
+ this.ctx.legend = new Legend(this.ctx)
+ this.ctx.toolbar = new Toolbar(this.ctx)
+ this.ctx.dimensions = new Dimensions(this.ctx)
+ this.ctx.updateHelpers = new UpdateHelpers(this.ctx)
+ this.ctx.zoomPanSelection = new ZoomPanSelection(this.ctx)
+ this.ctx.w.globals.tooltip = new Tooltip(this.ctx)
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Localization.js b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Localization.js
new file mode 100644
index 0000000..c06e862
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/Localization.js
@@ -0,0 +1,39 @@
+import Utils from '../../utils/Utils'
+
+import en from '../../locales/en.json'
+
+export default class Localization {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ setCurrentLocaleValues(localeName) {
+ let locales = this.w.config.chart.locales
+
+ // check if user has specified locales in global Apex variable
+ // if yes - then extend those with local chart's locale
+ if (
+ window.Apex.chart &&
+ window.Apex.chart.locales &&
+ window.Apex.chart.locales.length > 0
+ ) {
+ locales = this.w.config.chart.locales.concat(window.Apex.chart.locales)
+ }
+
+ // find the locale from the array of locales which user has set (either by chart.defaultLocale or by calling setLocale() method.)
+ const selectedLocale = locales.filter((c) => c.name === localeName)[0]
+
+ if (selectedLocale) {
+ // create a complete locale object by extending defaults so you don't get undefined errors.
+ let ret = Utils.extend(en, selectedLocale)
+
+ // store these locale options in global var for ease access
+ this.w.globals.locale = ret.options
+ } else {
+ throw new Error(
+ 'Wrong locale name provided. Please make sure you set the correct locale name in options'
+ )
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/helpers/UpdateHelpers.js b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/UpdateHelpers.js
new file mode 100644
index 0000000..6af9d36
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/helpers/UpdateHelpers.js
@@ -0,0 +1,282 @@
+import Defaults from '../settings/Defaults'
+import Config from '../settings/Config'
+import CoreUtils from '../CoreUtils'
+import Graphics from '../Graphics'
+import Utils from '../../utils/Utils'
+
+export default class UpdateHelpers {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ }
+
+ /**
+ * private method to update Options.
+ *
+ * @param {object} options - A new config object can be passed which will be merged with the existing config object
+ * @param {boolean} redraw - should redraw from beginning or should use existing paths and redraw from there
+ * @param {boolean} animate - should animate or not on updating Options
+ * @param {boolean} overwriteInitialConfig - should update the initial config or not
+ */
+ _updateOptions(
+ options,
+ redraw = false,
+ animate = true,
+ updateSyncedCharts = true,
+ overwriteInitialConfig = false
+ ) {
+ return new Promise((resolve) => {
+ let charts = [this.ctx]
+ if (updateSyncedCharts) {
+ charts = this.ctx.getSyncedCharts()
+ }
+
+ if (this.ctx.w.globals.isExecCalled) {
+ // If the user called exec method, we don't want to get grouped charts as user specifically provided a chartID to update
+ charts = [this.ctx]
+ this.ctx.w.globals.isExecCalled = false
+ }
+
+ charts.forEach((ch, chartIndex) => {
+ let w = ch.w
+
+ w.globals.shouldAnimate = animate
+
+ if (!redraw) {
+ w.globals.resized = true
+ w.globals.dataChanged = true
+
+ if (animate) {
+ ch.series.getPreviousPaths()
+ }
+ }
+
+ if (options && typeof options === 'object') {
+ ch.config = new Config(options)
+ options = CoreUtils.extendArrayProps(ch.config, options, w)
+
+ // fixes #914, #623
+ if (ch.w.globals.chartID !== this.ctx.w.globals.chartID) {
+ // don't overwrite series of synchronized charts
+ delete options.series
+ }
+
+ w.config = Utils.extend(w.config, options)
+
+ if (overwriteInitialConfig) {
+ // we need to forget the lastXAxis and lastYAxis as user forcefully overwriteInitialConfig. If we do not do this, and next time when user zooms the chart after setting yaxis.min/max or xaxis.min/max - the stored lastXAxis will never allow the chart to use the updated min/max by user.
+ w.globals.lastXAxis = options.xaxis
+ ? Utils.clone(options.xaxis)
+ : []
+ w.globals.lastYAxis = options.yaxis
+ ? Utils.clone(options.yaxis)
+ : []
+
+ // After forgetting lastAxes, we need to restore the new config in initialConfig/initialSeries
+ w.globals.initialConfig = Utils.extend({}, w.config)
+ w.globals.initialSeries = Utils.clone(w.config.series)
+
+ if (options.series) {
+ // Replace the collapsed series data
+ for (let i = 0; i < w.globals.collapsedSeriesIndices.length; i++) {
+ let series = w.config.series[w.globals.collapsedSeriesIndices[i]]
+ w.globals.collapsedSeries[i].data = w.globals.axisCharts ? series.data.slice() : series
+ }
+ for (let i = 0; i < w.globals.ancillaryCollapsedSeriesIndices.length; i++) {
+ let series = w.config.series[w.globals.ancillaryCollapsedSeriesIndices[i]]
+ w.globals.ancillaryCollapsedSeries[i].data = w.globals.axisCharts ? series.data.slice() : series
+ }
+
+ // Ensure that auto-generated axes are scaled to the visible data
+ ch.series.emptyCollapsedSeries(w.config.series)
+ }
+ }
+ }
+
+ return ch.update(options).then(() => {
+ if (chartIndex === charts.length - 1) {
+ resolve(ch)
+ }
+ })
+ })
+ })
+ }
+
+ /**
+ * Private method to update Series.
+ *
+ * @param {array} series - New series which will override the existing
+ */
+ _updateSeries(newSeries, animate, overwriteInitialSeries = false) {
+ return new Promise((resolve) => {
+ const w = this.w
+
+ w.globals.shouldAnimate = animate
+
+ w.globals.dataChanged = true
+
+ if (animate) {
+ this.ctx.series.getPreviousPaths()
+ }
+
+ let existingSeries
+
+ // axis charts
+ if (w.globals.axisCharts) {
+ existingSeries = newSeries.map((s, i) => {
+ return this._extendSeries(s, i)
+ })
+
+ if (existingSeries.length === 0) {
+ existingSeries = [{ data: [] }]
+ }
+ w.config.series = existingSeries
+ } else {
+ // non-axis chart (pie/radialbar)
+ w.config.series = newSeries.slice()
+ }
+
+ if (overwriteInitialSeries) {
+ w.globals.initialSeries = Utils.clone(w.config.series)
+ }
+ return this.ctx.update().then(() => {
+ resolve(this.ctx)
+ })
+ })
+ }
+
+ _extendSeries(s, i) {
+ const w = this.w
+ const ser = w.config.series[i]
+
+ return {
+ ...w.config.series[i],
+ name: s.name ? s.name : ser && ser.name,
+ color: s.color ? s.color : ser && ser.color,
+ type: s.type ? s.type : ser && ser.type,
+ data: s.data ? s.data : ser && ser.data
+ }
+ }
+
+ toggleDataPointSelection(seriesIndex, dataPointIndex) {
+ const w = this.w
+ let elPath = null
+ const parent = `.apexcharts-series[data\\:realIndex='${seriesIndex}']`
+
+ if (w.globals.axisCharts) {
+ elPath = w.globals.dom.Paper.select(
+ `${parent} path[j='${dataPointIndex}'], ${parent} circle[j='${dataPointIndex}'], ${parent} rect[j='${dataPointIndex}']`
+ ).members[0]
+ } else {
+ // dataPointIndex will be undefined here, hence using seriesIndex
+ if (typeof dataPointIndex === 'undefined') {
+ elPath = w.globals.dom.Paper.select(
+ `${parent} path[j='${seriesIndex}']`
+ ).members[0]
+
+ if (
+ w.config.chart.type === 'pie' ||
+ w.config.chart.type === 'polarArea' ||
+ w.config.chart.type === 'donut'
+ ) {
+ this.ctx.pie.pieClicked(seriesIndex)
+ }
+ }
+ }
+
+ if (elPath) {
+ const graphics = new Graphics(this.ctx)
+ graphics.pathMouseDown(elPath, null)
+ } else {
+ console.warn('toggleDataPointSelection: Element not found')
+ return null
+ }
+
+ return elPath.node ? elPath.node : null
+ }
+
+ forceXAxisUpdate(options) {
+ const w = this.w
+ const minmax = ['min', 'max']
+
+ minmax.forEach((a) => {
+ if (typeof options.xaxis[a] !== 'undefined') {
+ w.config.xaxis[a] = options.xaxis[a]
+ w.globals.lastXAxis[a] = options.xaxis[a]
+ }
+ })
+
+ if (options.xaxis.categories && options.xaxis.categories.length) {
+ w.config.xaxis.categories = options.xaxis.categories
+ }
+
+ if (w.config.xaxis.convertedCatToNumeric) {
+ const defaults = new Defaults(options)
+ options = defaults.convertCatToNumericXaxis(options, this.ctx)
+ }
+ return options
+ }
+
+ forceYAxisUpdate(options) {
+ const w = this.w
+ if (w.config.chart.stacked && w.config.chart.stackType === '100%') {
+ if (Array.isArray(options.yaxis)) {
+ options.yaxis.forEach((yaxe, index) => {
+ options.yaxis[index].min = 0
+ options.yaxis[index].max = 100
+ })
+ } else {
+ options.yaxis.min = 0
+ options.yaxis.max = 100
+ }
+ }
+ return options
+ }
+
+ /**
+ * This function reverts the yaxis and xaxis min/max values to what it was when the chart was defined.
+ * This function fixes an important bug where a user might load a new series after zooming in/out of previous series which resulted in wrong min/max
+ * Also, this should never be called internally on zoom/pan - the reset should only happen when user calls the updateSeries() function externally
+ * The function also accepts an object {xaxis, yaxis} which when present is set as the new xaxis/yaxis
+ */
+ revertDefaultAxisMinMax(opts) {
+ const w = this.w
+
+ let xaxis = w.globals.lastXAxis
+ let yaxis = w.globals.lastYAxis
+
+ if (opts && opts.xaxis) {
+ xaxis = opts.xaxis
+ }
+ if (opts && opts.yaxis) {
+ yaxis = opts.yaxis
+ }
+ w.config.xaxis.min = xaxis.min
+ w.config.xaxis.max = xaxis.max
+
+ const getLastYAxis = (index) => {
+ if (typeof yaxis[index] !== 'undefined') {
+ w.config.yaxis[index].min = yaxis[index].min
+ w.config.yaxis[index].max = yaxis[index].max
+ }
+ }
+
+ w.config.yaxis.map((yaxe, index) => {
+ if (w.globals.zoomed) {
+ // user has zoomed, check the last yaxis
+ getLastYAxis(index)
+ } else {
+ // user hasn't zoomed, check the last yaxis first
+ if (typeof yaxis[index] !== 'undefined') {
+ getLastYAxis(index)
+ } else {
+ // if last y-axis don't exist, check the original yaxis
+ if (typeof this.ctx.opts.yaxis[index] !== 'undefined') {
+ yaxe.min = this.ctx.opts.yaxis[index].min
+ yaxe.max = this.ctx.opts.yaxis[index].max
+ }
+ }
+ }
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/legend/Helpers.js b/cao_sunyata/static/libs/apexcharts/src/modules/legend/Helpers.js
new file mode 100644
index 0000000..e16a600
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/legend/Helpers.js
@@ -0,0 +1,296 @@
+import Graphics from '../Graphics'
+import Utils from '../../utils/Utils'
+
+export default class Helpers {
+ constructor(lgCtx) {
+ this.w = lgCtx.w
+ this.lgCtx = lgCtx
+ }
+
+ getLegendStyles() {
+ let stylesheet = document.createElement('style')
+ stylesheet.setAttribute('type', 'text/css')
+
+ const text = `
+
+ .apexcharts-legend {
+ display: flex;
+ overflow: auto;
+ padding: 0 10px;
+ }
+ .apexcharts-legend.apx-legend-position-bottom, .apexcharts-legend.apx-legend-position-top {
+ flex-wrap: wrap
+ }
+ .apexcharts-legend.apx-legend-position-right, .apexcharts-legend.apx-legend-position-left {
+ flex-direction: column;
+ bottom: 0;
+ }
+ .apexcharts-legend.apx-legend-position-bottom.apexcharts-align-left, .apexcharts-legend.apx-legend-position-top.apexcharts-align-left, .apexcharts-legend.apx-legend-position-right, .apexcharts-legend.apx-legend-position-left {
+ justify-content: flex-start;
+ }
+ .apexcharts-legend.apx-legend-position-bottom.apexcharts-align-center, .apexcharts-legend.apx-legend-position-top.apexcharts-align-center {
+ justify-content: center;
+ }
+ .apexcharts-legend.apx-legend-position-bottom.apexcharts-align-right, .apexcharts-legend.apx-legend-position-top.apexcharts-align-right {
+ justify-content: flex-end;
+ }
+ .apexcharts-legend-series {
+ cursor: pointer;
+ line-height: normal;
+ }
+ .apexcharts-legend.apx-legend-position-bottom .apexcharts-legend-series, .apexcharts-legend.apx-legend-position-top .apexcharts-legend-series{
+ display: flex;
+ align-items: center;
+ }
+ .apexcharts-legend-text {
+ position: relative;
+ font-size: 14px;
+ }
+ .apexcharts-legend-text *, .apexcharts-legend-marker * {
+ pointer-events: none;
+ }
+ .apexcharts-legend-marker {
+ position: relative;
+ display: inline-block;
+ cursor: pointer;
+ margin-right: 3px;
+ border-style: solid;
+ }
+
+ .apexcharts-legend.apexcharts-align-right .apexcharts-legend-series, .apexcharts-legend.apexcharts-align-left .apexcharts-legend-series{
+ display: inline-block;
+ }
+ .apexcharts-legend-series.apexcharts-no-click {
+ cursor: auto;
+ }
+ .apexcharts-legend .apexcharts-hidden-zero-series, .apexcharts-legend .apexcharts-hidden-null-series {
+ display: none !important;
+ }
+ .apexcharts-inactive-legend {
+ opacity: 0.45;
+ }`
+
+ let rules = document.createTextNode(text)
+
+ stylesheet.appendChild(rules)
+
+ return stylesheet
+ }
+
+ getLegendBBox() {
+ const w = this.w
+ let currLegendsWrap = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-legend'
+ )
+ let currLegendsWrapRect = currLegendsWrap.getBoundingClientRect()
+
+ let currLegendsWrapWidth = currLegendsWrapRect.width
+ let currLegendsWrapHeight = currLegendsWrapRect.height
+
+ return {
+ clwh: currLegendsWrapHeight,
+ clww: currLegendsWrapWidth
+ }
+ }
+
+ appendToForeignObject() {
+ const gl = this.w.globals
+
+ gl.dom.elLegendForeign = document.createElementNS(gl.SVGNS, 'foreignObject')
+
+ let elForeign = gl.dom.elLegendForeign
+
+ elForeign.setAttribute('x', 0)
+ elForeign.setAttribute('y', 0)
+ elForeign.setAttribute('width', gl.svgWidth)
+ elForeign.setAttribute('height', gl.svgHeight)
+ gl.dom.elLegendWrap.setAttribute('xmlns', 'http://www.w3.org/1999/xhtml')
+
+ elForeign.appendChild(gl.dom.elLegendWrap)
+ elForeign.appendChild(this.getLegendStyles())
+
+ //gl.dom.elGraphical.node.insertAdjacentElement('afterend', elForeign)
+ // the above line causes issue #1907
+ gl.dom.Paper.node.insertBefore(elForeign, gl.dom.elGraphical.node)
+ }
+
+ toggleDataSeries(seriesCnt, isHidden) {
+ const w = this.w
+ if (w.globals.axisCharts || w.config.chart.type === 'radialBar') {
+ w.globals.resized = true // we don't want initial animations again
+
+ let seriesEl = null
+
+ let realIndex = null
+
+ // yes, make it null. 1 series will rise at a time
+ w.globals.risingSeries = []
+
+ if (w.globals.axisCharts) {
+ seriesEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[data\\:realIndex='${seriesCnt}']`
+ )
+ realIndex = parseInt(seriesEl.getAttribute('data:realIndex'), 10)
+ } else {
+ seriesEl = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[rel='${seriesCnt + 1}']`
+ )
+ realIndex = parseInt(seriesEl.getAttribute('rel'), 10) - 1
+ }
+
+ if (isHidden) {
+ const seriesToMakeVisible = [
+ {
+ cs: w.globals.collapsedSeries,
+ csi: w.globals.collapsedSeriesIndices
+ },
+ {
+ cs: w.globals.ancillaryCollapsedSeries,
+ csi: w.globals.ancillaryCollapsedSeriesIndices
+ }
+ ]
+ seriesToMakeVisible.forEach((r) => {
+ this.riseCollapsedSeries(r.cs, r.csi, realIndex)
+ })
+ } else {
+ this.hideSeries({ seriesEl, realIndex })
+ }
+ } else {
+ // for non-axis charts i.e pie / donuts
+ let seriesEl = w.globals.dom.Paper.select(
+ ` .apexcharts-series[rel='${seriesCnt + 1}'] path`
+ )
+
+ const type = w.config.chart.type
+ if (type === 'pie' || type === 'polarArea' || type === 'donut') {
+ let dataLabels = w.config.plotOptions.pie.donut.labels
+
+ const graphics = new Graphics(this.lgCtx.ctx)
+ graphics.pathMouseDown(seriesEl.members[0], null)
+ this.lgCtx.ctx.pie.printDataLabelsInner(
+ seriesEl.members[0].node,
+ dataLabels
+ )
+ }
+
+ seriesEl.fire('click')
+ }
+ }
+
+ hideSeries({ seriesEl, realIndex }) {
+ const w = this.w
+
+ let series = Utils.clone(w.config.series)
+
+ if (w.globals.axisCharts) {
+ let shouldNotHideYAxis = false
+
+ if (
+ w.config.yaxis[realIndex] &&
+ w.config.yaxis[realIndex].show &&
+ w.config.yaxis[realIndex].showAlways
+ ) {
+ shouldNotHideYAxis = true
+ if (w.globals.ancillaryCollapsedSeriesIndices.indexOf(realIndex) < 0) {
+ w.globals.ancillaryCollapsedSeries.push({
+ index: realIndex,
+ data: series[realIndex].data.slice(),
+ type: seriesEl.parentNode.className.baseVal.split('-')[1]
+ })
+ w.globals.ancillaryCollapsedSeriesIndices.push(realIndex)
+ }
+ }
+
+ if (!shouldNotHideYAxis) {
+ w.globals.collapsedSeries.push({
+ index: realIndex,
+ data: series[realIndex].data.slice(),
+ type: seriesEl.parentNode.className.baseVal.split('-')[1]
+ })
+ w.globals.collapsedSeriesIndices.push(realIndex)
+
+ let removeIndexOfRising = w.globals.risingSeries.indexOf(realIndex)
+
+ w.globals.risingSeries.splice(removeIndexOfRising, 1)
+ }
+ } else {
+ w.globals.collapsedSeries.push({
+ index: realIndex,
+ data: series[realIndex]
+ })
+ w.globals.collapsedSeriesIndices.push(realIndex)
+ }
+
+ let seriesChildren = seriesEl.childNodes
+ for (let sc = 0; sc < seriesChildren.length; sc++) {
+ if (
+ seriesChildren[sc].classList.contains('apexcharts-series-markers-wrap')
+ ) {
+ if (seriesChildren[sc].classList.contains('apexcharts-hide')) {
+ seriesChildren[sc].classList.remove('apexcharts-hide')
+ } else {
+ seriesChildren[sc].classList.add('apexcharts-hide')
+ }
+ }
+ }
+
+ w.globals.allSeriesCollapsed =
+ w.globals.collapsedSeries.length === w.config.series.length
+
+ series = this._getSeriesBasedOnCollapsedState(series)
+ this.lgCtx.ctx.updateHelpers._updateSeries(
+ series,
+ w.config.chart.animations.dynamicAnimation.enabled
+ )
+ }
+
+ riseCollapsedSeries(collapsedSeries, seriesIndices, realIndex) {
+ const w = this.w
+ let series = Utils.clone(w.config.series)
+
+ if (collapsedSeries.length > 0) {
+ for (let c = 0; c < collapsedSeries.length; c++) {
+ if (collapsedSeries[c].index === realIndex) {
+ if (w.globals.axisCharts) {
+ series[realIndex].data = collapsedSeries[c].data.slice()
+ collapsedSeries.splice(c, 1)
+ seriesIndices.splice(c, 1)
+ w.globals.risingSeries.push(realIndex)
+ } else {
+ series[realIndex] = collapsedSeries[c].data
+ collapsedSeries.splice(c, 1)
+ seriesIndices.splice(c, 1)
+ w.globals.risingSeries.push(realIndex)
+ }
+ }
+ }
+
+ series = this._getSeriesBasedOnCollapsedState(series)
+
+ this.lgCtx.ctx.updateHelpers._updateSeries(
+ series,
+ w.config.chart.animations.dynamicAnimation.enabled
+ )
+ }
+ }
+
+ _getSeriesBasedOnCollapsedState(series) {
+ const w = this.w
+
+ if (w.globals.axisCharts) {
+ series.forEach((s, sI) => {
+ if (w.globals.collapsedSeriesIndices.indexOf(sI) > -1) {
+ series[sI].data = []
+ }
+ })
+ } else {
+ series.forEach((s, sI) => {
+ if (w.globals.collapsedSeriesIndices.indexOf(sI) > -1) {
+ series[sI] = 0
+ }
+ })
+ }
+
+ return series
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/legend/Legend.js b/cao_sunyata/static/libs/apexcharts/src/modules/legend/Legend.js
new file mode 100644
index 0000000..9fe8fec
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/legend/Legend.js
@@ -0,0 +1,481 @@
+import CoreUtils from '../CoreUtils'
+import Dimensions from '../dimensions/Dimensions'
+import Graphics from '../Graphics'
+import Series from '../Series'
+import Utils from '../../utils/Utils'
+import Helpers from './Helpers'
+
+/**
+ * ApexCharts Legend Class to draw legend.
+ *
+ * @module Legend
+ **/
+
+class Legend {
+ constructor(ctx, opts) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.onLegendClick = this.onLegendClick.bind(this)
+ this.onLegendHovered = this.onLegendHovered.bind(this)
+
+ this.isBarsDistributed =
+ this.w.config.chart.type === 'bar' &&
+ this.w.config.plotOptions.bar.distributed &&
+ this.w.config.series.length === 1
+
+ this.legendHelpers = new Helpers(this)
+ }
+
+ init() {
+ const w = this.w
+
+ const gl = w.globals
+ const cnf = w.config
+
+ const showLegendAlways =
+ (cnf.legend.showForSingleSeries && gl.series.length === 1) ||
+ this.isBarsDistributed ||
+ gl.series.length > 1
+
+ if ((showLegendAlways || !gl.axisCharts) && cnf.legend.show) {
+ while (gl.dom.elLegendWrap.firstChild) {
+ gl.dom.elLegendWrap.removeChild(gl.dom.elLegendWrap.firstChild)
+ }
+
+ this.drawLegends()
+ if (!Utils.isIE11()) {
+ this.legendHelpers.appendToForeignObject()
+ } else {
+ // IE11 doesn't supports foreignObject, hence append it to
+ document
+ .getElementsByTagName('head')[0]
+ .appendChild(this.legendHelpers.getLegendStyles())
+ }
+
+ if (cnf.legend.position === 'bottom' || cnf.legend.position === 'top') {
+ this.legendAlignHorizontal()
+ } else if (
+ cnf.legend.position === 'right' ||
+ cnf.legend.position === 'left'
+ ) {
+ this.legendAlignVertical()
+ }
+ }
+ }
+
+ drawLegends() {
+ let me = this
+ let w = this.w
+
+ let fontFamily = w.config.legend.fontFamily
+
+ let legendNames = w.globals.seriesNames
+ let fillcolor = w.globals.colors.slice()
+
+ if (w.config.chart.type === 'heatmap') {
+ const ranges = w.config.plotOptions.heatmap.colorScale.ranges
+ legendNames = ranges.map((colorScale) => {
+ return colorScale.name
+ ? colorScale.name
+ : colorScale.from + ' - ' + colorScale.to
+ })
+ fillcolor = ranges.map((color) => color.color)
+ } else if (this.isBarsDistributed) {
+ legendNames = w.globals.labels.slice()
+ }
+
+ if (w.config.legend.customLegendItems.length) {
+ legendNames = w.config.legend.customLegendItems
+ }
+ let legendFormatter = w.globals.legendFormatter
+
+ let isLegendInversed = w.config.legend.inverseOrder
+
+ for (
+ let i = isLegendInversed ? legendNames.length - 1 : 0;
+ isLegendInversed ? i >= 0 : i <= legendNames.length - 1;
+ isLegendInversed ? i-- : i++
+ ) {
+ let text = legendFormatter(legendNames[i], { seriesIndex: i, w })
+
+ let collapsedSeries = false
+ let ancillaryCollapsedSeries = false
+ if (w.globals.collapsedSeries.length > 0) {
+ for (let c = 0; c < w.globals.collapsedSeries.length; c++) {
+ if (w.globals.collapsedSeries[c].index === i) {
+ collapsedSeries = true
+ }
+ }
+ }
+
+ if (w.globals.ancillaryCollapsedSeriesIndices.length > 0) {
+ for (
+ let c = 0;
+ c < w.globals.ancillaryCollapsedSeriesIndices.length;
+ c++
+ ) {
+ if (w.globals.ancillaryCollapsedSeriesIndices[c] === i) {
+ ancillaryCollapsedSeries = true
+ }
+ }
+ }
+
+ let elMarker = document.createElement('span')
+ elMarker.classList.add('apexcharts-legend-marker')
+
+ let mOffsetX = w.config.legend.markers.offsetX
+ let mOffsetY = w.config.legend.markers.offsetY
+ let mHeight = w.config.legend.markers.height
+ let mWidth = w.config.legend.markers.width
+ let mBorderWidth = w.config.legend.markers.strokeWidth
+ let mBorderColor = w.config.legend.markers.strokeColor
+ let mBorderRadius = w.config.legend.markers.radius
+
+ // todo - untested code below
+ // if (Array.isArray(w.config.legend.markers.shape)) {
+ // } else {
+ // if (w.config.legend.markers.shape !== 'circle') {
+ // mBorderRadius = 1
+ // }
+ // }
+
+ let mStyle = elMarker.style
+
+ mStyle.background = fillcolor[i]
+ mStyle.color = fillcolor[i]
+ mStyle.setProperty('background', fillcolor[i], 'important')
+
+ // override fill color with custom legend.markers.fillColors
+ if (
+ w.config.legend.markers.fillColors &&
+ w.config.legend.markers.fillColors[i]
+ ) {
+ mStyle.background = w.config.legend.markers.fillColors[i]
+ }
+
+ // override with data color
+ if (w.globals.seriesColors[i] !== undefined) {
+ mStyle.background = w.globals.seriesColors[i]
+ mStyle.color = w.globals.seriesColors[i]
+ }
+
+ mStyle.height = Array.isArray(mHeight)
+ ? parseFloat(mHeight[i]) + 'px'
+ : parseFloat(mHeight) + 'px'
+ mStyle.width = Array.isArray(mWidth)
+ ? parseFloat(mWidth[i]) + 'px'
+ : parseFloat(mWidth) + 'px'
+ mStyle.left =
+ (Array.isArray(mOffsetX)
+ ? parseFloat(mOffsetX[i])
+ : parseFloat(mOffsetX)) + 'px'
+ mStyle.top =
+ (Array.isArray(mOffsetY)
+ ? parseFloat(mOffsetY[i])
+ : parseFloat(mOffsetY)) + 'px'
+ mStyle.borderWidth = Array.isArray(mBorderWidth)
+ ? mBorderWidth[i]
+ : mBorderWidth
+ mStyle.borderColor = Array.isArray(mBorderColor)
+ ? mBorderColor[i]
+ : mBorderColor
+ mStyle.borderRadius = Array.isArray(mBorderRadius)
+ ? parseFloat(mBorderRadius[i]) + 'px'
+ : parseFloat(mBorderRadius) + 'px'
+
+ if (w.config.legend.markers.customHTML) {
+ if (Array.isArray(w.config.legend.markers.customHTML)) {
+ if (w.config.legend.markers.customHTML[i]) {
+ elMarker.innerHTML = w.config.legend.markers.customHTML[i]()
+ }
+ } else {
+ elMarker.innerHTML = w.config.legend.markers.customHTML()
+ }
+ }
+
+ Graphics.setAttrs(elMarker, {
+ rel: i + 1,
+ 'data:collapsed': collapsedSeries || ancillaryCollapsedSeries
+ })
+
+ if (collapsedSeries || ancillaryCollapsedSeries) {
+ elMarker.classList.add('apexcharts-inactive-legend')
+ }
+
+ let elLegend = document.createElement('div')
+
+ let elLegendText = document.createElement('span')
+ elLegendText.classList.add('apexcharts-legend-text')
+ elLegendText.innerHTML = Array.isArray(text) ? text.join(' ') : text
+
+ let textColor = w.config.legend.labels.useSeriesColors
+ ? w.globals.colors[i]
+ : w.config.legend.labels.colors
+
+ if (!textColor) {
+ textColor = w.config.chart.foreColor
+ }
+
+ elLegendText.style.color = textColor
+
+ elLegendText.style.fontSize = parseFloat(w.config.legend.fontSize) + 'px'
+ elLegendText.style.fontWeight = w.config.legend.fontWeight
+ elLegendText.style.fontFamily = fontFamily || w.config.chart.fontFamily
+
+ Graphics.setAttrs(elLegendText, {
+ rel: i + 1,
+ i,
+ 'data:default-text': encodeURIComponent(text),
+ 'data:collapsed': collapsedSeries || ancillaryCollapsedSeries
+ })
+
+ elLegend.appendChild(elMarker)
+ elLegend.appendChild(elLegendText)
+
+ const coreUtils = new CoreUtils(this.ctx)
+ if (!w.config.legend.showForZeroSeries) {
+ const total = coreUtils.getSeriesTotalByIndex(i)
+
+ if (
+ total === 0 &&
+ coreUtils.seriesHaveSameValues(i) &&
+ !coreUtils.isSeriesNull(i) &&
+ w.globals.collapsedSeriesIndices.indexOf(i) === -1 &&
+ w.globals.ancillaryCollapsedSeriesIndices.indexOf(i) === -1
+ ) {
+ elLegend.classList.add('apexcharts-hidden-zero-series')
+ }
+ }
+
+ if (!w.config.legend.showForNullSeries) {
+ if (
+ coreUtils.isSeriesNull(i) &&
+ w.globals.collapsedSeriesIndices.indexOf(i) === -1 &&
+ w.globals.ancillaryCollapsedSeriesIndices.indexOf(i) === -1
+ ) {
+ elLegend.classList.add('apexcharts-hidden-null-series')
+ }
+ }
+
+ w.globals.dom.elLegendWrap.appendChild(elLegend)
+ w.globals.dom.elLegendWrap.classList.add(
+ `apexcharts-align-${w.config.legend.horizontalAlign}`
+ )
+ w.globals.dom.elLegendWrap.classList.add(
+ 'apx-legend-position-' + w.config.legend.position
+ )
+
+ elLegend.classList.add('apexcharts-legend-series')
+ elLegend.style.margin = `${w.config.legend.itemMargin.vertical}px ${w.config.legend.itemMargin.horizontal}px`
+ w.globals.dom.elLegendWrap.style.width = w.config.legend.width
+ ? w.config.legend.width + 'px'
+ : ''
+ w.globals.dom.elLegendWrap.style.height = w.config.legend.height
+ ? w.config.legend.height + 'px'
+ : ''
+
+ Graphics.setAttrs(elLegend, {
+ rel: i + 1,
+ seriesName: Utils.escapeString(legendNames[i]),
+ 'data:collapsed': collapsedSeries || ancillaryCollapsedSeries
+ })
+
+ if (collapsedSeries || ancillaryCollapsedSeries) {
+ elLegend.classList.add('apexcharts-inactive-legend')
+ }
+
+ if (!w.config.legend.onItemClick.toggleDataSeries) {
+ elLegend.classList.add('apexcharts-no-click')
+ }
+ }
+
+ w.globals.dom.elWrap.addEventListener('click', me.onLegendClick, true)
+
+ if (
+ w.config.legend.onItemHover.highlightDataSeries &&
+ w.config.legend.customLegendItems.length === 0
+ ) {
+ w.globals.dom.elWrap.addEventListener(
+ 'mousemove',
+ me.onLegendHovered,
+ true
+ )
+ w.globals.dom.elWrap.addEventListener(
+ 'mouseout',
+ me.onLegendHovered,
+ true
+ )
+ }
+ }
+
+ setLegendWrapXY(offsetX, offsetY) {
+ let w = this.w
+
+ let elLegendWrap = w.globals.dom.baseEl.querySelector('.apexcharts-legend')
+
+ const legendRect = elLegendWrap.getBoundingClientRect()
+
+ let x = 0
+ let y = 0
+
+ if (w.config.legend.position === 'bottom') {
+ y = y + (w.globals.svgHeight - legendRect.height / 2)
+ } else if (w.config.legend.position === 'top') {
+ const dim = new Dimensions(this.ctx)
+ const titleH = dim.dimHelpers.getTitleSubtitleCoords('title').height
+ const subtitleH = dim.dimHelpers.getTitleSubtitleCoords('subtitle').height
+
+ y =
+ y +
+ (titleH > 0 ? titleH - 10 : 0) +
+ (subtitleH > 0 ? subtitleH - 10 : 0)
+ }
+
+ elLegendWrap.style.position = 'absolute'
+
+ x = x + offsetX + w.config.legend.offsetX
+ y = y + offsetY + w.config.legend.offsetY
+
+ elLegendWrap.style.left = x + 'px'
+ elLegendWrap.style.top = y + 'px'
+
+ if (w.config.legend.position === 'bottom') {
+ elLegendWrap.style.top = 'auto'
+ elLegendWrap.style.bottom = 5 - w.config.legend.offsetY + 'px'
+ } else if (w.config.legend.position === 'right') {
+ elLegendWrap.style.left = 'auto'
+ elLegendWrap.style.right = 25 + w.config.legend.offsetX + 'px'
+ }
+
+ const fixedHeigthWidth = ['width', 'height']
+ fixedHeigthWidth.forEach((hw) => {
+ if (elLegendWrap.style[hw]) {
+ elLegendWrap.style[hw] = parseInt(w.config.legend[hw], 10) + 'px'
+ }
+ })
+ }
+
+ legendAlignHorizontal() {
+ let w = this.w
+
+ let elLegendWrap = w.globals.dom.baseEl.querySelector('.apexcharts-legend')
+
+ elLegendWrap.style.right = 0
+
+ let lRect = this.legendHelpers.getLegendBBox()
+
+ let dimensions = new Dimensions(this.ctx)
+ let titleRect = dimensions.dimHelpers.getTitleSubtitleCoords('title')
+ let subtitleRect = dimensions.dimHelpers.getTitleSubtitleCoords('subtitle')
+
+ let offsetX = 20
+ let offsetY = 0
+
+ // the whole legend box is set to bottom
+ if (w.config.legend.position === 'bottom') {
+ offsetY = -lRect.clwh / 1.8
+ } else if (w.config.legend.position === 'top') {
+ offsetY =
+ titleRect.height +
+ subtitleRect.height +
+ w.config.title.margin +
+ w.config.subtitle.margin -
+ 10
+ }
+
+ this.setLegendWrapXY(offsetX, offsetY)
+ }
+
+ legendAlignVertical() {
+ let w = this.w
+
+ let lRect = this.legendHelpers.getLegendBBox()
+
+ let offsetY = 20
+ let offsetX = 0
+
+ if (w.config.legend.position === 'left') {
+ offsetX = 20
+ }
+
+ if (w.config.legend.position === 'right') {
+ offsetX = w.globals.svgWidth - lRect.clww - 10
+ }
+
+ this.setLegendWrapXY(offsetX, offsetY)
+ }
+
+ onLegendHovered(e) {
+ const w = this.w
+
+ const hoverOverLegend =
+ e.target.classList.contains('apexcharts-legend-text') ||
+ e.target.classList.contains('apexcharts-legend-marker')
+
+ if (w.config.chart.type !== 'heatmap' && !this.isBarsDistributed) {
+ if (
+ !e.target.classList.contains('apexcharts-inactive-legend') &&
+ hoverOverLegend
+ ) {
+ let series = new Series(this.ctx)
+ series.toggleSeriesOnHover(e, e.target)
+ }
+ } else {
+ // for heatmap handling
+ if (hoverOverLegend) {
+ let seriesCnt = parseInt(e.target.getAttribute('rel'), 10) - 1
+ this.ctx.events.fireEvent('legendHover', [this.ctx, seriesCnt, this.w])
+
+ let series = new Series(this.ctx)
+ series.highlightRangeInSeries(e, e.target)
+ }
+ }
+ }
+
+ onLegendClick(e) {
+ const w = this.w
+
+ if (w.config.legend.customLegendItems.length) return
+
+ if (
+ e.target.classList.contains('apexcharts-legend-text') ||
+ e.target.classList.contains('apexcharts-legend-marker')
+ ) {
+ let seriesCnt = parseInt(e.target.getAttribute('rel'), 10) - 1
+ let isHidden = e.target.getAttribute('data:collapsed') === 'true'
+
+ const legendClick = this.w.config.chart.events.legendClick
+ if (typeof legendClick === 'function') {
+ legendClick(this.ctx, seriesCnt, this.w)
+ }
+
+ this.ctx.events.fireEvent('legendClick', [this.ctx, seriesCnt, this.w])
+
+ const markerClick = this.w.config.legend.markers.onClick
+ if (
+ typeof markerClick === 'function' &&
+ e.target.classList.contains('apexcharts-legend-marker')
+ ) {
+ markerClick(this.ctx, seriesCnt, this.w)
+ this.ctx.events.fireEvent('legendMarkerClick', [
+ this.ctx,
+ seriesCnt,
+ this.w
+ ])
+ }
+
+ // for now - just prevent click on heatmap legend - and allow hover only
+ const clickAllowed =
+ w.config.chart.type !== 'treemap' &&
+ w.config.chart.type !== 'heatmap' &&
+ !this.isBarsDistributed
+
+ if (clickAllowed && w.config.legend.onItemClick.toggleDataSeries) {
+ this.legendHelpers.toggleDataSeries(seriesCnt, isHidden)
+ }
+ }
+ }
+}
+
+export default Legend
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/settings/Config.js b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Config.js
new file mode 100644
index 0000000..5fc677f
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Config.js
@@ -0,0 +1,345 @@
+import Defaults from './Defaults'
+import Utils from './../../utils/Utils'
+import Options from './Options'
+
+/**
+ * ApexCharts Config Class for extending user options with pre-defined ApexCharts config.
+ *
+ * @module Config
+ **/
+export default class Config {
+ constructor(opts) {
+ this.opts = opts
+ }
+
+ init({ responsiveOverride }) {
+ let opts = this.opts
+ let options = new Options()
+ let defaults = new Defaults(opts)
+
+ this.chartType = opts.chart.type
+
+ if (this.chartType === 'histogram') {
+ // technically, a histogram can be drawn by a column chart with no spaces in between
+ opts.chart.type = 'bar'
+ opts = Utils.extend(
+ {
+ plotOptions: {
+ bar: {
+ columnWidth: '99.99%'
+ }
+ }
+ },
+ opts
+ )
+ }
+
+ opts = this.extendYAxis(opts)
+ opts = this.extendAnnotations(opts)
+
+ let config = options.init()
+ let newDefaults = {}
+ if (opts && typeof opts === 'object') {
+ let chartDefaults = {}
+ const chartTypes = [
+ 'line',
+ 'area',
+ 'bar',
+ 'candlestick',
+ 'boxPlot',
+ 'rangeBar',
+ 'histogram',
+ 'bubble',
+ 'scatter',
+ 'heatmap',
+ 'treemap',
+ 'pie',
+ 'polarArea',
+ 'donut',
+ 'radar',
+ 'radialBar'
+ ]
+
+ if (chartTypes.indexOf(opts.chart.type) !== -1) {
+ chartDefaults = defaults[opts.chart.type]()
+ } else {
+ chartDefaults = defaults.line()
+ }
+
+ if (opts.chart.brush && opts.chart.brush.enabled) {
+ chartDefaults = defaults.brush(chartDefaults)
+ }
+
+ if (opts.chart.stacked && opts.chart.stackType === '100%') {
+ opts = defaults.stacked100(opts)
+ }
+
+ // If user has specified a dark theme, make the tooltip dark too
+ this.checkForDarkTheme(window.Apex) // check global window Apex options
+ this.checkForDarkTheme(opts) // check locally passed options
+
+ opts.xaxis = opts.xaxis || window.Apex.xaxis || {}
+
+ // an important boolean needs to be set here
+ // otherwise all the charts will have this flag set to true window.Apex.xaxis is set globally
+ if (!responsiveOverride) {
+ opts.xaxis.convertedCatToNumeric = false
+ }
+
+ opts = this.checkForCatToNumericXAxis(this.chartType, chartDefaults, opts)
+
+ if (
+ (opts.chart.sparkline && opts.chart.sparkline.enabled) ||
+ (window.Apex.chart &&
+ window.Apex.chart.sparkline &&
+ window.Apex.chart.sparkline.enabled)
+ ) {
+ chartDefaults = defaults.sparkline(chartDefaults)
+ }
+ newDefaults = Utils.extend(config, chartDefaults)
+ }
+
+ // config should cascade in this fashion
+ // default-config < global-apex-variable-config < user-defined-config
+
+ // get GLOBALLY defined options and merge with the default config
+ let mergedWithDefaultConfig = Utils.extend(newDefaults, window.Apex)
+
+ // get the merged config and extend with user defined config
+ config = Utils.extend(mergedWithDefaultConfig, opts)
+
+ // some features are not supported. those mismatches should be handled
+ config = this.handleUserInputErrors(config)
+
+ return config
+ }
+
+ checkForCatToNumericXAxis(chartType, chartDefaults, opts) {
+ let defaults = new Defaults(opts)
+
+ const isBarHorizontal =
+ (chartType === 'bar' || chartType === 'boxPlot') &&
+ opts.plotOptions &&
+ opts.plotOptions.bar &&
+ opts.plotOptions.bar.horizontal
+
+ const unsupportedZoom =
+ chartType === 'pie' ||
+ chartType === 'polarArea' ||
+ chartType === 'donut' ||
+ chartType === 'radar' ||
+ chartType === 'radialBar' ||
+ chartType === 'heatmap'
+
+ const notNumericXAxis =
+ opts.xaxis.type !== 'datetime' && opts.xaxis.type !== 'numeric'
+
+ let tickPlacement = opts.xaxis.tickPlacement
+ ? opts.xaxis.tickPlacement
+ : chartDefaults.xaxis && chartDefaults.xaxis.tickPlacement
+ if (
+ !isBarHorizontal &&
+ !unsupportedZoom &&
+ notNumericXAxis &&
+ tickPlacement !== 'between'
+ ) {
+ opts = defaults.convertCatToNumeric(opts)
+ }
+
+ return opts
+ }
+
+ extendYAxis(opts, w) {
+ let options = new Options()
+
+ if (
+ typeof opts.yaxis === 'undefined' ||
+ !opts.yaxis ||
+ (Array.isArray(opts.yaxis) && opts.yaxis.length === 0)
+ ) {
+ opts.yaxis = {}
+ }
+
+ // extend global yaxis config (only if object is provided / not an array)
+ if (
+ opts.yaxis.constructor !== Array &&
+ window.Apex.yaxis &&
+ window.Apex.yaxis.constructor !== Array
+ ) {
+ opts.yaxis = Utils.extend(opts.yaxis, window.Apex.yaxis)
+ }
+
+ // as we can't extend nested object's array with extend, we need to do it first
+ // user can provide either an array or object in yaxis config
+ if (opts.yaxis.constructor !== Array) {
+ // convert the yaxis to array if user supplied object
+ opts.yaxis = [Utils.extend(options.yAxis, opts.yaxis)]
+ } else {
+ opts.yaxis = Utils.extendArray(opts.yaxis, options.yAxis)
+ }
+
+ let isLogY = false
+ opts.yaxis.forEach((y) => {
+ if (y.logarithmic) {
+ isLogY = true
+ }
+ })
+
+ let series = opts.series
+ if (w && !series) {
+ series = w.config.series
+ }
+
+ // A logarithmic chart works correctly when each series has a corresponding y-axis
+ // If this is not the case, we manually create yaxis for multi-series log chart
+ if (isLogY && series.length !== opts.yaxis.length && series.length) {
+ opts.yaxis = series.map((s, i) => {
+ if (!s.name) {
+ series[i].name = `series-${i + 1}`
+ }
+ if (opts.yaxis[i]) {
+ opts.yaxis[i].seriesName = series[i].name
+ return opts.yaxis[i]
+ } else {
+ const newYaxis = Utils.extend(options.yAxis, opts.yaxis[0])
+ newYaxis.show = false
+ return newYaxis
+ }
+ })
+ }
+
+ if (isLogY && series.length > 1 && series.length !== opts.yaxis.length) {
+ console.warn(
+ 'A multi-series logarithmic chart should have equal number of series and y-axes. Please make sure to equalize both.'
+ )
+ }
+ return opts
+ }
+
+ // annotations also accepts array, so we need to extend them manually
+ extendAnnotations(opts) {
+ if (typeof opts.annotations === 'undefined') {
+ opts.annotations = {}
+ opts.annotations.yaxis = []
+ opts.annotations.xaxis = []
+ opts.annotations.points = []
+ }
+
+ opts = this.extendYAxisAnnotations(opts)
+ opts = this.extendXAxisAnnotations(opts)
+ opts = this.extendPointAnnotations(opts)
+
+ return opts
+ }
+
+ extendYAxisAnnotations(opts) {
+ let options = new Options()
+
+ opts.annotations.yaxis = Utils.extendArray(
+ typeof opts.annotations.yaxis !== 'undefined'
+ ? opts.annotations.yaxis
+ : [],
+ options.yAxisAnnotation
+ )
+ return opts
+ }
+
+ extendXAxisAnnotations(opts) {
+ let options = new Options()
+
+ opts.annotations.xaxis = Utils.extendArray(
+ typeof opts.annotations.xaxis !== 'undefined'
+ ? opts.annotations.xaxis
+ : [],
+ options.xAxisAnnotation
+ )
+ return opts
+ }
+ extendPointAnnotations(opts) {
+ let options = new Options()
+
+ opts.annotations.points = Utils.extendArray(
+ typeof opts.annotations.points !== 'undefined'
+ ? opts.annotations.points
+ : [],
+ options.pointAnnotation
+ )
+ return opts
+ }
+
+ checkForDarkTheme(opts) {
+ if (opts.theme && opts.theme.mode === 'dark') {
+ if (!opts.tooltip) {
+ opts.tooltip = {}
+ }
+ if (opts.tooltip.theme !== 'light') {
+ opts.tooltip.theme = 'dark'
+ }
+
+ if (!opts.chart.foreColor) {
+ opts.chart.foreColor = '#f6f7f8'
+ }
+
+ if (!opts.chart.background) {
+ opts.chart.background = '#424242'
+ }
+
+ if (!opts.theme.palette) {
+ opts.theme.palette = 'palette4'
+ }
+ }
+ }
+
+ handleUserInputErrors(opts) {
+ let config = opts
+ // conflicting tooltip option. intersect makes sure to focus on 1 point at a time. Shared cannot be used along with it
+ if (config.tooltip.shared && config.tooltip.intersect) {
+ throw new Error(
+ 'tooltip.shared cannot be enabled when tooltip.intersect is true. Turn off any other option by setting it to false.'
+ )
+ }
+
+ if (config.chart.type === 'bar' && config.plotOptions.bar.horizontal) {
+ // No multiple yaxis for bars
+ if (config.yaxis.length > 1) {
+ throw new Error(
+ 'Multiple Y Axis for bars are not supported. Switch to column chart by setting plotOptions.bar.horizontal=false'
+ )
+ }
+
+ // if yaxis is reversed in horizontal bar chart, you should draw the y-axis on right side
+ if (config.yaxis[0].reversed) {
+ config.yaxis[0].opposite = true
+ }
+
+ config.xaxis.tooltip.enabled = false // no xaxis tooltip for horizontal bar
+ config.yaxis[0].tooltip.enabled = false // no xaxis tooltip for horizontal bar
+ config.chart.zoom.enabled = false // no zooming for horz bars
+ }
+
+ if (config.chart.type === 'bar' || config.chart.type === 'rangeBar') {
+ if (config.tooltip.shared) {
+ if (
+ config.xaxis.crosshairs.width === 'barWidth' &&
+ config.series.length > 1
+ ) {
+ config.xaxis.crosshairs.width = 'tickWidth'
+ }
+ }
+ }
+
+ if (
+ config.chart.type === 'candlestick' ||
+ config.chart.type === 'boxPlot'
+ ) {
+ if (config.yaxis[0].reversed) {
+ console.warn(
+ `Reversed y-axis in ${config.chart.type} chart is not supported.`
+ )
+ config.yaxis[0].reversed = false
+ }
+ }
+
+ return config
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/settings/Defaults.js b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Defaults.js
new file mode 100644
index 0000000..5858a0e
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Defaults.js
@@ -0,0 +1,857 @@
+import Utils from '../../utils/Utils'
+import RangeBar from '../../charts/RangeBar'
+
+/**
+ * ApexCharts Default Class for setting default options for all chart types.
+ *
+ * @module Defaults
+ **/
+
+export default class Defaults {
+ constructor(opts) {
+ this.opts = opts
+ }
+
+ line() {
+ return {
+ chart: {
+ animations: {
+ easing: 'swing'
+ }
+ },
+ dataLabels: {
+ enabled: false
+ },
+ stroke: {
+ width: 5,
+ curve: 'straight'
+ },
+ markers: {
+ size: 0,
+ hover: {
+ sizeOffset: 6
+ }
+ },
+ xaxis: {
+ crosshairs: {
+ width: 1
+ }
+ }
+ }
+ }
+
+ sparkline(defaults) {
+ this.opts.yaxis[0].show = false
+ this.opts.yaxis[0].title.text = ''
+ this.opts.yaxis[0].axisBorder.show = false
+ this.opts.yaxis[0].axisTicks.show = false
+ this.opts.yaxis[0].floating = true
+
+ const ret = {
+ grid: {
+ show: false,
+ padding: {
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ }
+ },
+ legend: {
+ show: false
+ },
+ xaxis: {
+ labels: {
+ show: false
+ },
+ tooltip: {
+ enabled: false
+ },
+ axisBorder: {
+ show: false
+ },
+ axisTicks: {
+ show: false
+ }
+ },
+ chart: {
+ toolbar: {
+ show: false
+ },
+ zoom: {
+ enabled: false
+ }
+ },
+ dataLabels: {
+ enabled: false
+ }
+ }
+
+ return Utils.extend(defaults, ret)
+ }
+
+ bar() {
+ return {
+ chart: {
+ stacked: false,
+ animations: {
+ easing: 'swing'
+ }
+ },
+ plotOptions: {
+ bar: {
+ dataLabels: {
+ position: 'center'
+ }
+ }
+ },
+ dataLabels: {
+ style: {
+ colors: ['#fff']
+ },
+ background: {
+ enabled: false
+ }
+ },
+ stroke: {
+ width: 0,
+ lineCap: 'round'
+ },
+ fill: {
+ opacity: 0.85
+ },
+ legend: {
+ markers: {
+ shape: 'square',
+ radius: 2,
+ size: 8
+ }
+ },
+ tooltip: {
+ shared: false,
+ intersect: true
+ },
+ xaxis: {
+ tooltip: {
+ enabled: false
+ },
+ tickPlacement: 'between',
+ crosshairs: {
+ width: 'barWidth',
+ position: 'back',
+ fill: {
+ type: 'gradient'
+ },
+ dropShadow: {
+ enabled: false
+ },
+ stroke: {
+ width: 0
+ }
+ }
+ }
+ }
+ }
+
+ candlestick() {
+ return {
+ stroke: {
+ width: 1,
+ colors: ['#333']
+ },
+ fill: {
+ opacity: 1
+ },
+ dataLabels: {
+ enabled: false
+ },
+ tooltip: {
+ shared: true,
+ custom: ({ seriesIndex, dataPointIndex, w }) => {
+ return this._getBoxTooltip(
+ w,
+ seriesIndex,
+ dataPointIndex,
+ ['Open', 'High', '', 'Low', 'Close'],
+ 'candlestick'
+ )
+ }
+ },
+ states: {
+ active: {
+ filter: {
+ type: 'none'
+ }
+ }
+ },
+ xaxis: {
+ crosshairs: {
+ width: 1
+ }
+ }
+ }
+ }
+
+ boxPlot() {
+ return {
+ chart: {
+ animations: {
+ dynamicAnimation: {
+ enabled: false
+ }
+ }
+ },
+ stroke: {
+ width: 1,
+ colors: ['#24292e']
+ },
+ dataLabels: {
+ enabled: false
+ },
+ tooltip: {
+ shared: true,
+ custom: ({ seriesIndex, dataPointIndex, w }) => {
+ return this._getBoxTooltip(
+ w,
+ seriesIndex,
+ dataPointIndex,
+ ['Minimum', 'Q1', 'Median', 'Q3', 'Maximum'],
+ 'boxPlot'
+ )
+ }
+ },
+ markers: {
+ size: 5,
+ strokeWidth: 1,
+ strokeColors: '#111'
+ },
+ xaxis: {
+ crosshairs: {
+ width: 1
+ }
+ }
+ }
+ }
+
+ rangeBar() {
+ const handleTimelineTooltip = (opts) => {
+ const rangeCtx = new RangeBar(opts.ctx, null)
+
+ const {
+ color,
+ seriesName,
+ ylabel,
+ startVal,
+ endVal
+ } = rangeCtx.getTooltipValues(opts)
+ return rangeCtx.buildCustomTooltipHTML({
+ color,
+ seriesName,
+ ylabel,
+ start: startVal,
+ end: endVal
+ })
+ }
+
+ const handleRangeColumnTooltip = (opts) => {
+ const rangeCtx = new RangeBar(opts.ctx, null)
+
+ const {
+ color,
+ seriesName,
+ ylabel,
+ start,
+ end
+ } = rangeCtx.getTooltipValues(opts)
+ return rangeCtx.buildCustomTooltipHTML({
+ color,
+ seriesName,
+ ylabel,
+ start,
+ end
+ })
+ }
+ return {
+ stroke: {
+ width: 0,
+ lineCap: 'square'
+ },
+ plotOptions: {
+ bar: {
+ borderRadius: 0,
+ dataLabels: {
+ position: 'center'
+ }
+ }
+ },
+ dataLabels: {
+ enabled: false,
+ formatter(val, { ctx, seriesIndex, dataPointIndex, w }) {
+ const start = w.globals.seriesRangeStart[seriesIndex][dataPointIndex]
+ const end = w.globals.seriesRangeEnd[seriesIndex][dataPointIndex]
+ return end - start
+ },
+ background: {
+ enabled: false
+ },
+ style: {
+ colors: ['#fff']
+ }
+ },
+ tooltip: {
+ shared: false,
+ followCursor: true,
+ custom(opts) {
+ if (
+ opts.w.config.plotOptions &&
+ opts.w.config.plotOptions.bar &&
+ opts.w.config.plotOptions.bar.horizontal
+ ) {
+ return handleTimelineTooltip(opts)
+ } else {
+ return handleRangeColumnTooltip(opts)
+ }
+ }
+ },
+ xaxis: {
+ tickPlacement: 'between',
+ tooltip: {
+ enabled: false
+ },
+ crosshairs: {
+ stroke: {
+ width: 0
+ }
+ }
+ }
+ }
+ }
+
+ area() {
+ return {
+ stroke: {
+ width: 4,
+ fill: {
+ type: 'solid',
+ gradient: {
+ inverseColors: false,
+ shade: 'light',
+ type: 'vertical',
+ opacityFrom: 0.65,
+ opacityTo: 0.5,
+ stops: [0, 100, 100]
+ }
+ }
+ },
+ fill: {
+ type: 'gradient',
+ gradient: {
+ inverseColors: false,
+ shade: 'light',
+ type: 'vertical',
+ opacityFrom: 0.65,
+ opacityTo: 0.5,
+ stops: [0, 100, 100]
+ }
+ },
+ markers: {
+ size: 0,
+ hover: {
+ sizeOffset: 6
+ }
+ },
+ tooltip: {
+ followCursor: false
+ }
+ }
+ }
+
+ brush(defaults) {
+ const ret = {
+ chart: {
+ toolbar: {
+ autoSelected: 'selection',
+ show: false
+ },
+ zoom: {
+ enabled: false
+ }
+ },
+ dataLabels: {
+ enabled: false
+ },
+ stroke: {
+ width: 1
+ },
+ tooltip: {
+ enabled: false
+ },
+ xaxis: {
+ tooltip: {
+ enabled: false
+ }
+ }
+ }
+
+ return Utils.extend(defaults, ret)
+ }
+
+ stacked100(opts) {
+ opts.dataLabels = opts.dataLabels || {}
+ opts.dataLabels.formatter = opts.dataLabels.formatter || undefined
+ const existingDataLabelFormatter = opts.dataLabels.formatter
+
+ opts.yaxis.forEach((yaxe, index) => {
+ opts.yaxis[index].min = 0
+ opts.yaxis[index].max = 100
+ })
+
+ const isBar = opts.chart.type === 'bar'
+
+ if (isBar) {
+ opts.dataLabels.formatter =
+ existingDataLabelFormatter ||
+ function(val) {
+ if (typeof val === 'number') {
+ return val ? val.toFixed(0) + '%' : val
+ }
+ return val
+ }
+ }
+ return opts
+ }
+
+ // This function removes the left and right spacing in chart for line/area/scatter if xaxis type = category for those charts by converting xaxis = numeric. Numeric/Datetime xaxis prevents the unnecessary spacing in the left/right of the chart area
+ convertCatToNumeric(opts) {
+ opts.xaxis.convertedCatToNumeric = true
+
+ return opts
+ }
+
+ convertCatToNumericXaxis(opts, ctx, cats) {
+ opts.xaxis.type = 'numeric'
+ opts.xaxis.labels = opts.xaxis.labels || {}
+ opts.xaxis.labels.formatter =
+ opts.xaxis.labels.formatter ||
+ function(val) {
+ return Utils.isNumber(val) ? Math.floor(val) : val
+ }
+
+ const defaultFormatter = opts.xaxis.labels.formatter
+ let labels =
+ opts.xaxis.categories && opts.xaxis.categories.length
+ ? opts.xaxis.categories
+ : opts.labels
+
+ if (cats && cats.length) {
+ labels = cats.map((c) => {
+ return Array.isArray(c) ? c : String(c)
+ })
+ }
+
+ if (labels && labels.length) {
+ opts.xaxis.labels.formatter = function(val) {
+ return Utils.isNumber(val)
+ ? defaultFormatter(labels[Math.floor(val) - 1])
+ : defaultFormatter(val)
+ }
+ }
+
+ opts.xaxis.categories = []
+ opts.labels = []
+ opts.xaxis.tickAmount = opts.xaxis.tickAmount || 'dataPoints'
+ return opts
+ }
+
+ bubble() {
+ return {
+ dataLabels: {
+ style: {
+ colors: ['#fff']
+ }
+ },
+ tooltip: {
+ shared: false,
+ intersect: true
+ },
+ xaxis: {
+ crosshairs: {
+ width: 0
+ }
+ },
+ fill: {
+ type: 'solid',
+ gradient: {
+ shade: 'light',
+ inverse: true,
+ shadeIntensity: 0.55,
+ opacityFrom: 0.4,
+ opacityTo: 0.8
+ }
+ }
+ }
+ }
+
+ scatter() {
+ return {
+ dataLabels: {
+ enabled: false
+ },
+ tooltip: {
+ shared: false,
+ intersect: true
+ },
+ markers: {
+ size: 6,
+ strokeWidth: 1,
+ hover: {
+ sizeOffset: 2
+ }
+ }
+ }
+ }
+
+ heatmap() {
+ return {
+ chart: {
+ stacked: false
+ },
+ fill: {
+ opacity: 1
+ },
+ dataLabels: {
+ style: {
+ colors: ['#fff']
+ }
+ },
+ stroke: {
+ colors: ['#fff']
+ },
+ tooltip: {
+ followCursor: true,
+ marker: {
+ show: false
+ },
+ x: {
+ show: false
+ }
+ },
+ legend: {
+ position: 'top',
+ markers: {
+ shape: 'square',
+ size: 10,
+ offsetY: 2
+ }
+ },
+ grid: {
+ padding: {
+ right: 20
+ }
+ }
+ }
+ }
+
+ treemap() {
+ return {
+ chart: {
+ zoom: {
+ enabled: false
+ }
+ },
+ dataLabels: {
+ style: {
+ fontSize: 14,
+ fontWeight: 600,
+ colors: ['#fff']
+ }
+ },
+ stroke: {
+ show: true,
+ width: 2,
+ colors: ['#fff']
+ },
+ legend: {
+ show: false
+ },
+ fill: {
+ gradient: {
+ stops: [0, 100]
+ }
+ },
+ tooltip: {
+ followCursor: true,
+ x: {
+ show: false
+ }
+ },
+ grid: {
+ padding: {
+ left: 0,
+ right: 0
+ }
+ },
+ xaxis: {
+ crosshairs: {
+ show: false
+ },
+ tooltip: {
+ enabled: false
+ }
+ }
+ }
+ }
+
+ pie() {
+ return {
+ chart: {
+ toolbar: {
+ show: false
+ }
+ },
+ plotOptions: {
+ pie: {
+ donut: {
+ labels: {
+ show: false
+ }
+ }
+ }
+ },
+ dataLabels: {
+ formatter(val) {
+ return val.toFixed(1) + '%'
+ },
+ style: {
+ colors: ['#fff']
+ },
+ background: {
+ enabled: false
+ },
+ dropShadow: {
+ enabled: true
+ }
+ },
+ stroke: {
+ colors: ['#fff']
+ },
+ fill: {
+ opacity: 1,
+ gradient: {
+ shade: 'light',
+ stops: [0, 100]
+ }
+ },
+ tooltip: {
+ theme: 'dark',
+ fillSeriesColor: true
+ },
+ legend: {
+ position: 'right'
+ }
+ }
+ }
+
+ donut() {
+ return {
+ chart: {
+ toolbar: {
+ show: false
+ }
+ },
+ dataLabels: {
+ formatter(val) {
+ return val.toFixed(1) + '%'
+ },
+ style: {
+ colors: ['#fff']
+ },
+ background: {
+ enabled: false
+ },
+ dropShadow: {
+ enabled: true
+ }
+ },
+ stroke: {
+ colors: ['#fff']
+ },
+ fill: {
+ opacity: 1,
+ gradient: {
+ shade: 'light',
+ shadeIntensity: 0.35,
+ stops: [80, 100],
+ opacityFrom: 1,
+ opacityTo: 1
+ }
+ },
+ tooltip: {
+ theme: 'dark',
+ fillSeriesColor: true
+ },
+ legend: {
+ position: 'right'
+ }
+ }
+ }
+
+ polarArea() {
+ this.opts.yaxis[0].tickAmount = this.opts.yaxis[0].tickAmount
+ ? this.opts.yaxis[0].tickAmount
+ : 6
+
+ return {
+ chart: {
+ toolbar: {
+ show: false
+ }
+ },
+ dataLabels: {
+ formatter(val) {
+ return val.toFixed(1) + '%'
+ },
+ enabled: false
+ },
+ stroke: {
+ show: true,
+ width: 2
+ },
+ fill: {
+ opacity: 0.7
+ },
+ tooltip: {
+ theme: 'dark',
+ fillSeriesColor: true
+ },
+ legend: {
+ position: 'right'
+ }
+ }
+ }
+
+ radar() {
+ this.opts.yaxis[0].labels.offsetY = this.opts.yaxis[0].labels.offsetY
+ ? this.opts.yaxis[0].labels.offsetY
+ : 6
+
+ return {
+ dataLabels: {
+ enabled: false,
+ style: {
+ fontSize: '11px'
+ }
+ },
+ stroke: {
+ width: 2
+ },
+ markers: {
+ size: 3,
+ strokeWidth: 1,
+ strokeOpacity: 1
+ },
+ fill: {
+ opacity: 0.2
+ },
+ tooltip: {
+ shared: false,
+ intersect: true,
+ followCursor: true
+ },
+ grid: {
+ show: false
+ },
+ xaxis: {
+ labels: {
+ formatter: (val) => val,
+ style: {
+ colors: ['#a8a8a8'],
+ fontSize: '11px'
+ }
+ },
+ tooltip: {
+ enabled: false
+ },
+ crosshairs: {
+ show: false
+ }
+ }
+ }
+ }
+
+ radialBar() {
+ return {
+ chart: {
+ animations: {
+ dynamicAnimation: {
+ enabled: true,
+ speed: 800
+ }
+ },
+ toolbar: {
+ show: false
+ }
+ },
+ fill: {
+ gradient: {
+ shade: 'dark',
+ shadeIntensity: 0.4,
+ inverseColors: false,
+ type: 'diagonal2',
+ opacityFrom: 1,
+ opacityTo: 1,
+ stops: [70, 98, 100]
+ }
+ },
+ legend: {
+ show: false,
+ position: 'right'
+ },
+ tooltip: {
+ enabled: false,
+ fillSeriesColor: true
+ }
+ }
+ }
+
+ _getBoxTooltip(w, seriesIndex, dataPointIndex, labels, chartType) {
+ const o = w.globals.seriesCandleO[seriesIndex][dataPointIndex]
+ const h = w.globals.seriesCandleH[seriesIndex][dataPointIndex]
+ const m = w.globals.seriesCandleM[seriesIndex][dataPointIndex]
+ const l = w.globals.seriesCandleL[seriesIndex][dataPointIndex]
+ const c = w.globals.seriesCandleC[seriesIndex][dataPointIndex]
+
+ if (
+ w.config.series[seriesIndex].type &&
+ w.config.series[seriesIndex].type !== chartType
+ ) {
+ return `
+ ${
+ w.config.series[seriesIndex].name
+ ? w.config.series[seriesIndex].name
+ : 'series-' + (seriesIndex + 1)
+ }: ${w.globals.series[seriesIndex][dataPointIndex]}
+
`
+ } else {
+ return (
+ `
'
+ )
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/settings/Globals.js b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Globals.js
new file mode 100644
index 0000000..9e161e1
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Globals.js
@@ -0,0 +1,226 @@
+import Utils from './../../utils/Utils'
+
+export default class Globals {
+ initGlobalVars(gl) {
+ gl.series = [] // the MAIN series array (y values)
+ gl.seriesCandleO = []
+ gl.seriesCandleH = []
+ gl.seriesCandleM = []
+ gl.seriesCandleL = []
+ gl.seriesCandleC = []
+ gl.seriesRangeStart = []
+ gl.seriesRangeEnd = []
+ gl.seriesRangeBar = []
+ gl.seriesPercent = []
+ gl.seriesGoals = []
+ gl.seriesX = []
+ gl.seriesZ = []
+ gl.seriesNames = []
+ gl.seriesTotals = []
+ gl.seriesLog = []
+ gl.seriesColors = []
+ gl.stackedSeriesTotals = []
+ gl.seriesXvalues = [] // we will need this in tooltip (it's x position)
+ // when we will have unequal x values, we will need
+ // some way to get x value depending on mouse pointer
+ gl.seriesYvalues = [] // we will need this when deciding which series
+ // user hovered on
+ gl.labels = []
+ gl.hasGroups = false
+ gl.groups = []
+ gl.categoryLabels = []
+ gl.timescaleLabels = []
+ gl.noLabelsProvided = false
+ gl.resizeTimer = null
+ gl.selectionResizeTimer = null
+ gl.delayedElements = []
+ gl.pointsArray = []
+ gl.dataLabelsRects = []
+ gl.isXNumeric = false
+ gl.xaxisLabelsCount = 0
+ gl.skipLastTimelinelabel = false
+ gl.skipFirstTimelinelabel = false
+ gl.isDataXYZ = false
+ gl.isMultiLineX = false
+ gl.isMultipleYAxis = false
+ gl.maxY = -Number.MAX_VALUE
+ gl.minY = Number.MIN_VALUE
+ gl.minYArr = []
+ gl.maxYArr = []
+ gl.maxX = -Number.MAX_VALUE
+ gl.minX = Number.MAX_VALUE
+ gl.initialMaxX = -Number.MAX_VALUE
+ gl.initialMinX = Number.MAX_VALUE
+ gl.maxDate = 0
+ gl.minDate = Number.MAX_VALUE
+ gl.minZ = Number.MAX_VALUE
+ gl.maxZ = -Number.MAX_VALUE
+ gl.minXDiff = Number.MAX_VALUE
+ gl.yAxisScale = []
+ gl.xAxisScale = null
+ gl.xAxisTicksPositions = []
+ gl.yLabelsCoords = []
+ gl.yTitleCoords = []
+ gl.barPadForNumericAxis = 0
+ gl.padHorizontal = 0
+ gl.xRange = 0
+ gl.yRange = []
+ gl.zRange = 0
+ gl.dataPoints = 0
+ gl.xTickAmount = 0
+ }
+
+ globalVars(config) {
+ return {
+ chartID: null, // chart ID - apexcharts-cuid
+ cuid: null, // chart ID - random numbers excluding "apexcharts" part
+ events: {
+ beforeMount: [],
+ mounted: [],
+ updated: [],
+ clicked: [],
+ selection: [],
+ dataPointSelection: [],
+ zoomed: [],
+ scrolled: []
+ },
+ colors: [],
+ clientX: null,
+ clientY: null,
+ fill: {
+ colors: []
+ },
+ stroke: {
+ colors: []
+ },
+ dataLabels: {
+ style: {
+ colors: []
+ }
+ },
+ radarPolygons: {
+ fill: {
+ colors: []
+ }
+ },
+ markers: {
+ colors: [],
+ size: config.markers.size,
+ largestSize: 0
+ },
+ animationEnded: false,
+ isTouchDevice: 'ontouchstart' in window || navigator.msMaxTouchPoints,
+ isDirty: false, // chart has been updated after the initial render. This is different than dataChanged property. isDirty means user manually called some method to update
+ isExecCalled: false, // whether user updated the chart through the exec method
+ initialConfig: null, // we will store the first config user has set to go back when user finishes interactions like zooming and come out of it
+ initialSeries: [],
+ lastXAxis: [],
+ lastYAxis: [],
+ columnSeries: null,
+ labels: [], // store the text to draw on x axis
+ // Don't mutate the labels, many things including tooltips depends on it!
+ timescaleLabels: [], // store the timescaleLabels Labels in another variable
+ noLabelsProvided: false, // if user didn't provide any categories/labels or x values, fallback to 1,2,3,4...
+ allSeriesCollapsed: false,
+ collapsedSeries: [], // when user collapses a series, it goes into this array
+ collapsedSeriesIndices: [], // this stores the index of the collapsedSeries instead of whole object for quick access
+ ancillaryCollapsedSeries: [], // when user collapses an "alwaysVisible" series, it goes into this array
+ ancillaryCollapsedSeriesIndices: [], // this stores the index of the ancillaryCollapsedSeries whose y-axis is always visible
+ risingSeries: [], // when user re-opens a collapsed series, it goes here
+ dataFormatXNumeric: false, // boolean value to indicate user has passed numeric x values
+ capturedSeriesIndex: -1,
+ capturedDataPointIndex: -1,
+ selectedDataPoints: [],
+ goldenPadding: 35, // this value is used at a lot of places for spacing purpose
+ invalidLogScale: false, // if a user enabled log scale but the data provided is not valid to generate a log scale, turn on this flag
+ ignoreYAxisIndexes: [], // when series are being collapsed in multiple y axes, ignore certain index
+ yAxisSameScaleIndices: [],
+ maxValsInArrayIndex: 0,
+ radialSize: 0,
+ selection: undefined,
+ zoomEnabled:
+ config.chart.toolbar.autoSelected === 'zoom' &&
+ config.chart.toolbar.tools.zoom &&
+ config.chart.zoom.enabled,
+ panEnabled:
+ config.chart.toolbar.autoSelected === 'pan' &&
+ config.chart.toolbar.tools.pan,
+ selectionEnabled:
+ config.chart.toolbar.autoSelected === 'selection' &&
+ config.chart.toolbar.tools.selection,
+ yaxis: null,
+ mousedown: false,
+ lastClientPosition: {}, // don't reset this variable this the chart is destroyed. It is used to detect right or left mousemove in panning
+ visibleXRange: undefined,
+ yValueDecimal: 0, // are there floating numbers in the series. If yes, this represent the len of the decimals
+ total: 0,
+ SVGNS: 'http://www.w3.org/2000/svg', // svg namespace
+ svgWidth: 0, // the whole svg width
+ svgHeight: 0, // the whole svg height
+ noData: false, // whether there is any data to display or not
+ locale: {}, // the current locale values will be preserved here for global access
+ dom: {}, // for storing all dom nodes in this particular property
+ memory: {
+ methodsToExec: []
+ },
+ shouldAnimate: true,
+ skipLastTimelinelabel: false, // when last label is cropped, skip drawing it
+ skipFirstTimelinelabel: false, // when first label is cropped, skip drawing it
+ delayedElements: [], // element which appear after animation has finished
+ axisCharts: true, // chart type = line or area or bar
+ // (refer them also as plot charts in the code)
+ isDataXYZ: false, // bool: data was provided in a {[x,y,z]} pattern
+ resized: false, // bool: user has resized
+ resizeTimer: null, // timeout function to make a small delay before
+ // drawing when user resized
+ comboCharts: false, // bool: whether it's a combination of line/column
+ dataChanged: false, // bool: has data changed dynamically
+ previousPaths: [], // array: when data is changed, it will animate from
+ // previous paths
+ allSeriesHasEqualX: true,
+ pointsArray: [], // store the points positions here to draw later on hover
+ // format is - [[x,y],[x,y]... [x,y]]
+ dataLabelsRects: [], // store the positions of datalabels to prevent collision
+ lastDrawnDataLabelsIndexes: [],
+ hasNullValues: false, // bool: whether series contains null values
+ easing: null, // function: animation effect to apply
+ zoomed: false, // whether user has zoomed or not
+ gridWidth: 0, // drawable width of actual graphs (series paths)
+ gridHeight: 0, // drawable height of actual graphs (series paths)
+ rotateXLabels: false,
+ defaultLabels: false,
+ xLabelFormatter: undefined, // formatter for x axis labels
+ yLabelFormatters: [],
+ xaxisTooltipFormatter: undefined, // formatter for x axis tooltip
+ ttKeyFormatter: undefined,
+ ttVal: undefined,
+ ttZFormatter: undefined,
+ LINE_HEIGHT_RATIO: 1.618,
+ xAxisLabelsHeight: 0,
+ xAxisGroupLabelsHeight: 0,
+ xAxisLabelsWidth: 0,
+ yAxisLabelsWidth: 0,
+ scaleX: 1,
+ scaleY: 1,
+ translateX: 0,
+ translateY: 0,
+ translateYAxisX: [],
+ yAxisWidths: [],
+ translateXAxisY: 0,
+ translateXAxisX: 0,
+ tooltip: null
+ }
+ }
+
+ init(config) {
+ let globals = this.globalVars(config)
+ this.initGlobalVars(globals)
+
+ globals.initialConfig = Utils.extend({}, config)
+ globals.initialSeries = Utils.clone(config.series)
+
+ globals.lastXAxis = Utils.clone(globals.initialConfig.xaxis)
+ globals.lastYAxis = Utils.clone(globals.initialConfig.yaxis)
+ return globals
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/settings/Options.js b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Options.js
new file mode 100644
index 0000000..210b50c
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/settings/Options.js
@@ -0,0 +1,1082 @@
+/**
+ * ApexCharts Options for setting the initial configuration of ApexCharts
+ **/
+import en from './../../locales/en.json'
+
+export default class Options {
+ constructor() {
+ this.yAxis = {
+ show: true,
+ showAlways: false,
+ showForNullSeries: true,
+ seriesName: undefined,
+ opposite: false,
+ reversed: false,
+ logarithmic: false,
+ logBase: 10,
+ tickAmount: undefined,
+ forceNiceScale: false,
+ max: undefined,
+ min: undefined,
+ floating: false,
+ decimalsInFloat: undefined,
+ labels: {
+ show: true,
+ minWidth: 0,
+ maxWidth: 160,
+ offsetX: 0,
+ offsetY: 0,
+ align: undefined,
+ rotate: 0,
+ padding: 20,
+ style: {
+ colors: [],
+ fontSize: '11px',
+ fontWeight: 400,
+ fontFamily: undefined,
+ cssClass: ''
+ },
+ formatter: undefined
+ },
+ axisBorder: {
+ show: false,
+ color: '#e0e0e0',
+ width: 1,
+ offsetX: 0,
+ offsetY: 0
+ },
+ axisTicks: {
+ show: false,
+ color: '#e0e0e0',
+ width: 6,
+ offsetX: 0,
+ offsetY: 0
+ },
+ title: {
+ text: undefined,
+ rotate: -90,
+ offsetY: 0,
+ offsetX: 0,
+ style: {
+ color: undefined,
+ fontSize: '11px',
+ fontWeight: 900,
+ fontFamily: undefined,
+ cssClass: ''
+ }
+ },
+ tooltip: {
+ enabled: false,
+ offsetX: 0
+ },
+ crosshairs: {
+ show: true,
+ position: 'front',
+ stroke: {
+ color: '#b6b6b6',
+ width: 1,
+ dashArray: 0
+ }
+ }
+ }
+
+ this.pointAnnotation = {
+ id: undefined,
+ x: 0,
+ y: null,
+ yAxisIndex: 0,
+ seriesIndex: 0,
+ mouseEnter: undefined,
+ mouseLeave: undefined,
+ marker: {
+ size: 4,
+ fillColor: '#fff',
+ strokeWidth: 2,
+ strokeColor: '#333',
+ shape: 'circle',
+ offsetX: 0,
+ offsetY: 0,
+ radius: 2,
+ cssClass: ''
+ },
+ label: {
+ borderColor: '#c2c2c2',
+ borderWidth: 1,
+ borderRadius: 2,
+ text: undefined,
+ textAnchor: 'middle',
+ offsetX: 0,
+ offsetY: 0,
+ mouseEnter: undefined,
+ mouseLeave: undefined,
+ style: {
+ background: '#fff',
+ color: undefined,
+ fontSize: '11px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ cssClass: '',
+ padding: {
+ left: 5,
+ right: 5,
+ top: 2,
+ bottom: 2
+ }
+ }
+ },
+ customSVG: {
+ // this will be deprecated in the next major version as it is going to be replaced with a better alternative below
+ SVG: undefined,
+ cssClass: undefined,
+ offsetX: 0,
+ offsetY: 0
+ },
+ image: {
+ path: undefined,
+ width: 20,
+ height: 20,
+ offsetX: 0,
+ offsetY: 0
+ }
+ }
+
+ this.yAxisAnnotation = {
+ id: undefined,
+ y: 0,
+ y2: null,
+ strokeDashArray: 1,
+ fillColor: '#c2c2c2',
+ borderColor: '#c2c2c2',
+ borderWidth: 1,
+ opacity: 0.3,
+ offsetX: 0,
+ offsetY: 0,
+ width: '100%',
+ yAxisIndex: 0,
+ label: {
+ borderColor: '#c2c2c2',
+ borderWidth: 1,
+ borderRadius: 2,
+ text: undefined,
+ textAnchor: 'end',
+ position: 'right',
+ offsetX: 0,
+ offsetY: -3,
+ mouseEnter: undefined,
+ mouseLeave: undefined,
+ style: {
+ background: '#fff',
+ color: undefined,
+ fontSize: '11px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ cssClass: '',
+ padding: {
+ left: 5,
+ right: 5,
+ top: 2,
+ bottom: 2
+ }
+ }
+ }
+ }
+
+ this.xAxisAnnotation = {
+ id: undefined,
+ x: 0,
+ x2: null,
+ strokeDashArray: 1,
+ fillColor: '#c2c2c2',
+ borderColor: '#c2c2c2',
+ borderWidth: 1,
+ opacity: 0.3,
+ offsetX: 0,
+ offsetY: 0,
+ label: {
+ borderColor: '#c2c2c2',
+ borderWidth: 1,
+ borderRadius: 2,
+ text: undefined,
+ textAnchor: 'middle',
+ orientation: 'vertical',
+ position: 'top',
+ offsetX: 0,
+ offsetY: 0,
+ mouseEnter: undefined,
+ mouseLeave: undefined,
+ style: {
+ background: '#fff',
+ color: undefined,
+ fontSize: '11px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ cssClass: '',
+ padding: {
+ left: 5,
+ right: 5,
+ top: 2,
+ bottom: 2
+ }
+ }
+ }
+ }
+
+ this.text = {
+ x: 0,
+ y: 0,
+ text: '',
+ textAnchor: 'start',
+ foreColor: undefined,
+ fontSize: '13px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ appendTo: '.apexcharts-annotations',
+ backgroundColor: 'transparent',
+ borderColor: '#c2c2c2',
+ borderRadius: 0,
+ borderWidth: 0,
+ paddingLeft: 4,
+ paddingRight: 4,
+ paddingTop: 2,
+ paddingBottom: 2
+ }
+ }
+ init() {
+ return {
+ annotations: {
+ position: 'front',
+ yaxis: [this.yAxisAnnotation],
+ xaxis: [this.xAxisAnnotation],
+ points: [this.pointAnnotation],
+ texts: [],
+ images: [],
+ shapes: []
+ },
+ chart: {
+ animations: {
+ enabled: true,
+ easing: 'easeinout', // linear, easeout, easein, easeinout, swing, bounce, elastic
+ speed: 800,
+ animateGradually: {
+ delay: 150,
+ enabled: true
+ },
+ dynamicAnimation: {
+ enabled: true,
+ speed: 350
+ }
+ },
+ background: 'transparent',
+ locales: [en],
+ defaultLocale: 'en',
+ dropShadow: {
+ enabled: false,
+ enabledOnSeries: undefined,
+ top: 2,
+ left: 2,
+ blur: 4,
+ color: '#000',
+ opacity: 0.35
+ },
+ events: {
+ animationEnd: undefined,
+ beforeMount: undefined,
+ mounted: undefined,
+ updated: undefined,
+ click: undefined,
+ mouseMove: undefined,
+ mouseLeave: undefined,
+ legendClick: undefined,
+ markerClick: undefined,
+ selection: undefined,
+ dataPointSelection: undefined,
+ dataPointMouseEnter: undefined,
+ dataPointMouseLeave: undefined,
+ beforeZoom: undefined,
+ beforeResetZoom: undefined,
+ zoomed: undefined,
+ scrolled: undefined,
+ brushScrolled: undefined
+ },
+ foreColor: '#373d3f',
+ fontFamily: 'Helvetica, Arial, sans-serif',
+ height: 'auto',
+ parentHeightOffset: 15,
+ redrawOnParentResize: true,
+ redrawOnWindowResize: true,
+ id: undefined,
+ group: undefined,
+ offsetX: 0,
+ offsetY: 0,
+ selection: {
+ enabled: false,
+ type: 'x',
+ // selectedPoints: undefined, // default datapoints that should be selected automatically
+ fill: {
+ color: '#24292e',
+ opacity: 0.1
+ },
+ stroke: {
+ width: 1,
+ color: '#24292e',
+ opacity: 0.4,
+ dashArray: 3
+ },
+ xaxis: {
+ min: undefined,
+ max: undefined
+ },
+ yaxis: {
+ min: undefined,
+ max: undefined
+ }
+ },
+ sparkline: {
+ enabled: false
+ },
+ brush: {
+ enabled: false,
+ autoScaleYaxis: true,
+ target: undefined
+ },
+ stacked: false,
+ stackType: 'normal',
+ toolbar: {
+ show: true,
+ offsetX: 0,
+ offsetY: 0,
+ tools: {
+ download: true,
+ selection: true,
+ zoom: true,
+ zoomin: true,
+ zoomout: true,
+ pan: true,
+ reset: true,
+ customIcons: []
+ },
+ export: {
+ csv: {
+ filename: undefined,
+ columnDelimiter: ',',
+ headerCategory: 'category',
+ headerValue: 'value',
+ dateFormatter(timestamp) {
+ return new Date(timestamp).toDateString()
+ }
+ },
+ png: {
+ filename: undefined
+ },
+ svg: {
+ filename: undefined
+ }
+ },
+ autoSelected: 'zoom' // accepts -> zoom, pan, selection
+ },
+ type: 'line',
+ width: '100%',
+ zoom: {
+ enabled: true,
+ type: 'x',
+ autoScaleYaxis: false,
+ zoomedArea: {
+ fill: {
+ color: '#90CAF9',
+ opacity: 0.4
+ },
+ stroke: {
+ color: '#0D47A1',
+ opacity: 0.4,
+ width: 1
+ }
+ }
+ }
+ },
+ plotOptions: {
+ area: {
+ fillTo: 'origin'
+ },
+ bar: {
+ horizontal: false,
+ columnWidth: '70%', // should be in percent 0 - 100
+ barHeight: '70%', // should be in percent 0 - 100
+ distributed: false,
+ borderRadius: 0,
+ rangeBarOverlap: true,
+ rangeBarGroupRows: false,
+ colors: {
+ ranges: [],
+ backgroundBarColors: [],
+ backgroundBarOpacity: 1,
+ backgroundBarRadius: 0
+ },
+ dataLabels: {
+ position: 'top', // top, center, bottom
+ maxItems: 100,
+ hideOverflowingLabels: true,
+ orientation: 'horizontal'
+ // TODO: provide stackedLabels for stacked charts which gives additions of values
+ }
+ },
+ bubble: {
+ minBubbleRadius: undefined,
+ maxBubbleRadius: undefined
+ },
+ candlestick: {
+ colors: {
+ upward: '#00B746',
+ downward: '#EF403C'
+ },
+ wick: {
+ useFillColor: true
+ }
+ },
+ boxPlot: {
+ colors: {
+ upper: '#00E396',
+ lower: '#008FFB'
+ }
+ },
+ heatmap: {
+ radius: 2,
+ enableShades: true,
+ shadeIntensity: 0.5,
+ reverseNegativeShade: false,
+ distributed: false,
+ useFillColorAsStroke: false,
+ colorScale: {
+ inverse: false,
+ ranges: [],
+ min: undefined,
+ max: undefined
+ }
+ },
+ treemap: {
+ enableShades: true,
+ shadeIntensity: 0.5,
+ distributed: false,
+ reverseNegativeShade: false,
+ useFillColorAsStroke: false,
+ colorScale: {
+ inverse: false,
+ ranges: [],
+ min: undefined,
+ max: undefined
+ }
+ },
+ radialBar: {
+ inverseOrder: false,
+ startAngle: 0,
+ endAngle: 360,
+ offsetX: 0,
+ offsetY: 0,
+ hollow: {
+ margin: 5,
+ size: '50%',
+ background: 'transparent',
+ image: undefined,
+ imageWidth: 150,
+ imageHeight: 150,
+ imageOffsetX: 0,
+ imageOffsetY: 0,
+ imageClipped: true,
+ position: 'front',
+ dropShadow: {
+ enabled: false,
+ top: 0,
+ left: 0,
+ blur: 3,
+ color: '#000',
+ opacity: 0.5
+ }
+ },
+ track: {
+ show: true,
+ startAngle: undefined,
+ endAngle: undefined,
+ background: '#f2f2f2',
+ strokeWidth: '97%',
+ opacity: 1,
+ margin: 5, // margin is in pixels
+ dropShadow: {
+ enabled: false,
+ top: 0,
+ left: 0,
+ blur: 3,
+ color: '#000',
+ opacity: 0.5
+ }
+ },
+ dataLabels: {
+ show: true,
+ name: {
+ show: true,
+ fontSize: '16px',
+ fontFamily: undefined,
+ fontWeight: 600,
+ color: undefined,
+ offsetY: 0,
+ formatter(val) {
+ return val
+ }
+ },
+ value: {
+ show: true,
+ fontSize: '14px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ color: undefined,
+ offsetY: 16,
+ formatter(val) {
+ return val + '%'
+ }
+ },
+ total: {
+ show: false,
+ label: 'Total',
+ fontSize: '16px',
+ fontWeight: 600,
+ fontFamily: undefined,
+ color: undefined,
+ formatter(w) {
+ return (
+ w.globals.seriesTotals.reduce((a, b) => a + b, 0) /
+ w.globals.series.length +
+ '%'
+ )
+ }
+ }
+ }
+ },
+ pie: {
+ customScale: 1,
+ offsetX: 0,
+ offsetY: 0,
+ startAngle: 0,
+ endAngle: 360,
+ expandOnClick: true,
+ dataLabels: {
+ // These are the percentage values which are displayed on slice
+ offset: 0, // offset by which labels will move outside
+ minAngleToShowLabel: 10
+ },
+ donut: {
+ size: '65%',
+ background: 'transparent',
+ labels: {
+ // These are the inner labels appearing inside donut
+ show: false,
+ name: {
+ show: true,
+ fontSize: '16px',
+ fontFamily: undefined,
+ fontWeight: 600,
+ color: undefined,
+ offsetY: -10,
+ formatter(val) {
+ return val
+ }
+ },
+ value: {
+ show: true,
+ fontSize: '20px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ color: undefined,
+ offsetY: 10,
+ formatter(val) {
+ return val
+ }
+ },
+ total: {
+ show: false,
+ showAlways: false,
+ label: 'Total',
+ fontSize: '16px',
+ fontWeight: 400,
+ fontFamily: undefined,
+ color: undefined,
+ formatter(w) {
+ return w.globals.seriesTotals.reduce((a, b) => a + b, 0)
+ }
+ }
+ }
+ }
+ },
+ polarArea: {
+ rings: {
+ strokeWidth: 1,
+ strokeColor: '#e8e8e8'
+ },
+ spokes: {
+ strokeWidth: 1,
+ connectorColors: '#e8e8e8'
+ }
+ },
+ radar: {
+ size: undefined,
+ offsetX: 0,
+ offsetY: 0,
+ polygons: {
+ // strokeColor: '#e8e8e8', // should be deprecated in the minor version i.e 3.2
+ strokeWidth: 1,
+ strokeColors: '#e8e8e8',
+ connectorColors: '#e8e8e8',
+ fill: {
+ colors: undefined
+ }
+ }
+ }
+ },
+ colors: undefined,
+ dataLabels: {
+ enabled: true,
+ enabledOnSeries: undefined,
+ formatter(val) {
+ return val !== null ? val : ''
+ },
+ textAnchor: 'middle',
+ distributed: false,
+ offsetX: 0,
+ offsetY: 0,
+ style: {
+ fontSize: '12px',
+ fontFamily: undefined,
+ fontWeight: 600,
+ colors: undefined
+ },
+ background: {
+ enabled: true,
+ foreColor: '#fff',
+ borderRadius: 2,
+ padding: 4,
+ opacity: 0.9,
+ borderWidth: 1,
+ borderColor: '#fff',
+ dropShadow: {
+ enabled: false,
+ top: 1,
+ left: 1,
+ blur: 1,
+ color: '#000',
+ opacity: 0.45
+ }
+ },
+ dropShadow: {
+ enabled: false,
+ top: 1,
+ left: 1,
+ blur: 1,
+ color: '#000',
+ opacity: 0.45
+ }
+ },
+ fill: {
+ type: 'solid',
+ colors: undefined, // array of colors
+ opacity: 0.85,
+ gradient: {
+ shade: 'dark',
+ type: 'horizontal',
+ shadeIntensity: 0.5,
+ gradientToColors: undefined,
+ inverseColors: true,
+ opacityFrom: 1,
+ opacityTo: 1,
+ stops: [0, 50, 100],
+ colorStops: []
+ },
+ image: {
+ src: [],
+ width: undefined, // optional
+ height: undefined // optional
+ },
+ pattern: {
+ style: 'squares', // String | Array of Strings
+ width: 6,
+ height: 6,
+ strokeWidth: 2
+ }
+ },
+ forecastDataPoints: {
+ count: 0,
+ fillOpacity: 0.5,
+ strokeWidth: undefined,
+ dashArray: 4
+ },
+ grid: {
+ show: true,
+ borderColor: '#e0e0e0',
+ strokeDashArray: 0,
+ position: 'back',
+ xaxis: {
+ lines: {
+ show: false
+ }
+ },
+ yaxis: {
+ lines: {
+ show: true
+ }
+ },
+ row: {
+ colors: undefined, // takes as array which will be repeated on rows
+ opacity: 0.5
+ },
+ column: {
+ colors: undefined, // takes an array which will be repeated on columns
+ opacity: 0.5
+ },
+ padding: {
+ top: 0,
+ right: 10,
+ bottom: 0,
+ left: 12
+ }
+ },
+ labels: [],
+ legend: {
+ show: true,
+ showForSingleSeries: false,
+ showForNullSeries: true,
+ showForZeroSeries: true,
+ floating: false,
+ position: 'bottom', // whether to position legends in 1 of 4
+ // direction - top, bottom, left, right
+ horizontalAlign: 'center', // when position top/bottom, you can specify whether to align legends left, right or center
+ inverseOrder: false,
+ fontSize: '12px',
+ fontFamily: undefined,
+ fontWeight: 400,
+ width: undefined,
+ height: undefined,
+ formatter: undefined,
+ tooltipHoverFormatter: undefined,
+ offsetX: -20,
+ offsetY: 4,
+ customLegendItems: [],
+ labels: {
+ colors: undefined,
+ useSeriesColors: false
+ },
+ markers: {
+ width: 12,
+ height: 12,
+ strokeWidth: 0,
+ fillColors: undefined,
+ strokeColor: '#fff',
+ radius: 12,
+ customHTML: undefined,
+ offsetX: 0,
+ offsetY: 0,
+ onClick: undefined
+ },
+ itemMargin: {
+ horizontal: 5,
+ vertical: 2
+ },
+ onItemClick: {
+ toggleDataSeries: true
+ },
+ onItemHover: {
+ highlightDataSeries: true
+ }
+ },
+ markers: {
+ discrete: [],
+ size: 0,
+ colors: undefined,
+ //strokeColor: '#fff', // TODO: deprecate in major version 4.0
+ strokeColors: '#fff',
+ strokeWidth: 2,
+ strokeOpacity: 0.9,
+ strokeDashArray: 0,
+ fillOpacity: 1,
+ shape: 'circle',
+ width: 8, // only applicable when shape is rect/square
+ height: 8, // only applicable when shape is rect/square
+ radius: 2,
+ offsetX: 0,
+ offsetY: 0,
+ onClick: undefined,
+ onDblClick: undefined,
+ showNullDataPoints: true,
+ hover: {
+ size: undefined,
+ sizeOffset: 3
+ }
+ },
+ noData: {
+ text: undefined,
+ align: 'center',
+ verticalAlign: 'middle',
+ offsetX: 0,
+ offsetY: 0,
+ style: {
+ color: undefined,
+ fontSize: '14px',
+ fontFamily: undefined
+ }
+ },
+ responsive: [], // breakpoints should follow ascending order 400, then 700, then 1000
+ series: undefined,
+ states: {
+ normal: {
+ filter: {
+ type: 'none',
+ value: 0
+ }
+ },
+ hover: {
+ filter: {
+ type: 'lighten',
+ value: 0.1
+ }
+ },
+ active: {
+ allowMultipleDataPointsSelection: false,
+ filter: {
+ type: 'darken',
+ value: 0.5
+ }
+ }
+ },
+ title: {
+ text: undefined,
+ align: 'left',
+ margin: 5,
+ offsetX: 0,
+ offsetY: 0,
+ floating: false,
+ style: {
+ fontSize: '14px',
+ fontWeight: 900,
+ fontFamily: undefined,
+ color: undefined
+ }
+ },
+ subtitle: {
+ text: undefined,
+ align: 'left',
+ margin: 5,
+ offsetX: 0,
+ offsetY: 30,
+ floating: false,
+ style: {
+ fontSize: '12px',
+ fontWeight: 400,
+ fontFamily: undefined,
+ color: undefined
+ }
+ },
+ stroke: {
+ show: true,
+ curve: 'smooth', // "smooth" / "straight" / "stepline"
+ lineCap: 'butt', // round, butt , square
+ width: 2,
+ colors: undefined, // array of colors
+ dashArray: 0, // single value or array of values
+ fill: {
+ type: 'solid',
+ colors: undefined, // array of colors
+ opacity: 0.85,
+ gradient: {
+ shade: 'dark',
+ type: 'horizontal',
+ shadeIntensity: 0.5,
+ gradientToColors: undefined,
+ inverseColors: true,
+ opacityFrom: 1,
+ opacityTo: 1,
+ stops: [0, 50, 100],
+ colorStops: []
+ }
+ }
+ },
+ tooltip: {
+ enabled: true,
+ enabledOnSeries: undefined,
+ shared: true,
+ followCursor: false, // when disabled, the tooltip will show on top of the series instead of mouse position
+ intersect: false, // when enabled, tooltip will only show when user directly hovers over point
+ inverseOrder: false,
+ custom: undefined,
+ fillSeriesColor: false,
+ theme: 'light',
+ cssClass: '',
+ style: {
+ fontSize: '12px',
+ fontFamily: undefined
+ },
+ onDatasetHover: {
+ highlightDataSeries: false
+ },
+ x: {
+ // x value
+ show: true,
+ format: 'dd MMM', // dd/MM, dd MMM yy, dd MMM yyyy
+ formatter: undefined // a custom user supplied formatter function
+ },
+ y: {
+ formatter: undefined,
+ title: {
+ formatter(seriesName) {
+ return seriesName ? seriesName + ': ' : ''
+ }
+ }
+ },
+ z: {
+ formatter: undefined,
+ title: 'Size: '
+ },
+ marker: {
+ show: true,
+ fillColors: undefined
+ },
+ items: {
+ display: 'flex'
+ },
+ fixed: {
+ enabled: false,
+ position: 'topRight', // topRight, topLeft, bottomRight, bottomLeft
+ offsetX: 0,
+ offsetY: 0
+ }
+ },
+ xaxis: {
+ type: 'category',
+ categories: [],
+ convertedCatToNumeric: false, // internal property which should not be altered outside
+ offsetX: 0,
+ offsetY: 0,
+ overwriteCategories: undefined,
+ labels: {
+ show: true,
+ rotate: -45,
+ rotateAlways: false,
+ hideOverlappingLabels: true,
+ trim: false,
+ minHeight: undefined,
+ maxHeight: 120,
+ showDuplicates: true,
+ style: {
+ colors: [],
+ fontSize: '12px',
+ fontWeight: 400,
+ fontFamily: undefined,
+ cssClass: ''
+ },
+ offsetX: 0,
+ offsetY: 0,
+ format: undefined,
+ formatter: undefined, // custom formatter function which will override format
+ datetimeUTC: true,
+ datetimeFormatter: {
+ year: 'yyyy',
+ month: "MMM 'yy",
+ day: 'dd MMM',
+ hour: 'HH:mm',
+ minute: 'HH:mm:ss',
+ second: 'HH:mm:ss'
+ }
+ },
+ group: {
+ groups: [],
+ style: {
+ colors: [],
+ fontSize: '12px',
+ fontWeight: 400,
+ fontFamily: undefined,
+ cssClass: ''
+ }
+ },
+ axisBorder: {
+ show: true,
+ color: '#e0e0e0',
+ width: '100%',
+ height: 1,
+ offsetX: 0,
+ offsetY: 0
+ },
+ axisTicks: {
+ show: true,
+ color: '#e0e0e0',
+ height: 6,
+ offsetX: 0,
+ offsetY: 0
+ },
+ tickAmount: undefined,
+ tickPlacement: 'on',
+ min: undefined,
+ max: undefined,
+ range: undefined,
+ floating: false,
+ decimalsInFloat: undefined,
+ position: 'bottom',
+ title: {
+ text: undefined,
+ offsetX: 0,
+ offsetY: 0,
+ style: {
+ color: undefined,
+ fontSize: '12px',
+ fontWeight: 900,
+ fontFamily: undefined,
+ cssClass: ''
+ }
+ },
+ crosshairs: {
+ show: true,
+ width: 1, // tickWidth/barWidth or an integer
+ position: 'back',
+ opacity: 0.9,
+ stroke: {
+ color: '#b6b6b6',
+ width: 1,
+ dashArray: 3
+ },
+ fill: {
+ type: 'solid', // solid, gradient
+ color: '#B1B9C4',
+ gradient: {
+ colorFrom: '#D8E3F0',
+ colorTo: '#BED1E6',
+ stops: [0, 100],
+ opacityFrom: 0.4,
+ opacityTo: 0.5
+ }
+ },
+ dropShadow: {
+ enabled: false,
+ left: 0,
+ top: 0,
+ blur: 1,
+ opacity: 0.4
+ }
+ },
+ tooltip: {
+ enabled: true,
+ offsetY: 0,
+ formatter: undefined,
+ style: {
+ fontSize: '12px',
+ fontFamily: undefined
+ }
+ }
+ },
+ yaxis: this.yAxis,
+ theme: {
+ mode: 'light',
+ palette: 'palette1', // If defined, it will overwrite globals.colors variable
+ monochrome: {
+ // monochrome allows you to select just 1 color and fill out the rest with light/dark shade (intensity can be selected)
+ enabled: false,
+ color: '#008FFB',
+ shadeTo: 'light',
+ shadeIntensity: 0.65
+ }
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/AxesTooltip.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/AxesTooltip.js
new file mode 100644
index 0000000..320e7d4
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/AxesTooltip.js
@@ -0,0 +1,193 @@
+/**
+ * ApexCharts Tooltip.AxesTooltip Class.
+ * This file deals with the x-axis and y-axis tooltips.
+ *
+ * @module Tooltip.AxesTooltip
+ **/
+
+class AxesTooltip {
+ constructor(tooltipContext) {
+ this.w = tooltipContext.w
+ this.ttCtx = tooltipContext
+ }
+
+ /**
+ * This method adds the secondary tooltip which appears below x axis
+ * @memberof Tooltip
+ **/
+ drawXaxisTooltip() {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ const isBottom = w.config.xaxis.position === 'bottom'
+
+ ttCtx.xaxisOffY = isBottom
+ ? w.globals.gridHeight + 1
+ : -w.globals.xAxisHeight - w.config.xaxis.axisTicks.height + 3
+ const tooltipCssClass = isBottom
+ ? 'apexcharts-xaxistooltip apexcharts-xaxistooltip-bottom'
+ : 'apexcharts-xaxistooltip apexcharts-xaxistooltip-top'
+
+ let renderTo = w.globals.dom.elWrap
+
+ if (ttCtx.isXAxisTooltipEnabled) {
+ let xaxisTooltip = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-xaxistooltip'
+ )
+
+ if (xaxisTooltip === null) {
+ ttCtx.xaxisTooltip = document.createElement('div')
+ ttCtx.xaxisTooltip.setAttribute(
+ 'class',
+ tooltipCssClass + ' apexcharts-theme-' + w.config.tooltip.theme
+ )
+
+ renderTo.appendChild(ttCtx.xaxisTooltip)
+
+ ttCtx.xaxisTooltipText = document.createElement('div')
+ ttCtx.xaxisTooltipText.classList.add('apexcharts-xaxistooltip-text')
+
+ ttCtx.xaxisTooltipText.style.fontFamily =
+ w.config.xaxis.tooltip.style.fontFamily || w.config.chart.fontFamily
+ ttCtx.xaxisTooltipText.style.fontSize =
+ w.config.xaxis.tooltip.style.fontSize
+
+ ttCtx.xaxisTooltip.appendChild(ttCtx.xaxisTooltipText)
+ }
+ }
+ }
+
+ /**
+ * This method adds the secondary tooltip which appears below x axis
+ * @memberof Tooltip
+ **/
+ drawYaxisTooltip() {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ for (let i = 0; i < w.config.yaxis.length; i++) {
+ const isRight =
+ w.config.yaxis[i].opposite || w.config.yaxis[i].crosshairs.opposite
+
+ ttCtx.yaxisOffX = isRight ? w.globals.gridWidth + 1 : 1
+ let tooltipCssClass = isRight
+ ? `apexcharts-yaxistooltip apexcharts-yaxistooltip-${i} apexcharts-yaxistooltip-right`
+ : `apexcharts-yaxistooltip apexcharts-yaxistooltip-${i} apexcharts-yaxistooltip-left`
+
+ w.globals.yAxisSameScaleIndices.map((samescales, ssi) => {
+ samescales.map((s, si) => {
+ if (si === i) {
+ tooltipCssClass += w.config.yaxis[si].show
+ ? ` `
+ : ` apexcharts-yaxistooltip-hidden`
+ }
+ })
+ })
+
+ let renderTo = w.globals.dom.elWrap
+
+ let yaxisTooltip = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-yaxistooltip apexcharts-yaxistooltip-${i}`
+ )
+
+ if (yaxisTooltip === null) {
+ ttCtx.yaxisTooltip = document.createElement('div')
+ ttCtx.yaxisTooltip.setAttribute(
+ 'class',
+ tooltipCssClass + ' apexcharts-theme-' + w.config.tooltip.theme
+ )
+
+ renderTo.appendChild(ttCtx.yaxisTooltip)
+
+ if (i === 0) ttCtx.yaxisTooltipText = []
+
+ ttCtx.yaxisTooltipText[i] = document.createElement('div')
+ ttCtx.yaxisTooltipText[i].classList.add('apexcharts-yaxistooltip-text')
+
+ ttCtx.yaxisTooltip.appendChild(ttCtx.yaxisTooltipText[i])
+ }
+ }
+ }
+
+ /**
+ * @memberof Tooltip
+ **/
+ setXCrosshairWidth() {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ // set xcrosshairs width
+ const xcrosshairs = ttCtx.getElXCrosshairs()
+ ttCtx.xcrosshairsWidth = parseInt(w.config.xaxis.crosshairs.width, 10)
+
+ if (!w.globals.comboCharts) {
+ if (w.config.xaxis.crosshairs.width === 'tickWidth') {
+ let count = w.globals.labels.length
+ ttCtx.xcrosshairsWidth = w.globals.gridWidth / count
+ } else if (w.config.xaxis.crosshairs.width === 'barWidth') {
+ let bar = w.globals.dom.baseEl.querySelector('.apexcharts-bar-area')
+ if (bar !== null) {
+ let barWidth = parseFloat(bar.getAttribute('barWidth'))
+ ttCtx.xcrosshairsWidth = barWidth
+ } else {
+ ttCtx.xcrosshairsWidth = 1
+ }
+ }
+ } else {
+ let bar = w.globals.dom.baseEl.querySelector('.apexcharts-bar-area')
+ if (bar !== null && w.config.xaxis.crosshairs.width === 'barWidth') {
+ let barWidth = parseFloat(bar.getAttribute('barWidth'))
+ ttCtx.xcrosshairsWidth = barWidth
+ } else {
+ if (w.config.xaxis.crosshairs.width === 'tickWidth') {
+ let count = w.globals.labels.length
+ ttCtx.xcrosshairsWidth = w.globals.gridWidth / count
+ }
+ }
+ }
+
+ if (w.globals.isBarHorizontal) {
+ ttCtx.xcrosshairsWidth = 0
+ }
+ if (xcrosshairs !== null && ttCtx.xcrosshairsWidth > 0) {
+ xcrosshairs.setAttribute('width', ttCtx.xcrosshairsWidth)
+ }
+ }
+
+ handleYCrosshair() {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ // set ycrosshairs height
+ ttCtx.ycrosshairs = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-ycrosshairs'
+ )
+
+ ttCtx.ycrosshairsHidden = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-ycrosshairs-hidden'
+ )
+ }
+
+ drawYaxisTooltipText(index, clientY, xyRatios) {
+ const ttCtx = this.ttCtx
+ const w = this.w
+
+ let lbFormatter = w.globals.yLabelFormatters[index]
+
+ if (ttCtx.yaxisTooltips[index]) {
+ const elGrid = ttCtx.getElGrid()
+ const seriesBound = elGrid.getBoundingClientRect()
+
+ const hoverY = (clientY - seriesBound.top) * xyRatios.yRatio[index]
+ const height = w.globals.maxYArr[index] - w.globals.minYArr[index]
+
+ const val = w.globals.minYArr[index] + (height - hoverY)
+
+ ttCtx.tooltipPosition.moveYCrosshairs(clientY - seriesBound.top)
+ ttCtx.yaxisTooltipText[index].innerHTML = lbFormatter(val)
+ ttCtx.tooltipPosition.moveYAxisTooltip(index)
+ }
+ }
+}
+
+export default AxesTooltip
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Intersect.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Intersect.js
new file mode 100644
index 0000000..e3a33b8
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Intersect.js
@@ -0,0 +1,369 @@
+import Utils from '../../utils/Utils'
+
+/**
+ * ApexCharts Tooltip.Intersect Class.
+ * This file deals with functions related to intersecting tooltips
+ * (tooltips that appear when user hovers directly over a data-point whether)
+ *
+ * @module Tooltip.Intersect
+ **/
+
+class Intersect {
+ constructor(tooltipContext) {
+ this.w = tooltipContext.w
+ this.ttCtx = tooltipContext
+ }
+
+ // a helper function to get an element's attribute value
+ getAttr(e, attr) {
+ return parseFloat(e.target.getAttribute(attr))
+ }
+
+ // handle tooltip for heatmaps and treemaps
+ handleHeatTreeTooltip({ e, opt, x, y, type }) {
+ const ttCtx = this.ttCtx
+ const w = this.w
+
+ if (e.target.classList.contains(`apexcharts-${type}-rect`)) {
+ let i = this.getAttr(e, 'i')
+ let j = this.getAttr(e, 'j')
+ let cx = this.getAttr(e, 'cx')
+ let cy = this.getAttr(e, 'cy')
+ let width = this.getAttr(e, 'width')
+ let height = this.getAttr(e, 'height')
+
+ ttCtx.tooltipLabels.drawSeriesTexts({
+ ttItems: opt.ttItems,
+ i,
+ j,
+ shared: false,
+ e
+ })
+
+ w.globals.capturedSeriesIndex = i
+ w.globals.capturedDataPointIndex = j
+
+ x = cx + ttCtx.tooltipRect.ttWidth / 2 + width
+ y = cy + ttCtx.tooltipRect.ttHeight / 2 - height / 2
+
+ ttCtx.tooltipPosition.moveXCrosshairs(cx + width / 2)
+
+ if (x > w.globals.gridWidth / 2) {
+ x = cx - ttCtx.tooltipRect.ttWidth / 2 + width
+ }
+ if (ttCtx.w.config.tooltip.followCursor) {
+ let seriesBound = w.globals.dom.elWrap.getBoundingClientRect()
+ x =
+ w.globals.clientX -
+ seriesBound.left -
+ (x > w.globals.gridWidth / 2 ? ttCtx.tooltipRect.ttWidth : 0)
+ y =
+ w.globals.clientY -
+ seriesBound.top -
+ (y > w.globals.gridHeight / 2 ? ttCtx.tooltipRect.ttHeight : 0)
+ }
+ }
+
+ return {
+ x,
+ y
+ }
+ }
+
+ /**
+ * handle tooltips for line/area/scatter charts where tooltip.intersect is true
+ * when user hovers over the marker directly, this function is executed
+ */
+ handleMarkerTooltip({ e, opt, x, y }) {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ let i
+ let j
+ if (e.target.classList.contains('apexcharts-marker')) {
+ let cx = parseInt(opt.paths.getAttribute('cx'), 10)
+ let cy = parseInt(opt.paths.getAttribute('cy'), 10)
+ let val = parseFloat(opt.paths.getAttribute('val'))
+
+ j = parseInt(opt.paths.getAttribute('rel'), 10)
+ i =
+ parseInt(
+ opt.paths.parentNode.parentNode.parentNode.getAttribute('rel'),
+ 10
+ ) - 1
+
+ if (ttCtx.intersect) {
+ const el = Utils.findAncestor(opt.paths, 'apexcharts-series')
+ if (el) {
+ i = parseInt(el.getAttribute('data:realIndex'), 10)
+ }
+ }
+
+ ttCtx.tooltipLabels.drawSeriesTexts({
+ ttItems: opt.ttItems,
+ i,
+ j,
+ shared: ttCtx.showOnIntersect ? false : w.config.tooltip.shared,
+ e
+ })
+
+ if (e.type === 'mouseup') {
+ ttCtx.markerClick(e, i, j)
+ }
+
+ w.globals.capturedSeriesIndex = i
+ w.globals.capturedDataPointIndex = j
+
+ x = cx
+ y = cy + w.globals.translateY - ttCtx.tooltipRect.ttHeight * 1.4
+
+ if (ttCtx.w.config.tooltip.followCursor) {
+ const elGrid = ttCtx.getElGrid()
+ const seriesBound = elGrid.getBoundingClientRect()
+ y = ttCtx.e.clientY + w.globals.translateY - seriesBound.top
+ }
+
+ if (val < 0) {
+ y = cy
+ }
+ ttCtx.marker.enlargeCurrentPoint(j, opt.paths, x, y)
+ }
+
+ return {
+ x,
+ y
+ }
+ }
+
+ /**
+ * handle tooltips for bar/column charts
+ */
+ handleBarTooltip({ e, opt }) {
+ const w = this.w
+ const ttCtx = this.ttCtx
+
+ const tooltipEl = ttCtx.getElTooltip()
+
+ let bx = 0
+ let x = 0
+ let y = 0
+ let i = 0
+ let strokeWidth
+ let barXY = this.getBarTooltipXY({
+ e,
+ opt
+ })
+ i = barXY.i
+ let barHeight = barXY.barHeight
+ let j = barXY.j
+
+ w.globals.capturedSeriesIndex = i
+ w.globals.capturedDataPointIndex = j
+
+ if (
+ (w.globals.isBarHorizontal && ttCtx.tooltipUtil.hasBars()) ||
+ !w.config.tooltip.shared
+ ) {
+ x = barXY.x
+ y = barXY.y
+ strokeWidth = Array.isArray(w.config.stroke.width)
+ ? w.config.stroke.width[i]
+ : w.config.stroke.width
+ bx = x
+ } else {
+ if (!w.globals.comboCharts && !w.config.tooltip.shared) {
+ // todo: re-check this condition as it's always 0
+ bx = bx / 2
+ }
+ }
+
+ // y is NaN, make it touch the bottom of grid area
+ if (isNaN(y)) {
+ y = w.globals.svgHeight - ttCtx.tooltipRect.ttHeight
+ } else if (y < 0) {
+ y = 0
+ }
+
+ const seriesIndex = parseInt(
+ opt.paths.parentNode.getAttribute('data:realIndex'),
+ 10
+ )
+
+ const isReversed = w.globals.isMultipleYAxis
+ ? w.config.yaxis[seriesIndex] && w.config.yaxis[seriesIndex].reversed
+ : w.config.yaxis[0].reversed
+
+ if (x + ttCtx.tooltipRect.ttWidth > w.globals.gridWidth && !isReversed) {
+ x = x - ttCtx.tooltipRect.ttWidth
+ } else if (x < 0) {
+ x = 0
+ }
+
+ if (ttCtx.w.config.tooltip.followCursor) {
+ const elGrid = ttCtx.getElGrid()
+ const seriesBound = elGrid.getBoundingClientRect()
+ y = ttCtx.e.clientY - seriesBound.top
+ }
+
+ // if tooltip is still null, querySelector
+ if (ttCtx.tooltip === null) {
+ ttCtx.tooltip = w.globals.dom.baseEl.querySelector('.apexcharts-tooltip')
+ }
+
+ if (!w.config.tooltip.shared) {
+ if (w.globals.comboBarCount > 0) {
+ ttCtx.tooltipPosition.moveXCrosshairs(bx + strokeWidth / 2)
+ } else {
+ ttCtx.tooltipPosition.moveXCrosshairs(bx)
+ }
+ }
+
+ // move tooltip here
+ if (
+ !ttCtx.fixedTooltip &&
+ (!w.config.tooltip.shared ||
+ (w.globals.isBarHorizontal && ttCtx.tooltipUtil.hasBars()))
+ ) {
+ if (isReversed) {
+ x = x - ttCtx.tooltipRect.ttWidth
+ if (x < 0) {
+ x = 0
+ }
+ }
+ if (
+ isReversed &&
+ !(w.globals.isBarHorizontal && ttCtx.tooltipUtil.hasBars())
+ ) {
+ y = y + barHeight - (w.globals.series[i][j] < 0 ? barHeight : 0) * 2
+ }
+ if (ttCtx.tooltipRect.ttHeight + y > w.globals.gridHeight) {
+ y =
+ w.globals.gridHeight -
+ ttCtx.tooltipRect.ttHeight +
+ w.globals.translateY
+ } else {
+ y = y + w.globals.translateY - ttCtx.tooltipRect.ttHeight / 2
+
+ if (y < 0) {
+ y = 0
+ }
+ }
+
+ tooltipEl.style.left = x + w.globals.translateX + 'px'
+ tooltipEl.style.top = y + 'px'
+ }
+ }
+
+ getBarTooltipXY({ e, opt }) {
+ let w = this.w
+ let j = null
+ const ttCtx = this.ttCtx
+ let i = 0
+ let x = 0
+ let y = 0
+ let barWidth = 0
+ let barHeight = 0
+
+ const cl = e.target.classList
+
+ if (
+ cl.contains('apexcharts-bar-area') ||
+ cl.contains('apexcharts-candlestick-area') ||
+ cl.contains('apexcharts-boxPlot-area') ||
+ cl.contains('apexcharts-rangebar-area')
+ ) {
+ let bar = e.target
+ let barRect = bar.getBoundingClientRect()
+
+ let seriesBound = opt.elGrid.getBoundingClientRect()
+
+ let bh = barRect.height
+ barHeight = barRect.height
+ let bw = barRect.width
+
+ let cx = parseInt(bar.getAttribute('cx'), 10)
+ let cy = parseInt(bar.getAttribute('cy'), 10)
+ barWidth = parseFloat(bar.getAttribute('barWidth'))
+ const clientX = e.type === 'touchmove' ? e.touches[0].clientX : e.clientX
+
+ j = parseInt(bar.getAttribute('j'), 10)
+ i = parseInt(bar.parentNode.getAttribute('rel'), 10) - 1
+
+ let y1 = bar.getAttribute('data-range-y1')
+ let y2 = bar.getAttribute('data-range-y2')
+
+ if (w.globals.comboCharts) {
+ i = parseInt(bar.parentNode.getAttribute('data:realIndex'), 10)
+ }
+
+ // if (w.config.tooltip.shared) {
+ // this check not needed at the moment
+ // const yDivisor = w.globals.gridHeight / (w.globals.series.length)
+ // const hoverY = ttCtx.clientY - ttCtx.seriesBound.top
+
+ // j = Math.ceil(hoverY / yDivisor)
+ // }
+
+ ttCtx.tooltipLabels.drawSeriesTexts({
+ ttItems: opt.ttItems,
+ i,
+ j,
+ y1: y1 ? parseInt(y1, 10) : null,
+ y2: y2 ? parseInt(y2, 10) : null,
+ shared: ttCtx.showOnIntersect ? false : w.config.tooltip.shared,
+ e
+ })
+
+ if (w.config.tooltip.followCursor) {
+ if (w.globals.isBarHorizontal) {
+ x = clientX - seriesBound.left + 15
+ y =
+ cy -
+ ttCtx.dataPointsDividedHeight +
+ bh / 2 -
+ ttCtx.tooltipRect.ttHeight / 2
+ } else {
+ if (w.globals.isXNumeric) {
+ x = cx - bw / 2
+ } else {
+ x = cx - ttCtx.dataPointsDividedWidth + bw / 2
+ }
+ y = e.clientY - seriesBound.top - ttCtx.tooltipRect.ttHeight / 2 - 15
+ }
+ } else {
+ if (w.globals.isBarHorizontal) {
+ x = cx
+ if (x < ttCtx.xyRatios.baseLineInvertedY) {
+ x = cx - ttCtx.tooltipRect.ttWidth
+ }
+
+ y =
+ cy -
+ ttCtx.dataPointsDividedHeight +
+ bh / 2 -
+ ttCtx.tooltipRect.ttHeight / 2
+ } else {
+ // if columns
+ if (w.globals.isXNumeric) {
+ x = cx - bw / 2
+ } else {
+ x = cx - ttCtx.dataPointsDividedWidth + bw / 2
+ }
+
+ y = cy // - ttCtx.tooltipRect.ttHeight / 2 + 10
+ }
+ }
+ }
+
+ return {
+ x,
+ y,
+ barHeight,
+ barWidth,
+ i,
+ j
+ }
+ }
+}
+
+export default Intersect
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Labels.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Labels.js
new file mode 100644
index 0000000..7e05bfe
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Labels.js
@@ -0,0 +1,506 @@
+import Formatters from '../Formatters'
+import DateTime from '../../utils/DateTime'
+import Utils from './Utils'
+
+/**
+ * ApexCharts Tooltip.Labels Class to draw texts on the tooltip.
+ * This file deals with printing actual text on the tooltip.
+ *
+ * @module Tooltip.Labels
+ **/
+
+export default class Labels {
+ constructor(tooltipContext) {
+ this.w = tooltipContext.w
+ this.ctx = tooltipContext.ctx
+ this.ttCtx = tooltipContext
+ this.tooltipUtil = new Utils(tooltipContext)
+ }
+
+ drawSeriesTexts({ shared = true, ttItems, i = 0, j = null, y1, y2, e }) {
+ let w = this.w
+
+ if (w.config.tooltip.custom !== undefined) {
+ this.handleCustomTooltip({ i, j, y1, y2, w })
+ } else {
+ this.toggleActiveInactiveSeries(shared)
+ }
+
+ let values = this.getValuesToPrint({
+ i,
+ j
+ })
+
+ this.printLabels({
+ i,
+ j,
+ values,
+ ttItems,
+ shared,
+ e
+ })
+
+ // Re-calculate tooltip dimensions now that we have drawn the text
+ const tooltipEl = this.ttCtx.getElTooltip()
+
+ this.ttCtx.tooltipRect.ttWidth = tooltipEl.getBoundingClientRect().width
+ this.ttCtx.tooltipRect.ttHeight = tooltipEl.getBoundingClientRect().height
+ }
+
+ printLabels({ i, j, values, ttItems, shared, e }) {
+ const w = this.w
+ let val
+ let goalVals = []
+ const hasGoalValues = (gi) => {
+ return (
+ w.globals.seriesGoals[gi] &&
+ w.globals.seriesGoals[gi][j] &&
+ Array.isArray(w.globals.seriesGoals[gi][j])
+ )
+ }
+
+ const { xVal, zVal, xAxisTTVal } = values
+
+ let seriesName = ''
+
+ let pColor = w.globals.colors[i] // The pColor here is for the markers inside tooltip
+ if (j !== null && w.config.plotOptions.bar.distributed) {
+ pColor = w.globals.colors[j]
+ }
+
+ for (
+ let t = 0, inverset = w.globals.series.length - 1;
+ t < w.globals.series.length;
+ t++, inverset--
+ ) {
+ let f = this.getFormatters(i)
+ seriesName = this.getSeriesName({
+ fn: f.yLbTitleFormatter,
+ index: i,
+ seriesIndex: i,
+ j
+ })
+
+ if (w.config.chart.type === 'treemap') {
+ seriesName = f.yLbTitleFormatter(String(w.config.series[i].data[j].x), {
+ series: w.globals.series,
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+
+ const tIndex = w.config.tooltip.inverseOrder ? inverset : t
+
+ if (w.globals.axisCharts) {
+ const getValBySeriesIndex = (index) => {
+ return f.yLbFormatter(w.globals.series[index][j], {
+ series: w.globals.series,
+ seriesIndex: index,
+ dataPointIndex: j,
+ w
+ })
+ }
+ if (shared) {
+ f = this.getFormatters(tIndex)
+
+ seriesName = this.getSeriesName({
+ fn: f.yLbTitleFormatter,
+ index: tIndex,
+ seriesIndex: i,
+ j
+ })
+ pColor = w.globals.colors[tIndex]
+
+ val = getValBySeriesIndex(tIndex)
+ if (hasGoalValues(tIndex)) {
+ goalVals = w.globals.seriesGoals[tIndex][j].map((goal) => {
+ return {
+ attrs: goal,
+ val: f.yLbFormatter(goal.value, {
+ seriesIndex: tIndex,
+ dataPointIndex: j,
+ w
+ })
+ }
+ })
+ }
+ } else {
+ // get a color from a hover area (if it's a line pattern then get from a first line)
+ const targetFill = e?.target?.getAttribute('fill');
+ if (targetFill) {
+ pColor = (targetFill.indexOf("url") !== -1) ? (
+ document
+ .querySelector(targetFill.substr(4).slice(0, -1))
+ .childNodes[0]
+ .getAttribute("stroke")
+ ) : targetFill;
+ }
+ val = getValBySeriesIndex(i)
+ if (hasGoalValues(i) && Array.isArray(w.globals.seriesGoals[i][j])) {
+ goalVals = w.globals.seriesGoals[i][j].map((goal) => {
+ return {
+ attrs: goal,
+ val: f.yLbFormatter(goal.value, {
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ })
+ }
+ })
+ }
+ }
+ }
+
+ // for pie / donuts
+ if (j === null) {
+ val = f.yLbFormatter(w.globals.series[i], {
+ ...w,
+ seriesIndex: i,
+ dataPointIndex: i
+ })
+ }
+
+ this.DOMHandling({
+ i,
+ t: tIndex,
+ j,
+ ttItems,
+ values: {
+ val,
+ goalVals,
+ xVal,
+ xAxisTTVal,
+ zVal
+ },
+ seriesName,
+ shared,
+ pColor
+ })
+ }
+ }
+
+ getFormatters(i) {
+ const w = this.w
+
+ let yLbFormatter = w.globals.yLabelFormatters[i]
+ let yLbTitleFormatter
+
+ if (w.globals.ttVal !== undefined) {
+ if (Array.isArray(w.globals.ttVal)) {
+ yLbFormatter = w.globals.ttVal[i] && w.globals.ttVal[i].formatter
+ yLbTitleFormatter =
+ w.globals.ttVal[i] &&
+ w.globals.ttVal[i].title &&
+ w.globals.ttVal[i].title.formatter
+ } else {
+ yLbFormatter = w.globals.ttVal.formatter
+ if (typeof w.globals.ttVal.title.formatter === 'function') {
+ yLbTitleFormatter = w.globals.ttVal.title.formatter
+ }
+ }
+ } else {
+ yLbTitleFormatter = w.config.tooltip.y.title.formatter
+ }
+
+ if (typeof yLbFormatter !== 'function') {
+ if (w.globals.yLabelFormatters[0]) {
+ yLbFormatter = w.globals.yLabelFormatters[0]
+ } else {
+ yLbFormatter = function (label) {
+ return label
+ }
+ }
+ }
+
+ if (typeof yLbTitleFormatter !== 'function') {
+ yLbTitleFormatter = function (label) {
+ return label
+ }
+ }
+
+ return {
+ yLbFormatter,
+ yLbTitleFormatter
+ }
+ }
+
+ getSeriesName({ fn, index, seriesIndex, j }) {
+ const w = this.w
+ return fn(String(w.globals.seriesNames[index]), {
+ series: w.globals.series,
+ seriesIndex,
+ dataPointIndex: j,
+ w
+ })
+ }
+
+ DOMHandling({ i, t, j, ttItems, values, seriesName, shared, pColor }) {
+ const w = this.w
+ const ttCtx = this.ttCtx
+
+ const { val, goalVals, xVal, xAxisTTVal, zVal } = values
+
+ let ttItemsChildren = null
+ ttItemsChildren = ttItems[t].children
+
+ if (w.config.tooltip.fillSeriesColor) {
+ ttItems[t].style.backgroundColor = pColor
+ ttItemsChildren[0].style.display = 'none'
+ }
+
+ if (ttCtx.showTooltipTitle) {
+ if (ttCtx.tooltipTitle === null) {
+ // get it once if null, and store it in class property
+ ttCtx.tooltipTitle = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-tooltip-title'
+ )
+ }
+ ttCtx.tooltipTitle.innerHTML = xVal
+ }
+
+ // if xaxis tooltip is constructed, we need to replace the innerHTML
+ if (ttCtx.isXAxisTooltipEnabled) {
+ ttCtx.xaxisTooltipText.innerHTML = xAxisTTVal !== '' ? xAxisTTVal : xVal
+ }
+
+ const ttYLabel = ttItems[t].querySelector(
+ '.apexcharts-tooltip-text-y-label'
+ )
+ if (ttYLabel) {
+ ttYLabel.innerHTML = seriesName ? seriesName : ''
+ }
+ const ttYVal = ttItems[t].querySelector('.apexcharts-tooltip-text-y-value')
+ if (ttYVal) {
+ ttYVal.innerHTML = typeof val !== 'undefined' ? val : ''
+ }
+
+ if (
+ ttItemsChildren[0] &&
+ ttItemsChildren[0].classList.contains('apexcharts-tooltip-marker')
+ ) {
+ if (
+ w.config.tooltip.marker.fillColors &&
+ Array.isArray(w.config.tooltip.marker.fillColors)
+ ) {
+ pColor = w.config.tooltip.marker.fillColors[t]
+ }
+
+ ttItemsChildren[0].style.backgroundColor = pColor
+ }
+
+ if (!w.config.tooltip.marker.show) {
+ ttItemsChildren[0].style.display = 'none'
+ }
+
+ const ttGLabel = ttItems[t].querySelector(
+ '.apexcharts-tooltip-text-goals-label'
+ )
+ const ttGVal = ttItems[t].querySelector(
+ '.apexcharts-tooltip-text-goals-value'
+ )
+
+ if (goalVals.length && w.globals.seriesGoals[t]) {
+ const createGoalsHtml = () => {
+ let gLabels = '
'
+ let gVals = '
'
+ goalVals.forEach((goal, gi) => {
+ gLabels += `
`
+ gVals += `
${goal.val}
`
+ })
+ ttGLabel.innerHTML = gLabels + `
`
+ ttGVal.innerHTML = gVals + `
`
+ }
+ if (shared) {
+ if (
+ w.globals.seriesGoals[t][j] &&
+ Array.isArray(w.globals.seriesGoals[t][j])
+ ) {
+ createGoalsHtml()
+ } else {
+ ttGLabel.innerHTML = ''
+ ttGVal.innerHTML = ''
+ }
+ } else {
+ createGoalsHtml()
+ }
+ } else {
+ ttGLabel.innerHTML = ''
+ ttGVal.innerHTML = ''
+ }
+
+ if (zVal !== null) {
+ const ttZLabel = ttItems[t].querySelector(
+ '.apexcharts-tooltip-text-z-label'
+ )
+ ttZLabel.innerHTML = w.config.tooltip.z.title
+ const ttZVal = ttItems[t].querySelector(
+ '.apexcharts-tooltip-text-z-value'
+ )
+ ttZVal.innerHTML = typeof zVal !== 'undefined' ? zVal : ''
+ }
+
+ if (shared && ttItemsChildren[0]) {
+ // hide when no Val or series collapsed
+ if (
+ typeof val === 'undefined' ||
+ val === null ||
+ w.globals.ancillaryCollapsedSeriesIndices.indexOf(t) > -1 ||
+ w.globals.collapsedSeriesIndices.indexOf(t) > -1
+ ) {
+ ttItemsChildren[0].parentNode.style.display = 'none'
+ } else {
+ ttItemsChildren[0].parentNode.style.display =
+ w.config.tooltip.items.display
+ }
+
+ // TODO: issue #1240 needs to be looked at again. commenting it because this also hides single series values with 0 in it (shared tooltip)
+
+ // if (w.globals.stackedSeriesTotals[j] === 0) {
+ // // shared tooltip and all values are null, so we need to hide the x value too
+ // let allYZeroForJ = false
+ // for (let si = 1; si < w.globals.seriesYvalues.length; si++) {
+ // if (
+ // w.globals.seriesYvalues[si][j] ===
+ // w.globals.seriesYvalues[si - 1][j]
+ // ) {
+ // allYZeroForJ = true
+ // }
+ // }
+
+ // if (allYZeroForJ) {
+ // ttCtx.tooltipTitle.style.display = 'none'
+ // } else {
+ // ttCtx.tooltipTitle.style.display = w.config.tooltip.items.display
+ // }
+ // } else {
+ // ttCtx.tooltipTitle.style.display = w.config.tooltip.items.display
+ // }
+ }
+ }
+
+ toggleActiveInactiveSeries(shared) {
+ const w = this.w
+ if (shared) {
+ // make all tooltips active
+ this.tooltipUtil.toggleAllTooltipSeriesGroups('enable')
+ } else {
+ // disable all tooltip text groups
+ this.tooltipUtil.toggleAllTooltipSeriesGroups('disable')
+
+ // enable the first tooltip text group
+ let firstTooltipSeriesGroup = w.globals.dom.baseEl.querySelector(
+ '.apexcharts-tooltip-series-group'
+ )
+
+ if (firstTooltipSeriesGroup) {
+ firstTooltipSeriesGroup.classList.add('apexcharts-active')
+ firstTooltipSeriesGroup.style.display = w.config.tooltip.items.display
+ }
+ }
+ }
+
+ getValuesToPrint({ i, j }) {
+ const w = this.w
+ const filteredSeriesX = this.ctx.series.filteredSeriesX()
+
+ let xVal = ''
+ let xAxisTTVal = ''
+ let zVal = null
+ let val = null
+
+ const customFormatterOpts = {
+ series: w.globals.series,
+ seriesIndex: i,
+ dataPointIndex: j,
+ w
+ }
+
+ let zFormatter = w.globals.ttZFormatter
+
+ if (j === null) {
+ val = w.globals.series[i]
+ } else {
+ if (w.globals.isXNumeric && w.config.chart.type !== 'treemap') {
+ xVal = filteredSeriesX[i][j]
+ if (filteredSeriesX[i].length === 0) {
+ // a series (possibly the first one) might be collapsed, so get the next active index
+ const firstActiveSeriesIndex = this.tooltipUtil.getFirstActiveXArray(
+ filteredSeriesX
+ )
+ xVal = filteredSeriesX[firstActiveSeriesIndex][j]
+ }
+ } else {
+ xVal =
+ typeof w.globals.labels[j] !== 'undefined' ? w.globals.labels[j] : ''
+ }
+ }
+
+ let bufferXVal = xVal
+
+ if (w.globals.isXNumeric && w.config.xaxis.type === 'datetime') {
+ let xFormat = new Formatters(this.ctx)
+ xVal = xFormat.xLabelFormat(
+ w.globals.ttKeyFormatter,
+ bufferXVal,
+ bufferXVal,
+ {
+ i: undefined,
+ dateFormatter: new DateTime(this.ctx).formatDate,
+ w: this.w
+ }
+ )
+ } else {
+ if (w.globals.isBarHorizontal) {
+ xVal = w.globals.yLabelFormatters[0](bufferXVal, customFormatterOpts)
+ } else {
+ xVal = w.globals.xLabelFormatter(bufferXVal, customFormatterOpts)
+ }
+ }
+
+ // override default x-axis formatter with tooltip formatter
+ if (w.config.tooltip.x.formatter !== undefined) {
+ xVal = w.globals.ttKeyFormatter(bufferXVal, customFormatterOpts)
+ }
+
+ if (w.globals.seriesZ.length > 0 && w.globals.seriesZ[i].length > 0) {
+ zVal = zFormatter(w.globals.seriesZ[i][j], w)
+ }
+
+ if (typeof w.config.xaxis.tooltip.formatter === 'function') {
+ xAxisTTVal = w.globals.xaxisTooltipFormatter(
+ bufferXVal,
+ customFormatterOpts
+ )
+ } else {
+ xAxisTTVal = xVal
+ }
+
+ return {
+ val: Array.isArray(val) ? val.join(' ') : val,
+ xVal: Array.isArray(xVal) ? xVal.join(' ') : xVal,
+ xAxisTTVal: Array.isArray(xAxisTTVal) ? xAxisTTVal.join(' ') : xAxisTTVal,
+ zVal
+ }
+ }
+
+ handleCustomTooltip({ i, j, y1, y2, w }) {
+ const tooltipEl = this.ttCtx.getElTooltip()
+ let fn = w.config.tooltip.custom
+
+ if (Array.isArray(fn) && fn[i]) {
+ fn = fn[i]
+ }
+
+ // override everything with a custom html tooltip and replace it
+ tooltipEl.innerHTML = fn({
+ ctx: this.ctx,
+ series: w.globals.series,
+ seriesIndex: i,
+ dataPointIndex: j,
+ y1,
+ y2,
+ w
+ })
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Marker.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Marker.js
new file mode 100644
index 0000000..9a6d6bd
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Marker.js
@@ -0,0 +1,188 @@
+import Graphics from '../Graphics'
+import Position from './Position'
+import Markers from '../../modules/Markers'
+import Utils from '../../utils/Utils'
+
+/**
+ * ApexCharts Tooltip.Marker Class to draw texts on the tooltip.
+ * This file deals with the markers that appear near tooltip in line/area charts.
+ * These markers helps the user to associate the data-points and the values
+ * that are shown in the tooltip
+ *
+ * @module Tooltip.Marker
+ **/
+
+export default class Marker {
+ constructor(tooltipContext) {
+ this.w = tooltipContext.w
+ this.ttCtx = tooltipContext
+ this.ctx = tooltipContext.ctx
+ this.tooltipPosition = new Position(tooltipContext)
+ }
+
+ drawDynamicPoints() {
+ let w = this.w
+
+ let graphics = new Graphics(this.ctx)
+ let marker = new Markers(this.ctx)
+
+ let elsSeries = w.globals.dom.baseEl.querySelectorAll('.apexcharts-series')
+
+ elsSeries = [...elsSeries]
+
+ if (w.config.chart.stacked) {
+ elsSeries.sort((a, b) => {
+ return (
+ parseFloat(a.getAttribute('data:realIndex')) -
+ parseFloat(b.getAttribute('data:realIndex'))
+ )
+ })
+ }
+
+ for (let i = 0; i < elsSeries.length; i++) {
+ let pointsMain = elsSeries[i].querySelector(
+ `.apexcharts-series-markers-wrap`
+ )
+
+ if (pointsMain !== null) {
+ // it can be null as we have tooltips in donut/bar charts
+ let point
+
+ let PointClasses = `apexcharts-marker w${(Math.random() + 1)
+ .toString(36)
+ .substring(4)}`
+ if (
+ (w.config.chart.type === 'line' || w.config.chart.type === 'area') &&
+ !w.globals.comboCharts &&
+ !w.config.tooltip.intersect
+ ) {
+ PointClasses += ' no-pointer-events'
+ }
+
+ let elPointOptions = marker.getMarkerConfig({
+ cssClass: PointClasses,
+ seriesIndex: Number(pointsMain.getAttribute('data:realIndex')) // fixes apexcharts/apexcharts.js #1427
+ })
+
+ point = graphics.drawMarker(0, 0, elPointOptions)
+
+ point.node.setAttribute('default-marker-size', 0)
+
+ let elPointsG = document.createElementNS(w.globals.SVGNS, 'g')
+ elPointsG.classList.add('apexcharts-series-markers')
+
+ elPointsG.appendChild(point.node)
+ pointsMain.appendChild(elPointsG)
+ }
+ }
+ }
+
+ enlargeCurrentPoint(rel, point, x = null, y = null) {
+ let w = this.w
+
+ if (w.config.chart.type !== 'bubble') {
+ this.newPointSize(rel, point)
+ }
+
+ let cx = point.getAttribute('cx')
+ let cy = point.getAttribute('cy')
+
+ if (x !== null && y !== null) {
+ cx = x
+ cy = y
+ }
+
+ this.tooltipPosition.moveXCrosshairs(cx)
+
+ if (!this.fixedTooltip) {
+ if (w.config.chart.type === 'radar') {
+ const elGrid = this.ttCtx.getElGrid()
+ const seriesBound = elGrid.getBoundingClientRect()
+
+ cx = this.ttCtx.e.clientX - seriesBound.left
+ }
+
+ this.tooltipPosition.moveTooltip(cx, cy, w.config.markers.hover.size)
+ }
+ }
+
+ enlargePoints(j) {
+ let w = this.w
+ let me = this
+ const ttCtx = this.ttCtx
+
+ let col = j
+
+ let points = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series:not(.apexcharts-series-collapsed) .apexcharts-marker'
+ )
+
+ let newSize = w.config.markers.hover.size
+
+ for (let p = 0; p < points.length; p++) {
+ let rel = points[p].getAttribute('rel')
+ let index = points[p].getAttribute('index')
+
+ if (newSize === undefined) {
+ newSize =
+ w.globals.markers.size[index] + w.config.markers.hover.sizeOffset
+ }
+
+ if (col === parseInt(rel, 10)) {
+ me.newPointSize(col, points[p])
+
+ let cx = points[p].getAttribute('cx')
+ let cy = points[p].getAttribute('cy')
+
+ me.tooltipPosition.moveXCrosshairs(cx)
+
+ if (!ttCtx.fixedTooltip) {
+ me.tooltipPosition.moveTooltip(cx, cy, newSize)
+ }
+ } else {
+ me.oldPointSize(points[p])
+ }
+ }
+ }
+
+ newPointSize(rel, point) {
+ let w = this.w
+ let newSize = w.config.markers.hover.size
+
+ let elPoint =
+ rel === 0 ? point.parentNode.firstChild : point.parentNode.lastChild
+
+ if (elPoint.getAttribute('default-marker-size') !== '0') {
+ const index = parseInt(elPoint.getAttribute('index'), 10)
+ if (newSize === undefined) {
+ newSize =
+ w.globals.markers.size[index] + w.config.markers.hover.sizeOffset
+ }
+
+ if (newSize < 0) newSize = 0
+ elPoint.setAttribute('r', newSize)
+ }
+ }
+
+ oldPointSize(point) {
+ const size = parseFloat(point.getAttribute('default-marker-size'))
+ point.setAttribute('r', size)
+ }
+
+ resetPointsSize() {
+ let w = this.w
+
+ let points = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series:not(.apexcharts-series-collapsed) .apexcharts-marker'
+ )
+
+ for (let p = 0; p < points.length; p++) {
+ const size = parseFloat(points[p].getAttribute('default-marker-size'))
+ if (Utils.isNumber(size) && size >= 0) {
+ points[p].setAttribute('r', size)
+ } else {
+ points[p].setAttribute('r', 0)
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Position.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Position.js
new file mode 100644
index 0000000..66be5cd
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Position.js
@@ -0,0 +1,434 @@
+import Graphics from '../Graphics'
+import Series from '../Series'
+
+/**
+ * ApexCharts Tooltip.Position Class to move the tooltip based on x and y position.
+ *
+ * @module Tooltip.Position
+ **/
+
+export default class Position {
+ constructor(tooltipContext) {
+ this.ttCtx = tooltipContext
+ this.ctx = tooltipContext.ctx
+ this.w = tooltipContext.w
+ }
+
+ /**
+ * This will move the crosshair (the vertical/horz line that moves along with mouse)
+ * Along with this, this function also calls the xaxisMove function
+ * @memberof Position
+ * @param {int} - cx = point's x position, wherever point's x is, you need to move crosshair
+ */
+ moveXCrosshairs(cx, j = null) {
+ const ttCtx = this.ttCtx
+ let w = this.w
+
+ const xcrosshairs = ttCtx.getElXCrosshairs()
+
+ let x = cx - ttCtx.xcrosshairsWidth / 2
+
+ let tickAmount = w.globals.labels.slice().length
+ if (j !== null) {
+ x = (w.globals.gridWidth / tickAmount) * j
+ }
+
+ if (xcrosshairs !== null && !w.globals.isBarHorizontal) {
+ xcrosshairs.setAttribute('x', x)
+ xcrosshairs.setAttribute('x1', x)
+ xcrosshairs.setAttribute('x2', x)
+ xcrosshairs.setAttribute('y2', w.globals.gridHeight)
+ xcrosshairs.classList.add('apexcharts-active')
+ }
+
+ if (x < 0) {
+ x = 0
+ }
+
+ if (x > w.globals.gridWidth) {
+ x = w.globals.gridWidth
+ }
+
+ if (ttCtx.isXAxisTooltipEnabled) {
+ let tx = x
+ if (
+ w.config.xaxis.crosshairs.width === 'tickWidth' ||
+ w.config.xaxis.crosshairs.width === 'barWidth'
+ ) {
+ tx = x + ttCtx.xcrosshairsWidth / 2
+ }
+ this.moveXAxisTooltip(tx)
+ }
+ }
+
+ /**
+ * This will move the crosshair (the vertical/horz line that moves along with mouse)
+ * Along with this, this function also calls the xaxisMove function
+ * @memberof Position
+ * @param {int} - cx = point's x position, wherever point's x is, you need to move crosshair
+ */
+ moveYCrosshairs(cy) {
+ const ttCtx = this.ttCtx
+
+ if (ttCtx.ycrosshairs !== null) {
+ Graphics.setAttrs(ttCtx.ycrosshairs, {
+ y1: cy,
+ y2: cy
+ })
+ }
+ if (ttCtx.ycrosshairsHidden !== null) {
+ Graphics.setAttrs(ttCtx.ycrosshairsHidden, {
+ y1: cy,
+ y2: cy
+ })
+ }
+ }
+
+ /**
+ ** AxisTooltip is the small rectangle which appears on x axis with x value, when user moves
+ * @memberof Position
+ * @param {int} - cx = point's x position, wherever point's x is, you need to move
+ */
+ moveXAxisTooltip(cx) {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ if (ttCtx.xaxisTooltip !== null && ttCtx.xcrosshairsWidth !== 0) {
+ ttCtx.xaxisTooltip.classList.add('apexcharts-active')
+
+ let cy =
+ ttCtx.xaxisOffY +
+ w.config.xaxis.tooltip.offsetY +
+ w.globals.translateY +
+ 1 +
+ w.config.xaxis.offsetY
+
+ let xaxisTTText = ttCtx.xaxisTooltip.getBoundingClientRect()
+ let xaxisTTTextWidth = xaxisTTText.width
+
+ cx = cx - xaxisTTTextWidth / 2
+
+ if (!isNaN(cx)) {
+ cx = cx + w.globals.translateX
+
+ let textRect = 0
+ const graphics = new Graphics(this.ctx)
+ textRect = graphics.getTextRects(ttCtx.xaxisTooltipText.innerHTML)
+
+ ttCtx.xaxisTooltipText.style.minWidth = textRect.width + 'px'
+ ttCtx.xaxisTooltip.style.left = cx + 'px'
+ ttCtx.xaxisTooltip.style.top = cy + 'px'
+ }
+ }
+ }
+
+ moveYAxisTooltip(index) {
+ const w = this.w
+ const ttCtx = this.ttCtx
+
+ if (ttCtx.yaxisTTEls === null) {
+ ttCtx.yaxisTTEls = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-yaxistooltip'
+ )
+ }
+
+ const ycrosshairsHiddenRectY1 = parseInt(
+ ttCtx.ycrosshairsHidden.getAttribute('y1'),
+ 10
+ )
+ let cy = w.globals.translateY + ycrosshairsHiddenRectY1
+
+ const yAxisTTRect = ttCtx.yaxisTTEls[index].getBoundingClientRect()
+ const yAxisTTHeight = yAxisTTRect.height
+ let cx = w.globals.translateYAxisX[index] - 2
+
+ if (w.config.yaxis[index].opposite) {
+ cx = cx - 26
+ }
+
+ cy = cy - yAxisTTHeight / 2
+
+ if (w.globals.ignoreYAxisIndexes.indexOf(index) === -1) {
+ ttCtx.yaxisTTEls[index].classList.add('apexcharts-active')
+ ttCtx.yaxisTTEls[index].style.top = cy + 'px'
+ ttCtx.yaxisTTEls[index].style.left =
+ cx + w.config.yaxis[index].tooltip.offsetX + 'px'
+ } else {
+ ttCtx.yaxisTTEls[index].classList.remove('apexcharts-active')
+ }
+ }
+
+ /**
+ ** moves the whole tooltip by changing x, y attrs
+ * @memberof Position
+ * @param {int} - cx = point's x position, wherever point's x is, you need to move tooltip
+ * @param {int} - cy = point's y position, wherever point's y is, you need to move tooltip
+ * @param {int} - r = point's radius
+ */
+ moveTooltip(cx, cy, r = null) {
+ let w = this.w
+
+ let ttCtx = this.ttCtx
+ const tooltipEl = ttCtx.getElTooltip()
+ let tooltipRect = ttCtx.tooltipRect
+
+ let pointR = r !== null ? parseFloat(r) : 1
+
+ let x = parseFloat(cx) + pointR + 5
+ let y = parseFloat(cy) + pointR / 2 // - tooltipRect.ttHeight / 2
+
+ if (x > w.globals.gridWidth / 2) {
+ x = x - tooltipRect.ttWidth - pointR - 10
+ }
+
+ if (x > w.globals.gridWidth - tooltipRect.ttWidth - 10) {
+ x = w.globals.gridWidth - tooltipRect.ttWidth
+ }
+
+ if (x < -20) {
+ x = -20
+ }
+
+ if (w.config.tooltip.followCursor) {
+ const elGrid = ttCtx.getElGrid()
+ const seriesBound = elGrid.getBoundingClientRect()
+ y =
+ ttCtx.e.clientY +
+ w.globals.translateY -
+ seriesBound.top -
+ tooltipRect.ttHeight / 2
+ } else {
+ if (!w.globals.isBarHorizontal) {
+ if (tooltipRect.ttHeight / 2 + y > w.globals.gridHeight) {
+ y = w.globals.gridHeight - tooltipRect.ttHeight + w.globals.translateY
+ }
+
+ if (y < 0) {
+ y = 0
+ }
+ }
+ }
+
+ if (!isNaN(x)) {
+ x = x + w.globals.translateX
+
+ tooltipEl.style.left = x + 'px'
+ tooltipEl.style.top = y + 'px'
+ }
+ }
+
+ moveMarkers(i, j) {
+ let w = this.w
+ let ttCtx = this.ttCtx
+
+ if (w.globals.markers.size[i] > 0) {
+ let allPoints = w.globals.dom.baseEl.querySelectorAll(
+ ` .apexcharts-series[data\\:realIndex='${i}'] .apexcharts-marker`
+ )
+ for (let p = 0; p < allPoints.length; p++) {
+ if (parseInt(allPoints[p].getAttribute('rel'), 10) === j) {
+ ttCtx.marker.resetPointsSize()
+ ttCtx.marker.enlargeCurrentPoint(j, allPoints[p])
+ }
+ }
+ } else {
+ ttCtx.marker.resetPointsSize()
+ this.moveDynamicPointOnHover(j, i)
+ }
+ }
+
+ // This function is used when you need to show markers/points only on hover -
+ // DIFFERENT X VALUES in multiple series
+ moveDynamicPointOnHover(j, capturedSeries) {
+ let w = this.w
+ let ttCtx = this.ttCtx
+ let cx = 0
+ let cy = 0
+
+ let pointsArr = w.globals.pointsArray
+
+ let hoverSize = ttCtx.tooltipUtil.getHoverMarkerSize(capturedSeries)
+
+ const serType = w.config.series[capturedSeries].type
+ if (
+ serType &&
+ (serType === 'column' ||
+ serType === 'candlestick' ||
+ serType === 'boxPlot')
+ ) {
+ // fix error mentioned in #811
+ return
+ }
+
+ cx = pointsArr[capturedSeries][j][0]
+ cy = pointsArr[capturedSeries][j][1] ? pointsArr[capturedSeries][j][1] : 0
+
+ let point = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-series[data\\:realIndex='${capturedSeries}'] .apexcharts-series-markers circle`
+ )
+
+ if (point && cy < w.globals.gridHeight && cy > 0) {
+ point.setAttribute('r', hoverSize)
+
+ point.setAttribute('cx', cx)
+ point.setAttribute('cy', cy)
+ }
+
+ // point.style.opacity = w.config.markers.hover.opacity
+
+ this.moveXCrosshairs(cx)
+
+ if (!ttCtx.fixedTooltip) {
+ this.moveTooltip(cx, cy, hoverSize)
+ }
+ }
+
+ // This function is used when you need to show markers/points only on hover -
+ // SAME X VALUES in multiple series
+ moveDynamicPointsOnHover(j) {
+ const ttCtx = this.ttCtx
+ let w = ttCtx.w
+ let cx = 0
+ let cy = 0
+ let activeSeries = 0
+
+ let pointsArr = w.globals.pointsArray
+
+ let series = new Series(this.ctx)
+ activeSeries = series.getActiveConfigSeriesIndex(true)
+
+ let hoverSize = ttCtx.tooltipUtil.getHoverMarkerSize(activeSeries)
+
+ if (pointsArr[activeSeries]) {
+ cx = pointsArr[activeSeries][j][0]
+ cy = pointsArr[activeSeries][j][1]
+ }
+
+ let points = ttCtx.tooltipUtil.getAllMarkers()
+
+ if (points !== null) {
+ for (let p = 0; p < w.globals.series.length; p++) {
+ let pointArr = pointsArr[p]
+
+ if (w.globals.comboCharts) {
+ // in a combo chart, if column charts are present, markers will not match with the number of series, hence this patch to push a null value in points array
+ if (typeof pointArr === 'undefined') {
+ // nodelist to array
+ points.splice(p, 0, null)
+ }
+ }
+ if (pointArr && pointArr.length) {
+ let pcy = pointsArr[p][j][1]
+ points[p].setAttribute('cx', cx)
+
+ if (
+ pcy !== null &&
+ !isNaN(pcy) &&
+ pcy < w.globals.gridHeight + hoverSize &&
+ pcy + hoverSize > 0
+ ) {
+ points[p] && points[p].setAttribute('r', hoverSize)
+ points[p] && points[p].setAttribute('cy', pcy)
+ } else {
+ points[p] && points[p].setAttribute('r', 0)
+ }
+ }
+ }
+ }
+
+ this.moveXCrosshairs(cx)
+
+ if (!ttCtx.fixedTooltip) {
+ let tcy = cy || w.globals.gridHeight
+ this.moveTooltip(cx, tcy, hoverSize)
+ }
+ }
+
+ moveStickyTooltipOverBars(j) {
+ const w = this.w
+ const ttCtx = this.ttCtx
+
+ let barLen = w.globals.columnSeries
+ ? w.globals.columnSeries.length
+ : w.globals.series.length
+
+ let i =
+ barLen >= 2 && barLen % 2 === 0
+ ? Math.floor(barLen / 2)
+ : Math.floor(barLen / 2) + 1
+
+ if (w.globals.isBarHorizontal) {
+ let series = new Series(this.ctx)
+ i = series.getActiveConfigSeriesIndex(false, 'desc') + 1
+ }
+ let jBar = w.globals.dom.baseEl.querySelector(
+ `.apexcharts-bar-series .apexcharts-series[rel='${i}'] path[j='${j}'], .apexcharts-candlestick-series .apexcharts-series[rel='${i}'] path[j='${j}'], .apexcharts-boxPlot-series .apexcharts-series[rel='${i}'] path[j='${j}'], .apexcharts-rangebar-series .apexcharts-series[rel='${i}'] path[j='${j}']`
+ )
+
+ let bcx = jBar ? parseFloat(jBar.getAttribute('cx')) : 0
+ let bcy = jBar ? parseFloat(jBar.getAttribute('cy')) : 0
+ let bw = jBar ? parseFloat(jBar.getAttribute('barWidth')) : 0
+ let bh = jBar ? parseFloat(jBar.getAttribute('barHeight')) : 0
+
+ const elGrid = ttCtx.getElGrid()
+ let seriesBound = elGrid.getBoundingClientRect()
+
+ const isBoxOrCandle =
+ jBar.classList.contains('apexcharts-candlestick-area') ||
+ jBar.classList.contains('apexcharts-boxPlot-area')
+ if (w.globals.isXNumeric) {
+ if (jBar && !isBoxOrCandle) {
+ bcx = bcx - (barLen % 2 !== 0 ? bw / 2 : 0)
+ }
+
+ if (
+ jBar && // fixes apexcharts.js#2354
+ isBoxOrCandle &&
+ w.globals.comboCharts
+ ) {
+ bcx = bcx - bw / 2
+ }
+ } else {
+ if (!w.globals.isBarHorizontal) {
+ bcx =
+ ttCtx.xAxisTicksPositions[j - 1] + ttCtx.dataPointsDividedWidth / 2
+ if (isNaN(bcx)) {
+ bcx = ttCtx.xAxisTicksPositions[j] - ttCtx.dataPointsDividedWidth / 2
+ }
+ }
+ }
+
+ if (!w.globals.isBarHorizontal) {
+ if (w.config.tooltip.followCursor) {
+ bcy = ttCtx.e.clientY - seriesBound.top - ttCtx.tooltipRect.ttHeight / 2
+ } else {
+ if (bcy + ttCtx.tooltipRect.ttHeight + 15 > w.globals.gridHeight) {
+ bcy = w.globals.gridHeight
+ }
+ }
+ } else {
+ if (bcy > w.globals.gridHeight / 2) {
+ bcy = bcy - ttCtx.tooltipRect.ttHeight
+ }
+
+ bcy = bcy + w.config.grid.padding.top + bh / 3
+
+ if (bcy + bh > w.globals.gridHeight) {
+ bcy = w.globals.gridHeight - bh
+ }
+ }
+
+ if (bcy < -10) {
+ bcy = -10
+ }
+
+ if (!w.globals.isBarHorizontal) {
+ this.moveXCrosshairs(bcx)
+ }
+
+ if (!ttCtx.fixedTooltip) {
+ let tcy = bcy || w.globals.gridHeight
+ this.moveTooltip(bcx, tcy)
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/README.md b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/README.md
new file mode 100644
index 0000000..bae129b
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/README.md
@@ -0,0 +1,20 @@
+### AxesTooltip.js
+This file deals with the x-axis and y-axis tooltips.
+
+### Intersect.js
+This file deals with functions related to intersecting tooltips (tooltips that appear when user hovers directly over a data-point whether).
+
+### Labels.js
+This file deals with printing actual text on the tooltip.
+
+### Marker.js
+This file deals with the markers that appear near tooltip in line/area charts. These markers helps the user to associate the data-points and the values that are shown in the tooltip
+
+### Position.js
+This file deals with positioning of the tooltip.
+
+### Tooltip.js
+This is the primary file which is an entry point for all tooltip related functionality.
+
+### Utils.js
+Helper functions related to tooltips.
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Tooltip.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Tooltip.js
new file mode 100644
index 0000000..1c7b828
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Tooltip.js
@@ -0,0 +1,886 @@
+import Labels from './Labels'
+import Position from './Position'
+import Marker from './Marker'
+import Intersect from './Intersect'
+import AxesTooltip from './AxesTooltip'
+import Graphics from '../Graphics'
+import Series from '../Series'
+import XAxis from './../axes/XAxis'
+import Utils from './Utils'
+
+/**
+ * ApexCharts Core Tooltip Class to handle the tooltip generation.
+ *
+ * @module Tooltip
+ **/
+
+export default class Tooltip {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+ const w = this.w
+
+ this.tConfig = w.config.tooltip
+
+ this.tooltipUtil = new Utils(this)
+ this.tooltipLabels = new Labels(this)
+ this.tooltipPosition = new Position(this)
+ this.marker = new Marker(this)
+ this.intersect = new Intersect(this)
+ this.axesTooltip = new AxesTooltip(this)
+ this.showOnIntersect = this.tConfig.intersect
+ this.showTooltipTitle = this.tConfig.x.show
+ this.fixedTooltip = this.tConfig.fixed.enabled
+ this.xaxisTooltip = null
+ this.yaxisTTEls = null
+ this.isBarShared = !w.globals.isBarHorizontal && this.tConfig.shared
+ this.lastHoverTime = Date.now()
+ }
+
+ getElTooltip(ctx) {
+ if (!ctx) ctx = this
+ if (!ctx.w.globals.dom.baseEl) return null
+
+ return ctx.w.globals.dom.baseEl.querySelector('.apexcharts-tooltip')
+ }
+
+ getElXCrosshairs() {
+ return this.w.globals.dom.baseEl.querySelector('.apexcharts-xcrosshairs')
+ }
+
+ getElGrid() {
+ return this.w.globals.dom.baseEl.querySelector('.apexcharts-grid')
+ }
+
+ drawTooltip(xyRatios) {
+ let w = this.w
+ this.xyRatios = xyRatios
+ this.isXAxisTooltipEnabled =
+ w.config.xaxis.tooltip.enabled && w.globals.axisCharts
+ this.yaxisTooltips = w.config.yaxis.map((y, i) => {
+ return y.show && y.tooltip.enabled && w.globals.axisCharts ? true : false
+ })
+ this.allTooltipSeriesGroups = []
+
+ if (!w.globals.axisCharts) {
+ this.showTooltipTitle = false
+ }
+
+ const tooltipEl = document.createElement('div')
+ tooltipEl.classList.add('apexcharts-tooltip')
+ if (w.config.tooltip.cssClass) {
+ tooltipEl.classList.add(w.config.tooltip.cssClass)
+ }
+ tooltipEl.classList.add(`apexcharts-theme-${this.tConfig.theme}`)
+ w.globals.dom.elWrap.appendChild(tooltipEl)
+
+ if (w.globals.axisCharts) {
+ this.axesTooltip.drawXaxisTooltip()
+ this.axesTooltip.drawYaxisTooltip()
+ this.axesTooltip.setXCrosshairWidth()
+ this.axesTooltip.handleYCrosshair()
+
+ let xAxis = new XAxis(this.ctx)
+ this.xAxisTicksPositions = xAxis.getXAxisTicksPositions()
+ }
+
+ // we forcefully set intersect true for these conditions
+ if (
+ (w.globals.comboCharts ||
+ this.tConfig.intersect ||
+ w.config.chart.type === 'rangeBar') &&
+ !this.tConfig.shared
+ ) {
+ this.showOnIntersect = true
+ }
+
+ if (w.config.markers.size === 0 || w.globals.markers.largestSize === 0) {
+ // when user don't want to show points all the time, but only on when hovering on series
+ this.marker.drawDynamicPoints(this)
+ }
+
+ // no visible series, exit
+ if (w.globals.collapsedSeries.length === w.globals.series.length) return
+
+ this.dataPointsDividedHeight = w.globals.gridHeight / w.globals.dataPoints
+ this.dataPointsDividedWidth = w.globals.gridWidth / w.globals.dataPoints
+
+ if (this.showTooltipTitle) {
+ this.tooltipTitle = document.createElement('div')
+ this.tooltipTitle.classList.add('apexcharts-tooltip-title')
+ this.tooltipTitle.style.fontFamily =
+ this.tConfig.style.fontFamily || w.config.chart.fontFamily
+ this.tooltipTitle.style.fontSize = this.tConfig.style.fontSize
+ tooltipEl.appendChild(this.tooltipTitle)
+ }
+
+ let ttItemsCnt = w.globals.series.length // whether shared or not, default is shared
+ if ((w.globals.xyCharts || w.globals.comboCharts) && this.tConfig.shared) {
+ if (!this.showOnIntersect) {
+ ttItemsCnt = w.globals.series.length
+ } else {
+ ttItemsCnt = 1
+ }
+ }
+
+ this.legendLabels = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-legend-text'
+ )
+
+ this.ttItems = this.createTTElements(ttItemsCnt)
+ this.addSVGEvents()
+ }
+
+ createTTElements(ttItemsCnt) {
+ const w = this.w
+ let ttItems = []
+
+ const tooltipEl = this.getElTooltip()
+ for (let i = 0; i < ttItemsCnt; i++) {
+ let gTxt = document.createElement('div')
+ gTxt.classList.add('apexcharts-tooltip-series-group')
+ gTxt.style.order = w.config.tooltip.inverseOrder ? ttItemsCnt - i : i + 1
+ if (
+ this.tConfig.shared &&
+ this.tConfig.enabledOnSeries &&
+ Array.isArray(this.tConfig.enabledOnSeries)
+ ) {
+ if (this.tConfig.enabledOnSeries.indexOf(i) < 0) {
+ gTxt.classList.add('apexcharts-tooltip-series-group-hidden')
+ }
+ }
+
+ let point = document.createElement('span')
+ point.classList.add('apexcharts-tooltip-marker')
+ point.style.backgroundColor = w.globals.colors[i]
+ gTxt.appendChild(point)
+
+ const gYZ = document.createElement('div')
+ gYZ.classList.add('apexcharts-tooltip-text')
+
+ gYZ.style.fontFamily =
+ this.tConfig.style.fontFamily || w.config.chart.fontFamily
+ gYZ.style.fontSize = this.tConfig.style.fontSize
+ ;['y', 'goals', 'z'].forEach((g) => {
+ const gValText = document.createElement('div')
+ gValText.classList.add(`apexcharts-tooltip-${g}-group`)
+
+ let txtLabel = document.createElement('span')
+ txtLabel.classList.add(`apexcharts-tooltip-text-${g}-label`)
+ gValText.appendChild(txtLabel)
+
+ let txtValue = document.createElement('span')
+ txtValue.classList.add(`apexcharts-tooltip-text-${g}-value`)
+ gValText.appendChild(txtValue)
+
+ gYZ.appendChild(gValText)
+ })
+
+ gTxt.appendChild(gYZ)
+
+ tooltipEl.appendChild(gTxt)
+
+ ttItems.push(gTxt)
+ }
+
+ return ttItems
+ }
+
+ addSVGEvents() {
+ const w = this.w
+ let type = w.config.chart.type
+ const tooltipEl = this.getElTooltip()
+
+ const commonBar = !!(
+ type === 'bar' ||
+ type === 'candlestick' ||
+ type === 'boxPlot' ||
+ type === 'rangeBar'
+ )
+
+ const chartWithmarkers =
+ type === 'area' ||
+ type === 'line' ||
+ type === 'scatter' ||
+ type === 'bubble' ||
+ type === 'radar'
+
+ let hoverArea = w.globals.dom.Paper.node
+
+ const elGrid = this.getElGrid()
+ if (elGrid) {
+ this.seriesBound = elGrid.getBoundingClientRect()
+ }
+
+ let tooltipY = []
+ let tooltipX = []
+
+ let seriesHoverParams = {
+ hoverArea,
+ elGrid,
+ tooltipEl,
+ tooltipY,
+ tooltipX,
+ ttItems: this.ttItems
+ }
+
+ let points
+
+ if (w.globals.axisCharts) {
+ if (chartWithmarkers) {
+ points = w.globals.dom.baseEl.querySelectorAll(
+ ".apexcharts-series[data\\:longestSeries='true'] .apexcharts-marker"
+ )
+ } else if (commonBar) {
+ points = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series .apexcharts-bar-area, .apexcharts-series .apexcharts-candlestick-area, .apexcharts-series .apexcharts-boxPlot-area, .apexcharts-series .apexcharts-rangebar-area'
+ )
+ } else if (type === 'heatmap' || type === 'treemap') {
+ points = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series .apexcharts-heatmap, .apexcharts-series .apexcharts-treemap'
+ )
+ }
+
+ if (points && points.length) {
+ for (let p = 0; p < points.length; p++) {
+ tooltipY.push(points[p].getAttribute('cy'))
+ tooltipX.push(points[p].getAttribute('cx'))
+ }
+ }
+ }
+
+ const validSharedChartTypes =
+ (w.globals.xyCharts && !this.showOnIntersect) ||
+ (w.globals.comboCharts && !this.showOnIntersect) ||
+ (commonBar && this.tooltipUtil.hasBars() && this.tConfig.shared)
+
+ if (validSharedChartTypes) {
+ this.addPathsEventListeners([hoverArea], seriesHoverParams)
+ } else if (
+ (commonBar && !w.globals.comboCharts) ||
+ (chartWithmarkers && this.showOnIntersect)
+ ) {
+ this.addDatapointEventsListeners(seriesHoverParams)
+ } else if (
+ !w.globals.axisCharts ||
+ type === 'heatmap' ||
+ type === 'treemap'
+ ) {
+ let seriesAll = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series'
+ )
+ this.addPathsEventListeners(seriesAll, seriesHoverParams)
+ }
+
+ if (this.showOnIntersect) {
+ let lineAreaPoints = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-line-series .apexcharts-marker, .apexcharts-area-series .apexcharts-marker'
+ )
+ if (lineAreaPoints.length > 0) {
+ // if we find any lineSeries, addEventListeners for them
+ this.addPathsEventListeners(lineAreaPoints, seriesHoverParams)
+ }
+
+ // combo charts may have bars, so add event listeners here too
+ if (this.tooltipUtil.hasBars() && !this.tConfig.shared) {
+ this.addDatapointEventsListeners(seriesHoverParams)
+ }
+ }
+ }
+
+ drawFixedTooltipRect() {
+ let w = this.w
+
+ const tooltipEl = this.getElTooltip()
+
+ let tooltipRect = tooltipEl.getBoundingClientRect()
+
+ let ttWidth = tooltipRect.width + 10
+ let ttHeight = tooltipRect.height + 10
+ let x = this.tConfig.fixed.offsetX
+ let y = this.tConfig.fixed.offsetY
+
+ const fixed = this.tConfig.fixed.position.toLowerCase()
+
+ if (fixed.indexOf('right') > -1) {
+ x = x + w.globals.svgWidth - ttWidth + 10
+ }
+ if (fixed.indexOf('bottom') > -1) {
+ y = y + w.globals.svgHeight - ttHeight - 10
+ }
+
+ tooltipEl.style.left = x + 'px'
+ tooltipEl.style.top = y + 'px'
+
+ return {
+ x,
+ y,
+ ttWidth,
+ ttHeight
+ }
+ }
+
+ addDatapointEventsListeners(seriesHoverParams) {
+ let w = this.w
+ let points = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series-markers .apexcharts-marker, .apexcharts-bar-area, .apexcharts-candlestick-area, .apexcharts-boxPlot-area, .apexcharts-rangebar-area'
+ )
+ this.addPathsEventListeners(points, seriesHoverParams)
+ }
+
+ addPathsEventListeners(paths, opts) {
+ let self = this
+
+ for (let p = 0; p < paths.length; p++) {
+ let extendedOpts = {
+ paths: paths[p],
+ tooltipEl: opts.tooltipEl,
+ tooltipY: opts.tooltipY,
+ tooltipX: opts.tooltipX,
+ elGrid: opts.elGrid,
+ hoverArea: opts.hoverArea,
+ ttItems: opts.ttItems
+ }
+
+ let events = ['mousemove', 'mouseup', 'touchmove', 'mouseout', 'touchend']
+
+ events.map((ev) => {
+ return paths[p].addEventListener(
+ ev,
+ self.onSeriesHover.bind(self, extendedOpts),
+ { capture: false, passive: true }
+ )
+ })
+ }
+ }
+
+ /*
+ ** Check to see if the tooltips should be updated based on a mouse / touch event
+ */
+ onSeriesHover(opt, e) {
+ // If a user is moving their mouse quickly, don't bother updating the tooltip every single frame
+
+ const targetDelay = 100
+ const timeSinceLastUpdate = Date.now() - this.lastHoverTime
+ if (timeSinceLastUpdate >= targetDelay) {
+ // The tooltip was last updated over 100ms ago - redraw it even if the user is still moving their
+ // mouse so they get some feedback that their moves are being registered
+ this.seriesHover(opt, e)
+ } else {
+ // The tooltip was last updated less than 100ms ago
+ // Cancel any other delayed draw, so we don't show stale data
+ clearTimeout(this.seriesHoverTimeout)
+
+ // Schedule the next draw so that it happens about 100ms after the last update
+ this.seriesHoverTimeout = setTimeout(() => {
+ this.seriesHover(opt, e)
+ }, targetDelay - timeSinceLastUpdate)
+ }
+ }
+
+ /*
+ ** The actual series hover function
+ */
+ seriesHover(opt, e) {
+ this.lastHoverTime = Date.now()
+ let chartGroups = []
+ const w = this.w
+
+ // if user has more than one charts in group, we need to sync
+ if (w.config.chart.group) {
+ chartGroups = this.ctx.getGroupedCharts()
+ }
+
+ if (
+ w.globals.axisCharts &&
+ ((w.globals.minX === -Infinity && w.globals.maxX === Infinity) ||
+ w.globals.dataPoints === 0)
+ ) {
+ return
+ }
+
+ if (chartGroups.length) {
+ chartGroups.forEach((ch) => {
+ const tooltipEl = this.getElTooltip(ch)
+
+ const newOpts = {
+ paths: opt.paths,
+ tooltipEl,
+ tooltipY: opt.tooltipY,
+ tooltipX: opt.tooltipX,
+ elGrid: opt.elGrid,
+ hoverArea: opt.hoverArea,
+ ttItems: ch.w.globals.tooltip.ttItems
+ }
+
+ // all the charts should have the same minX and maxX (same xaxis) for multiple tooltips to work correctly
+ if (
+ ch.w.globals.minX === this.w.globals.minX &&
+ ch.w.globals.maxX === this.w.globals.maxX
+ ) {
+ ch.w.globals.tooltip.seriesHoverByContext({
+ chartCtx: ch,
+ ttCtx: ch.w.globals.tooltip,
+ opt: newOpts,
+ e
+ })
+ }
+ })
+ } else {
+ this.seriesHoverByContext({
+ chartCtx: this.ctx,
+ ttCtx: this.w.globals.tooltip,
+ opt,
+ e
+ })
+ }
+ }
+
+ seriesHoverByContext({ chartCtx, ttCtx, opt, e }) {
+ let w = chartCtx.w
+ const tooltipEl = this.getElTooltip()
+
+ if (!tooltipEl) return
+
+ // tooltipRect is calculated on every mousemove, because the text is dynamic
+ ttCtx.tooltipRect = {
+ x: 0,
+ y: 0,
+ ttWidth: tooltipEl.getBoundingClientRect().width,
+ ttHeight: tooltipEl.getBoundingClientRect().height
+ }
+ ttCtx.e = e
+
+ // highlight the current hovered bars
+ if (
+ ttCtx.tooltipUtil.hasBars() &&
+ !w.globals.comboCharts &&
+ !ttCtx.isBarShared
+ ) {
+ if (this.tConfig.onDatasetHover.highlightDataSeries) {
+ let series = new Series(chartCtx)
+ series.toggleSeriesOnHover(e, e.target.parentNode)
+ }
+ }
+
+ if (ttCtx.fixedTooltip) {
+ ttCtx.drawFixedTooltipRect()
+ }
+
+ if (w.globals.axisCharts) {
+ ttCtx.axisChartsTooltips({
+ e,
+ opt,
+ tooltipRect: ttCtx.tooltipRect
+ })
+ } else {
+ // non-plot charts i.e pie/donut/circle
+ ttCtx.nonAxisChartsTooltips({
+ e,
+ opt,
+ tooltipRect: ttCtx.tooltipRect
+ })
+ }
+ }
+
+ // tooltip handling for line/area/bar/columns/scatter
+ axisChartsTooltips({ e, opt }) {
+ let w = this.w
+ let x, y
+
+ let seriesBound = opt.elGrid.getBoundingClientRect()
+
+ const clientX = e.type === 'touchmove' ? e.touches[0].clientX : e.clientX
+ const clientY = e.type === 'touchmove' ? e.touches[0].clientY : e.clientY
+
+ this.clientY = clientY
+ this.clientX = clientX
+
+ w.globals.capturedSeriesIndex = -1
+ w.globals.capturedDataPointIndex = -1
+
+ if (
+ clientY < seriesBound.top ||
+ clientY > seriesBound.top + seriesBound.height
+ ) {
+ this.handleMouseOut(opt)
+ return
+ }
+
+ if (
+ Array.isArray(this.tConfig.enabledOnSeries) &&
+ !w.config.tooltip.shared
+ ) {
+ const index = parseInt(opt.paths.getAttribute('index'), 10)
+ if (this.tConfig.enabledOnSeries.indexOf(index) < 0) {
+ this.handleMouseOut(opt)
+ return
+ }
+ }
+
+ const tooltipEl = this.getElTooltip()
+ const xcrosshairs = this.getElXCrosshairs()
+
+ let isStickyTooltip =
+ w.globals.xyCharts ||
+ (w.config.chart.type === 'bar' &&
+ !w.globals.isBarHorizontal &&
+ this.tooltipUtil.hasBars() &&
+ this.tConfig.shared) ||
+ (w.globals.comboCharts && this.tooltipUtil.hasBars())
+
+ if (
+ e.type === 'mousemove' ||
+ e.type === 'touchmove' ||
+ e.type === 'mouseup'
+ ) {
+ // there is no series to hover over
+ if (
+ w.globals.collapsedSeries.length +
+ w.globals.ancillaryCollapsedSeries.length ===
+ w.globals.series.length
+ ) {
+ return
+ }
+
+ if (xcrosshairs !== null) {
+ xcrosshairs.classList.add('apexcharts-active')
+ }
+
+ const hasYAxisTooltip = this.yaxisTooltips.filter((b) => {
+ return b === true
+ })
+ if (this.ycrosshairs !== null && hasYAxisTooltip.length) {
+ this.ycrosshairs.classList.add('apexcharts-active')
+ }
+
+ if (isStickyTooltip && !this.showOnIntersect) {
+ this.handleStickyTooltip(e, clientX, clientY, opt)
+ } else {
+ if (
+ w.config.chart.type === 'heatmap' ||
+ w.config.chart.type === 'treemap'
+ ) {
+ let markerXY = this.intersect.handleHeatTreeTooltip({
+ e,
+ opt,
+ x,
+ y,
+ type: w.config.chart.type
+ })
+ x = markerXY.x
+ y = markerXY.y
+
+ tooltipEl.style.left = x + 'px'
+ tooltipEl.style.top = y + 'px'
+ } else {
+ if (this.tooltipUtil.hasBars()) {
+ this.intersect.handleBarTooltip({
+ e,
+ opt
+ })
+ }
+
+ if (this.tooltipUtil.hasMarkers()) {
+ // intersect - line/area/scatter/bubble
+ this.intersect.handleMarkerTooltip({
+ e,
+ opt,
+ x,
+ y
+ })
+ }
+ }
+ }
+
+ if (this.yaxisTooltips.length) {
+ for (let yt = 0; yt < w.config.yaxis.length; yt++) {
+ this.axesTooltip.drawYaxisTooltipText(yt, clientY, this.xyRatios)
+ }
+ }
+
+ opt.tooltipEl.classList.add('apexcharts-active')
+ } else if (e.type === 'mouseout' || e.type === 'touchend') {
+ this.handleMouseOut(opt)
+ }
+ }
+
+ // tooltip handling for pie/donuts
+ nonAxisChartsTooltips({ e, opt, tooltipRect }) {
+ let w = this.w
+ let rel = opt.paths.getAttribute('rel')
+
+ const tooltipEl = this.getElTooltip()
+
+ let seriesBound = w.globals.dom.elWrap.getBoundingClientRect()
+
+ if (e.type === 'mousemove' || e.type === 'touchmove') {
+ tooltipEl.classList.add('apexcharts-active')
+
+ this.tooltipLabels.drawSeriesTexts({
+ ttItems: opt.ttItems,
+ i: parseInt(rel, 10) - 1,
+ shared: false
+ })
+
+ let x = w.globals.clientX - seriesBound.left - tooltipRect.ttWidth / 2
+ let y = w.globals.clientY - seriesBound.top - tooltipRect.ttHeight - 10
+
+ tooltipEl.style.left = x + 'px'
+ tooltipEl.style.top = y + 'px'
+
+ if (w.config.legend.tooltipHoverFormatter) {
+ let legendFormatter = w.config.legend.tooltipHoverFormatter
+
+ const i = rel - 1
+ const legendName = this.legendLabels[i].getAttribute(
+ 'data:default-text'
+ )
+
+ let text = legendFormatter(legendName, {
+ seriesIndex: i,
+ dataPointIndex: i,
+ w
+ })
+
+ this.legendLabels[i].innerHTML = text
+ }
+ } else if (e.type === 'mouseout' || e.type === 'touchend') {
+ tooltipEl.classList.remove('apexcharts-active')
+ if (w.config.legend.tooltipHoverFormatter) {
+ this.legendLabels.forEach((l) => {
+ const defaultText = l.getAttribute('data:default-text')
+ l.innerHTML = decodeURIComponent(defaultText)
+ })
+ }
+ }
+ }
+
+ handleStickyTooltip(e, clientX, clientY, opt) {
+ const w = this.w
+ let capj = this.tooltipUtil.getNearestValues({
+ context: this,
+ hoverArea: opt.hoverArea,
+ elGrid: opt.elGrid,
+ clientX,
+ clientY
+ })
+
+ let j = capj.j
+ let capturedSeries = capj.capturedSeries
+
+ const bounds = opt.elGrid.getBoundingClientRect()
+ if (capj.hoverX < 0 || capj.hoverX > bounds.width) {
+ this.handleMouseOut(opt)
+ return
+ }
+
+ if (capturedSeries !== null) {
+ this.handleStickyCapturedSeries(e, capturedSeries, opt, j)
+ } else {
+ // couldn't capture any series. check if shared X is same,
+ // if yes, draw a grouped tooltip
+ if (this.tooltipUtil.isXoverlap(j) || w.globals.isBarHorizontal) {
+ this.create(e, this, 0, j, opt.ttItems)
+ }
+ }
+ }
+
+ handleStickyCapturedSeries(e, capturedSeries, opt, j) {
+ const w = this.w
+ if (!this.tConfig.shared) {
+ let ignoreNull = w.globals.series[capturedSeries][j] === null
+ if (ignoreNull) {
+ this.handleMouseOut(opt)
+ return
+ }
+ }
+
+ if (typeof w.globals.series[capturedSeries][j] !== 'undefined') {
+ if (
+ this.tConfig.shared &&
+ this.tooltipUtil.isXoverlap(j) &&
+ this.tooltipUtil.isInitialSeriesSameLen()
+ ) {
+ this.create(e, this, capturedSeries, j, opt.ttItems)
+ } else {
+ this.create(e, this, capturedSeries, j, opt.ttItems, false)
+ }
+ } else {
+ if (this.tooltipUtil.isXoverlap(j)) {
+ this.create(e, this, 0, j, opt.ttItems)
+ }
+ }
+ }
+
+ deactivateHoverFilter() {
+ let w = this.w
+ let graphics = new Graphics(this.ctx)
+
+ let allPaths = w.globals.dom.Paper.select(`.apexcharts-bar-area`)
+
+ for (let b = 0; b < allPaths.length; b++) {
+ graphics.pathMouseLeave(allPaths[b])
+ }
+ }
+
+ handleMouseOut(opt) {
+ const w = this.w
+
+ const xcrosshairs = this.getElXCrosshairs()
+
+ opt.tooltipEl.classList.remove('apexcharts-active')
+ this.deactivateHoverFilter()
+ if (w.config.chart.type !== 'bubble') {
+ this.marker.resetPointsSize()
+ }
+ if (xcrosshairs !== null) {
+ xcrosshairs.classList.remove('apexcharts-active')
+ }
+ if (this.ycrosshairs !== null) {
+ this.ycrosshairs.classList.remove('apexcharts-active')
+ }
+ if (this.isXAxisTooltipEnabled) {
+ this.xaxisTooltip.classList.remove('apexcharts-active')
+ }
+ if (this.yaxisTooltips.length) {
+ if (this.yaxisTTEls === null) {
+ this.yaxisTTEls = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-yaxistooltip'
+ )
+ }
+ for (let i = 0; i < this.yaxisTTEls.length; i++) {
+ this.yaxisTTEls[i].classList.remove('apexcharts-active')
+ }
+ }
+
+ if (w.config.legend.tooltipHoverFormatter) {
+ this.legendLabels.forEach((l) => {
+ const defaultText = l.getAttribute('data:default-text')
+ l.innerHTML = decodeURIComponent(defaultText)
+ })
+ }
+ }
+
+ markerClick(e, seriesIndex, dataPointIndex) {
+ const w = this.w
+ if (typeof w.config.chart.events.markerClick === 'function') {
+ w.config.chart.events.markerClick(e, this.ctx, {
+ seriesIndex,
+ dataPointIndex,
+ w
+ })
+ }
+ this.ctx.events.fireEvent('markerClick', [
+ e,
+ this.ctx,
+ { seriesIndex, dataPointIndex, w }
+ ])
+ }
+
+ create(e, context, capturedSeries, j, ttItems, shared = null) {
+ let w = this.w
+ let ttCtx = context
+
+ if (e.type === 'mouseup') {
+ this.markerClick(e, capturedSeries, j)
+ }
+
+ if (shared === null) shared = this.tConfig.shared
+
+ const hasMarkers = this.tooltipUtil.hasMarkers()
+
+ const bars = this.tooltipUtil.getElBars()
+
+ if (w.config.legend.tooltipHoverFormatter) {
+ let legendFormatter = w.config.legend.tooltipHoverFormatter
+
+ let els = Array.from(this.legendLabels)
+
+ // reset all legend values first
+ els.forEach((l) => {
+ const legendName = l.getAttribute('data:default-text')
+ l.innerHTML = decodeURIComponent(legendName)
+ })
+
+ // for irregular time series
+ for (let i = 0; i < els.length; i++) {
+ const l = els[i]
+ const lsIndex = parseInt(l.getAttribute('i'), 10)
+ const legendName = decodeURIComponent(
+ l.getAttribute('data:default-text')
+ )
+
+ let text = legendFormatter(legendName, {
+ seriesIndex: shared ? lsIndex : capturedSeries,
+ dataPointIndex: j,
+ w
+ })
+
+ if (!shared) {
+ l.innerHTML = lsIndex === capturedSeries ? text : legendName
+ if (capturedSeries === lsIndex) {
+ break
+ }
+ } else {
+ l.innerHTML =
+ w.globals.collapsedSeriesIndices.indexOf(lsIndex) < 0
+ ? text
+ : legendName
+ }
+ }
+ }
+
+ if (shared) {
+ ttCtx.tooltipLabels.drawSeriesTexts({
+ ttItems,
+ i: capturedSeries,
+ j,
+ shared: this.showOnIntersect ? false : this.tConfig.shared
+ })
+
+ if (hasMarkers) {
+ if (w.globals.markers.largestSize > 0) {
+ ttCtx.marker.enlargePoints(j)
+ } else {
+ ttCtx.tooltipPosition.moveDynamicPointsOnHover(j)
+ }
+ }
+
+ if (this.tooltipUtil.hasBars()) {
+ this.barSeriesHeight = this.tooltipUtil.getBarsHeight(bars)
+ if (this.barSeriesHeight > 0) {
+ // hover state, activate snap filter
+ let graphics = new Graphics(this.ctx)
+ let paths = w.globals.dom.Paper.select(
+ `.apexcharts-bar-area[j='${j}']`
+ )
+
+ // de-activate first
+ this.deactivateHoverFilter()
+
+ this.tooltipPosition.moveStickyTooltipOverBars(j)
+
+ for (let b = 0; b < paths.length; b++) {
+ graphics.pathMouseEnter(paths[b])
+ }
+ }
+ }
+ } else {
+ ttCtx.tooltipLabels.drawSeriesTexts({
+ shared: false,
+ ttItems,
+ i: capturedSeries,
+ j
+ })
+
+ if (this.tooltipUtil.hasBars()) {
+ ttCtx.tooltipPosition.moveStickyTooltipOverBars(j)
+ }
+
+ if (hasMarkers) {
+ ttCtx.tooltipPosition.moveMarkers(capturedSeries, j)
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Utils.js b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Utils.js
new file mode 100644
index 0000000..84c47a0
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/modules/tooltip/Utils.js
@@ -0,0 +1,359 @@
+import Utilities from '../../utils/Utils'
+
+/**
+ * ApexCharts Tooltip.Utils Class to support Tooltip functionality.
+ *
+ * @module Tooltip.Utils
+ **/
+
+export default class Utils {
+ constructor(tooltipContext) {
+ this.w = tooltipContext.w
+ this.ttCtx = tooltipContext
+ this.ctx = tooltipContext.ctx
+ }
+
+ /**
+ ** When hovering over series, you need to capture which series is being hovered on.
+ ** This function will return both capturedseries index as well as inner index of that series
+ * @memberof Utils
+ * @param {object}
+ * - hoverArea = the rect on which user hovers
+ * - elGrid = dimensions of the hover rect (it can be different than hoverarea)
+ */
+ getNearestValues({ hoverArea, elGrid, clientX, clientY }) {
+ let w = this.w
+
+ const seriesBound = elGrid.getBoundingClientRect()
+ const hoverWidth = seriesBound.width
+ const hoverHeight = seriesBound.height
+
+ let xDivisor = hoverWidth / (w.globals.dataPoints - 1)
+ let yDivisor = hoverHeight / w.globals.dataPoints
+
+ const hasBars = this.hasBars()
+
+ if (
+ (w.globals.comboCharts || hasBars) &&
+ !w.config.xaxis.convertedCatToNumeric
+ ) {
+ xDivisor = hoverWidth / w.globals.dataPoints
+ }
+
+ let hoverX = clientX - seriesBound.left - w.globals.barPadForNumericAxis
+ let hoverY = clientY - seriesBound.top
+
+ const notInRect =
+ hoverX < 0 || hoverY < 0 || hoverX > hoverWidth || hoverY > hoverHeight
+
+ if (notInRect) {
+ hoverArea.classList.remove('hovering-zoom')
+ hoverArea.classList.remove('hovering-pan')
+ } else {
+ if (w.globals.zoomEnabled) {
+ hoverArea.classList.remove('hovering-pan')
+ hoverArea.classList.add('hovering-zoom')
+ } else if (w.globals.panEnabled) {
+ hoverArea.classList.remove('hovering-zoom')
+ hoverArea.classList.add('hovering-pan')
+ }
+ }
+
+ let j = Math.round(hoverX / xDivisor)
+ let jHorz = Math.floor(hoverY / yDivisor)
+
+ if (hasBars && !w.config.xaxis.convertedCatToNumeric) {
+ j = Math.ceil(hoverX / xDivisor)
+ j = j - 1
+ }
+
+ let capturedSeries = null
+ let closest = null
+ let seriesXValArr = []
+ let seriesYValArr = []
+
+ //add extra values to show markers for the first points. Included both axes to avoid incorrect positioning of the marker
+ w.globals.seriesXvalues.forEach((value) => {
+ seriesXValArr.push([value[0] + 0.000001].concat(value))
+ })
+ w.globals.seriesYvalues.forEach((value) => {
+ seriesYValArr.push([value[0] + 0.000001].concat(value))
+ })
+
+ seriesXValArr = seriesXValArr.map((seriesXVal) => {
+ return seriesXVal.filter((s) => Utilities.isNumber(s))
+ })
+ seriesYValArr = seriesYValArr.map((seriesYVal) => {
+ return seriesYVal.filter((s) => Utilities.isNumber(s))
+ })
+
+ // if X axis type is not category and tooltip is not shared, then we need to find the cursor position and get the nearest value
+ if (w.globals.isXNumeric) {
+ // Change origin of cursor position so that we can compute the relative nearest point to the cursor on our chart
+ // we only need to scale because all points are relative to the bounds.left and bounds.top => origin is virtually (0, 0)
+ const chartGridEl = this.ttCtx.getElGrid()
+ const chartGridElBoundingRect = chartGridEl.getBoundingClientRect()
+ const transformedHoverX =
+ hoverX * (chartGridElBoundingRect.width / hoverWidth)
+ const transformedHoverY =
+ hoverY * (chartGridElBoundingRect.height / hoverHeight)
+
+ closest = this.closestInMultiArray(
+ transformedHoverX,
+ transformedHoverY,
+ seriesXValArr,
+ seriesYValArr
+ )
+ capturedSeries = closest.index
+ j = closest.j
+
+ if (capturedSeries !== null) {
+ // initial push, it should be a little smaller than the 1st val
+ seriesXValArr = w.globals.seriesXvalues[capturedSeries]
+
+ closest = this.closestInArray(transformedHoverX, seriesXValArr)
+
+ j = closest.index
+ }
+ }
+
+ w.globals.capturedSeriesIndex =
+ capturedSeries === null ? -1 : capturedSeries
+
+ if (!j || j < 1) j = 0
+
+ if (w.globals.isBarHorizontal) {
+ w.globals.capturedDataPointIndex = jHorz
+ } else {
+ w.globals.capturedDataPointIndex = j
+ }
+
+ return {
+ capturedSeries,
+ j: w.globals.isBarHorizontal ? jHorz : j,
+ hoverX,
+ hoverY
+ }
+ }
+
+ closestInMultiArray(hoverX, hoverY, Xarrays, Yarrays) {
+ let w = this.w
+ let activeIndex = 0
+ let currIndex = null
+ let j = -1
+
+ if (w.globals.series.length > 1) {
+ activeIndex = this.getFirstActiveXArray(Xarrays)
+ } else {
+ currIndex = 0
+ }
+
+ let currX = Xarrays[activeIndex][0]
+ let diffX = Math.abs(hoverX - currX)
+
+ // find nearest point on x-axis
+ Xarrays.forEach((arrX) => {
+ arrX.forEach((x, iX) => {
+ const newDiff = Math.abs(hoverX - x)
+ if (newDiff < diffX) {
+ diffX = newDiff
+ j = iX
+ }
+ })
+ })
+
+ if (j !== -1) {
+ // find nearest graph on y-axis relevanted to nearest point on x-axis
+ let currY = Yarrays[activeIndex][j]
+ let diffY = Math.abs(hoverY - currY)
+ currIndex = activeIndex
+
+ Yarrays.forEach((arrY, iAY) => {
+ const newDiff = Math.abs(hoverY - arrY[j])
+ if (newDiff < diffY) {
+ diffY = newDiff
+ currIndex = iAY
+ }
+ })
+ }
+
+ return {
+ index: currIndex,
+ j
+ }
+ }
+
+ getFirstActiveXArray(Xarrays) {
+ const w = this.w
+ let activeIndex = 0
+
+ let firstActiveSeriesIndex = Xarrays.map((xarr, index) => {
+ return xarr.length > 0 ? index : -1
+ })
+
+ for (let a = 0; a < firstActiveSeriesIndex.length; a++) {
+ if (
+ firstActiveSeriesIndex[a] !== -1 &&
+ w.globals.collapsedSeriesIndices.indexOf(a) === -1 &&
+ w.globals.ancillaryCollapsedSeriesIndices.indexOf(a) === -1
+ ) {
+ activeIndex = firstActiveSeriesIndex[a]
+ break
+ }
+ }
+
+ return activeIndex
+ }
+
+ closestInArray(val, arr) {
+ let curr = arr[0]
+ let currIndex = null
+ let diff = Math.abs(val - curr)
+
+ for (let i = 0; i < arr.length; i++) {
+ let newdiff = Math.abs(val - arr[i])
+ if (newdiff < diff) {
+ diff = newdiff
+ currIndex = i
+ }
+ }
+
+ return {
+ index: currIndex
+ }
+ }
+
+ /**
+ * When there are multiple series, it is possible to have different x values for each series.
+ * But it may be possible in those multiple series, that there is same x value for 2 or more
+ * series.
+ * @memberof Utils
+ * @param {int}
+ * - j = is the inner index of series -> (series[i][j])
+ * @return {bool}
+ */
+ isXoverlap(j) {
+ let w = this.w
+ let xSameForAllSeriesJArr = []
+
+ const seriesX = w.globals.seriesX.filter((s) => typeof s[0] !== 'undefined')
+
+ if (seriesX.length > 0) {
+ for (let i = 0; i < seriesX.length - 1; i++) {
+ if (
+ typeof seriesX[i][j] !== 'undefined' &&
+ typeof seriesX[i + 1][j] !== 'undefined'
+ ) {
+ if (seriesX[i][j] !== seriesX[i + 1][j]) {
+ xSameForAllSeriesJArr.push('unEqual')
+ }
+ }
+ }
+ }
+
+ if (xSameForAllSeriesJArr.length === 0) {
+ return true
+ }
+
+ return false
+ }
+
+ isInitialSeriesSameLen() {
+ let sameLen = true
+
+ const initialSeries = this.w.globals.initialSeries
+
+ for (let i = 0; i < initialSeries.length - 1; i++) {
+ if (initialSeries[i].data.length !== initialSeries[i + 1].data.length) {
+ sameLen = false
+ break
+ }
+ }
+
+ return sameLen
+ }
+
+ getBarsHeight(allbars) {
+ let bars = [...allbars]
+ const totalHeight = bars.reduce((acc, bar) => acc + bar.getBBox().height, 0)
+
+ return totalHeight
+ }
+
+ getElMarkers() {
+ return this.w.globals.dom.baseEl.querySelectorAll(
+ ' .apexcharts-series-markers'
+ )
+ }
+
+ getAllMarkers() {
+ // first get all marker parents. This parent class contains series-index
+ // which helps to sort the markers as they are dynamic
+ let markersWraps = this.w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-series-markers-wrap'
+ )
+
+ markersWraps = [...markersWraps]
+ markersWraps.sort((a, b) => {
+ var indexA = Number(a.getAttribute('data:realIndex'))
+ var indexB = Number(b.getAttribute('data:realIndex'))
+ return indexB < indexA ? 1 : indexB > indexA ? -1 : 0
+ })
+
+ let markers = []
+ markersWraps.forEach((m) => {
+ markers.push(m.querySelector('.apexcharts-marker'))
+ })
+
+ return markers
+ }
+
+ hasMarkers() {
+ const markers = this.getElMarkers()
+ return markers.length > 0
+ }
+
+ getElBars() {
+ return this.w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-bar-series, .apexcharts-candlestick-series, .apexcharts-boxPlot-series, .apexcharts-rangebar-series'
+ )
+ }
+
+ hasBars() {
+ const bars = this.getElBars()
+ return bars.length > 0
+ }
+
+ getHoverMarkerSize(index) {
+ const w = this.w
+ let hoverSize = w.config.markers.hover.size
+
+ if (hoverSize === undefined) {
+ hoverSize =
+ w.globals.markers.size[index] + w.config.markers.hover.sizeOffset
+ }
+ return hoverSize
+ }
+
+ toggleAllTooltipSeriesGroups(state) {
+ let w = this.w
+ const ttCtx = this.ttCtx
+
+ if (ttCtx.allTooltipSeriesGroups.length === 0) {
+ ttCtx.allTooltipSeriesGroups = w.globals.dom.baseEl.querySelectorAll(
+ '.apexcharts-tooltip-series-group'
+ )
+ }
+
+ let allTooltipSeriesGroups = ttCtx.allTooltipSeriesGroups
+ for (let i = 0; i < allTooltipSeriesGroups.length; i++) {
+ if (state === 'enable') {
+ allTooltipSeriesGroups[i].classList.add('apexcharts-active')
+ allTooltipSeriesGroups[i].style.display = w.config.tooltip.items.display
+ } else {
+ allTooltipSeriesGroups[i].classList.remove('apexcharts-active')
+ allTooltipSeriesGroups[i].style.display = 'none'
+ }
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/svgjs/svg.js b/cao_sunyata/static/libs/apexcharts/src/svgjs/svg.js
new file mode 100644
index 0000000..ca9a884
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/svgjs/svg.js
@@ -0,0 +1,3752 @@
+/*!
+* svg.js - A lightweight library for manipulating and animating SVG.
+* @version 2.6.6
+* https://svgdotjs.github.io/
+*/;
+(function (root, factory) {
+ /* istanbul ignore next */
+ if (typeof define === 'function' && define.amd) {
+ define(function () {
+ return factory(root, root.document)
+ })
+ /* below check fixes #412 */
+ } else if (typeof exports === 'object' && typeof module !== 'undefined') {
+ module.exports = root.document ? factory(root, root.document) : function (w) { return factory(w, w.document) }
+ } else {
+ root.SVG = factory(root, root.document)
+ }
+}(typeof window !== 'undefined' ? window : this, function (window, document) {
+// Find global reference - uses 'this' by default when available,
+// falls back to 'window' otherwise (for bundlers like Webpack)
+ var globalRef = (typeof this !== 'undefined') ? this : window
+
+ // The main wrapping element
+ var SVG = globalRef.SVG = function (element) {
+ if (SVG.supported) {
+ element = new SVG.Doc(element)
+
+ if (!SVG.parser.draw) { SVG.prepare() }
+
+ return element
+ }
+ }
+
+ // Default namespaces
+ SVG.ns = 'http://www.w3.org/2000/svg'
+ SVG.xmlns = 'http://www.w3.org/2000/xmlns/'
+ SVG.xlink = 'http://www.w3.org/1999/xlink'
+ SVG.svgjs = 'http://svgjs.dev'
+
+ // Svg support test
+ SVG.supported = (function () {
+ return true
+ // !!document.createElementNS &&
+ // !! document.createElementNS(SVG.ns,'svg').createSVGRect
+ })()
+
+ // Don't bother to continue if SVG is not supported
+ if (!SVG.supported) return false
+
+ // Element id sequence
+ SVG.did = 1000
+
+ // Get next named element id
+ SVG.eid = function (name) {
+ return 'Svgjs' + capitalize(name) + (SVG.did++)
+ }
+
+ // Method for element creation
+ SVG.create = function (name) {
+ // create element
+ var element = document.createElementNS(this.ns, name)
+
+ // apply unique id
+ element.setAttribute('id', this.eid(name))
+
+ return element
+ }
+
+ // Method for extending objects
+ SVG.extend = function () {
+ var modules, methods
+
+ // Get list of modules
+ modules = [].slice.call(arguments)
+
+ // Get object with extensions
+ methods = modules.pop()
+
+ for (var i = modules.length - 1; i >= 0; i--) {
+ if (modules[i]) {
+ for (var key in methods) { modules[i].prototype[key] = methods[key] }
+ }
+ }
+
+ // Make sure SVG.Set inherits any newly added methods
+ if (SVG.Set && SVG.Set.inherit) { SVG.Set.inherit() }
+ }
+
+ // Invent new element
+ SVG.invent = function (config) {
+ // Create element initializer
+ var initializer = typeof config.create === 'function'
+ ? config.create
+ : function () {
+ this.constructor.call(this, SVG.create(config.create))
+ }
+
+ // Inherit prototype
+ if (config.inherit) { initializer.prototype = new config.inherit() }
+
+ // Extend with methods
+ if (config.extend) { SVG.extend(initializer, config.extend) }
+
+ // Attach construct method to parent
+ if (config.construct) { SVG.extend(config.parent || SVG.Container, config.construct) }
+
+ return initializer
+ }
+
+ // Adopt existing svg elements
+ SVG.adopt = function (node) {
+ // check for presence of node
+ if (!node) return null
+
+ // make sure a node isn't already adopted
+ if (node.instance) return node.instance
+
+ // initialize variables
+ var element
+
+ // adopt with element-specific settings
+ if (node.nodeName == 'svg') { element = node.parentNode instanceof window.SVGElement ? new SVG.Nested() : new SVG.Doc() } else if (node.nodeName == 'linearGradient') { element = new SVG.Gradient('linear') } else if (node.nodeName == 'radialGradient') { element = new SVG.Gradient('radial') } else if (SVG[capitalize(node.nodeName)]) { element = new SVG[capitalize(node.nodeName)]() } else { element = new SVG.Element(node) }
+
+ // ensure references
+ element.type = node.nodeName
+ element.node = node
+ node.instance = element
+
+ // SVG.Class specific preparations
+ if (element instanceof SVG.Doc) { element.namespace().defs() }
+
+ // pull svgjs data from the dom (getAttributeNS doesn't work in html5)
+ element.setData(JSON.parse(node.getAttribute('svgjs:data')) || {})
+
+ return element
+ }
+
+ // Initialize parsing element
+ SVG.prepare = function () {
+ // Select document body and create invisible svg element
+ var body = document.getElementsByTagName('body')[0],
+ draw = (body ? new SVG.Doc(body) : SVG.adopt(document.documentElement).nested()).size(2, 0)
+
+ // Create parser object
+ SVG.parser = {
+ body: body || document.documentElement,
+ draw: draw.style('opacity:0;position:absolute;left:-100%;top:-100%;overflow:hidden').node,
+ poly: draw.polyline().node,
+ path: draw.path().node,
+ native: SVG.create('svg')
+ }
+ }
+
+ SVG.parser = {
+ native: SVG.create('svg')
+ }
+
+ document.addEventListener('DOMContentLoaded', function () {
+ if (!SVG.parser.draw) { SVG.prepare() }
+ }, false)
+
+ // Storage for regular expressions
+ SVG.regex = {
+ // Parse unit value
+ numberAndUnit: /^([+-]?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?)([a-z%]*)$/i,
+
+ // Parse hex value
+ hex: /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,
+
+ // Parse rgb value
+ rgb: /rgb\((\d+),(\d+),(\d+)\)/,
+
+ // Parse reference id
+ reference: /#([a-z0-9\-_]+)/i,
+
+ // splits a transformation chain
+ transforms: /\)\s*,?\s*/,
+
+ // Whitespace
+ whitespace: /\s/g,
+
+ // Test hex value
+ isHex: /^#[a-f0-9]{3,6}$/i,
+
+ // Test rgb value
+ isRgb: /^rgb\(/,
+
+ // Test css declaration
+ isCss: /[^:]+:[^;]+;?/,
+
+ // Test for blank string
+ isBlank: /^(\s+)?$/,
+
+ // Test for numeric string
+ isNumber: /^[+-]?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,
+
+ // Test for percent value
+ isPercent: /^-?[\d\.]+%$/,
+
+ // Test for image url
+ isImage: /\.(jpg|jpeg|png|gif|svg)(\?[^=]+.*)?/i,
+
+ // split at whitespace and comma
+ delimiter: /[\s,]+/,
+
+ // The following regex are used to parse the d attribute of a path
+
+ // Matches all hyphens which are not after an exponent
+ hyphen: /([^e])\-/gi,
+
+ // Replaces and tests for all path letters
+ pathLetters: /[MLHVCSQTAZ]/gi,
+
+ // yes we need this one, too
+ isPathLetter: /[MLHVCSQTAZ]/i,
+
+ // matches 0.154.23.45
+ numbersWithDots: /((\d?\.\d+(?:e[+-]?\d+)?)((?:\.\d+(?:e[+-]?\d+)?)+))+/gi,
+
+ // matches .
+ dots: /\./g
+ }
+
+ SVG.utils = {
+ // Map function
+ map: function (array, block) {
+ var il = array.length,
+ result = []
+
+ for (var i = 0; i < il; i++) { result.push(block(array[i])) }
+
+ return result
+ },
+
+ // Filter function
+ filter: function (array, block) {
+ var il = array.length,
+ result = []
+
+ for (var i = 0; i < il; i++) {
+ if (block(array[i])) { result.push(array[i]) }
+ }
+
+ return result
+ },
+
+ filterSVGElements: function (nodes) {
+ return this.filter(nodes, function (el) { return el instanceof window.SVGElement })
+ }
+
+ }
+
+ SVG.defaults = {
+ // Default attribute values
+ attrs: {
+ // fill and stroke
+ 'fill-opacity': 1,
+ 'stroke-opacity': 1,
+ 'stroke-width': 0,
+ 'stroke-linejoin': 'miter',
+ 'stroke-linecap': 'butt',
+ fill: '#000000',
+ stroke: '#000000',
+ opacity: 1,
+ // position
+ x: 0,
+ y: 0,
+ cx: 0,
+ cy: 0,
+ // size
+ width: 0,
+ height: 0,
+ // radius
+ r: 0,
+ rx: 0,
+ ry: 0,
+ // gradient
+ offset: 0,
+ 'stop-opacity': 1,
+ 'stop-color': '#000000',
+ // text
+ 'font-size': 16,
+ 'font-family': 'Helvetica, Arial, sans-serif',
+ 'text-anchor': 'start'
+ }
+
+ }
+ // Module for color convertions
+ SVG.Color = function (color) {
+ var match
+
+ // initialize defaults
+ this.r = 0
+ this.g = 0
+ this.b = 0
+
+ if (!color) return
+
+ // parse color
+ if (typeof color === 'string') {
+ if (SVG.regex.isRgb.test(color)) {
+ // get rgb values
+ match = SVG.regex.rgb.exec(color.replace(SVG.regex.whitespace, ''))
+
+ // parse numeric values
+ this.r = parseInt(match[1])
+ this.g = parseInt(match[2])
+ this.b = parseInt(match[3])
+ } else if (SVG.regex.isHex.test(color)) {
+ // get hex values
+ match = SVG.regex.hex.exec(fullHex(color))
+
+ // parse numeric values
+ this.r = parseInt(match[1], 16)
+ this.g = parseInt(match[2], 16)
+ this.b = parseInt(match[3], 16)
+ }
+ } else if (typeof color === 'object') {
+ this.r = color.r
+ this.g = color.g
+ this.b = color.b
+ }
+ }
+
+ SVG.extend(SVG.Color, {
+ // Default to hex conversion
+ toString: function () {
+ return this.toHex()
+ },
+ // Build hex value
+ toHex: function () {
+ return '#' +
+ compToHex(this.r) +
+ compToHex(this.g) +
+ compToHex(this.b)
+ },
+ // Build rgb value
+ toRgb: function () {
+ return 'rgb(' + [this.r, this.g, this.b].join() + ')'
+ },
+ // Calculate true brightness
+ brightness: function () {
+ return (this.r / 255 * 0.30) +
+ (this.g / 255 * 0.59) +
+ (this.b / 255 * 0.11)
+ },
+ // Make color morphable
+ morph: function (color) {
+ this.destination = new SVG.Color(color)
+
+ return this
+ },
+ // Get morphed color at given position
+ at: function (pos) {
+ // make sure a destination is defined
+ if (!this.destination) return this
+
+ // normalise pos
+ pos = pos < 0 ? 0 : pos > 1 ? 1 : pos
+
+ // generate morphed color
+ return new SVG.Color({
+ r: ~~(this.r + (this.destination.r - this.r) * pos),
+ g: ~~(this.g + (this.destination.g - this.g) * pos),
+ b: ~~(this.b + (this.destination.b - this.b) * pos)
+ })
+ }
+
+ })
+
+ // Testers
+
+ // Test if given value is a color string
+ SVG.Color.test = function (color) {
+ color += ''
+ return SVG.regex.isHex.test(color) ||
+ SVG.regex.isRgb.test(color)
+ }
+
+ // Test if given value is a rgb object
+ SVG.Color.isRgb = function (color) {
+ return color && typeof color.r === 'number' &&
+ typeof color.g === 'number' &&
+ typeof color.b === 'number'
+ }
+
+ // Test if given value is a color
+ SVG.Color.isColor = function (color) {
+ return SVG.Color.isRgb(color) || SVG.Color.test(color)
+ }
+ // Module for array conversion
+ SVG.Array = function (array, fallback) {
+ array = (array || []).valueOf()
+
+ // if array is empty and fallback is provided, use fallback
+ if (array.length == 0 && fallback) { array = fallback.valueOf() }
+
+ // parse array
+ this.value = this.parse(array)
+ }
+
+ SVG.extend(SVG.Array, {
+
+ // Convert array to string
+ toString: function () {
+ return this.value.join(' ')
+ },
+ // Real value
+ valueOf: function () {
+ return this.value
+ },
+ // Parse whitespace separated string
+ parse: function (array) {
+ array = array.valueOf()
+
+ // if already is an array, no need to parse it
+ if (Array.isArray(array)) return array
+
+ return this.split(array)
+ },
+
+ })
+ // Poly points array
+ SVG.PointArray = function (array, fallback) {
+ SVG.Array.call(this, array, fallback || [[0, 0]])
+ }
+
+ // Inherit from SVG.Array
+ SVG.PointArray.prototype = new SVG.Array()
+ SVG.PointArray.prototype.constructor = SVG.PointArray
+
+
+ var pathHandlers = {
+ M: function (c, p, p0) {
+ p.x = p0.x = c[0]
+ p.y = p0.y = c[1]
+
+ return ['M', p.x, p.y]
+ },
+ L: function (c, p) {
+ p.x = c[0]
+ p.y = c[1]
+ return ['L', c[0], c[1]]
+ },
+ H: function (c, p) {
+ p.x = c[0]
+ return ['H', c[0]]
+ },
+ V: function (c, p) {
+ p.y = c[0]
+ return ['V', c[0]]
+ },
+ C: function (c, p) {
+ p.x = c[4]
+ p.y = c[5]
+ return ['C', c[0], c[1], c[2], c[3], c[4], c[5]]
+ },
+ Q: function (c, p) {
+ p.x = c[2]
+ p.y = c[3]
+ return ['Q', c[0], c[1], c[2], c[3]]
+ },
+ Z: function (c, p, p0) {
+ p.x = p0.x
+ p.y = p0.y
+ return ['Z']
+ },
+ }
+
+ var mlhvqtcsa = 'mlhvqtcsaz'.split('')
+
+ for (var i = 0, il = mlhvqtcsa.length; i < il; ++i) {
+ pathHandlers[mlhvqtcsa[i]] = (function (i) {
+ return function (c, p, p0) {
+ if (i == 'H') c[0] = c[0] + p.x
+ else if (i == 'V') c[0] = c[0] + p.y
+ else if (i == 'A') {
+ c[5] = c[5] + p.x,
+ c[6] = c[6] + p.y
+ } else {
+ for (var j = 0, jl = c.length; j < jl; ++j) {
+ c[j] = c[j] + (j % 2 ? p.y : p.x)
+ }
+ }
+
+ if(pathHandlers && typeof pathHandlers[i] === 'function') {
+ // this check fixes jest unit tests
+ return pathHandlers[i](c, p, p0)
+ }
+ }
+ })(mlhvqtcsa[i].toUpperCase())
+ }
+
+ // Path points array
+ SVG.PathArray = function (array, fallback) {
+ SVG.Array.call(this, array, fallback || [['M', 0, 0]])
+ }
+
+ // Inherit from SVG.Array
+ SVG.PathArray.prototype = new SVG.Array()
+ SVG.PathArray.prototype.constructor = SVG.PathArray
+
+ SVG.extend(SVG.PathArray, {
+ // Convert array to string
+ toString: function () {
+ return arrayToString(this.value)
+ },
+ // Move path string
+ move: function (x, y) {
+ // get bounding box of current situation
+ var box = this.bbox()
+
+ // get relative offset
+ x -= box.x
+ y -= box.y
+
+ return this
+ },
+ // Get morphed path array at given position
+ at: function (pos) {
+ // make sure a destination is defined
+ if (!this.destination) return this
+
+ var sourceArray = this.value,
+ destinationArray = this.destination.value,
+ array = [], pathArray = new SVG.PathArray(),
+ il, jl
+
+ // Animate has specified in the SVG spec
+ // See: https://www.w3.org/TR/SVG11/paths.html#PathElement
+ for (var i = 0, il = sourceArray.length; i < il; i++) {
+ array[i] = [sourceArray[i][0]]
+ for (var j = 1, jl = sourceArray[i].length; j < jl; j++) {
+ array[i][j] = sourceArray[i][j] + (destinationArray[i][j] - sourceArray[i][j]) * pos
+ }
+ // For the two flags of the elliptical arc command, the SVG spec say:
+ // Flags and booleans are interpolated as fractions between zero and one, with any non-zero value considered to be a value of one/true
+ // Elliptical arc command as an array followed by corresponding indexes:
+ // ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]
+ // 0 1 2 3 4 5 6 7
+ if (array[i][0] === 'A') {
+ array[i][4] = +(array[i][4] != 0)
+ array[i][5] = +(array[i][5] != 0)
+ }
+ }
+
+ // Directly modify the value of a path array, this is done this way for performance
+ pathArray.value = array
+ return pathArray
+ },
+ // Absolutize and parse path to array
+ parse: function (array) {
+ // if it's already a patharray, no need to parse it
+ if (array instanceof SVG.PathArray) return array.valueOf()
+
+ // prepare for parsing
+ var i, x0, y0, s, seg, arr,
+ x = 0,
+ y = 0,
+ paramCnt = { 'M': 2, 'L': 2, 'H': 1, 'V': 1, 'C': 6, 'S': 4, 'Q': 4, 'T': 2, 'A': 7, 'Z': 0 }
+
+ if (typeof array === 'string') {
+ array = array
+ .replace(SVG.regex.numbersWithDots, pathRegReplace) // convert 45.123.123 to 45.123 .123
+ .replace(SVG.regex.pathLetters, ' $& ') // put some room between letters and numbers
+ .replace(SVG.regex.hyphen, '$1 -') // add space before hyphen
+ .trim() // trim
+ .split(SVG.regex.delimiter) // split into array
+ } else {
+ array = array.reduce(function (prev, curr) {
+ return [].concat.call(prev, curr)
+ }, [])
+ }
+
+ // array now is an array containing all parts of a path e.g. ['M', '0', '0', 'L', '30', '30' ...]
+ var arr = [],
+ p = new SVG.Point(),
+ p0 = new SVG.Point(),
+ index = 0,
+ len = array.length
+
+ do {
+ // Test if we have a path letter
+ if (SVG.regex.isPathLetter.test(array[index])) {
+ s = array[index]
+ ++index
+ // If last letter was a move command and we got no new, it defaults to [L]ine
+ } else if (s == 'M') {
+ s = 'L'
+ } else if (s == 'm') {
+ s = 'l'
+ }
+
+ arr.push(pathHandlers[s].call(null,
+ array.slice(index, (index = index + paramCnt[s.toUpperCase()])).map(parseFloat),
+ p, p0
+ )
+ )
+ } while (len > index)
+
+ return arr
+ },
+ // Get bounding box of path
+ bbox: function () {
+ if (!SVG.parser.draw) { SVG.prepare() }
+ SVG.parser.path.setAttribute('d', this.toString())
+
+ return SVG.parser.path.getBBox()
+ }
+
+ })
+
+ // Module for unit convertions
+ SVG.Number = SVG.invent({
+ // Initialize
+ create: function (value, unit) {
+ // initialize defaults
+ this.value = 0
+ this.unit = unit || ''
+
+ // parse value
+ if (typeof value === 'number') {
+ // ensure a valid numeric value
+ this.value = isNaN(value) ? 0 : !isFinite(value) ? (value < 0 ? -3.4e+38 : +3.4e+38) : value
+ } else if (typeof value === 'string') {
+ unit = value.match(SVG.regex.numberAndUnit)
+
+ if (unit) {
+ // make value numeric
+ this.value = parseFloat(unit[1])
+
+ // normalize
+ if (unit[5] == '%') { this.value /= 100 } else if (unit[5] == 's') { this.value *= 1000 }
+
+ // store unit
+ this.unit = unit[5]
+ }
+ } else {
+ if (value instanceof SVG.Number) {
+ this.value = value.valueOf()
+ this.unit = value.unit
+ }
+ }
+ },
+ // Add methods
+ extend: {
+ // Stringalize
+ toString: function () {
+ return (
+ this.unit == '%'
+ ? ~~(this.value * 1e8) / 1e6
+ : this.unit == 's'
+ ? this.value / 1e3
+ : this.value
+ ) + this.unit
+ },
+ toJSON: function () {
+ return this.toString()
+ }, // Convert to primitive
+ valueOf: function () {
+ return this.value
+ },
+ // Add number
+ plus: function (number) {
+ number = new SVG.Number(number)
+ return new SVG.Number(this + number, this.unit || number.unit)
+ },
+ // Subtract number
+ minus: function (number) {
+ number = new SVG.Number(number)
+ return new SVG.Number(this - number, this.unit || number.unit)
+ },
+ // Multiply number
+ times: function (number) {
+ number = new SVG.Number(number)
+ return new SVG.Number(this * number, this.unit || number.unit)
+ },
+ // Divide number
+ divide: function (number) {
+ number = new SVG.Number(number)
+ return new SVG.Number(this / number, this.unit || number.unit)
+ },
+ // Convert to different unit
+ to: function (unit) {
+ var number = new SVG.Number(this)
+
+ if (typeof unit === 'string') { number.unit = unit }
+
+ return number
+ },
+ // Make number morphable
+ morph: function (number) {
+ this.destination = new SVG.Number(number)
+
+ if (number.relative) {
+ this.destination.value += this.value
+ }
+
+ return this
+ },
+ // Get morphed number at given position
+ at: function (pos) {
+ // Make sure a destination is defined
+ if (!this.destination) return this
+
+ // Generate new morphed number
+ return new SVG.Number(this.destination)
+ .minus(this)
+ .times(pos)
+ .plus(this)
+ }
+
+ }
+ })
+
+ SVG.Element = SVG.invent({
+ // Initialize node
+ create: function (node) {
+ // make stroke value accessible dynamically
+ this._stroke = SVG.defaults.attrs.stroke
+ this._event = null
+
+ // initialize data object
+ this.dom = {}
+
+ // create circular reference
+ if (this.node = node) {
+ this.type = node.nodeName
+ this.node.instance = this
+
+ // store current attribute value
+ this._stroke = node.getAttribute('stroke') || this._stroke
+ }
+ },
+
+ // Add class methods
+ extend: {
+ // Move over x-axis
+ x: function (x) {
+ return this.attr('x', x)
+ },
+ // Move over y-axis
+ y: function (y) {
+ return this.attr('y', y)
+ },
+ // Move by center over x-axis
+ cx: function (x) {
+ return x == null ? this.x() + this.width() / 2 : this.x(x - this.width() / 2)
+ },
+ // Move by center over y-axis
+ cy: function (y) {
+ return y == null ? this.y() + this.height() / 2 : this.y(y - this.height() / 2)
+ },
+ // Move element to given x and y values
+ move: function (x, y) {
+ return this.x(x).y(y)
+ },
+ // Move element by its center
+ center: function (x, y) {
+ return this.cx(x).cy(y)
+ },
+ // Set width of element
+ width: function (width) {
+ return this.attr('width', width)
+ },
+ // Set height of element
+ height: function (height) {
+ return this.attr('height', height)
+ },
+ // Set element size to given width and height
+ size: function (width, height) {
+ var p = proportionalSize(this, width, height)
+
+ return this
+ .width(new SVG.Number(p.width))
+ .height(new SVG.Number(p.height))
+ },
+ // Clone element
+ clone: function (parent) {
+ // write dom data to the dom so the clone can pickup the data
+ this.writeDataToDom()
+
+ // clone element and assign new id
+ var clone = assignNewId(this.node.cloneNode(true))
+
+ // insert the clone in the given parent or after myself
+ if (parent) parent.add(clone)
+ else this.after(clone)
+
+ return clone
+ },
+ // Remove element
+ remove: function () {
+ if (this.parent()) { this.parent().removeElement(this) }
+
+ return this
+ },
+ // Replace element
+ replace: function (element) {
+ this.after(element).remove()
+
+ return element
+ },
+ // Add element to given container and return self
+ addTo: function (parent) {
+ return parent.put(this)
+ },
+ // Add element to given container and return container
+ putIn: function (parent) {
+ return parent.add(this)
+ },
+ // Get / set id
+ id: function (id) {
+ return this.attr('id', id)
+ },
+
+ // Show element
+ show: function () {
+ return this.style('display', '')
+ },
+ // Hide element
+ hide: function () {
+ return this.style('display', 'none')
+ },
+ // Is element visible?
+ visible: function () {
+ return this.style('display') != 'none'
+ },
+ // Return id on string conversion
+ toString: function () {
+ return this.attr('id')
+ },
+ // Return array of classes on the node
+ classes: function () {
+ var attr = this.attr('class')
+
+ return attr == null ? [] : attr.trim().split(SVG.regex.delimiter)
+ },
+ // Return true if class exists on the node, false otherwise
+ hasClass: function (name) {
+ return this.classes().indexOf(name) != -1
+ },
+ // Add class to the node
+ addClass: function (name) {
+ if (!this.hasClass(name)) {
+ var array = this.classes()
+ array.push(name)
+ this.attr('class', array.join(' '))
+ }
+
+ return this
+ },
+ // Remove class from the node
+ removeClass: function (name) {
+ if (this.hasClass(name)) {
+ this.attr('class', this.classes().filter(function (c) {
+ return c != name
+ }).join(' '))
+ }
+
+ return this
+ },
+ // Toggle the presence of a class on the node
+ toggleClass: function (name) {
+ return this.hasClass(name) ? this.removeClass(name) : this.addClass(name)
+ },
+ // Get referenced element form attribute value
+ reference: function (attr) {
+ return SVG.get(this.attr(attr))
+ },
+ // Returns the parent element instance
+ parent: function (type) {
+ var parent = this
+
+ // check for parent
+ if (!parent.node.parentNode) return null
+
+ // get parent element
+ parent = SVG.adopt(parent.node.parentNode)
+
+ if (!type) return parent
+
+ // loop trough ancestors if type is given
+ while (parent && parent.node instanceof window.SVGElement) {
+ if (typeof type === 'string' ? parent.matches(type) : parent instanceof type) return parent
+ if (!parent.node.parentNode || parent.node.parentNode.nodeName == '#document') return null // #759, #720
+ parent = SVG.adopt(parent.node.parentNode)
+ }
+ },
+ // Get parent document
+ doc: function () {
+ return this instanceof SVG.Doc ? this : this.parent(SVG.Doc)
+ },
+ // return array of all ancestors of given type up to the root svg
+ parents: function (type) {
+ var parents = [], parent = this
+
+ do {
+ parent = parent.parent(type)
+ if (!parent || !parent.node) break
+
+ parents.push(parent)
+ } while (parent.parent)
+
+ return parents
+ },
+ // matches the element vs a css selector
+ matches: function (selector) {
+ return matches(this.node, selector)
+ },
+ // Returns the svg node to call native svg methods on it
+ native: function () {
+ return this.node
+ },
+ // Import raw svg
+ svg: function (svg) {
+ // create temporary holder
+ var well = document.createElement('svg')
+
+ // act as a setter if svg is given
+ if (svg && this instanceof SVG.Parent) {
+ // dump raw svg
+ well.innerHTML = '
' + svg.replace(/\n/, '').replace(/<([\w:-]+)([^<]+?)\/>/g, '<$1$2>') + ' '
+
+ // transplant nodes
+ for (var i = 0, il = well.firstChild.childNodes.length; i < il; i++) { this.node.appendChild(well.firstChild.firstChild) }
+
+ // otherwise act as a getter
+ } else {
+ // create a wrapping svg element in case of partial content
+ well.appendChild(svg = document.createElement('svg'))
+
+ // write svgjs data to the dom
+ this.writeDataToDom()
+
+ // insert a copy of this node
+ svg.appendChild(this.node.cloneNode(true))
+
+ // return target element
+ return well.innerHTML.replace(/^
/, '').replace(/<\/svg>$/, '')
+ }
+
+ return this
+ },
+
+ // write svgjs data to the dom
+ writeDataToDom: function () {
+ // dump variables recursively
+ if (this.each || this.lines) {
+ var fn = this.each ? this : this.lines()
+ fn.each(function () {
+ this.writeDataToDom()
+ })
+ }
+
+ // remove previously set data
+ this.node.removeAttribute('svgjs:data')
+
+ if (Object.keys(this.dom).length) { this.node.setAttribute('svgjs:data', JSON.stringify(this.dom)) } // see #428
+
+ return this
+ },
+ // set given data to the elements data property
+ setData: function (o) {
+ this.dom = o
+ return this
+ },
+ is: function (obj) {
+ return is(this, obj)
+ }
+ }
+ })
+
+ SVG.easing = {
+ '-': function (pos) { return pos },
+ '<>': function (pos) { return -Math.cos(pos * Math.PI) / 2 + 0.5 },
+ '>': function (pos) { return Math.sin(pos * Math.PI / 2) },
+ '<': function (pos) { return -Math.cos(pos * Math.PI / 2) + 1 }
+ }
+
+ SVG.morph = function (pos) {
+ return function (from, to) {
+ return new SVG.MorphObj(from, to).at(pos)
+ }
+ }
+
+ SVG.Situation = SVG.invent({
+
+ create: function (o) {
+ this.init = false
+ this.reversed = false
+ this.reversing = false
+
+ this.duration = new SVG.Number(o.duration).valueOf()
+ this.delay = new SVG.Number(o.delay).valueOf()
+
+ this.start = +new Date() + this.delay
+ this.finish = this.start + this.duration
+ this.ease = o.ease
+
+ // this.loop is incremented from 0 to this.loops
+ // it is also incremented when in an infinite loop (when this.loops is true)
+ this.loop = 0
+ this.loops = false
+
+ this.animations = {
+ // functionToCall: [list of morphable objects]
+ // e.g. move: [SVG.Number, SVG.Number]
+ }
+
+ this.attrs = {
+ // holds all attributes which are not represented from a function svg.js provides
+ // e.g. someAttr: SVG.Number
+ }
+
+ this.styles = {
+ // holds all styles which should be animated
+ // e.g. fill-color: SVG.Color
+ }
+
+ this.transforms = [
+ // holds all transformations as transformation objects
+ // e.g. [SVG.Rotate, SVG.Translate, SVG.Matrix]
+ ]
+
+ this.once = {
+ // functions to fire at a specific position
+ // e.g. "0.5": function foo(){}
+ }
+ }
+
+ })
+
+ SVG.FX = SVG.invent({
+
+ create: function (element) {
+ this._target = element
+ this.situations = []
+ this.active = false
+ this.situation = null
+ this.paused = false
+ this.lastPos = 0
+ this.pos = 0
+ // The absolute position of an animation is its position in the context of its complete duration (including delay and loops)
+ // When performing a delay, absPos is below 0 and when performing a loop, its value is above 1
+ this.absPos = 0
+ this._speed = 1
+ },
+
+ extend: {
+
+ /**
+ * sets or returns the target of this animation
+ * @param o object || number In case of Object it holds all parameters. In case of number its the duration of the animation
+ * @param ease function || string Function which should be used for easing or easing keyword
+ * @param delay Number indicating the delay before the animation starts
+ * @return target || this
+ */
+ animate: function (o, ease, delay) {
+ if (typeof o === 'object') {
+ ease = o.ease
+ delay = o.delay
+ o = o.duration
+ }
+
+ var situation = new SVG.Situation({
+ duration: o || 1000,
+ delay: delay || 0,
+ ease: SVG.easing[ease || '-'] || ease
+ })
+
+ this.queue(situation)
+
+ return this
+ },
+
+ /**
+ * sets a delay before the next element of the queue is called
+ * @param delay Duration of delay in milliseconds
+ * @return this.target()
+ */
+
+
+ /**
+ * sets or returns the target of this animation
+ * @param null || target SVG.Element which should be set as new target
+ * @return target || this
+ */
+ target: function (target) {
+ if (target && target instanceof SVG.Element) {
+ this._target = target
+ return this
+ }
+
+ return this._target
+ },
+
+ // returns the absolute position at a given time
+ timeToAbsPos: function (timestamp) {
+ return (timestamp - this.situation.start) / (this.situation.duration / this._speed)
+ },
+
+ // returns the timestamp from a given absolute positon
+ absPosToTime: function (absPos) {
+ return this.situation.duration / this._speed * absPos + this.situation.start
+ },
+
+ // starts the animationloop
+ startAnimFrame: function () {
+ this.stopAnimFrame()
+ this.animationFrame = window.requestAnimationFrame(function () { this.step() }.bind(this))
+ },
+
+ // cancels the animationframe
+ stopAnimFrame: function () {
+ window.cancelAnimationFrame(this.animationFrame)
+ },
+
+ // kicks off the animation - only does something when the queue is currently not active and at least one situation is set
+ start: function () {
+ // dont start if already started
+ if (!this.active && this.situation) {
+ this.active = true
+ this.startCurrent()
+ }
+
+ return this
+ },
+
+ // start the current situation
+ startCurrent: function () {
+ this.situation.start = +new Date() + this.situation.delay / this._speed
+ this.situation.finish = this.situation.start + this.situation.duration / this._speed
+ return this.initAnimations().step()
+ },
+
+ /**
+ * adds a function / Situation to the animation queue
+ * @param fn function / situation to add
+ * @return this
+ */
+ queue: function (fn) {
+ if (typeof fn === 'function' || fn instanceof SVG.Situation) { this.situations.push(fn) }
+
+ if (!this.situation) this.situation = this.situations.shift()
+
+ return this
+ },
+
+ /**
+ * pulls next element from the queue and execute it
+ * @return this
+ */
+ dequeue: function () {
+ // stop current animation
+ this.stop()
+
+ // get next animation from queue
+ this.situation = this.situations.shift()
+
+ if (this.situation) {
+ if (this.situation instanceof SVG.Situation) {
+ this.start()
+ } else {
+ // If it is not a SVG.Situation, then it is a function, we execute it
+ this.situation.call(this)
+ }
+ }
+
+ return this
+ },
+
+ // updates all animations to the current state of the element
+ // this is important when one property could be changed from another property
+ initAnimations: function () {
+ var source
+ var s = this.situation
+
+ if (s.init) return this
+
+ for (var i in s.animations) {
+ source = this.target()[i]()
+
+ if (!Array.isArray(source)) {
+ source = [source]
+ }
+
+ if (!Array.isArray(s.animations[i])) {
+ s.animations[i] = [s.animations[i]]
+ }
+
+ // if(s.animations[i].length > source.length) {
+ // source.concat = source.concat(s.animations[i].slice(source.length, s.animations[i].length))
+ // }
+
+ for (var j = source.length; j--;) {
+ // The condition is because some methods return a normal number instead
+ // of a SVG.Number
+ if (s.animations[i][j] instanceof SVG.Number) { source[j] = new SVG.Number(source[j]) }
+
+ s.animations[i][j] = source[j].morph(s.animations[i][j])
+ }
+ }
+
+ for (var i in s.attrs) {
+ s.attrs[i] = new SVG.MorphObj(this.target().attr(i), s.attrs[i])
+ }
+
+ for (var i in s.styles) {
+ s.styles[i] = new SVG.MorphObj(this.target().style(i), s.styles[i])
+ }
+
+ s.initialTransformation = this.target().matrixify()
+
+ s.init = true
+ return this
+ },
+ clearQueue: function () {
+ this.situations = []
+ return this
+ },
+ clearCurrent: function () {
+ this.situation = null
+ return this
+ },
+ /** stops the animation immediately
+ * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately.
+ * @param clearQueue A Boolean indicating whether to remove queued animation as well.
+ * @return this
+ */
+ stop: function (jumpToEnd, clearQueue) {
+ var active = this.active
+ this.active = false
+
+ if (clearQueue) {
+ this.clearQueue()
+ }
+
+ if (jumpToEnd && this.situation) {
+ // initialize the situation if it was not
+ !active && this.startCurrent()
+ this.atEnd()
+ }
+
+ this.stopAnimFrame()
+
+ return this.clearCurrent()
+ },
+
+
+
+ after: function (fn) {
+ var c = this.last(),
+ wrapper = function wrapper (e) {
+ if (e.detail.situation == c) {
+ fn.call(this, c)
+ this.off('finished.fx', wrapper) // prevent memory leak
+ }
+ }
+
+ this.target().on('finished.fx', wrapper)
+
+ return this._callStart()
+ },
+ // adds a callback which is called whenever one animation step is performed
+ during: function (fn) {
+ var c = this.last(),
+ wrapper = function (e) {
+ if (e.detail.situation == c) {
+ fn.call(this, e.detail.pos, SVG.morph(e.detail.pos), e.detail.eased, c)
+ }
+ }
+
+ // see above
+ this.target().off('during.fx', wrapper).on('during.fx', wrapper)
+
+ this.after(function () {
+ this.off('during.fx', wrapper)
+ })
+
+ return this._callStart()
+ },
+
+ // calls after ALL animations in the queue are finished
+ afterAll: function (fn) {
+ var wrapper = function wrapper (e) {
+ fn.call(this)
+ this.off('allfinished.fx', wrapper)
+ }
+
+ // see above
+ this.target().off('allfinished.fx', wrapper).on('allfinished.fx', wrapper)
+
+ return this._callStart()
+ },
+
+
+ last: function () {
+ return this.situations.length ? this.situations[this.situations.length - 1] : this.situation
+ },
+
+ // adds one property to the animations
+ add: function (method, args, type) {
+ this.last()[type || 'animations'][method] = args
+ return this._callStart()
+ },
+
+ /** perform one step of the animation
+ * @param ignoreTime Boolean indicating whether to ignore time and use position directly or recalculate position based on time
+ * @return this
+ */
+ step: function (ignoreTime) {
+ // convert current time to an absolute position
+ if (!ignoreTime) this.absPos = this.timeToAbsPos(+new Date())
+
+ // This part convert an absolute position to a position
+ if (this.situation.loops !== false) {
+ var absPos, absPosInt, lastLoop
+
+ // If the absolute position is below 0, we just treat it as if it was 0
+ absPos = Math.max(this.absPos, 0)
+ absPosInt = Math.floor(absPos)
+
+ if (this.situation.loops === true || absPosInt < this.situation.loops) {
+ this.pos = absPos - absPosInt
+ lastLoop = this.situation.loop
+ this.situation.loop = absPosInt
+ } else {
+ this.absPos = this.situation.loops
+ this.pos = 1
+ // The -1 here is because we don't want to toggle reversed when all the loops have been completed
+ lastLoop = this.situation.loop - 1
+ this.situation.loop = this.situation.loops
+ }
+
+ if (this.situation.reversing) {
+ // Toggle reversed if an odd number of loops as occured since the last call of step
+ this.situation.reversed = this.situation.reversed != Boolean((this.situation.loop - lastLoop) % 2)
+ }
+ } else {
+ // If there are no loop, the absolute position must not be above 1
+ this.absPos = Math.min(this.absPos, 1)
+ this.pos = this.absPos
+ }
+
+ // while the absolute position can be below 0, the position must not be below 0
+ if (this.pos < 0) this.pos = 0
+
+ if (this.situation.reversed) this.pos = 1 - this.pos
+
+ // apply easing
+ var eased = this.situation.ease(this.pos)
+
+ // call once-callbacks
+ for (var i in this.situation.once) {
+ if (i > this.lastPos && i <= eased) {
+ this.situation.once[i].call(this.target(), this.pos, eased)
+ delete this.situation.once[i]
+ }
+ }
+
+ // fire during callback with position, eased position and current situation as parameter
+ if (this.active) this.target().fire('during', {pos: this.pos, eased: eased, fx: this, situation: this.situation})
+
+ // the user may call stop or finish in the during callback
+ // so make sure that we still have a valid situation
+ if (!this.situation) {
+ return this
+ }
+
+ // apply the actual animation to every property
+ this.eachAt()
+
+ // do final code when situation is finished
+ if ((this.pos == 1 && !this.situation.reversed) || (this.situation.reversed && this.pos == 0)) {
+ // stop animation callback
+ this.stopAnimFrame()
+
+ // fire finished callback with current situation as parameter
+ this.target().fire('finished', {fx: this, situation: this.situation})
+
+ if (!this.situations.length) {
+ this.target().fire('allfinished')
+
+ // Recheck the length since the user may call animate in the afterAll callback
+ if (!this.situations.length) {
+ this.target().off('.fx') // there shouldnt be any binding left, but to make sure...
+ this.active = false
+ }
+ }
+
+ // start next animation
+ if (this.active) this.dequeue()
+ else this.clearCurrent()
+ } else if (!this.paused && this.active) {
+ // we continue animating when we are not at the end
+ this.startAnimFrame()
+ }
+
+ // save last eased position for once callback triggering
+ this.lastPos = eased
+ return this
+ },
+
+ // calculates the step for every property and calls block with it
+ eachAt: function () {
+ var len, at, self = this, target = this.target(), s = this.situation
+
+ // apply animations which can be called trough a method
+ for (var i in s.animations) {
+ at = [].concat(s.animations[i]).map(function (el) {
+ return typeof el !== 'string' && el.at ? el.at(s.ease(self.pos), self.pos) : el
+ })
+
+ target[i].apply(target, at)
+ }
+
+ // apply animation which has to be applied with attr()
+ for (var i in s.attrs) {
+ at = [i].concat(s.attrs[i]).map(function (el) {
+ return typeof el !== 'string' && el.at ? el.at(s.ease(self.pos), self.pos) : el
+ })
+
+ target.attr.apply(target, at)
+ }
+
+ // apply animation which has to be applied with style()
+ for (var i in s.styles) {
+ at = [i].concat(s.styles[i]).map(function (el) {
+ return typeof el !== 'string' && el.at ? el.at(s.ease(self.pos), self.pos) : el
+ })
+
+ target.style.apply(target, at)
+ }
+
+ // animate initialTransformation which has to be chained
+ if (s.transforms.length) {
+ // get initial initialTransformation
+ at = s.initialTransformation
+ for (var i = 0, len = s.transforms.length; i < len; i++) {
+ // get next transformation in chain
+ var a = s.transforms[i]
+
+ // multiply matrix directly
+ if (a instanceof SVG.Matrix) {
+ if (a.relative) {
+ at = at.multiply(new SVG.Matrix().morph(a).at(s.ease(this.pos)))
+ } else {
+ at = at.morph(a).at(s.ease(this.pos))
+ }
+ continue
+ }
+
+ // when transformation is absolute we have to reset the needed transformation first
+ if (!a.relative) { a.undo(at.extract()) }
+
+ // and reapply it after
+ at = at.multiply(a.at(s.ease(this.pos)))
+ }
+
+ // set new matrix on element
+ target.matrix(at)
+ }
+
+ return this
+ },
+
+ // adds an once-callback which is called at a specific position and never again
+ once: function (pos, fn, isEased) {
+ var c = this.last()
+ if (!isEased) pos = c.ease(pos)
+
+ c.once[pos] = fn
+
+ return this
+ },
+
+ _callStart: function () {
+ setTimeout(function () { this.start() }.bind(this), 0)
+ return this
+ }
+
+ },
+
+ parent: SVG.Element,
+
+ // Add method to parent elements
+ construct: {
+ // Get fx module or create a new one, then animate with given duration and ease
+ animate: function (o, ease, delay) {
+ return (this.fx || (this.fx = new SVG.FX(this))).animate(o, ease, delay)
+ },
+ delay: function (delay) {
+ return (this.fx || (this.fx = new SVG.FX(this))).delay(delay)
+ },
+ stop: function (jumpToEnd, clearQueue) {
+ if (this.fx) { this.fx.stop(jumpToEnd, clearQueue) }
+
+ return this
+ },
+ finish: function () {
+ if (this.fx) { this.fx.finish() }
+
+ return this
+ },
+
+ }
+
+ })
+
+ // MorphObj is used whenever no morphable object is given
+ SVG.MorphObj = SVG.invent({
+
+ create: function (from, to) {
+ // prepare color for morphing
+ if (SVG.Color.isColor(to)) return new SVG.Color(from).morph(to)
+ // check if we have a list of values
+ if (SVG.regex.delimiter.test(from)) {
+ // prepare path for morphing
+ if (SVG.regex.pathLetters.test(from)) return new SVG.PathArray(from).morph(to)
+ // prepare value list for morphing
+ else return new SVG.Array(from).morph(to)
+ }
+ // prepare number for morphing
+ if (SVG.regex.numberAndUnit.test(to)) return new SVG.Number(from).morph(to)
+
+ // prepare for plain morphing
+ this.value = from
+ this.destination = to
+ },
+
+ extend: {
+ at: function (pos, real) {
+ return real < 1 ? this.value : this.destination
+ },
+
+ valueOf: function () {
+ return this.value
+ }
+ }
+
+ })
+
+ SVG.extend(SVG.FX, {
+ // Add animatable attributes
+ attr: function (a, v, relative) {
+ // apply attributes individually
+ if (typeof a === 'object') {
+ for (var key in a) { this.attr(key, a[key]) }
+ } else {
+ this.add(a, v, 'attrs')
+ }
+
+ return this
+ },
+ // Add animatable plot
+ plot: function (a, b, c, d) {
+ // Lines can be plotted with 4 arguments
+ if (arguments.length == 4) {
+ return this.plot([a, b, c, d])
+ }
+
+ return this.add('plot', new (this.target().morphArray)(a))
+ },
+ })
+
+ SVG.Box = SVG.invent({
+ create: function (x, y, width, height) {
+ if (typeof x === 'object' && !(x instanceof SVG.Element)) {
+ // chromes getBoundingClientRect has no x and y property
+ return SVG.Box.call(this, x.left != null ? x.left : x.x, x.top != null ? x.top : x.y, x.width, x.height)
+ } else if (arguments.length == 4) {
+ this.x = x
+ this.y = y
+ this.width = width
+ this.height = height
+ }
+
+ // add center, right, bottom...
+ fullBox(this)
+ }
+ })
+
+ SVG.BBox = SVG.invent({
+ // Initialize
+ create: function (element) {
+ SVG.Box.apply(this, [].slice.call(arguments))
+
+ // get values if element is given
+ if (element instanceof SVG.Element) {
+ var box
+
+ // yes this is ugly, but Firefox can be a pain when it comes to elements that are not yet rendered
+ try {
+ if (!document.documentElement.contains) {
+ // This is IE - it does not support contains() for top-level SVGs
+ var topParent = element.node
+ while (topParent.parentNode) {
+ topParent = topParent.parentNode
+ }
+ if (topParent != document) throw new Error('Element not in the dom')
+ } else {
+ // the element is NOT in the dom, throw error
+ // disabling the check below which fixes issue #76
+ // if (!document.documentElement.contains(element.node)) throw new Exception('Element not in the dom')
+ }
+
+ // find native bbox
+ box = element.node.getBBox()
+ } catch (e) {
+ if (element instanceof SVG.Shape) {
+ if (!SVG.parser.draw) {
+ // fixes apexcharts/vue-apexcharts #14
+ SVG.prepare()
+ }
+ var clone = element.clone(SVG.parser.draw.instance).show()
+
+ if(clone && clone.node && typeof clone.node.getBBox === 'function') {
+ // this check fixes jest unit tests
+ box = clone.node.getBBox()
+ }
+ if(clone && typeof clone.remove === 'function') {
+ clone.remove()
+ }
+ } else {
+ box = {
+ x: element.node.clientLeft,
+ y: element.node.clientTop,
+ width: element.node.clientWidth,
+ height: element.node.clientHeight
+ }
+ }
+ }
+
+ SVG.Box.call(this, box)
+ }
+ },
+
+ // Define ancestor
+ inherit: SVG.Box,
+
+ // Define Parent
+ parent: SVG.Element,
+
+ // Constructor
+ construct: {
+ // Get bounding box
+ bbox: function () {
+ return new SVG.BBox(this)
+ }
+ }
+
+ })
+
+ SVG.BBox.prototype.constructor = SVG.BBox
+
+
+ SVG.Matrix = SVG.invent({
+ // Initialize
+ create: function (source) {
+ var base = arrayToMatrix([1, 0, 0, 1, 0, 0])
+
+ // ensure source as object
+ source = source === null ? base : source instanceof SVG.Element
+ ? source.matrixify()
+ : typeof source === 'string'
+ ? arrayToMatrix(source.split(SVG.regex.delimiter).map(parseFloat))
+ : arguments.length == 6
+ ? arrayToMatrix([].slice.call(arguments))
+ : Array.isArray(source)
+ ? arrayToMatrix(source)
+ : source && typeof source === 'object'
+ ? source : base
+
+ // merge source
+ for (var i = abcdef.length - 1; i >= 0; --i) {
+ this[abcdef[i]] = source[abcdef[i]] != null
+ ? source[abcdef[i]] : base[abcdef[i]]
+ }
+ },
+
+ // Add methods
+ extend: {
+ // Extract individual transformations
+ extract: function () {
+ // find delta transform points
+ var px = deltaTransformPoint(this, 0, 1),
+ py = deltaTransformPoint(this, 1, 0),
+ skewX = 180 / Math.PI * Math.atan2(px.y, px.x) - 90
+
+ return {
+ // translation
+ x: this.e,
+ y: this.f,
+ transformedX: (this.e * Math.cos(skewX * Math.PI / 180) + this.f * Math.sin(skewX * Math.PI / 180)) / Math.sqrt(this.a * this.a + this.b * this.b),
+ transformedY: (this.f * Math.cos(skewX * Math.PI / 180) + this.e * Math.sin(-skewX * Math.PI / 180)) / Math.sqrt(this.c * this.c + this.d * this.d),
+
+ // rotation
+ rotation: skewX,
+ a: this.a,
+ b: this.b,
+ c: this.c,
+ d: this.d,
+ e: this.e,
+ f: this.f,
+ matrix: new SVG.Matrix(this)
+ }
+ },
+ // Clone matrix
+ clone: function () {
+ return new SVG.Matrix(this)
+ },
+ // Morph one matrix into another
+ morph: function (matrix) {
+ // store new destination
+ this.destination = new SVG.Matrix(matrix)
+
+ return this
+ },
+
+ // Multiplies by given matrix
+ multiply: function (matrix) {
+ return new SVG.Matrix(this.native().multiply(parseMatrix(matrix).native()))
+ },
+ // Inverses matrix
+ inverse: function () {
+ return new SVG.Matrix(this.native().inverse())
+ },
+ // Translate matrix
+ translate: function (x, y) {
+ return new SVG.Matrix(this.native().translate(x || 0, y || 0))
+ },
+
+
+ // Convert to native SVGMatrix
+ native: function () {
+ // create new matrix
+ var matrix = SVG.parser.native.createSVGMatrix()
+
+ // update with current values
+ for (var i = abcdef.length - 1; i >= 0; i--) { matrix[abcdef[i]] = this[abcdef[i]] }
+
+ return matrix
+ },
+ // Convert matrix to string
+ toString: function () {
+ // Construct the matrix directly, avoid values that are too small
+ return 'matrix(' + float32String(this.a) + ',' + float32String(this.b) +
+ ',' + float32String(this.c) + ',' + float32String(this.d) +
+ ',' + float32String(this.e) + ',' + float32String(this.f) +
+ ')'
+ }
+ },
+
+ // Define parent
+ parent: SVG.Element,
+
+ // Add parent method
+ construct: {
+ // Get current matrix
+ ctm: function () {
+ return new SVG.Matrix(this.node.getCTM())
+ },
+ // Get current screen matrix
+ screenCTM: function () {
+ /* https://bugzilla.mozilla.org/show_bug.cgi?id=1344537
+ This is needed because FF does not return the transformation matrix
+ for the inner coordinate system when getScreenCTM() is called on nested svgs.
+ However all other Browsers do that */
+ if (this instanceof SVG.Nested) {
+ var rect = this.rect(1, 1)
+ var m = rect.node.getScreenCTM()
+ rect.remove()
+ return new SVG.Matrix(m)
+ }
+ return new SVG.Matrix(this.node.getScreenCTM())
+ }
+
+ }
+
+ })
+
+ SVG.Point = SVG.invent({
+ // Initialize
+ create: function (x, y) {
+ var i, source, base = {x: 0, y: 0}
+
+ // ensure source as object
+ source = Array.isArray(x)
+ ? {x: x[0], y: x[1]}
+ : typeof x === 'object'
+ ? {x: x.x, y: x.y}
+ : x != null
+ ? {x: x, y: (y != null ? y : x)} : base // If y has no value, then x is used has its value
+
+ // merge source
+ this.x = source.x
+ this.y = source.y
+ },
+
+ // Add methods
+ extend: {
+ // Clone point
+ clone: function () {
+ return new SVG.Point(this)
+ },
+ // Morph one point into another
+ morph: function (x, y) {
+ // store new destination
+ this.destination = new SVG.Point(x, y)
+
+ return this
+ },
+
+
+
+ }
+
+ })
+
+ SVG.extend(SVG.Element, {
+
+ // Get point
+ point: function (x, y) {
+ return new SVG.Point(x, y).transform(this.screenCTM().inverse())
+ }
+
+ })
+
+ SVG.extend(SVG.Element, {
+ // Set svg element attribute
+ attr: function (a, v, n) {
+ // act as full getter
+ if (a == null) {
+ // get an object of attributes
+ a = {}
+ v = this.node.attributes
+ for (var n = v.length - 1; n >= 0; n--) { a[v[n].nodeName] = SVG.regex.isNumber.test(v[n].nodeValue) ? parseFloat(v[n].nodeValue) : v[n].nodeValue }
+
+ return a
+ } else if (typeof a === 'object') {
+ // apply every attribute individually if an object is passed
+ for (var v_ in a) this.attr(v_, a[v_])
+ } else if (v === null) {
+ // remove value
+ this.node.removeAttribute(a)
+ } else if (v == null) {
+ // act as a getter if the first and only argument is not an object
+ v = this.node.getAttribute(a)
+ return v == null
+ ? SVG.defaults.attrs[a]
+ : SVG.regex.isNumber.test(v)
+ ? parseFloat(v) : v
+ } else {
+ // BUG FIX: some browsers will render a stroke if a color is given even though stroke width is 0
+ if (a == 'stroke-width') { this.attr('stroke', parseFloat(v) > 0 ? this._stroke : null) } else if (a == 'stroke') { this._stroke = v }
+
+ // convert image fill and stroke to patterns
+ if (a == 'fill' || a == 'stroke') {
+ if (SVG.regex.isImage.test(v)) { v = this.doc().defs().image(v, 0, 0) }
+
+ if (v instanceof SVG.Image) {
+ v = this.doc().defs().pattern(0, 0, function () {
+ this.add(v)
+ })
+ }
+ }
+
+ // ensure correct numeric values (also accepts NaN and Infinity)
+ if (typeof v === 'number') { v = new SVG.Number(v) }
+
+ // ensure full hex color
+ else if (SVG.Color.isColor(v)) { v = new SVG.Color(v) }
+
+ // parse array values
+ else if (Array.isArray(v)) { v = new SVG.Array(v) }
+
+ // if the passed attribute is leading...
+ if (a == 'leading') {
+ // ... call the leading method instead
+ if (this.leading) { this.leading(v) }
+ } else {
+ // set given attribute on node
+ typeof n === 'string'
+ ? this.node.setAttributeNS(n, a, v.toString())
+ : this.node.setAttribute(a, v.toString())
+ }
+
+ // rebuild if required
+ if (this.rebuild && (a == 'font-size' || a == 'x')) { this.rebuild(a, v) }
+ }
+
+ return this
+ }
+ })
+
+ SVG.extend(SVG.Element, {
+ // Add transformations
+ transform: function (o, relative) {
+ // get target in case of the fx module, otherwise reference this
+ var target = this,
+ matrix, bbox
+
+ // act as a getter
+ if (typeof o !== 'object') {
+ // get current matrix
+ matrix = new SVG.Matrix(target).extract()
+
+ return typeof o === 'string' ? matrix[o] : matrix
+ }
+
+ // get current matrix
+ matrix = new SVG.Matrix(target)
+
+ // ensure relative flag
+ relative = !!relative || !!o.relative
+
+ // act on matrix
+ if (o.a != null) {
+ matrix = relative
+ // relative
+ ? matrix.multiply(new SVG.Matrix(o))
+ // absolute
+ : new SVG.Matrix(o)
+ }
+
+ return this.attr('transform', matrix)
+ }
+ })
+
+
+
+ SVG.extend(SVG.Element, {
+ // Reset all transformations
+ untransform: function () {
+ return this.attr('transform', null)
+ },
+ // merge the whole transformation chain into one matrix and returns it
+ matrixify: function () {
+ var matrix = (this.attr('transform') || '')
+ // split transformations
+ .split(SVG.regex.transforms).slice(0, -1).map(function (str) {
+ // generate key => value pairs
+ var kv = str.trim().split('(')
+ return [kv[0], kv[1].split(SVG.regex.delimiter).map(function (str) { return parseFloat(str) })]
+ })
+ // merge every transformation into one matrix
+ .reduce(function (matrix, transform) {
+ if (transform[0] == 'matrix') return matrix.multiply(arrayToMatrix(transform[1]))
+ return matrix[transform[0]].apply(matrix, transform[1])
+ }, new SVG.Matrix())
+
+ return matrix
+ },
+ // add an element to another parent without changing the visual representation on the screen
+ toParent: function (parent) {
+ if (this == parent) return this
+ var ctm = this.screenCTM()
+ var pCtm = parent.screenCTM().inverse()
+
+ this.addTo(parent).untransform().transform(pCtm.multiply(ctm))
+
+ return this
+ },
+ // same as above with parent equals root-svg
+ toDoc: function () {
+ return this.toParent(this.doc())
+ }
+
+ })
+
+ SVG.Transformation = SVG.invent({
+
+ create: function (source, inversed) {
+ if (arguments.length > 1 && typeof inversed !== 'boolean') {
+ return this.constructor.call(this, [].slice.call(arguments))
+ }
+
+ if (Array.isArray(source)) {
+ for (var i = 0, len = this.arguments.length; i < len; ++i) {
+ this[this.arguments[i]] = source[i]
+ }
+ } else if (source && typeof source === 'object') {
+ for (var i = 0, len = this.arguments.length; i < len; ++i) {
+ this[this.arguments[i]] = source[this.arguments[i]]
+ }
+ }
+
+ this.inversed = false
+
+ if (inversed === true) {
+ this.inversed = true
+ }
+ },
+
+ })
+
+ SVG.Translate = SVG.invent({
+
+ parent: SVG.Matrix,
+ inherit: SVG.Transformation,
+
+ create: function (source, inversed) {
+ this.constructor.apply(this, [].slice.call(arguments))
+ },
+
+ extend: {
+ arguments: ['transformedX', 'transformedY'],
+ method: 'translate'
+ }
+
+ })
+
+
+
+
+
+ SVG.extend(SVG.Element, {
+ // Dynamic style generator
+ style: function (s, v) {
+ if (arguments.length == 0) {
+ // get full style
+ return this.node.style.cssText || ''
+ } else if (arguments.length < 2) {
+ // apply every style individually if an object is passed
+ if (typeof s === 'object') {
+ for (var v_ in s) this.style(v_, s[v_])
+ } else if (SVG.regex.isCss.test(s)) {
+ // parse css string
+ s = s.split(/\s*;\s*/)
+ // filter out suffix ; and stuff like ;;
+ .filter(function (e) { return !!e })
+ .map(function (e) { return e.split(/\s*:\s*/) })
+
+ // apply every definition individually
+ while (v = s.pop()) {
+ this.style(v[0], v[1])
+ }
+ } else {
+ // act as a getter if the first and only argument is not an object
+ return this.node.style[camelCase(s)]
+ }
+ } else {
+ this.node.style[camelCase(s)] = v === null || SVG.regex.isBlank.test(v) ? '' : v
+ }
+
+ return this
+ }
+ })
+ SVG.Parent = SVG.invent({
+ // Initialize node
+ create: function (element) {
+ this.constructor.call(this, element)
+ },
+
+ // Inherit from
+ inherit: SVG.Element,
+
+ // Add class methods
+ extend: {
+ // Returns all child elements
+ children: function () {
+ return SVG.utils.map(SVG.utils.filterSVGElements(this.node.childNodes), function (node) {
+ return SVG.adopt(node)
+ })
+ },
+ // Add given element at a position
+ add: function (element, i) {
+ if (i == null) { this.node.appendChild(element.node) } else if (element.node != this.node.childNodes[i]) { this.node.insertBefore(element.node, this.node.childNodes[i]) }
+
+ return this
+ },
+ // Basically does the same as `add()` but returns the added element instead
+ put: function (element, i) {
+ this.add(element, i)
+ return element
+ },
+ // Checks if the given element is a child
+ has: function (element) {
+ return this.index(element) >= 0
+ },
+ // Gets index of given element
+ index: function (element) {
+ return [].slice.call(this.node.childNodes).indexOf(element.node)
+ },
+ // Get a element at the given index
+ get: function (i) {
+ return SVG.adopt(this.node.childNodes[i])
+ },
+ // Get first child
+ first: function () {
+ return this.get(0)
+ },
+ // Get the last child
+ last: function () {
+ return this.get(this.node.childNodes.length - 1)
+ },
+ // Iterates over all children and invokes a given block
+ each: function (block, deep) {
+ var il,
+ children = this.children()
+
+ for (var i = 0, il = children.length; i < il; i++) {
+ if (children[i] instanceof SVG.Element) { block.apply(children[i], [i, children]) }
+
+ if (deep && (children[i] instanceof SVG.Container)) { children[i].each(block, deep) }
+ }
+
+ return this
+ },
+ // Remove a given child
+ removeElement: function (element) {
+ this.node.removeChild(element.node)
+
+ return this
+ },
+ // Remove all elements in this container
+ clear: function () {
+ // remove children
+ while (this.node.hasChildNodes()) { this.node.removeChild(this.node.lastChild) }
+
+ // remove defs reference
+ delete this._defs
+
+ return this
+ }, // Get defs
+ defs: function () {
+ return this.doc().defs()
+ }
+ }
+
+ })
+
+ SVG.extend(SVG.Parent, {
+
+ ungroup: function (parent, depth) {
+ if (depth === 0 || this instanceof SVG.Defs || this.node == SVG.parser.draw) return this
+
+ parent = parent || (this instanceof SVG.Doc ? this : this.parent(SVG.Parent))
+ depth = depth || Infinity
+
+ this.each(function () {
+ if (this instanceof SVG.Defs) return this
+ if (this instanceof SVG.Parent) return this.ungroup(parent, depth - 1)
+ return this.toParent(parent)
+ })
+
+ this.node.firstChild || this.remove()
+
+ return this
+ },
+
+ flatten: function (parent, depth) {
+ return this.ungroup(parent, depth)
+ }
+
+ })
+ SVG.Container = SVG.invent({
+ // Initialize node
+ create: function (element) {
+ this.constructor.call(this, element)
+ },
+
+ // Inherit from
+ inherit: SVG.Parent
+
+ })
+
+ SVG.ViewBox = SVG.invent({
+
+ // Define parent
+ parent: SVG.Container,
+
+ // Add parent method
+ construct: {
+
+ }
+
+ })
+ // Add events to elements
+ ;[ 'click',
+ 'dblclick',
+ 'mousedown',
+ 'mouseup',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ // , 'mouseenter' -> not supported by IE
+ // , 'mouseleave' -> not supported by IE
+ 'touchstart',
+ 'touchmove',
+ 'touchleave',
+ 'touchend',
+ 'touchcancel' ].forEach(function (event) {
+ // add event to SVG.Element
+ SVG.Element.prototype[event] = function (f) {
+ // bind event to element rather than element node
+ SVG.on(this.node, event, f)
+ return this
+ }
+ })
+
+ // Initialize listeners stack
+ SVG.listeners = []
+ SVG.handlerMap = []
+ SVG.listenerId = 0
+
+ // Add event binder in the SVG namespace
+ SVG.on = function (node, event, listener, binding, options) {
+ // create listener, get object-index
+ var l = listener.bind(binding || node.instance || node),
+ index = (SVG.handlerMap.indexOf(node) + 1 || SVG.handlerMap.push(node)) - 1,
+ ev = event.split('.')[0],
+ ns = event.split('.')[1] || '*'
+
+ // ensure valid object
+ SVG.listeners[index] = SVG.listeners[index] || {}
+ SVG.listeners[index][ev] = SVG.listeners[index][ev] || {}
+ SVG.listeners[index][ev][ns] = SVG.listeners[index][ev][ns] || {}
+
+ if (!listener._svgjsListenerId) { listener._svgjsListenerId = ++SVG.listenerId }
+
+ // reference listener
+ SVG.listeners[index][ev][ns][listener._svgjsListenerId] = l
+
+ // add listener
+ node.addEventListener(ev, l, options || { passive: true })
+ }
+
+ // Add event unbinder in the SVG namespace
+ SVG.off = function (node, event, listener) {
+ var index = SVG.handlerMap.indexOf(node),
+ ev = event && event.split('.')[0],
+ ns = event && event.split('.')[1],
+ namespace = ''
+
+ if (index == -1) return
+
+ if (listener) {
+ if (typeof listener === 'function') listener = listener._svgjsListenerId
+ if (!listener) return
+
+ // remove listener reference
+ if (SVG.listeners[index][ev] && SVG.listeners[index][ev][ns || '*']) {
+ // remove listener
+ node.removeEventListener(ev, SVG.listeners[index][ev][ns || '*'][listener], false)
+
+ delete SVG.listeners[index][ev][ns || '*'][listener]
+ }
+ } else if (ns && ev) {
+ // remove all listeners for a namespaced event
+ if (SVG.listeners[index][ev] && SVG.listeners[index][ev][ns]) {
+ for (var listener_ in SVG.listeners[index][ev][ns]) { SVG.off(node, [ev, ns].join('.'), listener_) }
+
+ delete SVG.listeners[index][ev][ns]
+ }
+ } else if (ns) {
+ // remove all listeners for a specific namespace
+ for (var event_ in SVG.listeners[index]) {
+ for (var namespace in SVG.listeners[index][event_]) {
+ if (ns === namespace) {
+ SVG.off(node, [event_, ns].join('.'))
+ }
+ }
+ }
+ } else if (ev) {
+ // remove all listeners for the event
+ if (SVG.listeners[index][ev]) {
+ for (var namespace in SVG.listeners[index][ev]) { SVG.off(node, [ev, namespace].join('.')) }
+
+ delete SVG.listeners[index][ev]
+ }
+ } else {
+ // remove all listeners on a given node
+ for (var event_ in SVG.listeners[index]) { SVG.off(node, event_) }
+
+ delete SVG.listeners[index]
+ delete SVG.handlerMap[index]
+ }
+ }
+
+ //
+ SVG.extend(SVG.Element, {
+ // Bind given event to listener
+ on: function (event, listener, binding, options) {
+ SVG.on(this.node, event, listener, binding, options)
+
+ return this
+ },
+ // Unbind event from listener
+ off: function (event, listener) {
+ SVG.off(this.node, event, listener)
+
+ return this
+ },
+ // Fire given event
+ fire: function (event, data) {
+ // Dispatch event
+ if (event instanceof window.Event) {
+ this.node.dispatchEvent(event)
+ } else {
+ this.node.dispatchEvent(event = new SVG.CustomEvent(event, {detail: data, cancelable: true}))
+ }
+
+ this._event = event
+ return this
+ },
+ event: function () {
+ return this._event
+ }
+ })
+
+ SVG.Defs = SVG.invent({
+ // Initialize node
+ create: 'defs',
+
+ // Inherit from
+ inherit: SVG.Container
+
+ })
+ SVG.G = SVG.invent({
+ // Initialize node
+ create: 'g',
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ // Add class methods
+ extend: {
+ // Move over x-axis
+ x: function (x) {
+ return x == null ? this.transform('x') : this.transform({ x: x - this.x() }, true)
+ },
+ },
+
+ // Add parent method
+ construct: {
+ // Create a group element
+ group: function () {
+ return this.put(new SVG.G())
+ }
+ }
+ })
+
+ SVG.Doc = SVG.invent({
+ // Initialize node
+ create: function (element) {
+ if (element) {
+ // ensure the presence of a dom element
+ element = typeof element === 'string'
+ ? document.getElementById(element)
+ : element
+
+ // If the target is an svg element, use that element as the main wrapper.
+ // This allows svg.js to work with svg documents as well.
+ if (element.nodeName == 'svg') {
+ this.constructor.call(this, element)
+ } else {
+ this.constructor.call(this, SVG.create('svg'))
+ element.appendChild(this.node)
+ this.size('100%', '100%')
+ }
+
+ // set svg element attributes and ensure defs node
+ this.namespace().defs()
+ }
+ },
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ // Add class methods
+ extend: {
+ // Add namespaces
+ namespace: function () {
+ return this
+ .attr({ xmlns: SVG.ns, version: '1.1' })
+ .attr('xmlns:xlink', SVG.xlink, SVG.xmlns)
+ .attr('xmlns:svgjs', SVG.svgjs, SVG.xmlns)
+ },
+ // Creates and returns defs element
+ defs: function () {
+ if (!this._defs) {
+ var defs
+
+ // Find or create a defs element in this instance
+ if (defs = this.node.getElementsByTagName('defs')[0]) { this._defs = SVG.adopt(defs) } else { this._defs = new SVG.Defs() }
+
+ // Make sure the defs node is at the end of the stack
+ this.node.appendChild(this._defs.node)
+ }
+
+ return this._defs
+ },
+ // custom parent method
+ parent: function () {
+ if (!this.node.parentNode || this.node.parentNode.nodeName == '#document') return null
+ return this.node.parentNode
+ },
+
+
+ // Removes the doc from the DOM
+ remove: function () {
+ if (this.parent()) {
+ this.parent().removeChild(this.node)
+ }
+
+ return this
+ },
+ clear: function () {
+ // remove children
+ while (this.node.hasChildNodes()) { this.node.removeChild(this.node.lastChild) }
+
+ // remove defs reference
+ delete this._defs
+
+ // add back parser
+ if (SVG.parser.draw && !SVG.parser.draw.parentNode) { this.node.appendChild(SVG.parser.draw) }
+
+ return this
+ },
+ clone: function (parent) {
+ // write dom data to the dom so the clone can pickup the data
+ this.writeDataToDom()
+
+ // get reference to node
+ var node = this.node
+
+ // clone element and assign new id
+ var clone = assignNewId(node.cloneNode(true))
+
+ // insert the clone in the given parent or after myself
+ if (parent) {
+ (parent.node || parent).appendChild(clone.node)
+ } else {
+ node.parentNode.insertBefore(clone.node, node.nextSibling)
+ }
+
+ return clone
+ }
+ }
+
+ })
+
+ // ### This module adds backward / forward functionality to elements.
+
+ //
+ SVG.extend(SVG.Element, {
+ // Get all siblings, including myself
+
+
+ })
+
+
+
+ SVG.Gradient = SVG.invent({
+ // Initialize node
+ create: function (type) {
+ this.constructor.call(this, SVG.create(type + 'Gradient'))
+
+ // store type
+ this.type = type
+ },
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ // Add class methods
+ extend: {
+ // Add a color stop
+ at: function (offset, color, opacity) {
+ return this.put(new SVG.Stop()).update(offset, color, opacity)
+ },
+ // Update gradient
+ update: function (block) {
+ // remove all stops
+ this.clear()
+
+ // invoke passed block
+ if (typeof block === 'function') { block.call(this, this) }
+
+ return this
+ },
+ // Return the fill id
+ fill: function () {
+ return 'url(#' + this.id() + ')'
+ },
+ // Alias string convertion to fill
+ toString: function () {
+ return this.fill()
+ },
+ // custom attr to handle transform
+ attr: function (a, b, c) {
+ if (a == 'transform') a = 'gradientTransform'
+ return SVG.Container.prototype.attr.call(this, a, b, c)
+ }
+ },
+
+ // Add parent method
+ construct: {
+ // Create gradient element in defs
+ gradient: function (type, block) {
+ return this.defs().gradient(type, block)
+ }
+ }
+ })
+
+ // Add animatable methods to both gradient and fx module
+ SVG.extend(SVG.Gradient, SVG.FX, {
+ // From position
+ from: function (x, y) {
+ return (this._target || this).type == 'radial'
+ ? this.attr({ fx: new SVG.Number(x), fy: new SVG.Number(y) })
+ : this.attr({ x1: new SVG.Number(x), y1: new SVG.Number(y) })
+ },
+ // To position
+ to: function (x, y) {
+ return (this._target || this).type == 'radial'
+ ? this.attr({ cx: new SVG.Number(x), cy: new SVG.Number(y) })
+ : this.attr({ x2: new SVG.Number(x), y2: new SVG.Number(y) })
+ }
+ })
+
+ // Base gradient generation
+ SVG.extend(SVG.Defs, {
+ // define gradient
+ gradient: function (type, block) {
+ return this.put(new SVG.Gradient(type)).update(block)
+ }
+
+ })
+
+ SVG.Stop = SVG.invent({
+ // Initialize node
+ create: 'stop',
+
+ // Inherit from
+ inherit: SVG.Element,
+
+ // Add class methods
+ extend: {
+ // add color stops
+ update: function (o) {
+ if (typeof o === 'number' || o instanceof SVG.Number) {
+ o = {
+ offset: arguments[0],
+ color: arguments[1],
+ opacity: arguments[2]
+ }
+ }
+
+ // set attributes
+ if (o.opacity != null) this.attr('stop-opacity', o.opacity)
+ if (o.color != null) this.attr('stop-color', o.color)
+ if (o.offset != null) this.attr('offset', new SVG.Number(o.offset))
+
+ return this
+ }
+ }
+
+ })
+
+ SVG.Pattern = SVG.invent({
+ // Initialize node
+ create: 'pattern',
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ // Add class methods
+ extend: {
+ // Return the fill id
+ fill: function () {
+ return 'url(#' + this.id() + ')'
+ },
+ // Update pattern by rebuilding
+ update: function (block) {
+ // remove content
+ this.clear()
+
+ // invoke passed block
+ if (typeof block === 'function') { block.call(this, this) }
+
+ return this
+ },
+ // Alias string convertion to fill
+ toString: function () {
+ return this.fill()
+ },
+ // custom attr to handle transform
+ attr: function (a, b, c) {
+ if (a == 'transform') a = 'patternTransform'
+ return SVG.Container.prototype.attr.call(this, a, b, c)
+ }
+
+ },
+
+ // Add parent method
+ construct: {
+ // Create pattern element in defs
+ pattern: function (width, height, block) {
+ return this.defs().pattern(width, height, block)
+ }
+ }
+ })
+
+ SVG.extend(SVG.Defs, {
+ // Define gradient
+ pattern: function (width, height, block) {
+ return this.put(new SVG.Pattern()).update(block).attr({
+ x: 0,
+ y: 0,
+ width: width,
+ height: height,
+ patternUnits: 'userSpaceOnUse'
+ })
+ }
+
+ })
+ SVG.Shape = SVG.invent({
+ // Initialize node
+ create: function (element) {
+ this.constructor.call(this, element)
+ },
+
+ // Inherit from
+ inherit: SVG.Element
+
+ })
+
+ SVG.Symbol = SVG.invent({
+ // Initialize node
+ create: 'symbol',
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ construct: {
+ // create symbol
+ symbol: function () {
+ return this.put(new SVG.Symbol())
+ }
+ }
+ })
+
+ SVG.Use = SVG.invent({
+ // Initialize node
+ create: 'use',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // Use element as a reference
+ element: function (element, file) {
+ // Set lined element
+ return this.attr('href', (file || '') + '#' + element, SVG.xlink)
+ }
+ },
+
+ // Add parent method
+ construct: {
+ // Create a use element
+ use: function (element, file) {
+ return this.put(new SVG.Use()).element(element, file)
+ }
+ }
+ })
+ SVG.Rect = SVG.invent({
+ // Initialize node
+ create: 'rect',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add parent method
+ construct: {
+ // Create a rect element
+ rect: function (width, height) {
+ return this.put(new SVG.Rect()).size(width, height)
+ }
+ }
+ })
+ SVG.Circle = SVG.invent({
+ // Initialize node
+ create: 'circle',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add parent method
+ construct: {
+ // Create circle element, based on ellipse
+ circle: function (size) {
+ return this.put(new SVG.Circle()).rx(new SVG.Number(size).divide(2)).move(0, 0)
+ }
+ }
+ })
+
+ SVG.extend(SVG.Circle, SVG.FX, {
+ // Radius x value
+ rx: function (rx) {
+ return this.attr('r', rx)
+ },
+ // Alias radius x value
+ ry: function (ry) {
+ return this.rx(ry)
+ }
+ })
+
+ SVG.Ellipse = SVG.invent({
+ // Initialize node
+ create: 'ellipse',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add parent method
+ construct: {
+ // Create an ellipse
+ ellipse: function (width, height) {
+ return this.put(new SVG.Ellipse()).size(width, height).move(0, 0)
+ }
+ }
+ })
+
+ SVG.extend(SVG.Ellipse, SVG.Rect, SVG.FX, {
+ // Radius x value
+ rx: function (rx) {
+ return this.attr('rx', rx)
+ },
+ // Radius y value
+ ry: function (ry) {
+ return this.attr('ry', ry)
+ }
+ })
+
+ // Add common method
+ SVG.extend(SVG.Circle, SVG.Ellipse, {
+ // Move over x-axis
+ x: function (x) {
+ return x == null ? this.cx() - this.rx() : this.cx(x + this.rx())
+ },
+ // Move over y-axis
+ y: function (y) {
+ return y == null ? this.cy() - this.ry() : this.cy(y + this.ry())
+ },
+ // Move by center over x-axis
+ cx: function (x) {
+ return x == null ? this.attr('cx') : this.attr('cx', x)
+ },
+ // Move by center over y-axis
+ cy: function (y) {
+ return y == null ? this.attr('cy') : this.attr('cy', y)
+ },
+ // Set width of element
+ width: function (width) {
+ return width == null ? this.rx() * 2 : this.rx(new SVG.Number(width).divide(2))
+ },
+ // Set height of element
+ height: function (height) {
+ return height == null ? this.ry() * 2 : this.ry(new SVG.Number(height).divide(2))
+ },
+ // Custom size function
+ size: function (width, height) {
+ var p = proportionalSize(this, width, height)
+
+ return this
+ .rx(new SVG.Number(p.width).divide(2))
+ .ry(new SVG.Number(p.height).divide(2))
+ }
+ })
+ SVG.Line = SVG.invent({
+ // Initialize node
+ create: 'line',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // Get array
+ array: function () {
+ return new SVG.PointArray([
+ [ this.attr('x1'), this.attr('y1') ],
+ [ this.attr('x2'), this.attr('y2') ]
+ ])
+ },
+ // Overwrite native plot() method
+ plot: function (x1, y1, x2, y2) {
+ if (x1 == null) { return this.array() } else if (typeof y1 !== 'undefined') { x1 = { x1: x1, y1: y1, x2: x2, y2: y2 } } else { x1 = new SVG.PointArray(x1).toLine() }
+
+ return this.attr(x1)
+ },
+ // Move by left top corner
+ move: function (x, y) {
+ return this.attr(this.array().move(x, y).toLine())
+ },
+ // Set element size to given width and height
+ size: function (width, height) {
+ var p = proportionalSize(this, width, height)
+
+ return this.attr(this.array().size(p.width, p.height).toLine())
+ }
+ },
+
+ // Add parent method
+ construct: {
+ // Create a line element
+ line: function (x1, y1, x2, y2) {
+ // make sure plot is called as a setter
+ // x1 is not necessarily a number, it can also be an array, a string and a SVG.PointArray
+ return SVG.Line.prototype.plot.apply(
+ this.put(new SVG.Line())
+ , x1 != null ? [x1, y1, x2, y2] : [0, 0, 0, 0]
+ )
+ }
+ }
+ })
+
+ SVG.Polyline = SVG.invent({
+ // Initialize node
+ create: 'polyline',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add parent method
+ construct: {
+ // Create a wrapped polyline element
+ polyline: function (p) {
+ // make sure plot is called as a setter
+ return this.put(new SVG.Polyline()).plot(p || new SVG.PointArray())
+ }
+ }
+ })
+
+ SVG.Polygon = SVG.invent({
+ // Initialize node
+ create: 'polygon',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add parent method
+ construct: {
+ // Create a wrapped polygon element
+ polygon: function (p) {
+ // make sure plot is called as a setter
+ return this.put(new SVG.Polygon()).plot(p || new SVG.PointArray())
+ }
+ }
+ })
+
+ // Add polygon-specific functions
+ SVG.extend(SVG.Polyline, SVG.Polygon, {
+ // Get array
+ array: function () {
+ return this._array || (this._array = new SVG.PointArray(this.attr('points')))
+ },
+ // Plot new path
+ plot: function (p) {
+ return (p == null)
+ ? this.array()
+ : this.clear().attr('points', typeof p === 'string' ? p : (this._array = new SVG.PointArray(p)))
+ },
+ // Clear array cache
+ clear: function () {
+ delete this._array
+ return this
+ },
+ // Move by left top corner
+ move: function (x, y) {
+ return this.attr('points', this.array().move(x, y))
+ },
+ // Set element size to given width and height
+ size: function (width, height) {
+ var p = proportionalSize(this, width, height)
+
+ return this.attr('points', this.array().size(p.width, p.height))
+ }
+
+ })
+
+ // unify all point to point elements
+ SVG.extend(SVG.Line, SVG.Polyline, SVG.Polygon, {
+ // Define morphable array
+ morphArray: SVG.PointArray,
+ // Move by left top corner over x-axis
+ x: function (x) {
+ return x == null ? this.bbox().x : this.move(x, this.bbox().y)
+ },
+ // Move by left top corner over y-axis
+ y: function (y) {
+ return y == null ? this.bbox().y : this.move(this.bbox().x, y)
+ },
+ // Set width of element
+ width: function (width) {
+ var b = this.bbox()
+
+ return width == null ? b.width : this.size(width, b.height)
+ },
+ // Set height of element
+ height: function (height) {
+ var b = this.bbox()
+
+ return height == null ? b.height : this.size(b.width, height)
+ }
+ })
+ SVG.Path = SVG.invent({
+ // Initialize node
+ create: 'path',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // Define morphable array
+ morphArray: SVG.PathArray,
+ // Get array
+ array: function () {
+ return this._array || (this._array = new SVG.PathArray(this.attr('d')))
+ },
+ // Plot new path
+ plot: function (d) {
+ return (d == null)
+ ? this.array()
+ : this.clear().attr('d', typeof d === 'string' ? d : (this._array = new SVG.PathArray(d)))
+ },
+ // Clear array cache
+ clear: function () {
+ delete this._array
+ return this
+ },
+
+ },
+
+ // Add parent method
+ construct: {
+ // Create a wrapped path element
+ path: function (d) {
+ // make sure plot is called as a setter
+ return this.put(new SVG.Path()).plot(d || new SVG.PathArray())
+ }
+ }
+ })
+
+ SVG.Image = SVG.invent({
+ // Initialize node
+ create: 'image',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // (re)load image
+ load: function (url) {
+ if (!url) return this
+
+ var self = this,
+ img = new window.Image()
+
+ // preload image
+ SVG.on(img, 'load', function () {
+ SVG.off(img)
+
+ var p = self.parent(SVG.Pattern)
+
+ if (p === null) return
+
+ // ensure image size
+ if (self.width() == 0 && self.height() == 0) { self.size(img.width, img.height) }
+
+ // ensure pattern size if not set
+ if (p && p.width() == 0 && p.height() == 0) { p.size(self.width(), self.height()) }
+
+ // callback
+ if (typeof self._loaded === 'function') {
+ self._loaded.call(self, {
+ width: img.width,
+ height: img.height,
+ ratio: img.width / img.height,
+ url: url
+ })
+ }
+ })
+
+ SVG.on(img, 'error', function (e) {
+ SVG.off(img)
+
+ if (typeof self._error === 'function') {
+ self._error.call(self, e)
+ }
+ })
+
+ return this.attr('href', (img.src = this.src = url), SVG.xlink)
+ },
+ // Add loaded callback
+ loaded: function (loaded) {
+ this._loaded = loaded
+ return this
+ },
+
+ error: function (error) {
+ this._error = error
+ return this
+ }
+ },
+
+ // Add parent method
+ construct: {
+ // create image element, load image and set its size
+ image: function (source, width, height) {
+ return this.put(new SVG.Image()).load(source).size(width || 0, height || width || 0)
+ }
+ }
+
+ })
+ SVG.Text = SVG.invent({
+ // Initialize node
+ create: function () {
+ this.constructor.call(this, SVG.create('text'))
+
+ this.dom.leading = new SVG.Number(1.3) // store leading value for rebuilding
+ this._rebuild = true // enable automatic updating of dy values
+ this._build = false // disable build mode for adding multiple lines
+
+ // set default font
+ this.attr('font-family', SVG.defaults.attrs['font-family'])
+ },
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // Move over x-axis
+ x: function (x) {
+ // act as getter
+ if (x == null) { return this.attr('x') }
+
+ return this.attr('x', x)
+ },
+ // Set the text content
+ text: function (text) {
+ // act as getter
+ if (typeof text === 'undefined') {
+ var text = ''
+ var children = this.node.childNodes
+ for (var i = 0, len = children.length; i < len; ++i) {
+ // add newline if its not the first child and newLined is set to true
+ if (i != 0 && children[i].nodeType != 3 && SVG.adopt(children[i]).dom.newLined == true) {
+ text += '\n'
+ }
+
+ // add content of this node
+ text += children[i].textContent
+ }
+
+ return text
+ }
+
+ // remove existing content
+ this.clear().build(true)
+
+ if (typeof text === 'function') {
+ // call block
+ text.call(this, this)
+ } else {
+ // store text and make sure text is not blank
+ text = text.split('\n')
+
+ // build new lines
+ for (var i = 0, il = text.length; i < il; i++) { this.tspan(text[i]).newLine() }
+ }
+
+ // disable build mode and rebuild lines
+ return this.build(false).rebuild()
+ },
+ // Set font size
+ size: function (size) {
+ return this.attr('font-size', size).rebuild()
+ },
+ // Set / get leading
+ leading: function (value) {
+ // act as getter
+ if (value == null) { return this.dom.leading }
+
+ // act as setter
+ this.dom.leading = new SVG.Number(value)
+
+ return this.rebuild()
+ },
+ // Get all the first level lines
+ lines: function () {
+ var node = (this.textPath && this.textPath() || this).node
+
+ // filter tspans and map them to SVG.js instances
+ var lines = SVG.utils.map(SVG.utils.filterSVGElements(node.childNodes), function (el) {
+ return SVG.adopt(el)
+ })
+
+ // return an instance of SVG.set
+ return new SVG.Set(lines)
+ },
+ // Rebuild appearance type
+ rebuild: function (rebuild) {
+ // store new rebuild flag if given
+ if (typeof rebuild === 'boolean') { this._rebuild = rebuild }
+
+ // define position of all lines
+ if (this._rebuild) {
+ var self = this,
+ blankLineOffset = 0,
+ dy = this.dom.leading * new SVG.Number(this.attr('font-size'))
+
+ this.lines().each(function () {
+ if (this.dom.newLined) {
+ if (!self.textPath()) { this.attr('x', self.attr('x')) }
+ if (this.text() == '\n') {
+ blankLineOffset += dy
+ } else {
+ this.attr('dy', dy + blankLineOffset)
+ blankLineOffset = 0
+ }
+ }
+ })
+
+ this.fire('rebuild')
+ }
+
+ return this
+ },
+ // Enable / disable build mode
+ build: function (build) {
+ this._build = !!build
+ return this
+ },
+ // overwrite method from parent to set data properly
+ setData: function (o) {
+ this.dom = o
+ this.dom.leading = new SVG.Number(o.leading || 1.3)
+ return this
+ }
+ },
+
+ // Add parent method
+ construct: {
+ // Create text element
+ text: function (text) {
+ return this.put(new SVG.Text()).text(text)
+ },
+ // Create plain text element
+ plain: function (text) {
+ return this.put(new SVG.Text()).plain(text)
+ }
+ }
+
+ })
+
+ SVG.Tspan = SVG.invent({
+ // Initialize node
+ create: 'tspan',
+
+ // Inherit from
+ inherit: SVG.Shape,
+
+ // Add class methods
+ extend: {
+ // Set text content
+ text: function (text) {
+ if (text == null) return this.node.textContent + (this.dom.newLined ? '\n' : '')
+
+ typeof text === 'function' ? text.call(this, this) : this.plain(text)
+
+ return this
+ },
+ // Shortcut dx
+ dx: function (dx) {
+ return this.attr('dx', dx)
+ },
+ // Shortcut dy
+ dy: function (dy) {
+ return this.attr('dy', dy)
+ },
+ // Create new line
+ newLine: function () {
+ // fetch text parent
+ var t = this.parent(SVG.Text)
+
+ // mark new line
+ this.dom.newLined = true
+
+ // apply new hy¡n
+ return this.dy(t.dom.leading * t.attr('font-size')).attr('x', t.x())
+ }
+ }
+
+ })
+
+ SVG.extend(SVG.Text, SVG.Tspan, {
+ // Create plain text node
+ plain: function (text) {
+ // clear if build mode is disabled
+ if (this._build === false) { this.clear() }
+
+ // create text node
+ this.node.appendChild(document.createTextNode(text))
+
+ return this
+ },
+ // Create a tspan
+ tspan: function (text) {
+ var node = (this.textPath && this.textPath() || this).node,
+ tspan = new SVG.Tspan()
+
+ // clear if build mode is disabled
+ if (this._build === false) { this.clear() }
+
+ // add new tspan
+ node.appendChild(tspan.node)
+
+ return tspan.text(text)
+ },
+ // Clear all lines
+ clear: function () {
+ var node = (this.textPath && this.textPath() || this).node
+
+ // remove existing child nodes
+ while (node.hasChildNodes()) { node.removeChild(node.lastChild) }
+
+ return this
+ },
+ // Get length of text element
+ length: function () {
+ return this.node.getComputedTextLength()
+ }
+ })
+
+ SVG.TextPath = SVG.invent({
+ // Initialize node
+ create: 'textPath',
+
+ // Inherit from
+ inherit: SVG.Parent,
+
+ // Define parent class
+ parent: SVG.Text,
+
+ // Add parent method
+ construct: {
+ morphArray: SVG.PathArray,
+ // return the array of the path track element
+ array: function () {
+ var track = this.track()
+
+ return track ? track.array() : null
+ },
+ // Plot path if any
+ plot: function (d) {
+ var track = this.track(),
+ pathArray = null
+
+ if (track) {
+ pathArray = track.plot(d)
+ }
+
+ return (d == null) ? pathArray : this
+ },
+ // Get the path track element
+ track: function () {
+ var path = this.textPath()
+
+ if (path) { return path.reference('href') }
+ },
+ // Get the textPath child
+ textPath: function () {
+ if (this.node.firstChild && this.node.firstChild.nodeName == 'textPath') { return SVG.adopt(this.node.firstChild) }
+ }
+ }
+ })
+
+ SVG.Nested = SVG.invent({
+ // Initialize node
+ create: function () {
+ this.constructor.call(this, SVG.create('svg'))
+
+ this.style('overflow', 'visible')
+ },
+
+ // Inherit from
+ inherit: SVG.Container,
+
+ // Add parent method
+ construct: {
+ // Create nested svg document
+ nested: function () {
+ return this.put(new SVG.Nested())
+ }
+ }
+ })
+
+
+
+ // Define list of available attributes for stroke and fill
+ var sugar = {
+ stroke: ['color', 'width', 'opacity', 'linecap', 'linejoin', 'miterlimit', 'dasharray', 'dashoffset'],
+ fill: ['color', 'opacity', 'rule'],
+ prefix: function (t, a) {
+ return a == 'color' ? t : t + '-' + a
+ }
+ }
+
+// Add sugar for fill and stroke
+;['fill', 'stroke'].forEach(function (m) {
+ var extension = {}
+
+ extension[m] = function (o) {
+ if (typeof o === 'undefined') { return this }
+ if (typeof o === 'string' || SVG.Color.isRgb(o) || (o && typeof o.fill === 'function')) { this.attr(m, o) } else
+ // set all attributes from sugar.fill and sugar.stroke list
+ {
+ for (var i = sugar[m].length - 1; i >= 0; i--) {
+ if (o[sugar[m][i]] != null) { this.attr(sugar.prefix(m, sugar[m][i]), o[sugar[m][i]]) }
+ }
+ }
+
+ return this
+ }
+
+ SVG.extend(SVG.Element, SVG.FX, extension)
+ })
+
+ SVG.extend(SVG.Element, SVG.FX, {
+
+ // Map translate to transform
+ translate: function (x, y) {
+ return this.transform({ x: x, y: y })
+ },
+ // Map matrix to transform
+ matrix: function (m) {
+ return this.attr('transform', new SVG.Matrix(arguments.length == 6 ? [].slice.call(arguments) : m))
+ },
+ // Opacity
+ opacity: function (value) {
+ return this.attr('opacity', value)
+ },
+ // Relative move over x axis
+ dx: function (x) {
+ return this.x(new SVG.Number(x).plus(this instanceof SVG.FX ? 0 : this.x()), true)
+ },
+ // Relative move over y axis
+ dy: function (y) {
+ return this.y(new SVG.Number(y).plus(this instanceof SVG.FX ? 0 : this.y()), true)
+ },
+
+ })
+
+
+ SVG.extend(SVG.Path, {
+ // Get path length
+ length: function () {
+ return this.node.getTotalLength()
+ },
+ // Get point at length
+ pointAt: function (length) {
+ return this.node.getPointAtLength(length)
+ }
+ })
+
+
+ SVG.Set = SVG.invent({
+ // Initialize
+ create: function (members) {
+ // Set initial state
+ Array.isArray(members) ? this.members = members : this.clear()
+ },
+
+ // Add class methods
+ extend: {
+ // Add element to set
+ add: function () {
+ var il, elements = [].slice.call(arguments)
+
+ for (var i = 0, il = elements.length; i < il; i++) { this.members.push(elements[i]) }
+
+ return this
+ },
+ // Remove element from set
+ remove: function (element) {
+ var i = this.index(element)
+
+ // remove given child
+ if (i > -1) { this.members.splice(i, 1) }
+
+ return this
+ },
+ // Iterate over all members
+ each: function (block) {
+ for (var i = 0, il = this.members.length; i < il; i++) { block.apply(this.members[i], [i, this.members]) }
+
+ return this
+ },
+ // Restore to defaults
+ clear: function () {
+ // initialize store
+ this.members = []
+
+ return this
+ },
+ // Get the length of a set
+ length: function () {
+ return this.members.length
+ },
+ // Checks if a given element is present in set
+ has: function (element) {
+ return this.index(element) >= 0
+ },
+ // retuns index of given element in set
+ index: function (element) {
+ return this.members.indexOf(element)
+ },
+ // Get member at given index
+ get: function (i) {
+ return this.members[i]
+ },
+ // Get first member
+ first: function () {
+ return this.get(0)
+ },
+ // Get last member
+ last: function () {
+ return this.get(this.members.length - 1)
+ },
+ // Default value
+ valueOf: function () {
+ return this.members
+ },
+
+ },
+
+ // Add parent method
+ construct: {
+ // Create a new set
+ set: function (members) {
+ return new SVG.Set(members)
+ }
+ }
+ })
+
+ SVG.FX.Set = SVG.invent({
+ // Initialize node
+ create: function (set) {
+ // store reference to set
+ this.set = set
+ }
+
+ })
+
+ // Alias methods
+ SVG.Set.inherit = function () {
+ var methods = []
+
+ // gather shape methods
+ for (var m in SVG.Shape.prototype) {
+ if (typeof SVG.Shape.prototype[m] === 'function' && typeof SVG.Set.prototype[m] !== 'function') { methods.push(m) }
+ }
+
+ // apply shape aliasses
+ methods.forEach(function (method) {
+ SVG.Set.prototype[method] = function () {
+ for (var i = 0, il = this.members.length; i < il; i++) {
+ if (this.members[i] && typeof this.members[i][method] === 'function') { this.members[i][method].apply(this.members[i], arguments) }
+ }
+
+ return method == 'animate' ? (this.fx || (this.fx = new SVG.FX.Set(this))) : this
+ }
+ })
+
+ // clear methods for the next round
+ methods = []
+
+ // gather fx methods
+ for (var m in SVG.FX.prototype) {
+ if (typeof SVG.FX.prototype[m] === 'function' && typeof SVG.FX.Set.prototype[m] !== 'function') { methods.push(m) }
+ }
+
+ // apply fx aliasses
+ methods.forEach(function (method) {
+ SVG.FX.Set.prototype[method] = function () {
+ for (var i = 0, il = this.set.members.length; i < il; i++) { this.set.members[i].fx[method].apply(this.set.members[i].fx, arguments) }
+
+ return this
+ }
+ })
+ }
+
+ SVG.extend(SVG.Element, {
+
+ })
+ SVG.extend(SVG.Element, {
+ // Remember arbitrary data
+ remember: function (k, v) {
+ // remember every item in an object individually
+ if (typeof arguments[0] === 'object') {
+ for (var v_ in k) { this.remember(v_, k[v_]) }
+ }
+
+ // retrieve memory
+ else if (arguments.length == 1) { return this.memory()[k] }
+
+ // store memory
+ else { this.memory()[k] = v }
+
+ return this
+ },
+
+ // Erase a given memory
+ forget: function () {
+ if (arguments.length == 0) { this._memory = {} } else {
+ for (var i = arguments.length - 1; i >= 0; i--) { delete this.memory()[arguments[i]] }
+ }
+
+ return this
+ },
+
+ // Initialize or return local memory object
+ memory: function () {
+ return this._memory || (this._memory = {})
+ }
+
+ })
+ // Method for getting an element by id
+ SVG.get = function (id) {
+ var node = document.getElementById(idFromReference(id) || id)
+ return SVG.adopt(node)
+ }
+
+ // Select elements by query string
+ SVG.select = function (query, parent) {
+ return new SVG.Set(
+ SVG.utils.map((parent || document).querySelectorAll(query), function (node) {
+ return SVG.adopt(node)
+ })
+ )
+ }
+
+ SVG.extend(SVG.Parent, {
+ // Scoped select method
+ select: function (query) {
+ return SVG.select(query, this.node)
+ }
+
+ })
+ function pathRegReplace (a, b, c, d) {
+ return c + d.replace(SVG.regex.dots, ' .')
+ }
+
+ // creates deep clone of array
+ function array_clone (arr) {
+ var clone = arr.slice(0)
+ for (var i = clone.length; i--;) {
+ if (Array.isArray(clone[i])) {
+ clone[i] = array_clone(clone[i])
+ }
+ }
+ return clone
+ }
+
+ // tests if a given element is instance of an object
+ function is (el, obj) {
+ return el instanceof obj
+ }
+
+ // tests if a given selector matches an element
+ function matches (el, selector) {
+ return (el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector).call(el, selector)
+ }
+
+ // Convert dash-separated-string to camelCase
+ function camelCase (s) {
+ return s.toLowerCase().replace(/-(.)/g, function (m, g) {
+ return g.toUpperCase()
+ })
+ }
+
+ // Capitalize first letter of a string
+ function capitalize (s) {
+ return s.charAt(0).toUpperCase() + s.slice(1)
+ }
+
+ // Ensure to six-based hex
+ function fullHex (hex) {
+ return hex.length == 4
+ ? [ '#',
+ hex.substring(1, 2), hex.substring(1, 2),
+ hex.substring(2, 3), hex.substring(2, 3),
+ hex.substring(3, 4), hex.substring(3, 4)
+ ].join('') : hex
+ }
+
+ // Component to hex value
+ function compToHex (comp) {
+ var hex = comp.toString(16)
+ return hex.length == 1 ? '0' + hex : hex
+ }
+
+ // Calculate proportional width and height values when necessary
+ function proportionalSize (element, width, height) {
+ if (width == null || height == null) {
+ var box = element.bbox()
+
+ if (width == null) { width = box.width / box.height * height } else if (height == null) { height = box.height / box.width * width }
+ }
+
+ return {
+ width: width,
+ height: height
+ }
+ }
+
+ // Delta transform point
+ function deltaTransformPoint (matrix, x, y) {
+ return {
+ x: x * matrix.a + y * matrix.c + 0,
+ y: x * matrix.b + y * matrix.d + 0
+ }
+ }
+
+ // Map matrix array to object
+ function arrayToMatrix (a) {
+ return { a: a[0], b: a[1], c: a[2], d: a[3], e: a[4], f: a[5] }
+ }
+
+ // Parse matrix if required
+ function parseMatrix (matrix) {
+ if (!(matrix instanceof SVG.Matrix)) { matrix = new SVG.Matrix(matrix) }
+
+ return matrix
+ }
+
+ // Add centre point to transform object
+ function ensureCentre (o, target) {
+ o.cx = o.cx == null ? target.bbox().cx : o.cx
+ o.cy = o.cy == null ? target.bbox().cy : o.cy
+ }
+
+ // PathArray Helpers
+ function arrayToString (a) {
+ for (var i = 0, il = a.length, s = ''; i < il; i++) {
+ s += a[i][0]
+
+ if (a[i][1] != null) {
+ s += a[i][1]
+
+ if (a[i][2] != null) {
+ s += ' '
+ s += a[i][2]
+
+ if (a[i][3] != null) {
+ s += ' '
+ s += a[i][3]
+ s += ' '
+ s += a[i][4]
+
+ if (a[i][5] != null) {
+ s += ' '
+ s += a[i][5]
+ s += ' '
+ s += a[i][6]
+
+ if (a[i][7] != null) {
+ s += ' '
+ s += a[i][7]
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return s + ' '
+ }
+
+ // Deep new id assignment
+ function assignNewId (node) {
+ // do the same for SVG child nodes as well
+ for (var i = node.childNodes.length - 1; i >= 0; i--) {
+ if (node.childNodes[i] instanceof window.SVGElement) { assignNewId(node.childNodes[i]) }
+ }
+
+ return SVG.adopt(node).id(SVG.eid(node.nodeName))
+ }
+
+ // Add more bounding box properties
+ function fullBox (b) {
+ if (b.x == null) {
+ b.x = 0
+ b.y = 0
+ b.width = 0
+ b.height = 0
+ }
+
+ b.w = b.width
+ b.h = b.height
+ b.x2 = b.x + b.width
+ b.y2 = b.y + b.height
+ b.cx = b.x + b.width / 2
+ b.cy = b.y + b.height / 2
+
+ return b
+ }
+
+ // Get id from reference string
+ function idFromReference (url) {
+ var m = (url || '').toString().match(SVG.regex.reference)
+
+ if (m) return m[1]
+ }
+
+ // If values like 1e-88 are passed, this is not a valid 32 bit float,
+ // but in those cases, we are so close to 0 that 0 works well!
+ function float32String (v) {
+ return Math.abs(v) > 1e-37 ? v : 0
+ }
+
+ // Create matrix array for looping
+ var abcdef = 'abcdef'.split('')
+
+
+ // Add CustomEvent to IE9 and IE10
+ if (typeof window.CustomEvent !== 'function') {
+ // Code from: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent
+ var CustomEventPoly = function (event, options) {
+ options = options || { bubbles: false, cancelable: false, detail: undefined }
+ var e = document.createEvent('CustomEvent')
+ e.initCustomEvent(event, options.bubbles, options.cancelable, options.detail)
+ return e
+ }
+
+ CustomEventPoly.prototype = window.Event.prototype
+
+ SVG.CustomEvent = CustomEventPoly
+ } else {
+ SVG.CustomEvent = window.CustomEvent
+ }
+
+ return SVG
+}))
diff --git a/cao_sunyata/static/libs/apexcharts/src/utils/DateTime.js b/cao_sunyata/static/libs/apexcharts/src/utils/DateTime.js
new file mode 100644
index 0000000..4b7e821
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/utils/DateTime.js
@@ -0,0 +1,240 @@
+import Utils from './Utils'
+
+/**
+ * DateTime Class to manipulate datetime values.
+ *
+ * @module DateTime
+ **/
+
+class DateTime {
+ constructor(ctx) {
+ this.ctx = ctx
+ this.w = ctx.w
+
+ this.months31 = [1, 3, 5, 7, 8, 10, 12]
+ this.months30 = [2, 4, 6, 9, 11]
+
+ this.daysCntOfYear = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
+ }
+
+ isValidDate(date) {
+ return !isNaN(this.parseDate(date))
+ }
+
+ getTimeStamp(dateStr) {
+ if (!Date.parse(dateStr)) {
+ return dateStr
+ }
+ const utc = this.w.config.xaxis.labels.datetimeUTC
+ return !utc
+ ? new Date(dateStr).getTime()
+ : new Date(new Date(dateStr).toISOString().substr(0, 25)).getTime()
+ }
+
+ getDate(timestamp) {
+ const utc = this.w.config.xaxis.labels.datetimeUTC
+
+ return utc
+ ? new Date(new Date(timestamp).toUTCString())
+ : new Date(timestamp)
+ }
+
+ parseDate(dateStr) {
+ const parsed = Date.parse(dateStr)
+ if (!isNaN(parsed)) {
+ return this.getTimeStamp(dateStr)
+ }
+
+ let output = Date.parse(dateStr.replace(/-/g, '/').replace(/[a-z]+/gi, ' '))
+ output = this.getTimeStamp(output)
+ return output
+ }
+
+ // This fixes the difference of x-axis labels between chrome/safari
+ // Fixes #1726, #1544, #1485, #1255
+ parseDateWithTimezone(dateStr) {
+ return Date.parse(dateStr.replace(/-/g, '/').replace(/[a-z]+/gi, ' '))
+ }
+
+ // http://stackoverflow.com/questions/14638018/current-time-formatting-with-javascript#answer-14638191
+ formatDate(date, format) {
+ const locale = this.w.globals.locale
+
+ const utc = this.w.config.xaxis.labels.datetimeUTC
+
+ let MMMM = ['\x00', ...locale.months]
+ let MMM = ['\x01', ...locale.shortMonths]
+ let dddd = ['\x02', ...locale.days]
+ let ddd = ['\x03', ...locale.shortDays]
+
+ function ii(i, len) {
+ let s = i + ''
+ len = len || 2
+ while (s.length < len) s = '0' + s
+ return s
+ }
+
+ let y = utc ? date.getUTCFullYear() : date.getFullYear()
+ format = format.replace(/(^|[^\\])yyyy+/g, '$1' + y)
+ format = format.replace(/(^|[^\\])yy/g, '$1' + y.toString().substr(2, 2))
+ format = format.replace(/(^|[^\\])y/g, '$1' + y)
+
+ let M = (utc ? date.getUTCMonth() : date.getMonth()) + 1
+ format = format.replace(/(^|[^\\])MMMM+/g, '$1' + MMMM[0])
+ format = format.replace(/(^|[^\\])MMM/g, '$1' + MMM[0])
+ format = format.replace(/(^|[^\\])MM/g, '$1' + ii(M))
+ format = format.replace(/(^|[^\\])M/g, '$1' + M)
+
+ let d = utc ? date.getUTCDate() : date.getDate()
+ format = format.replace(/(^|[^\\])dddd+/g, '$1' + dddd[0])
+ format = format.replace(/(^|[^\\])ddd/g, '$1' + ddd[0])
+ format = format.replace(/(^|[^\\])dd/g, '$1' + ii(d))
+ format = format.replace(/(^|[^\\])d/g, '$1' + d)
+
+ let H = utc ? date.getUTCHours() : date.getHours()
+ format = format.replace(/(^|[^\\])HH+/g, '$1' + ii(H))
+ format = format.replace(/(^|[^\\])H/g, '$1' + H)
+
+ let h = H > 12 ? H - 12 : H === 0 ? 12 : H
+ format = format.replace(/(^|[^\\])hh+/g, '$1' + ii(h))
+ format = format.replace(/(^|[^\\])h/g, '$1' + h)
+
+ let m = utc ? date.getUTCMinutes() : date.getMinutes()
+ format = format.replace(/(^|[^\\])mm+/g, '$1' + ii(m))
+ format = format.replace(/(^|[^\\])m/g, '$1' + m)
+
+ let s = utc ? date.getUTCSeconds() : date.getSeconds()
+ format = format.replace(/(^|[^\\])ss+/g, '$1' + ii(s))
+ format = format.replace(/(^|[^\\])s/g, '$1' + s)
+
+ let f = utc ? date.getUTCMilliseconds() : date.getMilliseconds()
+ format = format.replace(/(^|[^\\])fff+/g, '$1' + ii(f, 3))
+ f = Math.round(f / 10)
+ format = format.replace(/(^|[^\\])ff/g, '$1' + ii(f))
+ f = Math.round(f / 10)
+ format = format.replace(/(^|[^\\])f/g, '$1' + f)
+
+ let T = H < 12 ? 'AM' : 'PM'
+ format = format.replace(/(^|[^\\])TT+/g, '$1' + T)
+ format = format.replace(/(^|[^\\])T/g, '$1' + T.charAt(0))
+
+ let t = T.toLowerCase()
+ format = format.replace(/(^|[^\\])tt+/g, '$1' + t)
+ format = format.replace(/(^|[^\\])t/g, '$1' + t.charAt(0))
+
+ let tz = -date.getTimezoneOffset()
+ let K = utc || !tz ? 'Z' : tz > 0 ? '+' : '-'
+
+ if (!utc) {
+ tz = Math.abs(tz)
+ let tzHrs = Math.floor(tz / 60)
+ let tzMin = tz % 60
+ K += ii(tzHrs) + ':' + ii(tzMin)
+ }
+
+ format = format.replace(/(^|[^\\])K/g, '$1' + K)
+
+ let day = (utc ? date.getUTCDay() : date.getDay()) + 1
+ format = format.replace(new RegExp(dddd[0], 'g'), dddd[day])
+ format = format.replace(new RegExp(ddd[0], 'g'), ddd[day])
+
+ format = format.replace(new RegExp(MMMM[0], 'g'), MMMM[M])
+ format = format.replace(new RegExp(MMM[0], 'g'), MMM[M])
+
+ format = format.replace(/\\(.)/g, '$1')
+
+ return format
+ }
+
+ getTimeUnitsfromTimestamp(minX, maxX, utc) {
+ let w = this.w
+
+ if (w.config.xaxis.min !== undefined) {
+ minX = w.config.xaxis.min
+ }
+ if (w.config.xaxis.max !== undefined) {
+ maxX = w.config.xaxis.max
+ }
+
+ const tsMin = this.getDate(minX)
+ const tsMax = this.getDate(maxX)
+
+ const minD = this.formatDate(tsMin, 'yyyy MM dd HH mm ss fff').split(' ')
+ const maxD = this.formatDate(tsMax, 'yyyy MM dd HH mm ss fff').split(' ')
+
+ return {
+ minMillisecond: parseInt(minD[6], 10),
+ maxMillisecond: parseInt(maxD[6], 10),
+ minSecond: parseInt(minD[5], 10),
+ maxSecond: parseInt(maxD[5], 10),
+ minMinute: parseInt(minD[4], 10),
+ maxMinute: parseInt(maxD[4], 10),
+ minHour: parseInt(minD[3], 10),
+ maxHour: parseInt(maxD[3], 10),
+ minDate: parseInt(minD[2], 10),
+ maxDate: parseInt(maxD[2], 10),
+ minMonth: parseInt(minD[1], 10) - 1,
+ maxMonth: parseInt(maxD[1], 10) - 1,
+ minYear: parseInt(minD[0], 10),
+ maxYear: parseInt(maxD[0], 10)
+ }
+ }
+
+ isLeapYear(year) {
+ return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0
+ }
+
+ calculcateLastDaysOfMonth(month, year, subtract) {
+ const days = this.determineDaysOfMonths(month, year)
+
+ // whatever days we get, subtract the number of days asked
+ return days - subtract
+ }
+
+ determineDaysOfYear(year) {
+ let days = 365
+
+ if (this.isLeapYear(year)) {
+ days = 366
+ }
+
+ return days
+ }
+
+ determineRemainingDaysOfYear(year, month, date) {
+ let dayOfYear = this.daysCntOfYear[month] + date
+ if (month > 1 && this.isLeapYear()) dayOfYear++
+ return dayOfYear
+ }
+
+ determineDaysOfMonths(month, year) {
+ let days = 30
+
+ month = Utils.monthMod(month)
+
+ switch (true) {
+ case this.months30.indexOf(month) > -1:
+ if (month === 2) {
+ if (this.isLeapYear(year)) {
+ days = 29
+ } else {
+ days = 28
+ }
+ }
+
+ break
+
+ case this.months31.indexOf(month) > -1:
+ days = 31
+ break
+
+ default:
+ days = 31
+ break
+ }
+
+ return days
+ }
+}
+
+export default DateTime
diff --git a/cao_sunyata/static/libs/apexcharts/src/utils/Resize.js b/cao_sunyata/static/libs/apexcharts/src/utils/Resize.js
new file mode 100644
index 0000000..5865410
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/utils/Resize.js
@@ -0,0 +1,45 @@
+// Helpers to react to element resizes, regardless of what caused them
+// TODO Currently this creates a new ResizeObserver every time we want to observe an element for resizes
+// Ideally, we should be able to use a single observer for all elements
+let ros = new WeakMap() // Map callbacks to ResizeObserver instances for easy removal
+
+export function addResizeListener(el, fn) {
+ let called = false
+
+ const elRect = el.getBoundingClientRect()
+ if (el.style.display === 'none' || elRect.width === 0) {
+ // if elRect.width=0, the chart is not rendered at all
+ // (it has either display none or hidden in a different tab)
+ // fixes https://github.com/apexcharts/apexcharts.js/issues/2825
+ // fixes https://github.com/apexcharts/apexcharts.js/issues/2991
+ // fixes https://github.com/apexcharts/apexcharts.js/issues/2992
+ called = true
+ }
+
+ let ro = new ResizeObserver((r) => {
+ // ROs fire immediately after being created,
+ // per spec: https://drafts.csswg.org/resize-observer/#ref-for-element%E2%91%A3
+ // we don't want that so we just discard the first run
+ if (called) {
+ fn.call(el, r)
+ }
+ called = true
+ })
+
+ if (el.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+ // Document fragment, observe children instead (needed for Shadow DOM, see #1332)
+ Array.from(el.children).forEach((c) => ro.observe(c))
+ } else {
+ ro.observe(el)
+ }
+
+ ros.set(fn, ro)
+}
+
+export function removeResizeListener(el, fn) {
+ let ro = ros.get(fn)
+ if (ro) {
+ ro.disconnect()
+ ros.delete(fn)
+ }
+}
diff --git a/cao_sunyata/static/libs/apexcharts/src/utils/Utils.js b/cao_sunyata/static/libs/apexcharts/src/utils/Utils.js
new file mode 100644
index 0000000..53c7991
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/src/utils/Utils.js
@@ -0,0 +1,402 @@
+/*
+ ** Generic functions which are not dependent on ApexCharts
+ */
+
+class Utils {
+ static bind(fn, me) {
+ return function () {
+ return fn.apply(me, arguments)
+ }
+ }
+
+ static isObject(item) {
+ return (
+ item && typeof item === 'object' && !Array.isArray(item) && item != null
+ )
+ }
+
+ // Type checking that works across different window objects
+ static is(type, val) {
+ return Object.prototype.toString.call(val) === '[object ' + type + ']';
+ }
+
+ static listToArray(list) {
+ let i,
+ array = []
+ for (i = 0; i < list.length; i++) {
+ array[i] = list[i]
+ }
+ return array
+ }
+
+ // to extend defaults with user options
+ // credit: http://stackoverflow.com/questions/27936772/deep-object-merging-in-es6-es7#answer-34749873
+ static extend(target, source) {
+ if (typeof Object.assign !== 'function') {
+ ; (function () {
+ Object.assign = function (target) {
+ 'use strict'
+ // We must check against these specific cases.
+ if (target === undefined || target === null) {
+ throw new TypeError('Cannot convert undefined or null to object')
+ }
+
+ let output = Object(target)
+ for (let index = 1; index < arguments.length; index++) {
+ let source = arguments[index]
+ if (source !== undefined && source !== null) {
+ for (let nextKey in source) {
+ if (source.hasOwnProperty(nextKey)) {
+ output[nextKey] = source[nextKey]
+ }
+ }
+ }
+ }
+ return output
+ }
+ })()
+ }
+
+ let output = Object.assign({}, target)
+ if (this.isObject(target) && this.isObject(source)) {
+ Object.keys(source).forEach((key) => {
+ if (this.isObject(source[key])) {
+ if (!(key in target)) {
+ Object.assign(output, {
+ [key]: source[key]
+ })
+ } else {
+ output[key] = this.extend(target[key], source[key])
+ }
+ } else {
+ Object.assign(output, {
+ [key]: source[key]
+ })
+ }
+ })
+ }
+ return output
+ }
+
+ static extendArray(arrToExtend, resultArr) {
+ let extendedArr = []
+ arrToExtend.map((item) => {
+ extendedArr.push(Utils.extend(resultArr, item))
+ })
+ arrToExtend = extendedArr
+ return arrToExtend
+ }
+
+ // If month counter exceeds 12, it starts again from 1
+ static monthMod(month) {
+ return month % 12
+ }
+
+ static clone(source) {
+ if (Utils.is('Array', source)) {
+ let cloneResult = []
+ for (let i = 0; i < source.length; i++) {
+ cloneResult[i] = this.clone(source[i])
+ }
+ return cloneResult
+ } else if (Utils.is('Null', source)) {
+ // fixes an issue where null values were converted to {}
+ return null
+ } else if (Utils.is('Date', source)) {
+ return source
+ } else if (typeof source === 'object') {
+ let cloneResult = {}
+ for (let prop in source) {
+ if (source.hasOwnProperty(prop)) {
+ cloneResult[prop] = this.clone(source[prop])
+ }
+ }
+ return cloneResult
+ } else {
+ return source
+ }
+ }
+
+ static log10(x) {
+ return Math.log(x) / Math.LN10
+ }
+
+ static roundToBase10(x) {
+ return Math.pow(10, Math.floor(Math.log10(x)))
+ }
+
+ static roundToBase(x, base) {
+ return Math.pow(base, Math.floor(Math.log(x) / Math.log(base)))
+ }
+
+ static parseNumber(val) {
+ if (val === null) return val
+ return parseFloat(val)
+ }
+
+ static randomId() {
+ return (Math.random() + 1).toString(36).substring(4)
+ }
+
+ static noExponents(val) {
+ let data = String(val).split(/[eE]/)
+ if (data.length === 1) return data[0]
+
+ let z = '',
+ sign = val < 0 ? '-' : '',
+ str = data[0].replace('.', ''),
+ mag = Number(data[1]) + 1
+
+ if (mag < 0) {
+ z = sign + '0.'
+ while (mag++) z += '0'
+ return z + str.replace(/^-/, '')
+ }
+ mag -= str.length
+ while (mag--) z += '0'
+ return str + z
+ }
+
+ static getDimensions(el) {
+ const computedStyle = getComputedStyle(el, null)
+
+ let elementHeight = el.clientHeight
+ let elementWidth = el.clientWidth
+ elementHeight -=
+ parseFloat(computedStyle.paddingTop) +
+ parseFloat(computedStyle.paddingBottom)
+ elementWidth -=
+ parseFloat(computedStyle.paddingLeft) +
+ parseFloat(computedStyle.paddingRight)
+
+ return [elementWidth, elementHeight]
+ }
+
+ static getBoundingClientRect(element) {
+ const rect = element.getBoundingClientRect()
+ return {
+ top: rect.top,
+ right: rect.right,
+ bottom: rect.bottom,
+ left: rect.left,
+ width: element.clientWidth,
+ height: element.clientHeight,
+ x: rect.left,
+ y: rect.top
+ }
+ }
+
+ static getLargestStringFromArr(arr) {
+ return arr.reduce((a, b) => {
+ if (Array.isArray(b)) {
+ b = b.reduce((aa, bb) => (aa.length > bb.length ? aa : bb))
+ }
+ return a.length > b.length ? a : b
+ }, 0)
+ }
+
+ // http://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb#answer-12342275
+ static hexToRgba(hex = '#999999', opacity = 0.6) {
+ if (hex.substring(0, 1) !== '#') {
+ hex = '#999999'
+ }
+
+ let h = hex.replace('#', '')
+ h = h.match(new RegExp('(.{' + h.length / 3 + '})', 'g'))
+
+ for (let i = 0; i < h.length; i++) {
+ h[i] = parseInt(h[i].length === 1 ? h[i] + h[i] : h[i], 16)
+ }
+
+ if (typeof opacity !== 'undefined') h.push(opacity)
+
+ return 'rgba(' + h.join(',') + ')'
+ }
+
+ static getOpacityFromRGBA(rgba) {
+ return parseFloat(rgba.replace(/^.*,(.+)\)/, '$1'))
+ }
+
+ static rgb2hex(rgb) {
+ rgb = rgb.match(
+ /^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i
+ )
+ return rgb && rgb.length === 4
+ ? '#' +
+ ('0' + parseInt(rgb[1], 10).toString(16)).slice(-2) +
+ ('0' + parseInt(rgb[2], 10).toString(16)).slice(-2) +
+ ('0' + parseInt(rgb[3], 10).toString(16)).slice(-2)
+ : ''
+ }
+
+ shadeRGBColor(percent, color) {
+ let f = color.split(','),
+ t = percent < 0 ? 0 : 255,
+ p = percent < 0 ? percent * -1 : percent,
+ R = parseInt(f[0].slice(4), 10),
+ G = parseInt(f[1], 10),
+ B = parseInt(f[2], 10)
+ return (
+ 'rgb(' +
+ (Math.round((t - R) * p) + R) +
+ ',' +
+ (Math.round((t - G) * p) + G) +
+ ',' +
+ (Math.round((t - B) * p) + B) +
+ ')'
+ )
+ }
+
+ shadeHexColor(percent, color) {
+ let f = parseInt(color.slice(1), 16),
+ t = percent < 0 ? 0 : 255,
+ p = percent < 0 ? percent * -1 : percent,
+ R = f >> 16,
+ G = (f >> 8) & 0x00ff,
+ B = f & 0x0000ff
+ return (
+ '#' +
+ (
+ 0x1000000 +
+ (Math.round((t - R) * p) + R) * 0x10000 +
+ (Math.round((t - G) * p) + G) * 0x100 +
+ (Math.round((t - B) * p) + B)
+ )
+ .toString(16)
+ .slice(1)
+ )
+ }
+
+ // beautiful color shading blending code
+ // http://stackoverflow.com/questions/5560248/programmatically-lighten-or-darken-a-hex-color-or-rgb-and-blend-colors
+ shadeColor(p, color) {
+ if (Utils.isColorHex(color)) {
+ return this.shadeHexColor(p, color)
+ } else {
+ return this.shadeRGBColor(p, color)
+ }
+ }
+
+ static isColorHex(color) {
+ return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)|(^#[0-9A-F]{8}$)/i.test(color)
+ }
+
+ static getPolygonPos(size, dataPointsLen) {
+ let dotsArray = []
+ let angle = (Math.PI * 2) / dataPointsLen
+ for (let i = 0; i < dataPointsLen; i++) {
+ let curPos = {}
+ curPos.x = size * Math.sin(i * angle)
+ curPos.y = -size * Math.cos(i * angle)
+ dotsArray.push(curPos)
+ }
+ return dotsArray
+ }
+
+ static polarToCartesian(centerX, centerY, radius, angleInDegrees) {
+ let angleInRadians = ((angleInDegrees - 90) * Math.PI) / 180.0
+
+ return {
+ x: centerX + radius * Math.cos(angleInRadians),
+ y: centerY + radius * Math.sin(angleInRadians)
+ }
+ }
+
+ static escapeString(str, escapeWith = 'x') {
+ let newStr = str.toString().slice()
+ newStr = newStr.replace(
+ /[` ~!@#$%^&*()_|+\-=?;:'",.<>{}[\]\\/]/gi,
+ escapeWith
+ )
+ return newStr
+ }
+
+ static negToZero(val) {
+ return val < 0 ? 0 : val
+ }
+
+ static moveIndexInArray(arr, old_index, new_index) {
+ if (new_index >= arr.length) {
+ let k = new_index - arr.length + 1
+ while (k--) {
+ arr.push(undefined)
+ }
+ }
+ arr.splice(new_index, 0, arr.splice(old_index, 1)[0])
+ return arr
+ }
+
+ static extractNumber(s) {
+ return parseFloat(s.replace(/[^\d.]*/g, ''))
+ }
+
+ static findAncestor(el, cls) {
+ while ((el = el.parentElement) && !el.classList.contains(cls));
+ return el
+ }
+
+ static setELstyles(el, styles) {
+ for (let key in styles) {
+ if (styles.hasOwnProperty(key)) {
+ el.style.key = styles[key]
+ }
+ }
+ }
+
+ static isNumber(value) {
+ return (
+ !isNaN(value) &&
+ parseFloat(Number(value)) === value &&
+ !isNaN(parseInt(value, 10))
+ )
+ }
+
+ static isFloat(n) {
+ return Number(n) === n && n % 1 !== 0
+ }
+
+ static isSafari() {
+ return /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
+ }
+
+ static isFirefox() {
+ return navigator.userAgent.toLowerCase().indexOf('firefox') > -1
+ }
+
+ static isIE11() {
+ if (
+ window.navigator.userAgent.indexOf('MSIE') !== -1 ||
+ window.navigator.appVersion.indexOf('Trident/') > -1
+ ) {
+ return true
+ }
+ }
+
+ static isIE() {
+ let ua = window.navigator.userAgent
+
+ let msie = ua.indexOf('MSIE ')
+ if (msie > 0) {
+ // IE 10 or older => return version number
+ return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10)
+ }
+
+ let trident = ua.indexOf('Trident/')
+ if (trident > 0) {
+ // IE 11 => return version number
+ let rv = ua.indexOf('rv:')
+ return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10)
+ }
+
+ let edge = ua.indexOf('Edge/')
+ if (edge > 0) {
+ // Edge (IE 12+) => return version number
+ return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10)
+ }
+
+ // other browser
+ return false
+ }
+}
+
+export default Utils
diff --git a/cao_sunyata/static/libs/apexcharts/types/apexcharts.d.ts b/cao_sunyata/static/libs/apexcharts/types/apexcharts.d.ts
new file mode 100644
index 0000000..af81bc8
--- /dev/null
+++ b/cao_sunyata/static/libs/apexcharts/types/apexcharts.d.ts
@@ -0,0 +1,1198 @@
+// Typescript declarations for Apex class and module.
+// Note: When you have a class and a module with the same name; the module is merged
+// with the class. This is necessary since apexcharts exports the main ApexCharts class only.
+//
+// This is a sparse typed declarations of chart interfaces. See Apex Chart documentation
+// for comprehensive API: https://apexcharts.com/docs/options
+//
+// There is on-going work to provide a comprehensive typed definition for this component.
+// See https://github.com/DefinitelyTyped/DefinitelyTyped/pull/28733
+
+declare class ApexCharts {
+ constructor(el: any, options: any)
+ render(): Promise
+ updateOptions(
+ options: any,
+ redrawPaths?: boolean,
+ animate?: boolean,
+ updateSyncedCharts?: boolean
+ ): Promise
+ updateSeries(
+ newSeries: ApexAxisChartSeries | ApexNonAxisChartSeries,
+ animate?: boolean
+ ): Promise
+ appendSeries(
+ newSeries: ApexAxisChartSeries | ApexNonAxisChartSeries,
+ animate?: boolean
+ ): Promise
+ appendData(data: any[], overwriteInitialSeries?: boolean): void
+ toggleSeries(seriesName: string): any
+ showSeries(seriesName: string): void
+ hideSeries(seriesName: string): void
+ resetSeries(): void
+ zoomX(min: number, max: number): void
+ toggleDataPointSelection(seriesIndex: number, dataPointIndex?: number): any
+ destroy(): void
+ setLocale(localeName: string): void
+ paper(): void
+ addXaxisAnnotation(options: any, pushToMemory?: boolean, context?: any): void
+ addYaxisAnnotation(options: any, pushToMemory?: boolean, context?: any): void
+ addPointAnnotation(options: any, pushToMemory?: boolean, context?: any): void
+ removeAnnotation(id: string, options?: any): void
+ clearAnnotations(options?: any): void
+ dataURI(options?: { scale?: number, width?: number }): Promise<{ imgURI: string } | { blob: Blob }>
+ static exec(chartID: string, fn: string, ...args: Array): any
+ static getChartByID(chartID: string): ApexCharts|undefined
+ static initOnLoad(): void
+ exports: {
+ cleanup(): string
+ svgUrl(): string
+ dataURI(options?: { scale?: number, width?: number }): Promise<{ imgURI: string } | { blob: Blob }>
+ exportToSVG(): void
+ exportToPng(): void
+ exportToCSV(options?: { series?: any, columnDelimiter?: string, lineDelimiter?: string }): void
+ getSvgString(scale?: number): void
+ triggerDownload(href: string, filename?: string, ext?: string): void
+ }
+}
+
+declare module ApexCharts {
+ export interface ApexOptions {
+ annotations?: ApexAnnotations
+ chart?: ApexChart
+ colors?: any[]
+ dataLabels?: ApexDataLabels
+ fill?: ApexFill
+ forecastDataPoints?: ApexForecastDataPoints;
+ grid?: ApexGrid
+ labels?: string[]
+ legend?: ApexLegend
+ markers?: ApexMarkers
+ noData?: ApexNoData
+ plotOptions?: ApexPlotOptions
+ responsive?: ApexResponsive[]
+ series?: ApexAxisChartSeries | ApexNonAxisChartSeries
+ states?: ApexStates
+ stroke?: ApexStroke
+ subtitle?: ApexTitleSubtitle
+ theme?: ApexTheme
+ title?: ApexTitleSubtitle
+ tooltip?: ApexTooltip
+ xaxis?: ApexXAxis
+ yaxis?: ApexYAxis | ApexYAxis[]
+ }
+}
+
+type ApexDropShadow = {
+ enabled?: boolean
+ top?: number
+ left?: number
+ blur?: number
+ opacity?: number
+ color?: string
+}
+
+/**
+ * Main Chart options
+ * See https://apexcharts.com/docs/options/chart/
+ */
+type ApexChart = {
+ width?: string | number
+ height?: string | number
+ type?:
+ | 'line'
+ | 'area'
+ | 'bar'
+ | 'histogram'
+ | 'pie'
+ | 'donut'
+ | 'radialBar'
+ | 'scatter'
+ | 'bubble'
+ | 'heatmap'
+ | 'candlestick'
+ | 'boxPlot'
+ | 'radar'
+ | 'polarArea'
+ | 'rangeBar'
+ | 'treemap'
+ foreColor?: string
+ fontFamily?: string
+ background?: string
+ offsetX?: number
+ offsetY?: number
+ dropShadow?: ApexDropShadow & {
+ enabledOnSeries?: undefined | number[]
+ color?: string | string[]
+ }
+ events?: {
+ animationEnd?(chart: any, options?: any): void
+ beforeMount?(chart: any, options?: any): void
+ mounted?(chart: any, options?: any): void
+ updated?(chart: any, options?: any): void
+ mouseMove?(e: any, chart?: any, options?: any): void
+ mouseLeave?(e: any, chart?: any, options?: any): void
+ click?(e: any, chart?: any, options?: any): void
+ legendClick?(chart: any, seriesIndex?: number, options?: any): void
+ markerClick?(e: any, chart?: any, options?: any): void
+ selection?(chart: any, options?: any): void
+ dataPointSelection?(e: any, chart?: any, options?: any): void
+ dataPointMouseEnter?(e: any, chart?: any, options?: any): void
+ dataPointMouseLeave?(e: any, chart?: any, options?: any): void
+ beforeZoom?(chart: any, options?: any): void
+ beforeResetZoom?(chart: any, options?: any): void
+ zoomed?(chart: any, options?: any): void
+ scrolled?(chart: any, options?: any): void
+ brushScrolled?(chart: any, options?: any): void
+ }
+ brush?: {
+ enabled?: boolean
+ autoScaleYaxis?: boolean
+ target?: string
+ }
+ id?: string
+ group?: string
+ locales?: ApexLocale[]
+ defaultLocale?: string
+ parentHeightOffset?: number
+ redrawOnParentResize?: boolean
+ redrawOnWindowResize?: boolean | Function
+ sparkline?: {
+ enabled?: boolean
+ }
+ stacked?: boolean
+ stackType?: 'normal' | '100%'
+ toolbar?: {
+ show?: boolean
+ offsetX?: number
+ offsetY?: number
+ tools?: {
+ download?: boolean | string
+ selection?: boolean | string
+ zoom?: boolean | string
+ zoomin?: boolean | string
+ zoomout?: boolean | string
+ pan?: boolean | string
+ reset?: boolean | string
+ customIcons?: {
+ icon?: string
+ title?: string
+ index?: number
+ class?: string
+ click?(chart?: any, options?: any, e?: any): any
+ }[]
+ }
+ export?: {
+ csv?: {
+ filename?: undefined | string
+ columnDelimiter?: string
+ headerCategory?: string
+ headerValue?: string
+ dateFormatter?(timestamp?: number): any
+ },
+ svg?: {
+ filename?: undefined | string
+ }
+ png?: {
+ filename?: undefined | string
+ }
+ }
+ autoSelected?: 'zoom' | 'selection' | 'pan'
+ }
+ zoom?: {
+ enabled?: boolean
+ type?: 'x' | 'y' | 'xy'
+ autoScaleYaxis?: boolean
+ zoomedArea?: {
+ fill?: {
+ color?: string
+ opacity?: number
+ }
+ stroke?: {
+ color?: string
+ opacity?: number
+ width?: number
+ }
+ }
+ }
+ selection?: {
+ enabled?: boolean
+ type?: string
+ fill?: {
+ color?: string
+ opacity?: number
+ }
+ stroke?: {
+ width?: number
+ color?: string
+ opacity?: number
+ dashArray?: number
+ }
+ xaxis?: {
+ min?: number
+ max?: number
+ }
+ yaxis?: {
+ min?: number
+ max?: number
+ }
+ }
+ animations?: {
+ enabled?: boolean
+ easing?: 'linear' | 'easein' | 'easeout' | 'easeinout'
+ speed?: number
+ animateGradually?: {
+ enabled?: boolean
+ delay?: number
+ }
+ dynamicAnimation?: {
+ enabled?: boolean
+ speed?: number
+ }
+ }
+}
+
+type ApexStates = {
+ normal?: {
+ filter?: {
+ type?: string
+ value?: number
+ }
+ }
+ hover?: {
+ filter?: {
+ type?: string
+ value?: number
+ }
+ }
+ active?: {
+ allowMultipleDataPointsSelection?: boolean
+ filter?: {
+ type?: string
+ value?: number
+ }
+ }
+}
+
+/**
+ * Chart Title options
+ * See https://apexcharts.com/docs/options/title/
+ */
+type ApexTitleSubtitle = {
+ text?: string
+ align?: 'left' | 'center' | 'right'
+ margin?: number
+ offsetX?: number
+ offsetY?: number
+ floating?: boolean
+ style?: {
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ color?: string
+ }
+}
+
+/**
+ * Chart Series options.
+ * Use ApexNonAxisChartSeries for Pie and Donut charts.
+ * See https://apexcharts.com/docs/options/series/
+ *
+ * According to the documentation at
+ * https://apexcharts.com/docs/series/
+ * Section 1: data can be a list of single numbers
+ * Sections 2.1 and 3.1: data can be a list of tuples of two numbers
+ * Sections 2.2 and 3.2: data can be a list of objects where x is a string
+ * and y is a number
+ * And according to the demos, data can contain null.
+ * https://apexcharts.com/javascript-chart-demos/line-charts/null-values/
+ */
+type ApexAxisChartSeries = {
+ name?: string
+ type?: string
+ color?: string
+ data:
+ | (number | null)[]
+ | {
+ x: any;
+ y: any;
+ fillColor?: string;
+ strokeColor?: string;
+ meta?: any;
+ goals?: any;
+ }[]
+ | [number, number | null][]
+ | [number, (number | null)[]][];
+}[]
+
+type ApexNonAxisChartSeries = number[]
+
+/**
+ * Options for the line drawn on line and area charts.
+ * See https://apexcharts.com/docs/options/stroke/
+ */
+type ApexStroke = {
+ show?: boolean
+ curve?: 'smooth' | 'straight' | 'stepline' | ('smooth' | 'straight' | 'stepline')[]
+ lineCap?: 'butt' | 'square' | 'round'
+ colors?: string[]
+ width?: number | number[]
+ dashArray?: number | number[]
+ fill?: ApexFill
+}
+
+type ApexAnnotations = {
+ position?: string
+ yaxis?: YAxisAnnotations[]
+ xaxis?: XAxisAnnotations[]
+ points?: PointAnnotations[]
+ texts?: TextAnnotations[]
+ images?: ImageAnnotations[]
+}
+
+type AnnotationLabel = {
+ borderColor?: string
+ borderWidth?: number
+ borderRadius?: number
+ text?: string
+ textAnchor?: string
+ offsetX?: number
+ offsetY?: number
+ style?: AnnotationStyle
+ position?: string
+ orientation?: string
+ mouseEnter?: Function
+ mouseLeave?: Function
+}
+
+type AnnotationStyle = {
+ background?: string
+ color?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ fontSize?: string
+ cssClass?: string
+ padding?: {
+ left?: number
+ right?: number
+ top?: number
+ bottom?: number
+ }
+}
+
+type XAxisAnnotations = {
+ id?: number | string
+ x?: null | number | string
+ x2?: null | number | string
+ strokeDashArray?: number
+ fillColor?: string
+ borderColor?: string
+ borderWidth?: number
+ opacity?: number
+ offsetX?: number
+ offsetY?: number
+ label?: AnnotationLabel
+}
+
+type YAxisAnnotations = {
+ id?: number | string
+ y?: null | number | string
+ y2?: null | number | string
+ strokeDashArray?: number
+ fillColor?: string
+ borderColor?: string
+ borderWidth?: number
+ opacity?: number
+ offsetX?: number
+ offsetY?: number
+ width?: number | string
+ yAxisIndex?: number
+ label?: AnnotationLabel
+}
+
+type PointAnnotations = {
+ id?: number | string
+ x?: number | string
+ y?: null | number
+ yAxisIndex?: number
+ seriesIndex?: number
+ mouseEnter?: Function
+ mouseLeave?: Function
+ marker?: {
+ size?: number
+ fillColor?: string
+ strokeColor?: string
+ strokeWidth?: number
+ shape?: string
+ offsetX?: number
+ offsetY?: number
+ radius?: number
+ cssClass?: string
+ }
+ label?: AnnotationLabel
+ image?: {
+ path?: string
+ width?: number
+ height?: number
+ offsetX?: number
+ offsetY?: number
+ }
+}
+
+
+type TextAnnotations = {
+ x?: number
+ y?: number
+ text?: string
+ textAnchor?: string
+ foreColor?: string
+ fontSize?: string | number
+ fontFamily?: undefined | string
+ fontWeight?: string | number
+ backgroundColor?: string
+ borderColor?: string
+ borderRadius?: number
+ borderWidth?: number
+ paddingLeft?: number
+ paddingRight?: number
+ paddingTop?: number
+ paddingBottom?: number
+}
+
+type ImageAnnotations = {
+ path?: string
+ x?: number,
+ y?: number,
+ width?: number,
+ height?: number,
+}
+
+/**
+ * Options for localization.
+ * See https://apexcharts.com/docs/options/chart/locales
+ */
+type ApexLocale = {
+ name?: string
+ options?: {
+ months?: string[]
+ shortMonths?: string[]
+ days?: string[]
+ shortDays?: string[]
+ toolbar?: {
+ download?: string
+ selection?: string
+ selectionZoom?: string
+ zoomIn?: string
+ zoomOut?: string
+ pan?: string
+ reset?: string
+ exportToSVG?: string
+ exportToPNG?: string
+ exportToCSV: string
+ }
+ }
+}
+
+/**
+ * PlotOptions for specifying chart-type-specific configuration.
+ * See https://apexcharts.com/docs/options/plotoptions/bar/
+ */
+type ApexPlotOptions = {
+ area?: {
+ fillTo?: 'origin' | 'end'
+ }
+ bar?: {
+ horizontal?: boolean
+ columnWidth?: string
+ barHeight?: string
+ distributed?: boolean
+ borderRadius?: number | number[]
+ rangeBarOverlap?: boolean
+ rangeBarGroupRows?: boolean
+ colors?: {
+ ranges?: {
+ from?: number
+ to?: number
+ color?: string
+ }[]
+ backgroundBarColors?: string[]
+ backgroundBarOpacity?: number
+ backgroundBarRadius?: number
+ }
+ dataLabels?: {
+ maxItems?: number
+ hideOverflowingLabels?: boolean
+ position?: string
+ orientation?: 'horizontal' | 'vertical'
+ }
+ }
+ bubble?: {
+ minBubbleRadius?: number
+ maxBubbleRadius?: number
+ }
+ candlestick?: {
+ colors?: {
+ upward?: string
+ downward?: string
+ }
+ wick?: {
+ useFillColor?: boolean
+ }
+ }
+ boxPlot?: {
+ colors?: {
+ upper?: string,
+ lower?: string
+ }
+ }
+ heatmap?: {
+ radius?: number
+ enableShades?: boolean
+ shadeIntensity?: number
+ reverseNegativeShade?: boolean
+ distributed?: boolean
+ useFillColorAsStroke?: boolean
+ colorScale?: {
+ ranges?: {
+ from?: number
+ to?: number
+ color?: string
+ foreColor?: string
+ name?: string
+ }[]
+ inverse?: boolean
+ min?: number
+ max?: number
+ }
+ }
+ treemap?: {
+ enableShades?: boolean
+ shadeIntensity?: number
+ distributed?: boolean
+ reverseNegativeShade?: boolean
+ useFillColorAsStroke?: boolean
+ colorScale?: {
+ inverse?: boolean
+ ranges?: {
+ from?: number
+ to?: number
+ color?: string
+ foreColor?: string
+ name?: string
+ }[];
+ min?: number
+ max?: number
+ };
+ }
+ pie?: {
+ startAngle?: number
+ endAngle?: number
+ customScale?: number
+ offsetX?: number
+ offsetY?: number
+ expandOnClick?: boolean
+ dataLabels?: {
+ offset?: number
+ minAngleToShowLabel?: number
+ }
+ donut?: {
+ size?: string
+ background?: string
+ labels?: {
+ show?: boolean
+ name?: {
+ show?: boolean
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ color?: string
+ offsetY?: number,
+ formatter?(val: string): string
+ }
+ value?: {
+ show?: boolean
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ color?: string
+ offsetY?: number
+ formatter?(val: string): string
+ }
+ total?: {
+ show?: boolean
+ showAlways?: boolean
+ fontFamily?: string
+ fontWeight?: string | number
+ fontSize?: string
+ label?: string
+ color?: string
+ formatter?(w: any): string
+ }
+ }
+ }
+ }
+ polarArea?: {
+ rings?: {
+ strokeWidth?: number
+ strokeColor?: string
+ }
+ spokes?: {
+ strokeWidth?: number;
+ connectorColors?: string | string[];
+ };
+ }
+ radar?: {
+ size?: number
+ offsetX?: number
+ offsetY?: number
+ polygons?: {
+ strokeColors?: string | string[]
+ strokeWidth?: string | string[]
+ connectorColors?: string | string[]
+ fill?: {
+ colors?: string[]
+ }
+ }
+ }
+ radialBar?: {
+ inverseOrder?: boolean
+ startAngle?: number
+ endAngle?: number
+ offsetX?: number
+ offsetY?: number
+ hollow?: {
+ margin?: number
+ size?: string
+ background?: string
+ image?: string
+ imageWidth?: number
+ imageHeight?: number
+ imageOffsetX?: number
+ imageOffsetY?: number
+ imageClipped?: boolean
+ position?: 'front' | 'back'
+ dropShadow?: ApexDropShadow
+ }
+ track?: {
+ show?: boolean
+ startAngle?: number
+ endAngle?: number
+ background?: string
+ strokeWidth?: string
+ opacity?: number
+ margin?: number
+ dropShadow?: ApexDropShadow
+ }
+ dataLabels?: {
+ show?: boolean
+ name?: {
+ show?: boolean
+ fontFamily?: string
+ fontWeight?: string | number
+ fontSize?: string
+ color?: string
+ offsetY?: number
+ }
+ value?: {
+ show?: boolean
+ fontFamily?: string
+ fontSize?: string
+ fontWeight?: string | number
+ color?: string
+ offsetY?: number
+ formatter?(val: number): string
+ }
+ total?: {
+ show?: boolean
+ label?: string
+ color?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ fontSize?: string
+ formatter?(opts: any): string
+ }
+ }
+ }
+}
+
+type ApexFill = {
+ colors?: any[]
+ opacity?: number | number[]
+ type?: string | string[]
+ gradient?: {
+ shade?: string
+ type?: string
+ shadeIntensity?: number
+ gradientToColors?: string[]
+ inverseColors?: boolean
+ opacityFrom?: number
+ opacityTo?: number
+ stops?: number[],
+ colorStops?: any[]
+ }
+ image?: {
+ src?: string | string[]
+ width?: number
+ height?: number
+ }
+ pattern?: {
+ style?: string | string[]
+ width?: number
+ height?: number
+ strokeWidth?: number
+ }
+}
+
+/**
+ * Chart Legend configuration options.
+ * See https://apexcharts.com/docs/options/legend/
+ */
+type ApexLegend = {
+ show?: boolean
+ showForSingleSeries?: boolean
+ showForNullSeries?: boolean
+ showForZeroSeries?: boolean
+ floating?: boolean
+ inverseOrder?: boolean
+ position?: 'top' | 'right' | 'bottom' | 'left'
+ horizontalAlign?: 'left' | 'center' | 'right'
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ width?: number
+ height?: number
+ offsetX?: number
+ offsetY?: number
+ formatter?(legendName: string, opts?: any): string
+ tooltipHoverFormatter?(legendName: string, opts?: any): string
+ textAnchor?: string
+ customLegendItems?: string[]
+ labels?: {
+ colors?: string | string[]
+ useSeriesColors?: boolean
+ }
+ markers?: {
+ width?: number
+ height?: number
+ strokeColor?: string
+ strokeWidth?: number
+ fillColors?: string[]
+ offsetX?: number
+ offsetY?: number
+ radius?: number
+ customHTML?(): any
+ onClick?(): void
+ }
+ itemMargin?: {
+ horizontal?: number
+ vertical?: number
+ }
+ containerMargin?: {
+ left?: number
+ top?: number
+ }
+ onItemClick?: {
+ toggleDataSeries?: boolean
+ }
+ onItemHover?: {
+ highlightDataSeries?: boolean
+ }
+}
+
+type ApexMarkerShape = "circle" | "square" | "rect" | string[]
+
+type ApexDiscretePoint = {
+ seriesIndex?: number
+ dataPointIndex?: number
+ fillColor?: string
+ strokeColor?: string
+ size?: number
+ shape?: ApexMarkerShape
+}
+
+type ApexMarkers = {
+ size?: number | number[]
+ colors?: string | string[]
+ strokeColors?: string | string[]
+ strokeWidth?: number | number[]
+ strokeOpacity?: number | number[]
+ strokeDashArray?: number | number[]
+ fillOpacity?: number | number[]
+ discrete?: ApexDiscretePoint[]
+ shape?: ApexMarkerShape
+ width?: number | number[]
+ height?: number | number[]
+ radius?: number
+ offsetX?: number
+ offsetY?: number
+ showNullDataPoints?: boolean
+ onClick?(e?: any): void
+ onDblClick?(e?: any): void
+ hover?: {
+ size?: number
+ sizeOffset?: number
+ }
+}
+
+type ApexNoData = {
+ text?: string
+ align?: 'left' | 'right' | 'center'
+ verticalAlign?: 'top' | 'middle' | 'bottom'
+ offsetX?: number
+ offsetY?: number
+ style?: {
+ color?: string
+ fontSize?: string
+ fontFamily?: string
+ }
+}
+
+/**
+ * Chart Datalabels options
+ * See https://apexcharts.com/docs/options/datalabels/
+ */
+type ApexDataLabels = {
+ enabled?: boolean
+ enabledOnSeries?: undefined | number[]
+ textAnchor?: 'start' | 'middle' | 'end'
+ distributed?: boolean
+ offsetX?: number
+ offsetY?: number
+ style?: {
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ colors?: any[]
+ }
+ background?: {
+ enabled?: boolean
+ foreColor?: string
+ borderRadius?: number
+ padding?: number
+ opacity?: number
+ borderWidth?: number
+ borderColor?: string
+ dropShadow: ApexDropShadow
+ }
+ dropShadow?: ApexDropShadow
+ formatter?(val: string | number | number[], opts?: any): string | number
+}
+
+type ApexResponsive = {
+ breakpoint?: number
+ options?: any
+}
+
+type ApexTooltipY = {
+ title?: {
+ formatter?(seriesName: string): string
+ }
+ formatter?(val: number, opts?: any): string
+}
+
+/**
+ * Chart Tooltip options
+ * See https://apexcharts.com/docs/options/tooltip/
+ */
+type ApexTooltip = {
+ enabled?: boolean
+ enabledOnSeries?: undefined | number[]
+ shared?: boolean
+ followCursor?: boolean
+ intersect?: boolean
+ inverseOrder?: boolean
+ custom?: ((options: any) => any) | ((options: any) => any)[]
+ fillSeriesColor?: boolean
+ theme?: string
+ cssClass?: string
+ style?: {
+ fontSize?: string
+ fontFamily?: string
+ }
+ onDatasetHover?: {
+ highlightDataSeries?: boolean
+ }
+ x?: {
+ show?: boolean
+ format?: string
+ formatter?(val: number, opts?: any): string
+ }
+ y?: ApexTooltipY | ApexTooltipY[]
+ z?: {
+ title?: string
+ formatter?(val: number): string
+ }
+ marker?: {
+ show?: boolean
+ fillColors?: string[]
+ }
+ items?: {
+ display?: string
+ }
+ fixed?: {
+ enabled?: boolean
+ position?: string // topRight; topLeft; bottomRight; bottomLeft
+ offsetX?: number
+ offsetY?: number
+ }
+}
+
+/**
+ * X Axis options
+ * See https://apexcharts.com/docs/options/xaxis/
+ */
+type ApexXAxis = {
+ type?: 'category' | 'datetime' | 'numeric'
+ categories?: any;
+ overwriteCategories?: number[] | string[] | undefined;
+ offsetX?: number;
+ offsetY?: number;
+ sorted?: boolean;
+ labels?: {
+ show?: boolean
+ rotate?: number
+ rotateAlways?: boolean
+ hideOverlappingLabels?: boolean
+ showDuplicates?: boolean
+ trim?: boolean
+ minHeight?: number
+ maxHeight?: number
+ style?: {
+ colors?: string | string[]
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ cssClass?: string
+ }
+ offsetX?: number
+ offsetY?: number
+ format?: string
+ formatter?(value: string, timestamp?: number, opts?:any): string | string[]
+ datetimeUTC?: boolean
+ datetimeFormatter?: {
+ year?: string
+ month?: string
+ day?: string
+ hour?: string
+ minute?: string
+ }
+ }
+ group?: {
+ groups?: { title: string, cols: number }[],
+ style?: {
+ colors?: string | string[]
+ fontSize?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ cssClass?: string
+ }
+ }
+ axisBorder?: {
+ show?: boolean
+ color?: string
+ offsetX?: number
+ offsetY?: number
+ strokeWidth?: number
+ }
+ axisTicks?: {
+ show?: boolean
+ borderType?: string
+ color?: string
+ height?: number
+ offsetX?: number
+ offsetY?: number
+ }
+ tickPlacement?: string
+ tickAmount?: number | 'dataPoints'
+ min?: number
+ max?: number
+ range?: number
+ floating?: boolean
+ decimalsInFloat?: number
+ position?: string
+ title?: {
+ text?: string
+ offsetX?: number
+ offsetY?: number
+ style?: {
+ color?: string
+ fontFamily?: string
+ fontWeight?: string | number
+ fontSize?: string
+ cssClass?: string
+ }
+ }
+ crosshairs?: {
+ show?: boolean
+ width?: number | string
+ position?: string
+ opacity?: number
+ stroke?: {
+ color?: string
+ width?: number
+ dashArray?: number
+ }
+ fill?: {
+ type?: string
+ color?: string
+ gradient?: {
+ colorFrom?: string
+ colorTo?: string
+ stops?: number[]
+ opacityFrom?: number
+ opacityTo?: number
+ }
+ }
+ dropShadow?: ApexDropShadow
+ }
+ tooltip?: {
+ enabled?: boolean
+ offsetY?: number
+ formatter?(value: string, opts?: object): string
+ style?: {
+ fontSize?: string
+ fontFamily?: string
+ }
+ }
+}
+
+/**
+ * Y Axis options
+ * See https://apexcharts.com/docs/options/yaxis/
+ */
+
+type ApexYAxis = {
+ show?: boolean
+ showAlways?: boolean
+ showForNullSeries?: boolean
+ seriesName?: string
+ opposite?: boolean
+ reversed?: boolean
+ logarithmic?: boolean,
+ logBase?: number,
+ tickAmount?: number
+ forceNiceScale?: boolean
+ min?: number | ((min: number) => number)
+ max?: number | ((max: number) => number)
+ floating?: boolean
+ decimalsInFloat?: number
+ labels?: {
+ show?: boolean
+ minWidth?: number
+ maxWidth?: number
+ offsetX?: number
+ offsetY?: number
+ rotate?: number
+ align?: 'left' | 'center' | 'right'
+ padding?: number
+ style?: {
+ colors?: string | string[]
+ fontSize?: string
+ fontWeight?: string | number
+ fontFamily?: string
+ cssClass?: string
+ }
+ formatter?(val: number, opts?: any): string | string[]
+ }
+ axisBorder?: {
+ show?: boolean
+ color?: string
+ width?: number
+ offsetX?: number
+ offsetY?: number
+ }
+ axisTicks?: {
+ show?: boolean
+ color?: string
+ width?: number
+ offsetX?: number
+ offsetY?: number
+ }
+ title?: {
+ text?: string
+ rotate?: number
+ offsetX?: number
+ offsetY?: number
+ style?: {
+ color?: string
+ fontSize?: string
+ fontWeight?: string | number
+ fontFamily?: string
+ cssClass?: string
+ }
+ }
+ crosshairs?: {
+ show?: boolean
+ position?: string
+ stroke?: {
+ color?: string
+ width?: number
+ dashArray?: number
+ }
+ }
+ tooltip?: {
+ enabled?: boolean
+ offsetX?: number
+ }
+}
+
+type ApexForecastDataPoints = {
+ count?: number
+ fillOpacity?: number
+ strokeWidth?: undefined | number
+ dashArray: number
+}
+
+/**
+ * Plot X and Y grid options
+ * See https://apexcharts.com/docs/options/grid/
+ */
+type ApexGrid = {
+ show?: boolean
+ borderColor?: string
+ strokeDashArray?: number
+ position?: 'front' | 'back'
+ xaxis?: {
+ lines?: {
+ show?: boolean
+ offsetX?: number
+ offsetY?: number
+ }
+ }
+ yaxis?: {
+ lines?: {
+ show?: boolean
+ offsetX?: number
+ offsetY?: number
+ }
+ }
+ row?: {
+ colors?: string[]
+ opacity?: number
+ }
+ column?: {
+ colors?: string[]
+ opacity?: number
+ }
+ padding?: {
+ top?: number
+ right?: number
+ bottom?: number
+ left?: number
+ }
+}
+
+type ApexTheme = {
+ mode?: 'light' | 'dark'
+ palette?: string
+ monochrome?: {
+ enabled?: boolean
+ color?: string
+ shadeTo?: 'light' | 'dark'
+ shadeIntensity?: number
+ }
+}
+
+declare module 'apexcharts' {
+ export = ApexCharts
+}
diff --git a/cao_sunyata/static/libs/bootstrap/LICENSE b/cao_sunyata/static/libs/bootstrap/LICENSE
new file mode 100644
index 0000000..dda75ca
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2022 Twitter, Inc.
+Copyright (c) 2011-2022 The Bootstrap Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/cao_sunyata/static/libs/bootstrap/README.md b/cao_sunyata/static/libs/bootstrap/README.md
new file mode 100644
index 0000000..4821c17
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/README.md
@@ -0,0 +1,247 @@
+
+
+
+
+
+Bootstrap
+
+
+ Sleek, intuitive, and powerful front-end framework for faster and easier web development.
+ Explore Bootstrap docs » Report bug
+ ·
+ Request feature
+ ·
+ Themes
+ ·
+ Blog
+
+
+
+## Bootstrap 5
+
+Our default branch is for development of our Bootstrap 5 release. Head to the [`v4-dev` branch](https://github.com/twbs/bootstrap/tree/v4-dev) to view the readme, documentation, and source code for Bootstrap 4.
+
+
+## Table of contents
+
+- [Quick start](#quick-start)
+- [Status](#status)
+- [What's included](#whats-included)
+- [Bugs and feature requests](#bugs-and-feature-requests)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [Community](#community)
+- [Versioning](#versioning)
+- [Creators](#creators)
+- [Thanks](#thanks)
+- [Copyright and license](#copyright-and-license)
+
+
+## Quick start
+
+Several quick start options are available:
+
+- [Download the latest release](https://github.com/twbs/bootstrap/archive/v5.2.0-beta1.zip)
+- Clone the repo: `git clone https://github.com/twbs/bootstrap.git`
+- Install with [npm](https://www.npmjs.com/): `npm install bootstrap`
+- Install with [yarn](https://yarnpkg.com/): `yarn add bootstrap`
+- Install with [Composer](https://getcomposer.org/): `composer require twbs/bootstrap:5.2.0-beta1`
+- Install with [NuGet](https://www.nuget.org/): CSS: `Install-Package bootstrap` Sass: `Install-Package bootstrap.sass`
+
+Read the [Getting started page](https://getbootstrap.com/docs/5.2/getting-started/introduction/) for information on the framework contents, templates, examples, and more.
+
+
+## Status
+
+[](https://bootstrap-slack.herokuapp.com/)
+[](https://github.com/twbs/bootstrap/actions?query=workflow%3AJS+Tests+branch%3Amain)
+[](https://www.npmjs.com/package/bootstrap)
+[](https://rubygems.org/gems/bootstrap)
+[](https://atmospherejs.com/twbs/bootstrap)
+[](https://packagist.org/packages/twbs/bootstrap)
+[](https://www.nuget.org/packages/bootstrap/absoluteLatest)
+[](https://coveralls.io/github/twbs/bootstrap?branch=main)
+[](https://github.com/twbs/bootstrap/blob/main/dist/css/bootstrap.min.css)
+[](https://github.com/twbs/bootstrap/blob/main/dist/css/bootstrap.min.css)
+[](https://github.com/twbs/bootstrap/blob/main/dist/js/bootstrap.min.js)
+[](https://github.com/twbs/bootstrap/blob/main/dist/js/bootstrap.min.js)
+[](https://www.browserstack.com/automate/public-build/SkxZcStBeExEdVJqQ2hWYnlWckpkNmNEY213SFp6WHFETWk2bGFuY3pCbz0tLXhqbHJsVlZhQnRBdEpod3NLSDMzaHc9PQ==--3d0b75245708616eb93113221beece33e680b229)
+[](#backers)
+[](#sponsors)
+
+
+## What's included
+
+Within the download you'll find the following directories and files, logically grouping common assets and providing both compiled and minified variations.
+
+
+ Download contents
+
+ ```text
+ bootstrap/
+ ├── css/
+ │ ├── bootstrap-grid.css
+ │ ├── bootstrap-grid.css.map
+ │ ├── bootstrap-grid.min.css
+ │ ├── bootstrap-grid.min.css.map
+ │ ├── bootstrap-grid.rtl.css
+ │ ├── bootstrap-grid.rtl.css.map
+ │ ├── bootstrap-grid.rtl.min.css
+ │ ├── bootstrap-grid.rtl.min.css.map
+ │ ├── bootstrap-reboot.css
+ │ ├── bootstrap-reboot.css.map
+ │ ├── bootstrap-reboot.min.css
+ │ ├── bootstrap-reboot.min.css.map
+ │ ├── bootstrap-reboot.rtl.css
+ │ ├── bootstrap-reboot.rtl.css.map
+ │ ├── bootstrap-reboot.rtl.min.css
+ │ ├── bootstrap-reboot.rtl.min.css.map
+ │ ├── bootstrap-utilities.css
+ │ ├── bootstrap-utilities.css.map
+ │ ├── bootstrap-utilities.min.css
+ │ ├── bootstrap-utilities.min.css.map
+ │ ├── bootstrap-utilities.rtl.css
+ │ ├── bootstrap-utilities.rtl.css.map
+ │ ├── bootstrap-utilities.rtl.min.css
+ │ ├── bootstrap-utilities.rtl.min.css.map
+ │ ├── bootstrap.css
+ │ ├── bootstrap.css.map
+ │ ├── bootstrap.min.css
+ │ ├── bootstrap.min.css.map
+ │ ├── bootstrap.rtl.css
+ │ ├── bootstrap.rtl.css.map
+ │ ├── bootstrap.rtl.min.css
+ │ └── bootstrap.rtl.min.css.map
+ └── js/
+ ├── bootstrap.bundle.js
+ ├── bootstrap.bundle.js.map
+ ├── bootstrap.bundle.min.js
+ ├── bootstrap.bundle.min.js.map
+ ├── bootstrap.esm.js
+ ├── bootstrap.esm.js.map
+ ├── bootstrap.esm.min.js
+ ├── bootstrap.esm.min.js.map
+ ├── bootstrap.js
+ ├── bootstrap.js.map
+ ├── bootstrap.min.js
+ └── bootstrap.min.js.map
+ ```
+
+
+We provide compiled CSS and JS (`bootstrap.*`), as well as compiled and minified CSS and JS (`bootstrap.min.*`). [Source maps](https://developers.google.com/web/tools/chrome-devtools/javascript/source-maps) (`bootstrap.*.map`) are available for use with certain browsers' developer tools. Bundled JS files (`bootstrap.bundle.js` and minified `bootstrap.bundle.min.js`) include [Popper](https://popper.js.org/).
+
+
+## Bugs and feature requests
+
+Have a bug or a feature request? Please first read the [issue guidelines](https://github.com/twbs/bootstrap/blob/main/.github/CONTRIBUTING.md#using-the-issue-tracker) and search for existing and closed issues. If your problem or idea is not addressed yet, [please open a new issue](https://github.com/twbs/bootstrap/issues/new).
+
+
+## Documentation
+
+Bootstrap's documentation, included in this repo in the root directory, is built with [Hugo](https://gohugo.io/) and publicly hosted on GitHub Pages at
+-
+
+**Jacob Thornton**
+
+-
+-
+
+
+## Thanks
+
+
+
+
+Thanks to [BrowserStack](https://www.browserstack.com/) for providing the infrastructure that allows us to test in real browsers!
+
+
+
+
+Thanks to [Netlify](https://www.netlify.com/) for providing us with Deploy Previews!
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/bootstrap#sponsor)]
+
+[](https://opencollective.com/bootstrap/sponsor/0/website)
+[](https://opencollective.com/bootstrap/sponsor/1/website)
+[](https://opencollective.com/bootstrap/sponsor/2/website)
+[](https://opencollective.com/bootstrap/sponsor/3/website)
+[](https://opencollective.com/bootstrap/sponsor/4/website)
+[](https://opencollective.com/bootstrap/sponsor/5/website)
+[](https://opencollective.com/bootstrap/sponsor/6/website)
+[](https://opencollective.com/bootstrap/sponsor/7/website)
+[](https://opencollective.com/bootstrap/sponsor/8/website)
+[](https://opencollective.com/bootstrap/sponsor/9/website)
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/bootstrap#backer)]
+
+[](https://opencollective.com/bootstrap#backers)
+
+
+## Copyright and license
+
+Code and documentation copyright 2011–2022 the [Bootstrap Authors](https://github.com/twbs/bootstrap/graphs/contributors) and [Twitter, Inc.](https://twitter.com) Code released under the [MIT License](https://github.com/twbs/bootstrap/blob/main/LICENSE). Docs released under [Creative Commons](https://creativecommons.org/licenses/by/3.0/).
diff --git a/cao_sunyata/static/libs/bootstrap/js/index.esm.js b/cao_sunyata/static/libs/bootstrap/js/index.esm.js
new file mode 100644
index 0000000..b837649
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/index.esm.js
@@ -0,0 +1,19 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): index.esm.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+export { default as Alert } from './src/alert'
+export { default as Button } from './src/button'
+export { default as Carousel } from './src/carousel'
+export { default as Collapse } from './src/collapse'
+export { default as Dropdown } from './src/dropdown'
+export { default as Modal } from './src/modal'
+export { default as Offcanvas } from './src/offcanvas'
+export { default as Popover } from './src/popover'
+export { default as ScrollSpy } from './src/scrollspy'
+export { default as Tab } from './src/tab'
+export { default as Toast } from './src/toast'
+export { default as Tooltip } from './src/tooltip'
diff --git a/cao_sunyata/static/libs/bootstrap/js/index.umd.js b/cao_sunyata/static/libs/bootstrap/js/index.umd.js
new file mode 100644
index 0000000..5abe8db
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/index.umd.js
@@ -0,0 +1,34 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): index.umd.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import Alert from './src/alert'
+import Button from './src/button'
+import Carousel from './src/carousel'
+import Collapse from './src/collapse'
+import Dropdown from './src/dropdown'
+import Modal from './src/modal'
+import Offcanvas from './src/offcanvas'
+import Popover from './src/popover'
+import ScrollSpy from './src/scrollspy'
+import Tab from './src/tab'
+import Toast from './src/toast'
+import Tooltip from './src/tooltip'
+
+export default {
+ Alert,
+ Button,
+ Carousel,
+ Collapse,
+ Dropdown,
+ Modal,
+ Offcanvas,
+ Popover,
+ ScrollSpy,
+ Tab,
+ Toast,
+ Tooltip
+}
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/alert.js b/cao_sunyata/static/libs/bootstrap/js/src/alert.js
new file mode 100644
index 0000000..59de828
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/alert.js
@@ -0,0 +1,87 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): alert.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin } from './util/index'
+import EventHandler from './dom/event-handler'
+import BaseComponent from './base-component'
+import { enableDismissTrigger } from './util/component-functions'
+
+/**
+ * Constants
+ */
+
+const NAME = 'alert'
+const DATA_KEY = 'bs.alert'
+const EVENT_KEY = `.${DATA_KEY}`
+
+const EVENT_CLOSE = `close${EVENT_KEY}`
+const EVENT_CLOSED = `closed${EVENT_KEY}`
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_SHOW = 'show'
+
+/**
+ * Class definition
+ */
+
+class Alert extends BaseComponent {
+ // Getters
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ close() {
+ const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE)
+
+ if (closeEvent.defaultPrevented) {
+ return
+ }
+
+ this._element.classList.remove(CLASS_NAME_SHOW)
+
+ const isAnimated = this._element.classList.contains(CLASS_NAME_FADE)
+ this._queueCallback(() => this._destroyElement(), this._element, isAnimated)
+ }
+
+ // Private
+ _destroyElement() {
+ this._element.remove()
+ EventHandler.trigger(this._element, EVENT_CLOSED)
+ this.dispose()
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Alert.getOrCreateInstance(this)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config](this)
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+enableDismissTrigger(Alert, 'close')
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Alert)
+
+export default Alert
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/base-component.js b/cao_sunyata/static/libs/bootstrap/js/src/base-component.js
new file mode 100644
index 0000000..0c1a259
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/base-component.js
@@ -0,0 +1,85 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): base-component.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import Data from './dom/data'
+import { executeAfterTransition, getElement } from './util/index'
+import EventHandler from './dom/event-handler'
+import Config from './util/config'
+
+/**
+ * Constants
+ */
+
+const VERSION = '5.2.3'
+
+/**
+ * Class definition
+ */
+
+class BaseComponent extends Config {
+ constructor(element, config) {
+ super()
+
+ element = getElement(element)
+ if (!element) {
+ return
+ }
+
+ this._element = element
+ this._config = this._getConfig(config)
+
+ Data.set(this._element, this.constructor.DATA_KEY, this)
+ }
+
+ // Public
+ dispose() {
+ Data.remove(this._element, this.constructor.DATA_KEY)
+ EventHandler.off(this._element, this.constructor.EVENT_KEY)
+
+ for (const propertyName of Object.getOwnPropertyNames(this)) {
+ this[propertyName] = null
+ }
+ }
+
+ _queueCallback(callback, element, isAnimated = true) {
+ executeAfterTransition(callback, element, isAnimated)
+ }
+
+ _getConfig(config) {
+ config = this._mergeConfigObj(config, this._element)
+ config = this._configAfterMerge(config)
+ this._typeCheckConfig(config)
+ return config
+ }
+
+ // Static
+ static getInstance(element) {
+ return Data.get(getElement(element), this.DATA_KEY)
+ }
+
+ static getOrCreateInstance(element, config = {}) {
+ return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null)
+ }
+
+ static get VERSION() {
+ return VERSION
+ }
+
+ static get DATA_KEY() {
+ return `bs.${this.NAME}`
+ }
+
+ static get EVENT_KEY() {
+ return `.${this.DATA_KEY}`
+ }
+
+ static eventName(name) {
+ return `${name}${this.EVENT_KEY}`
+ }
+}
+
+export default BaseComponent
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/button.js b/cao_sunyata/static/libs/bootstrap/js/src/button.js
new file mode 100644
index 0000000..03e7604
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/button.js
@@ -0,0 +1,72 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): button.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin } from './util/index'
+import EventHandler from './dom/event-handler'
+import BaseComponent from './base-component'
+
+/**
+ * Constants
+ */
+
+const NAME = 'button'
+const DATA_KEY = 'bs.button'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+
+const CLASS_NAME_ACTIVE = 'active'
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]'
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+
+/**
+ * Class definition
+ */
+
+class Button extends BaseComponent {
+ // Getters
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ toggle() {
+ // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
+ this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE))
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Button.getOrCreateInstance(this)
+
+ if (config === 'toggle') {
+ data[config]()
+ }
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, event => {
+ event.preventDefault()
+
+ const button = event.target.closest(SELECTOR_DATA_TOGGLE)
+ const data = Button.getOrCreateInstance(button)
+
+ data.toggle()
+})
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Button)
+
+export default Button
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/carousel.js b/cao_sunyata/static/libs/bootstrap/js/src/carousel.js
new file mode 100644
index 0000000..24bbe39
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/carousel.js
@@ -0,0 +1,475 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): carousel.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import {
+ defineJQueryPlugin,
+ getElementFromSelector,
+ getNextActiveElement,
+ isRTL,
+ isVisible,
+ reflow,
+ triggerTransitionEnd
+} from './util/index'
+import EventHandler from './dom/event-handler'
+import Manipulator from './dom/manipulator'
+import SelectorEngine from './dom/selector-engine'
+import Swipe from './util/swipe'
+import BaseComponent from './base-component'
+
+/**
+ * Constants
+ */
+
+const NAME = 'carousel'
+const DATA_KEY = 'bs.carousel'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+
+const ARROW_LEFT_KEY = 'ArrowLeft'
+const ARROW_RIGHT_KEY = 'ArrowRight'
+const TOUCHEVENT_COMPAT_WAIT = 500 // Time for mouse compat events to fire after touch
+
+const ORDER_NEXT = 'next'
+const ORDER_PREV = 'prev'
+const DIRECTION_LEFT = 'left'
+const DIRECTION_RIGHT = 'right'
+
+const EVENT_SLIDE = `slide${EVENT_KEY}`
+const EVENT_SLID = `slid${EVENT_KEY}`
+const EVENT_KEYDOWN = `keydown${EVENT_KEY}`
+const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY}`
+const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY}`
+const EVENT_DRAG_START = `dragstart${EVENT_KEY}`
+const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+
+const CLASS_NAME_CAROUSEL = 'carousel'
+const CLASS_NAME_ACTIVE = 'active'
+const CLASS_NAME_SLIDE = 'slide'
+const CLASS_NAME_END = 'carousel-item-end'
+const CLASS_NAME_START = 'carousel-item-start'
+const CLASS_NAME_NEXT = 'carousel-item-next'
+const CLASS_NAME_PREV = 'carousel-item-prev'
+
+const SELECTOR_ACTIVE = '.active'
+const SELECTOR_ITEM = '.carousel-item'
+const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM
+const SELECTOR_ITEM_IMG = '.carousel-item img'
+const SELECTOR_INDICATORS = '.carousel-indicators'
+const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'
+const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'
+
+const KEY_TO_DIRECTION = {
+ [ARROW_LEFT_KEY]: DIRECTION_RIGHT,
+ [ARROW_RIGHT_KEY]: DIRECTION_LEFT
+}
+
+const Default = {
+ interval: 5000,
+ keyboard: true,
+ pause: 'hover',
+ ride: false,
+ touch: true,
+ wrap: true
+}
+
+const DefaultType = {
+ interval: '(number|boolean)', // TODO:v6 remove boolean support
+ keyboard: 'boolean',
+ pause: '(string|boolean)',
+ ride: '(boolean|string)',
+ touch: 'boolean',
+ wrap: 'boolean'
+}
+
+/**
+ * Class definition
+ */
+
+class Carousel extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._interval = null
+ this._activeElement = null
+ this._isSliding = false
+ this.touchTimeout = null
+ this._swipeHelper = null
+
+ this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element)
+ this._addEventListeners()
+
+ if (this._config.ride === CLASS_NAME_CAROUSEL) {
+ this.cycle()
+ }
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ next() {
+ this._slide(ORDER_NEXT)
+ }
+
+ nextWhenVisible() {
+ // FIXME TODO use `document.visibilityState`
+ // Don't call next when the page isn't visible
+ // or the carousel or its parent isn't visible
+ if (!document.hidden && isVisible(this._element)) {
+ this.next()
+ }
+ }
+
+ prev() {
+ this._slide(ORDER_PREV)
+ }
+
+ pause() {
+ if (this._isSliding) {
+ triggerTransitionEnd(this._element)
+ }
+
+ this._clearInterval()
+ }
+
+ cycle() {
+ this._clearInterval()
+ this._updateInterval()
+
+ this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval)
+ }
+
+ _maybeEnableCycle() {
+ if (!this._config.ride) {
+ return
+ }
+
+ if (this._isSliding) {
+ EventHandler.one(this._element, EVENT_SLID, () => this.cycle())
+ return
+ }
+
+ this.cycle()
+ }
+
+ to(index) {
+ const items = this._getItems()
+ if (index > items.length - 1 || index < 0) {
+ return
+ }
+
+ if (this._isSliding) {
+ EventHandler.one(this._element, EVENT_SLID, () => this.to(index))
+ return
+ }
+
+ const activeIndex = this._getItemIndex(this._getActive())
+ if (activeIndex === index) {
+ return
+ }
+
+ const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV
+
+ this._slide(order, items[index])
+ }
+
+ dispose() {
+ if (this._swipeHelper) {
+ this._swipeHelper.dispose()
+ }
+
+ super.dispose()
+ }
+
+ // Private
+ _configAfterMerge(config) {
+ config.defaultInterval = config.interval
+ return config
+ }
+
+ _addEventListeners() {
+ if (this._config.keyboard) {
+ EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event))
+ }
+
+ if (this._config.pause === 'hover') {
+ EventHandler.on(this._element, EVENT_MOUSEENTER, () => this.pause())
+ EventHandler.on(this._element, EVENT_MOUSELEAVE, () => this._maybeEnableCycle())
+ }
+
+ if (this._config.touch && Swipe.isSupported()) {
+ this._addTouchEventListeners()
+ }
+ }
+
+ _addTouchEventListeners() {
+ for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
+ EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault())
+ }
+
+ const endCallBack = () => {
+ if (this._config.pause !== 'hover') {
+ return
+ }
+
+ // If it's a touch-enabled device, mouseenter/leave are fired as
+ // part of the mouse compatibility events on first tap - the carousel
+ // would stop cycling until user tapped out of it;
+ // here, we listen for touchend, explicitly pause the carousel
+ // (as if it's the second time we tap on it, mouseenter compat event
+ // is NOT fired) and after a timeout (to allow for mouse compatibility
+ // events to fire) we explicitly restart cycling
+
+ this.pause()
+ if (this.touchTimeout) {
+ clearTimeout(this.touchTimeout)
+ }
+
+ this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval)
+ }
+
+ const swipeConfig = {
+ leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
+ rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
+ endCallback: endCallBack
+ }
+
+ this._swipeHelper = new Swipe(this._element, swipeConfig)
+ }
+
+ _keydown(event) {
+ if (/input|textarea/i.test(event.target.tagName)) {
+ return
+ }
+
+ const direction = KEY_TO_DIRECTION[event.key]
+ if (direction) {
+ event.preventDefault()
+ this._slide(this._directionToOrder(direction))
+ }
+ }
+
+ _getItemIndex(element) {
+ return this._getItems().indexOf(element)
+ }
+
+ _setActiveIndicatorElement(index) {
+ if (!this._indicatorsElement) {
+ return
+ }
+
+ const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement)
+
+ activeIndicator.classList.remove(CLASS_NAME_ACTIVE)
+ activeIndicator.removeAttribute('aria-current')
+
+ const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement)
+
+ if (newActiveIndicator) {
+ newActiveIndicator.classList.add(CLASS_NAME_ACTIVE)
+ newActiveIndicator.setAttribute('aria-current', 'true')
+ }
+ }
+
+ _updateInterval() {
+ const element = this._activeElement || this._getActive()
+
+ if (!element) {
+ return
+ }
+
+ const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10)
+
+ this._config.interval = elementInterval || this._config.defaultInterval
+ }
+
+ _slide(order, element = null) {
+ if (this._isSliding) {
+ return
+ }
+
+ const activeElement = this._getActive()
+ const isNext = order === ORDER_NEXT
+ const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap)
+
+ if (nextElement === activeElement) {
+ return
+ }
+
+ const nextElementIndex = this._getItemIndex(nextElement)
+
+ const triggerEvent = eventName => {
+ return EventHandler.trigger(this._element, eventName, {
+ relatedTarget: nextElement,
+ direction: this._orderToDirection(order),
+ from: this._getItemIndex(activeElement),
+ to: nextElementIndex
+ })
+ }
+
+ const slideEvent = triggerEvent(EVENT_SLIDE)
+
+ if (slideEvent.defaultPrevented) {
+ return
+ }
+
+ if (!activeElement || !nextElement) {
+ // Some weirdness is happening, so we bail
+ // todo: change tests that use empty divs to avoid this check
+ return
+ }
+
+ const isCycling = Boolean(this._interval)
+ this.pause()
+
+ this._isSliding = true
+
+ this._setActiveIndicatorElement(nextElementIndex)
+ this._activeElement = nextElement
+
+ const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END
+ const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV
+
+ nextElement.classList.add(orderClassName)
+
+ reflow(nextElement)
+
+ activeElement.classList.add(directionalClassName)
+ nextElement.classList.add(directionalClassName)
+
+ const completeCallBack = () => {
+ nextElement.classList.remove(directionalClassName, orderClassName)
+ nextElement.classList.add(CLASS_NAME_ACTIVE)
+
+ activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName)
+
+ this._isSliding = false
+
+ triggerEvent(EVENT_SLID)
+ }
+
+ this._queueCallback(completeCallBack, activeElement, this._isAnimated())
+
+ if (isCycling) {
+ this.cycle()
+ }
+ }
+
+ _isAnimated() {
+ return this._element.classList.contains(CLASS_NAME_SLIDE)
+ }
+
+ _getActive() {
+ return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
+ }
+
+ _getItems() {
+ return SelectorEngine.find(SELECTOR_ITEM, this._element)
+ }
+
+ _clearInterval() {
+ if (this._interval) {
+ clearInterval(this._interval)
+ this._interval = null
+ }
+ }
+
+ _directionToOrder(direction) {
+ if (isRTL()) {
+ return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT
+ }
+
+ return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV
+ }
+
+ _orderToDirection(order) {
+ if (isRTL()) {
+ return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT
+ }
+
+ return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Carousel.getOrCreateInstance(this, config)
+
+ if (typeof config === 'number') {
+ data.to(config)
+ return
+ }
+
+ if (typeof config === 'string') {
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ }
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (event) {
+ const target = getElementFromSelector(this)
+
+ if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
+ return
+ }
+
+ event.preventDefault()
+
+ const carousel = Carousel.getOrCreateInstance(target)
+ const slideIndex = this.getAttribute('data-bs-slide-to')
+
+ if (slideIndex) {
+ carousel.to(slideIndex)
+ carousel._maybeEnableCycle()
+ return
+ }
+
+ if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
+ carousel.next()
+ carousel._maybeEnableCycle()
+ return
+ }
+
+ carousel.prev()
+ carousel._maybeEnableCycle()
+})
+
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+ const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE)
+
+ for (const carousel of carousels) {
+ Carousel.getOrCreateInstance(carousel)
+ }
+})
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Carousel)
+
+export default Carousel
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/collapse.js b/cao_sunyata/static/libs/bootstrap/js/src/collapse.js
new file mode 100644
index 0000000..204d180
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/collapse.js
@@ -0,0 +1,302 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): collapse.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import {
+ defineJQueryPlugin,
+ getElement,
+ getElementFromSelector,
+ getSelectorFromElement,
+ reflow
+} from './util/index'
+import EventHandler from './dom/event-handler'
+import SelectorEngine from './dom/selector-engine'
+import BaseComponent from './base-component'
+
+/**
+ * Constants
+ */
+
+const NAME = 'collapse'
+const DATA_KEY = 'bs.collapse'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+
+const CLASS_NAME_SHOW = 'show'
+const CLASS_NAME_COLLAPSE = 'collapse'
+const CLASS_NAME_COLLAPSING = 'collapsing'
+const CLASS_NAME_COLLAPSED = 'collapsed'
+const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`
+const CLASS_NAME_HORIZONTAL = 'collapse-horizontal'
+
+const WIDTH = 'width'
+const HEIGHT = 'height'
+
+const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing'
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="collapse"]'
+
+const Default = {
+ parent: null,
+ toggle: true
+}
+
+const DefaultType = {
+ parent: '(null|element)',
+ toggle: 'boolean'
+}
+
+/**
+ * Class definition
+ */
+
+class Collapse extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._isTransitioning = false
+ this._triggerArray = []
+
+ const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE)
+
+ for (const elem of toggleList) {
+ const selector = getSelectorFromElement(elem)
+ const filterElement = SelectorEngine.find(selector)
+ .filter(foundElement => foundElement === this._element)
+
+ if (selector !== null && filterElement.length) {
+ this._triggerArray.push(elem)
+ }
+ }
+
+ this._initializeChildren()
+
+ if (!this._config.parent) {
+ this._addAriaAndCollapsedClass(this._triggerArray, this._isShown())
+ }
+
+ if (this._config.toggle) {
+ this.toggle()
+ }
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ toggle() {
+ if (this._isShown()) {
+ this.hide()
+ } else {
+ this.show()
+ }
+ }
+
+ show() {
+ if (this._isTransitioning || this._isShown()) {
+ return
+ }
+
+ let activeChildren = []
+
+ // find active children
+ if (this._config.parent) {
+ activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES)
+ .filter(element => element !== this._element)
+ .map(element => Collapse.getOrCreateInstance(element, { toggle: false }))
+ }
+
+ if (activeChildren.length && activeChildren[0]._isTransitioning) {
+ return
+ }
+
+ const startEvent = EventHandler.trigger(this._element, EVENT_SHOW)
+ if (startEvent.defaultPrevented) {
+ return
+ }
+
+ for (const activeInstance of activeChildren) {
+ activeInstance.hide()
+ }
+
+ const dimension = this._getDimension()
+
+ this._element.classList.remove(CLASS_NAME_COLLAPSE)
+ this._element.classList.add(CLASS_NAME_COLLAPSING)
+
+ this._element.style[dimension] = 0
+
+ this._addAriaAndCollapsedClass(this._triggerArray, true)
+ this._isTransitioning = true
+
+ const complete = () => {
+ this._isTransitioning = false
+
+ this._element.classList.remove(CLASS_NAME_COLLAPSING)
+ this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW)
+
+ this._element.style[dimension] = ''
+
+ EventHandler.trigger(this._element, EVENT_SHOWN)
+ }
+
+ const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1)
+ const scrollSize = `scroll${capitalizedDimension}`
+
+ this._queueCallback(complete, this._element, true)
+ this._element.style[dimension] = `${this._element[scrollSize]}px`
+ }
+
+ hide() {
+ if (this._isTransitioning || !this._isShown()) {
+ return
+ }
+
+ const startEvent = EventHandler.trigger(this._element, EVENT_HIDE)
+ if (startEvent.defaultPrevented) {
+ return
+ }
+
+ const dimension = this._getDimension()
+
+ this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`
+
+ reflow(this._element)
+
+ this._element.classList.add(CLASS_NAME_COLLAPSING)
+ this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW)
+
+ for (const trigger of this._triggerArray) {
+ const element = getElementFromSelector(trigger)
+
+ if (element && !this._isShown(element)) {
+ this._addAriaAndCollapsedClass([trigger], false)
+ }
+ }
+
+ this._isTransitioning = true
+
+ const complete = () => {
+ this._isTransitioning = false
+ this._element.classList.remove(CLASS_NAME_COLLAPSING)
+ this._element.classList.add(CLASS_NAME_COLLAPSE)
+ EventHandler.trigger(this._element, EVENT_HIDDEN)
+ }
+
+ this._element.style[dimension] = ''
+
+ this._queueCallback(complete, this._element, true)
+ }
+
+ _isShown(element = this._element) {
+ return element.classList.contains(CLASS_NAME_SHOW)
+ }
+
+ // Private
+ _configAfterMerge(config) {
+ config.toggle = Boolean(config.toggle) // Coerce string values
+ config.parent = getElement(config.parent)
+ return config
+ }
+
+ _getDimension() {
+ return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT
+ }
+
+ _initializeChildren() {
+ if (!this._config.parent) {
+ return
+ }
+
+ const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE)
+
+ for (const element of children) {
+ const selected = getElementFromSelector(element)
+
+ if (selected) {
+ this._addAriaAndCollapsedClass([element], this._isShown(selected))
+ }
+ }
+ }
+
+ _getFirstLevelChildren(selector) {
+ const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent)
+ // remove children if greater depth
+ return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element))
+ }
+
+ _addAriaAndCollapsedClass(triggerArray, isOpen) {
+ if (!triggerArray.length) {
+ return
+ }
+
+ for (const element of triggerArray) {
+ element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen)
+ element.setAttribute('aria-expanded', isOpen)
+ }
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ const _config = {}
+ if (typeof config === 'string' && /show|hide/.test(config)) {
+ _config.toggle = false
+ }
+
+ return this.each(function () {
+ const data = Collapse.getOrCreateInstance(this, _config)
+
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ }
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+ // preventDefault only for elements (which change the URL) not inside the collapsible element
+ if (event.target.tagName === 'A' || (event.delegateTarget && event.delegateTarget.tagName === 'A')) {
+ event.preventDefault()
+ }
+
+ const selector = getSelectorFromElement(this)
+ const selectorElements = SelectorEngine.find(selector)
+
+ for (const element of selectorElements) {
+ Collapse.getOrCreateInstance(element, { toggle: false }).toggle()
+ }
+})
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Collapse)
+
+export default Collapse
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/dom/data.js b/cao_sunyata/static/libs/bootstrap/js/src/dom/data.js
new file mode 100644
index 0000000..2c6a46e
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/dom/data.js
@@ -0,0 +1,55 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): dom/data.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+/**
+ * Constants
+ */
+
+const elementMap = new Map()
+
+export default {
+ set(element, key, instance) {
+ if (!elementMap.has(element)) {
+ elementMap.set(element, new Map())
+ }
+
+ const instanceMap = elementMap.get(element)
+
+ // make it clear we only want one instance per element
+ // can be removed later when multiple key/instances are fine to be used
+ if (!instanceMap.has(key) && instanceMap.size !== 0) {
+ // eslint-disable-next-line no-console
+ console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`)
+ return
+ }
+
+ instanceMap.set(key, instance)
+ },
+
+ get(element, key) {
+ if (elementMap.has(element)) {
+ return elementMap.get(element).get(key) || null
+ }
+
+ return null
+ },
+
+ remove(element, key) {
+ if (!elementMap.has(element)) {
+ return
+ }
+
+ const instanceMap = elementMap.get(element)
+
+ instanceMap.delete(key)
+
+ // free up element references if there are no instances left for an element
+ if (instanceMap.size === 0) {
+ elementMap.delete(element)
+ }
+ }
+}
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/dom/event-handler.js b/cao_sunyata/static/libs/bootstrap/js/src/dom/event-handler.js
new file mode 100644
index 0000000..9876d77
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/dom/event-handler.js
@@ -0,0 +1,320 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): dom/event-handler.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { getjQuery } from '../util/index'
+
+/**
+ * Constants
+ */
+
+const namespaceRegex = /[^.]*(?=\..*)\.|.*/
+const stripNameRegex = /\..*/
+const stripUidRegex = /::\d+$/
+const eventRegistry = {} // Events storage
+let uidEvent = 1
+const customEvents = {
+ mouseenter: 'mouseover',
+ mouseleave: 'mouseout'
+}
+
+const nativeEvents = new Set([
+ 'click',
+ 'dblclick',
+ 'mouseup',
+ 'mousedown',
+ 'contextmenu',
+ 'mousewheel',
+ 'DOMMouseScroll',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'selectstart',
+ 'selectend',
+ 'keydown',
+ 'keypress',
+ 'keyup',
+ 'orientationchange',
+ 'touchstart',
+ 'touchmove',
+ 'touchend',
+ 'touchcancel',
+ 'pointerdown',
+ 'pointermove',
+ 'pointerup',
+ 'pointerleave',
+ 'pointercancel',
+ 'gesturestart',
+ 'gesturechange',
+ 'gestureend',
+ 'focus',
+ 'blur',
+ 'change',
+ 'reset',
+ 'select',
+ 'submit',
+ 'focusin',
+ 'focusout',
+ 'load',
+ 'unload',
+ 'beforeunload',
+ 'resize',
+ 'move',
+ 'DOMContentLoaded',
+ 'readystatechange',
+ 'error',
+ 'abort',
+ 'scroll'
+])
+
+/**
+ * Private methods
+ */
+
+function makeEventUid(element, uid) {
+ return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++
+}
+
+function getElementEvents(element) {
+ const uid = makeEventUid(element)
+
+ element.uidEvent = uid
+ eventRegistry[uid] = eventRegistry[uid] || {}
+
+ return eventRegistry[uid]
+}
+
+function bootstrapHandler(element, fn) {
+ return function handler(event) {
+ hydrateObj(event, { delegateTarget: element })
+
+ if (handler.oneOff) {
+ EventHandler.off(element, event.type, fn)
+ }
+
+ return fn.apply(element, [event])
+ }
+}
+
+function bootstrapDelegationHandler(element, selector, fn) {
+ return function handler(event) {
+ const domElements = element.querySelectorAll(selector)
+
+ for (let { target } = event; target && target !== this; target = target.parentNode) {
+ for (const domElement of domElements) {
+ if (domElement !== target) {
+ continue
+ }
+
+ hydrateObj(event, { delegateTarget: target })
+
+ if (handler.oneOff) {
+ EventHandler.off(element, event.type, selector, fn)
+ }
+
+ return fn.apply(target, [event])
+ }
+ }
+ }
+}
+
+function findHandler(events, callable, delegationSelector = null) {
+ return Object.values(events)
+ .find(event => event.callable === callable && event.delegationSelector === delegationSelector)
+}
+
+function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
+ const isDelegated = typeof handler === 'string'
+ // todo: tooltip passes `false` instead of selector, so we need to check
+ const callable = isDelegated ? delegationFunction : (handler || delegationFunction)
+ let typeEvent = getTypeEvent(originalTypeEvent)
+
+ if (!nativeEvents.has(typeEvent)) {
+ typeEvent = originalTypeEvent
+ }
+
+ return [isDelegated, callable, typeEvent]
+}
+
+function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
+ if (typeof originalTypeEvent !== 'string' || !element) {
+ return
+ }
+
+ let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
+
+ // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
+ // this prevents the handler from being dispatched the same way as mouseover or mouseout does
+ if (originalTypeEvent in customEvents) {
+ const wrapFunction = fn => {
+ return function (event) {
+ if (!event.relatedTarget || (event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget))) {
+ return fn.call(this, event)
+ }
+ }
+ }
+
+ callable = wrapFunction(callable)
+ }
+
+ const events = getElementEvents(element)
+ const handlers = events[typeEvent] || (events[typeEvent] = {})
+ const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null)
+
+ if (previousFunction) {
+ previousFunction.oneOff = previousFunction.oneOff && oneOff
+
+ return
+ }
+
+ const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''))
+ const fn = isDelegated ?
+ bootstrapDelegationHandler(element, handler, callable) :
+ bootstrapHandler(element, callable)
+
+ fn.delegationSelector = isDelegated ? handler : null
+ fn.callable = callable
+ fn.oneOff = oneOff
+ fn.uidEvent = uid
+ handlers[uid] = fn
+
+ element.addEventListener(typeEvent, fn, isDelegated)
+}
+
+function removeHandler(element, events, typeEvent, handler, delegationSelector) {
+ const fn = findHandler(events[typeEvent], handler, delegationSelector)
+
+ if (!fn) {
+ return
+ }
+
+ element.removeEventListener(typeEvent, fn, Boolean(delegationSelector))
+ delete events[typeEvent][fn.uidEvent]
+}
+
+function removeNamespacedHandlers(element, events, typeEvent, namespace) {
+ const storeElementEvent = events[typeEvent] || {}
+
+ for (const handlerKey of Object.keys(storeElementEvent)) {
+ if (handlerKey.includes(namespace)) {
+ const event = storeElementEvent[handlerKey]
+ removeHandler(element, events, typeEvent, event.callable, event.delegationSelector)
+ }
+ }
+}
+
+function getTypeEvent(event) {
+ // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
+ event = event.replace(stripNameRegex, '')
+ return customEvents[event] || event
+}
+
+const EventHandler = {
+ on(element, event, handler, delegationFunction) {
+ addHandler(element, event, handler, delegationFunction, false)
+ },
+
+ one(element, event, handler, delegationFunction) {
+ addHandler(element, event, handler, delegationFunction, true)
+ },
+
+ off(element, originalTypeEvent, handler, delegationFunction) {
+ if (typeof originalTypeEvent !== 'string' || !element) {
+ return
+ }
+
+ const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
+ const inNamespace = typeEvent !== originalTypeEvent
+ const events = getElementEvents(element)
+ const storeElementEvent = events[typeEvent] || {}
+ const isNamespace = originalTypeEvent.startsWith('.')
+
+ if (typeof callable !== 'undefined') {
+ // Simplest case: handler is passed, remove that listener ONLY.
+ if (!Object.keys(storeElementEvent).length) {
+ return
+ }
+
+ removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null)
+ return
+ }
+
+ if (isNamespace) {
+ for (const elementEvent of Object.keys(events)) {
+ removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1))
+ }
+ }
+
+ for (const keyHandlers of Object.keys(storeElementEvent)) {
+ const handlerKey = keyHandlers.replace(stripUidRegex, '')
+
+ if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
+ const event = storeElementEvent[keyHandlers]
+ removeHandler(element, events, typeEvent, event.callable, event.delegationSelector)
+ }
+ }
+ },
+
+ trigger(element, event, args) {
+ if (typeof event !== 'string' || !element) {
+ return null
+ }
+
+ const $ = getjQuery()
+ const typeEvent = getTypeEvent(event)
+ const inNamespace = event !== typeEvent
+
+ let jQueryEvent = null
+ let bubbles = true
+ let nativeDispatch = true
+ let defaultPrevented = false
+
+ if (inNamespace && $) {
+ jQueryEvent = $.Event(event, args)
+
+ $(element).trigger(jQueryEvent)
+ bubbles = !jQueryEvent.isPropagationStopped()
+ nativeDispatch = !jQueryEvent.isImmediatePropagationStopped()
+ defaultPrevented = jQueryEvent.isDefaultPrevented()
+ }
+
+ let evt = new Event(event, { bubbles, cancelable: true })
+ evt = hydrateObj(evt, args)
+
+ if (defaultPrevented) {
+ evt.preventDefault()
+ }
+
+ if (nativeDispatch) {
+ element.dispatchEvent(evt)
+ }
+
+ if (evt.defaultPrevented && jQueryEvent) {
+ jQueryEvent.preventDefault()
+ }
+
+ return evt
+ }
+}
+
+function hydrateObj(obj, meta) {
+ for (const [key, value] of Object.entries(meta || {})) {
+ try {
+ obj[key] = value
+ } catch {
+ Object.defineProperty(obj, key, {
+ configurable: true,
+ get() {
+ return value
+ }
+ })
+ }
+ }
+
+ return obj
+}
+
+export default EventHandler
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/dom/manipulator.js b/cao_sunyata/static/libs/bootstrap/js/src/dom/manipulator.js
new file mode 100644
index 0000000..38ecfe4
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/dom/manipulator.js
@@ -0,0 +1,71 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): dom/manipulator.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+function normalizeData(value) {
+ if (value === 'true') {
+ return true
+ }
+
+ if (value === 'false') {
+ return false
+ }
+
+ if (value === Number(value).toString()) {
+ return Number(value)
+ }
+
+ if (value === '' || value === 'null') {
+ return null
+ }
+
+ if (typeof value !== 'string') {
+ return value
+ }
+
+ try {
+ return JSON.parse(decodeURIComponent(value))
+ } catch {
+ return value
+ }
+}
+
+function normalizeDataKey(key) {
+ return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`)
+}
+
+const Manipulator = {
+ setDataAttribute(element, key, value) {
+ element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value)
+ },
+
+ removeDataAttribute(element, key) {
+ element.removeAttribute(`data-bs-${normalizeDataKey(key)}`)
+ },
+
+ getDataAttributes(element) {
+ if (!element) {
+ return {}
+ }
+
+ const attributes = {}
+ const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'))
+
+ for (const key of bsKeys) {
+ let pureKey = key.replace(/^bs/, '')
+ pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length)
+ attributes[pureKey] = normalizeData(element.dataset[key])
+ }
+
+ return attributes
+ },
+
+ getDataAttribute(element, key) {
+ return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`))
+ }
+}
+
+export default Manipulator
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/dom/selector-engine.js b/cao_sunyata/static/libs/bootstrap/js/src/dom/selector-engine.js
new file mode 100644
index 0000000..1ba104f
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/dom/selector-engine.js
@@ -0,0 +1,83 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): dom/selector-engine.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { isDisabled, isVisible } from '../util/index'
+
+/**
+ * Constants
+ */
+
+const SelectorEngine = {
+ find(selector, element = document.documentElement) {
+ return [].concat(...Element.prototype.querySelectorAll.call(element, selector))
+ },
+
+ findOne(selector, element = document.documentElement) {
+ return Element.prototype.querySelector.call(element, selector)
+ },
+
+ children(element, selector) {
+ return [].concat(...element.children).filter(child => child.matches(selector))
+ },
+
+ parents(element, selector) {
+ const parents = []
+ let ancestor = element.parentNode.closest(selector)
+
+ while (ancestor) {
+ parents.push(ancestor)
+ ancestor = ancestor.parentNode.closest(selector)
+ }
+
+ return parents
+ },
+
+ prev(element, selector) {
+ let previous = element.previousElementSibling
+
+ while (previous) {
+ if (previous.matches(selector)) {
+ return [previous]
+ }
+
+ previous = previous.previousElementSibling
+ }
+
+ return []
+ },
+ // TODO: this is now unused; remove later along with prev()
+ next(element, selector) {
+ let next = element.nextElementSibling
+
+ while (next) {
+ if (next.matches(selector)) {
+ return [next]
+ }
+
+ next = next.nextElementSibling
+ }
+
+ return []
+ },
+
+ focusableChildren(element) {
+ const focusables = [
+ 'a',
+ 'button',
+ 'input',
+ 'textarea',
+ 'select',
+ 'details',
+ '[tabindex]',
+ '[contenteditable="true"]'
+ ].map(selector => `${selector}:not([tabindex^="-"])`).join(',')
+
+ return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el))
+ }
+}
+
+export default SelectorEngine
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/dropdown.js b/cao_sunyata/static/libs/bootstrap/js/src/dropdown.js
new file mode 100644
index 0000000..9596baa
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/dropdown.js
@@ -0,0 +1,454 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): dropdown.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import * as Popper from '@popperjs/core'
+import {
+ defineJQueryPlugin,
+ getElement,
+ getNextActiveElement,
+ isDisabled,
+ isElement,
+ isRTL,
+ isVisible,
+ noop
+} from './util/index'
+import EventHandler from './dom/event-handler'
+import Manipulator from './dom/manipulator'
+import SelectorEngine from './dom/selector-engine'
+import BaseComponent from './base-component'
+
+/**
+ * Constants
+ */
+
+const NAME = 'dropdown'
+const DATA_KEY = 'bs.dropdown'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+
+const ESCAPE_KEY = 'Escape'
+const TAB_KEY = 'Tab'
+const ARROW_UP_KEY = 'ArrowUp'
+const ARROW_DOWN_KEY = 'ArrowDown'
+const RIGHT_MOUSE_BUTTON = 2 // MouseEvent.button value for the secondary button, usually the right button
+
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY}${DATA_API_KEY}`
+const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY}${DATA_API_KEY}`
+
+const CLASS_NAME_SHOW = 'show'
+const CLASS_NAME_DROPUP = 'dropup'
+const CLASS_NAME_DROPEND = 'dropend'
+const CLASS_NAME_DROPSTART = 'dropstart'
+const CLASS_NAME_DROPUP_CENTER = 'dropup-center'
+const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center'
+
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)'
+const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE}.${CLASS_NAME_SHOW}`
+const SELECTOR_MENU = '.dropdown-menu'
+const SELECTOR_NAVBAR = '.navbar'
+const SELECTOR_NAVBAR_NAV = '.navbar-nav'
+const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
+
+const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start'
+const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end'
+const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start'
+const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end'
+const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start'
+const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start'
+const PLACEMENT_TOPCENTER = 'top'
+const PLACEMENT_BOTTOMCENTER = 'bottom'
+
+const Default = {
+ autoClose: true,
+ boundary: 'clippingParents',
+ display: 'dynamic',
+ offset: [0, 2],
+ popperConfig: null,
+ reference: 'toggle'
+}
+
+const DefaultType = {
+ autoClose: '(boolean|string)',
+ boundary: '(string|element)',
+ display: 'string',
+ offset: '(array|string|function)',
+ popperConfig: '(null|object|function)',
+ reference: '(string|element|object)'
+}
+
+/**
+ * Class definition
+ */
+
+class Dropdown extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._popper = null
+ this._parent = this._element.parentNode // dropdown wrapper
+ // todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/
+ this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] ||
+ SelectorEngine.prev(this._element, SELECTOR_MENU)[0] ||
+ SelectorEngine.findOne(SELECTOR_MENU, this._parent)
+ this._inNavbar = this._detectNavbar()
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ toggle() {
+ return this._isShown() ? this.hide() : this.show()
+ }
+
+ show() {
+ if (isDisabled(this._element) || this._isShown()) {
+ return
+ }
+
+ const relatedTarget = {
+ relatedTarget: this._element
+ }
+
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, relatedTarget)
+
+ if (showEvent.defaultPrevented) {
+ return
+ }
+
+ this._createPopper()
+
+ // If this is a touch-enabled device we add extra
+ // empty mouseover listeners to the body's immediate children;
+ // only needed because of broken event delegation on iOS
+ // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
+ if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
+ for (const element of [].concat(...document.body.children)) {
+ EventHandler.on(element, 'mouseover', noop)
+ }
+ }
+
+ this._element.focus()
+ this._element.setAttribute('aria-expanded', true)
+
+ this._menu.classList.add(CLASS_NAME_SHOW)
+ this._element.classList.add(CLASS_NAME_SHOW)
+ EventHandler.trigger(this._element, EVENT_SHOWN, relatedTarget)
+ }
+
+ hide() {
+ if (isDisabled(this._element) || !this._isShown()) {
+ return
+ }
+
+ const relatedTarget = {
+ relatedTarget: this._element
+ }
+
+ this._completeHide(relatedTarget)
+ }
+
+ dispose() {
+ if (this._popper) {
+ this._popper.destroy()
+ }
+
+ super.dispose()
+ }
+
+ update() {
+ this._inNavbar = this._detectNavbar()
+ if (this._popper) {
+ this._popper.update()
+ }
+ }
+
+ // Private
+ _completeHide(relatedTarget) {
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE, relatedTarget)
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ // If this is a touch-enabled device we remove the extra
+ // empty mouseover listeners we added for iOS support
+ if ('ontouchstart' in document.documentElement) {
+ for (const element of [].concat(...document.body.children)) {
+ EventHandler.off(element, 'mouseover', noop)
+ }
+ }
+
+ if (this._popper) {
+ this._popper.destroy()
+ }
+
+ this._menu.classList.remove(CLASS_NAME_SHOW)
+ this._element.classList.remove(CLASS_NAME_SHOW)
+ this._element.setAttribute('aria-expanded', 'false')
+ Manipulator.removeDataAttribute(this._menu, 'popper')
+ EventHandler.trigger(this._element, EVENT_HIDDEN, relatedTarget)
+ }
+
+ _getConfig(config) {
+ config = super._getConfig(config)
+
+ if (typeof config.reference === 'object' && !isElement(config.reference) &&
+ typeof config.reference.getBoundingClientRect !== 'function'
+ ) {
+ // Popper virtual elements require a getBoundingClientRect method
+ throw new TypeError(`${NAME.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`)
+ }
+
+ return config
+ }
+
+ _createPopper() {
+ if (typeof Popper === 'undefined') {
+ throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)')
+ }
+
+ let referenceElement = this._element
+
+ if (this._config.reference === 'parent') {
+ referenceElement = this._parent
+ } else if (isElement(this._config.reference)) {
+ referenceElement = getElement(this._config.reference)
+ } else if (typeof this._config.reference === 'object') {
+ referenceElement = this._config.reference
+ }
+
+ const popperConfig = this._getPopperConfig()
+ this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig)
+ }
+
+ _isShown() {
+ return this._menu.classList.contains(CLASS_NAME_SHOW)
+ }
+
+ _getPlacement() {
+ const parentDropdown = this._parent
+
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
+ return PLACEMENT_RIGHT
+ }
+
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
+ return PLACEMENT_LEFT
+ }
+
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
+ return PLACEMENT_TOPCENTER
+ }
+
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
+ return PLACEMENT_BOTTOMCENTER
+ }
+
+ // We need to trim the value because custom properties can also include spaces
+ const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'
+
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
+ return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP
+ }
+
+ return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM
+ }
+
+ _detectNavbar() {
+ return this._element.closest(SELECTOR_NAVBAR) !== null
+ }
+
+ _getOffset() {
+ const { offset } = this._config
+
+ if (typeof offset === 'string') {
+ return offset.split(',').map(value => Number.parseInt(value, 10))
+ }
+
+ if (typeof offset === 'function') {
+ return popperData => offset(popperData, this._element)
+ }
+
+ return offset
+ }
+
+ _getPopperConfig() {
+ const defaultBsPopperConfig = {
+ placement: this._getPlacement(),
+ modifiers: [{
+ name: 'preventOverflow',
+ options: {
+ boundary: this._config.boundary
+ }
+ },
+ {
+ name: 'offset',
+ options: {
+ offset: this._getOffset()
+ }
+ }]
+ }
+
+ // Disable Popper if we have a static display or Dropdown is in Navbar
+ if (this._inNavbar || this._config.display === 'static') {
+ Manipulator.setDataAttribute(this._menu, 'popper', 'static') // todo:v6 remove
+ defaultBsPopperConfig.modifiers = [{
+ name: 'applyStyles',
+ enabled: false
+ }]
+ }
+
+ return {
+ ...defaultBsPopperConfig,
+ ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
+ }
+ }
+
+ _selectMenuItem({ key, target }) {
+ const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element))
+
+ if (!items.length) {
+ return
+ }
+
+ // if target isn't included in items (e.g. when expanding the dropdown)
+ // allow cycling to get the last item in case key equals ARROW_UP_KEY
+ getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus()
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Dropdown.getOrCreateInstance(this, config)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ })
+ }
+
+ static clearMenus(event) {
+ if (event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY)) {
+ return
+ }
+
+ const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN)
+
+ for (const toggle of openToggles) {
+ const context = Dropdown.getInstance(toggle)
+ if (!context || context._config.autoClose === false) {
+ continue
+ }
+
+ const composedPath = event.composedPath()
+ const isMenuTarget = composedPath.includes(context._menu)
+ if (
+ composedPath.includes(context._element) ||
+ (context._config.autoClose === 'inside' && !isMenuTarget) ||
+ (context._config.autoClose === 'outside' && isMenuTarget)
+ ) {
+ continue
+ }
+
+ // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
+ if (context._menu.contains(event.target) && ((event.type === 'keyup' && event.key === TAB_KEY) || /input|select|option|textarea|form/i.test(event.target.tagName))) {
+ continue
+ }
+
+ const relatedTarget = { relatedTarget: context._element }
+
+ if (event.type === 'click') {
+ relatedTarget.clickEvent = event
+ }
+
+ context._completeHide(relatedTarget)
+ }
+ }
+
+ static dataApiKeydownHandler(event) {
+ // If not an UP | DOWN | ESCAPE key => not a dropdown command
+ // If input/textarea && if key is other than ESCAPE => not a dropdown command
+
+ const isInput = /input|textarea/i.test(event.target.tagName)
+ const isEscapeEvent = event.key === ESCAPE_KEY
+ const isUpOrDownEvent = [ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key)
+
+ if (!isUpOrDownEvent && !isEscapeEvent) {
+ return
+ }
+
+ if (isInput && !isEscapeEvent) {
+ return
+ }
+
+ event.preventDefault()
+
+ // todo: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.2/forms/input-group/
+ const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE) ?
+ this :
+ (SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0] ||
+ SelectorEngine.next(this, SELECTOR_DATA_TOGGLE)[0] ||
+ SelectorEngine.findOne(SELECTOR_DATA_TOGGLE, event.delegateTarget.parentNode))
+
+ const instance = Dropdown.getOrCreateInstance(getToggleButton)
+
+ if (isUpOrDownEvent) {
+ event.stopPropagation()
+ instance.show()
+ instance._selectMenuItem(event)
+ return
+ }
+
+ if (instance._isShown()) { // else is escape and we check if it is shown
+ event.stopPropagation()
+ instance.hide()
+ getToggleButton.focus()
+ }
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE, Dropdown.dataApiKeydownHandler)
+EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler)
+EventHandler.on(document, EVENT_CLICK_DATA_API, Dropdown.clearMenus)
+EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus)
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+ event.preventDefault()
+ Dropdown.getOrCreateInstance(this).toggle()
+})
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Dropdown)
+
+export default Dropdown
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/modal.js b/cao_sunyata/static/libs/bootstrap/js/src/modal.js
new file mode 100644
index 0000000..26c7e8c
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/modal.js
@@ -0,0 +1,377 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): modal.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin, getElementFromSelector, isRTL, isVisible, reflow } from './util/index'
+import EventHandler from './dom/event-handler'
+import SelectorEngine from './dom/selector-engine'
+import ScrollBarHelper from './util/scrollbar'
+import BaseComponent from './base-component'
+import Backdrop from './util/backdrop'
+import FocusTrap from './util/focustrap'
+import { enableDismissTrigger } from './util/component-functions'
+
+/**
+ * Constants
+ */
+
+const NAME = 'modal'
+const DATA_KEY = 'bs.modal'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const ESCAPE_KEY = 'Escape'
+
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_RESIZE = `resize${EVENT_KEY}`
+const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`
+const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY}`
+const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+
+const CLASS_NAME_OPEN = 'modal-open'
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_SHOW = 'show'
+const CLASS_NAME_STATIC = 'modal-static'
+
+const OPEN_SELECTOR = '.modal.show'
+const SELECTOR_DIALOG = '.modal-dialog'
+const SELECTOR_MODAL_BODY = '.modal-body'
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="modal"]'
+
+const Default = {
+ backdrop: true,
+ focus: true,
+ keyboard: true
+}
+
+const DefaultType = {
+ backdrop: '(boolean|string)',
+ focus: 'boolean',
+ keyboard: 'boolean'
+}
+
+/**
+ * Class definition
+ */
+
+class Modal extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element)
+ this._backdrop = this._initializeBackDrop()
+ this._focustrap = this._initializeFocusTrap()
+ this._isShown = false
+ this._isTransitioning = false
+ this._scrollBar = new ScrollBarHelper()
+
+ this._addEventListeners()
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ toggle(relatedTarget) {
+ return this._isShown ? this.hide() : this.show(relatedTarget)
+ }
+
+ show(relatedTarget) {
+ if (this._isShown || this._isTransitioning) {
+ return
+ }
+
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, {
+ relatedTarget
+ })
+
+ if (showEvent.defaultPrevented) {
+ return
+ }
+
+ this._isShown = true
+ this._isTransitioning = true
+
+ this._scrollBar.hide()
+
+ document.body.classList.add(CLASS_NAME_OPEN)
+
+ this._adjustDialog()
+
+ this._backdrop.show(() => this._showElement(relatedTarget))
+ }
+
+ hide() {
+ if (!this._isShown || this._isTransitioning) {
+ return
+ }
+
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE)
+
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ this._isShown = false
+ this._isTransitioning = true
+ this._focustrap.deactivate()
+
+ this._element.classList.remove(CLASS_NAME_SHOW)
+
+ this._queueCallback(() => this._hideModal(), this._element, this._isAnimated())
+ }
+
+ dispose() {
+ for (const htmlElement of [window, this._dialog]) {
+ EventHandler.off(htmlElement, EVENT_KEY)
+ }
+
+ this._backdrop.dispose()
+ this._focustrap.deactivate()
+ super.dispose()
+ }
+
+ handleUpdate() {
+ this._adjustDialog()
+ }
+
+ // Private
+ _initializeBackDrop() {
+ return new Backdrop({
+ isVisible: Boolean(this._config.backdrop), // 'static' option will be translated to true, and booleans will keep their value,
+ isAnimated: this._isAnimated()
+ })
+ }
+
+ _initializeFocusTrap() {
+ return new FocusTrap({
+ trapElement: this._element
+ })
+ }
+
+ _showElement(relatedTarget) {
+ // try to append dynamic modal
+ if (!document.body.contains(this._element)) {
+ document.body.append(this._element)
+ }
+
+ this._element.style.display = 'block'
+ this._element.removeAttribute('aria-hidden')
+ this._element.setAttribute('aria-modal', true)
+ this._element.setAttribute('role', 'dialog')
+ this._element.scrollTop = 0
+
+ const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog)
+ if (modalBody) {
+ modalBody.scrollTop = 0
+ }
+
+ reflow(this._element)
+
+ this._element.classList.add(CLASS_NAME_SHOW)
+
+ const transitionComplete = () => {
+ if (this._config.focus) {
+ this._focustrap.activate()
+ }
+
+ this._isTransitioning = false
+ EventHandler.trigger(this._element, EVENT_SHOWN, {
+ relatedTarget
+ })
+ }
+
+ this._queueCallback(transitionComplete, this._dialog, this._isAnimated())
+ }
+
+ _addEventListeners() {
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
+ if (event.key !== ESCAPE_KEY) {
+ return
+ }
+
+ if (this._config.keyboard) {
+ event.preventDefault()
+ this.hide()
+ return
+ }
+
+ this._triggerBackdropTransition()
+ })
+
+ EventHandler.on(window, EVENT_RESIZE, () => {
+ if (this._isShown && !this._isTransitioning) {
+ this._adjustDialog()
+ }
+ })
+
+ EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {
+ // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
+ EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {
+ if (this._element !== event.target || this._element !== event2.target) {
+ return
+ }
+
+ if (this._config.backdrop === 'static') {
+ this._triggerBackdropTransition()
+ return
+ }
+
+ if (this._config.backdrop) {
+ this.hide()
+ }
+ })
+ })
+ }
+
+ _hideModal() {
+ this._element.style.display = 'none'
+ this._element.setAttribute('aria-hidden', true)
+ this._element.removeAttribute('aria-modal')
+ this._element.removeAttribute('role')
+ this._isTransitioning = false
+
+ this._backdrop.hide(() => {
+ document.body.classList.remove(CLASS_NAME_OPEN)
+ this._resetAdjustments()
+ this._scrollBar.reset()
+ EventHandler.trigger(this._element, EVENT_HIDDEN)
+ })
+ }
+
+ _isAnimated() {
+ return this._element.classList.contains(CLASS_NAME_FADE)
+ }
+
+ _triggerBackdropTransition() {
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED)
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight
+ const initialOverflowY = this._element.style.overflowY
+ // return if the following background transition hasn't yet completed
+ if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
+ return
+ }
+
+ if (!isModalOverflowing) {
+ this._element.style.overflowY = 'hidden'
+ }
+
+ this._element.classList.add(CLASS_NAME_STATIC)
+ this._queueCallback(() => {
+ this._element.classList.remove(CLASS_NAME_STATIC)
+ this._queueCallback(() => {
+ this._element.style.overflowY = initialOverflowY
+ }, this._dialog)
+ }, this._dialog)
+
+ this._element.focus()
+ }
+
+ /**
+ * The following methods are used to handle overflowing modals
+ */
+
+ _adjustDialog() {
+ const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight
+ const scrollbarWidth = this._scrollBar.getWidth()
+ const isBodyOverflowing = scrollbarWidth > 0
+
+ if (isBodyOverflowing && !isModalOverflowing) {
+ const property = isRTL() ? 'paddingLeft' : 'paddingRight'
+ this._element.style[property] = `${scrollbarWidth}px`
+ }
+
+ if (!isBodyOverflowing && isModalOverflowing) {
+ const property = isRTL() ? 'paddingRight' : 'paddingLeft'
+ this._element.style[property] = `${scrollbarWidth}px`
+ }
+ }
+
+ _resetAdjustments() {
+ this._element.style.paddingLeft = ''
+ this._element.style.paddingRight = ''
+ }
+
+ // Static
+ static jQueryInterface(config, relatedTarget) {
+ return this.each(function () {
+ const data = Modal.getOrCreateInstance(this, config)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config](relatedTarget)
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+ const target = getElementFromSelector(this)
+
+ if (['A', 'AREA'].includes(this.tagName)) {
+ event.preventDefault()
+ }
+
+ EventHandler.one(target, EVENT_SHOW, showEvent => {
+ if (showEvent.defaultPrevented) {
+ // only register focus restorer if modal will actually get shown
+ return
+ }
+
+ EventHandler.one(target, EVENT_HIDDEN, () => {
+ if (isVisible(this)) {
+ this.focus()
+ }
+ })
+ })
+
+ // avoid conflict when clicking modal toggler while another one is open
+ const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR)
+ if (alreadyOpen) {
+ Modal.getInstance(alreadyOpen).hide()
+ }
+
+ const data = Modal.getOrCreateInstance(target)
+
+ data.toggle(this)
+})
+
+enableDismissTrigger(Modal)
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Modal)
+
+export default Modal
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/offcanvas.js b/cao_sunyata/static/libs/bootstrap/js/src/offcanvas.js
new file mode 100644
index 0000000..7dd06fd
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/offcanvas.js
@@ -0,0 +1,283 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): offcanvas.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import {
+ defineJQueryPlugin,
+ getElementFromSelector,
+ isDisabled,
+ isVisible
+} from './util/index'
+import ScrollBarHelper from './util/scrollbar'
+import EventHandler from './dom/event-handler'
+import BaseComponent from './base-component'
+import SelectorEngine from './dom/selector-engine'
+import Backdrop from './util/backdrop'
+import FocusTrap from './util/focustrap'
+import { enableDismissTrigger } from './util/component-functions'
+
+/**
+ * Constants
+ */
+
+const NAME = 'offcanvas'
+const DATA_KEY = 'bs.offcanvas'
+const EVENT_KEY = `.${DATA_KEY}`
+const DATA_API_KEY = '.data-api'
+const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`
+const ESCAPE_KEY = 'Escape'
+
+const CLASS_NAME_SHOW = 'show'
+const CLASS_NAME_SHOWING = 'showing'
+const CLASS_NAME_HIDING = 'hiding'
+const CLASS_NAME_BACKDROP = 'offcanvas-backdrop'
+const OPEN_SELECTOR = '.offcanvas.show'
+
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_RESIZE = `resize${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
+const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`
+
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="offcanvas"]'
+
+const Default = {
+ backdrop: true,
+ keyboard: true,
+ scroll: false
+}
+
+const DefaultType = {
+ backdrop: '(boolean|string)',
+ keyboard: 'boolean',
+ scroll: 'boolean'
+}
+
+/**
+ * Class definition
+ */
+
+class Offcanvas extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._isShown = false
+ this._backdrop = this._initializeBackDrop()
+ this._focustrap = this._initializeFocusTrap()
+ this._addEventListeners()
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ toggle(relatedTarget) {
+ return this._isShown ? this.hide() : this.show(relatedTarget)
+ }
+
+ show(relatedTarget) {
+ if (this._isShown) {
+ return
+ }
+
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, { relatedTarget })
+
+ if (showEvent.defaultPrevented) {
+ return
+ }
+
+ this._isShown = true
+ this._backdrop.show()
+
+ if (!this._config.scroll) {
+ new ScrollBarHelper().hide()
+ }
+
+ this._element.setAttribute('aria-modal', true)
+ this._element.setAttribute('role', 'dialog')
+ this._element.classList.add(CLASS_NAME_SHOWING)
+
+ const completeCallBack = () => {
+ if (!this._config.scroll || this._config.backdrop) {
+ this._focustrap.activate()
+ }
+
+ this._element.classList.add(CLASS_NAME_SHOW)
+ this._element.classList.remove(CLASS_NAME_SHOWING)
+ EventHandler.trigger(this._element, EVENT_SHOWN, { relatedTarget })
+ }
+
+ this._queueCallback(completeCallBack, this._element, true)
+ }
+
+ hide() {
+ if (!this._isShown) {
+ return
+ }
+
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE)
+
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ this._focustrap.deactivate()
+ this._element.blur()
+ this._isShown = false
+ this._element.classList.add(CLASS_NAME_HIDING)
+ this._backdrop.hide()
+
+ const completeCallback = () => {
+ this._element.classList.remove(CLASS_NAME_SHOW, CLASS_NAME_HIDING)
+ this._element.removeAttribute('aria-modal')
+ this._element.removeAttribute('role')
+
+ if (!this._config.scroll) {
+ new ScrollBarHelper().reset()
+ }
+
+ EventHandler.trigger(this._element, EVENT_HIDDEN)
+ }
+
+ this._queueCallback(completeCallback, this._element, true)
+ }
+
+ dispose() {
+ this._backdrop.dispose()
+ this._focustrap.deactivate()
+ super.dispose()
+ }
+
+ // Private
+ _initializeBackDrop() {
+ const clickCallback = () => {
+ if (this._config.backdrop === 'static') {
+ EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED)
+ return
+ }
+
+ this.hide()
+ }
+
+ // 'static' option will be translated to true, and booleans will keep their value
+ const isVisible = Boolean(this._config.backdrop)
+
+ return new Backdrop({
+ className: CLASS_NAME_BACKDROP,
+ isVisible,
+ isAnimated: true,
+ rootElement: this._element.parentNode,
+ clickCallback: isVisible ? clickCallback : null
+ })
+ }
+
+ _initializeFocusTrap() {
+ return new FocusTrap({
+ trapElement: this._element
+ })
+ }
+
+ _addEventListeners() {
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
+ if (event.key !== ESCAPE_KEY) {
+ return
+ }
+
+ if (!this._config.keyboard) {
+ EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED)
+ return
+ }
+
+ this.hide()
+ })
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Offcanvas.getOrCreateInstance(this, config)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config](this)
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+ const target = getElementFromSelector(this)
+
+ if (['A', 'AREA'].includes(this.tagName)) {
+ event.preventDefault()
+ }
+
+ if (isDisabled(this)) {
+ return
+ }
+
+ EventHandler.one(target, EVENT_HIDDEN, () => {
+ // focus on trigger when it is closed
+ if (isVisible(this)) {
+ this.focus()
+ }
+ })
+
+ // avoid conflict when clicking a toggler of an offcanvas, while another is open
+ const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR)
+ if (alreadyOpen && alreadyOpen !== target) {
+ Offcanvas.getInstance(alreadyOpen).hide()
+ }
+
+ const data = Offcanvas.getOrCreateInstance(target)
+ data.toggle(this)
+})
+
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+ for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {
+ Offcanvas.getOrCreateInstance(selector).show()
+ }
+})
+
+EventHandler.on(window, EVENT_RESIZE, () => {
+ for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {
+ if (getComputedStyle(element).position !== 'fixed') {
+ Offcanvas.getOrCreateInstance(element).hide()
+ }
+ }
+})
+
+enableDismissTrigger(Offcanvas)
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Offcanvas)
+
+export default Offcanvas
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/popover.js b/cao_sunyata/static/libs/bootstrap/js/src/popover.js
new file mode 100644
index 0000000..1b09dd4
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/popover.js
@@ -0,0 +1,97 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): popover.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin } from './util/index'
+import Tooltip from './tooltip'
+
+/**
+ * Constants
+ */
+
+const NAME = 'popover'
+
+const SELECTOR_TITLE = '.popover-header'
+const SELECTOR_CONTENT = '.popover-body'
+
+const Default = {
+ ...Tooltip.Default,
+ content: '',
+ offset: [0, 8],
+ placement: 'right',
+ template: '' +
+ '
' +
+ '' +
+ '
' +
+ '
and markup a parent is the previous sibling of any nav ancestor
+ for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
+ item.classList.add(CLASS_NAME_ACTIVE)
+ }
+ }
+ }
+
+ _clearActiveClass(parent) {
+ parent.classList.remove(CLASS_NAME_ACTIVE)
+
+ const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE}`, parent)
+ for (const node of activeNodes) {
+ node.classList.remove(CLASS_NAME_ACTIVE)
+ }
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = ScrollSpy.getOrCreateInstance(this, config)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+ for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
+ ScrollSpy.getOrCreateInstance(spy)
+ }
+})
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(ScrollSpy)
+
+export default ScrollSpy
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/tab.js b/cao_sunyata/static/libs/bootstrap/js/src/tab.js
new file mode 100644
index 0000000..8dc4644
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/tab.js
@@ -0,0 +1,305 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): tab.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin, getElementFromSelector, getNextActiveElement, isDisabled } from './util/index'
+import EventHandler from './dom/event-handler'
+import SelectorEngine from './dom/selector-engine'
+import BaseComponent from './base-component'
+
+/**
+ * Constants
+ */
+
+const NAME = 'tab'
+const DATA_KEY = 'bs.tab'
+const EVENT_KEY = `.${DATA_KEY}`
+
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+const EVENT_CLICK_DATA_API = `click${EVENT_KEY}`
+const EVENT_KEYDOWN = `keydown${EVENT_KEY}`
+const EVENT_LOAD_DATA_API = `load${EVENT_KEY}`
+
+const ARROW_LEFT_KEY = 'ArrowLeft'
+const ARROW_RIGHT_KEY = 'ArrowRight'
+const ARROW_UP_KEY = 'ArrowUp'
+const ARROW_DOWN_KEY = 'ArrowDown'
+
+const CLASS_NAME_ACTIVE = 'active'
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_SHOW = 'show'
+const CLASS_DROPDOWN = 'dropdown'
+
+const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'
+const SELECTOR_DROPDOWN_MENU = '.dropdown-menu'
+const NOT_SELECTOR_DROPDOWN_TOGGLE = ':not(.dropdown-toggle)'
+
+const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]'
+const SELECTOR_OUTER = '.nav-item, .list-group-item'
+const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`
+const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]' // todo:v6: could be only `tab`
+const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`
+
+const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`
+
+/**
+ * Class definition
+ */
+
+class Tab extends BaseComponent {
+ constructor(element) {
+ super(element)
+ this._parent = this._element.closest(SELECTOR_TAB_PANEL)
+
+ if (!this._parent) {
+ return
+ // todo: should Throw exception on v6
+ // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
+ }
+
+ // Set up initial aria attributes
+ this._setInitialAttributes(this._parent, this._getChildren())
+
+ EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event))
+ }
+
+ // Getters
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ show() { // Shows this elem and deactivate the active sibling if exists
+ const innerElem = this._element
+ if (this._elemIsActive(innerElem)) {
+ return
+ }
+
+ // Search for active tab on same parent to deactivate it
+ const active = this._getActiveElem()
+
+ const hideEvent = active ?
+ EventHandler.trigger(active, EVENT_HIDE, { relatedTarget: innerElem }) :
+ null
+
+ const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW, { relatedTarget: active })
+
+ if (showEvent.defaultPrevented || (hideEvent && hideEvent.defaultPrevented)) {
+ return
+ }
+
+ this._deactivate(active, innerElem)
+ this._activate(innerElem, active)
+ }
+
+ // Private
+ _activate(element, relatedElem) {
+ if (!element) {
+ return
+ }
+
+ element.classList.add(CLASS_NAME_ACTIVE)
+
+ this._activate(getElementFromSelector(element)) // Search and activate/show the proper section
+
+ const complete = () => {
+ if (element.getAttribute('role') !== 'tab') {
+ element.classList.add(CLASS_NAME_SHOW)
+ return
+ }
+
+ element.removeAttribute('tabindex')
+ element.setAttribute('aria-selected', true)
+ this._toggleDropDown(element, true)
+ EventHandler.trigger(element, EVENT_SHOWN, {
+ relatedTarget: relatedElem
+ })
+ }
+
+ this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE))
+ }
+
+ _deactivate(element, relatedElem) {
+ if (!element) {
+ return
+ }
+
+ element.classList.remove(CLASS_NAME_ACTIVE)
+ element.blur()
+
+ this._deactivate(getElementFromSelector(element)) // Search and deactivate the shown section too
+
+ const complete = () => {
+ if (element.getAttribute('role') !== 'tab') {
+ element.classList.remove(CLASS_NAME_SHOW)
+ return
+ }
+
+ element.setAttribute('aria-selected', false)
+ element.setAttribute('tabindex', '-1')
+ this._toggleDropDown(element, false)
+ EventHandler.trigger(element, EVENT_HIDDEN, { relatedTarget: relatedElem })
+ }
+
+ this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE))
+ }
+
+ _keydown(event) {
+ if (!([ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key))) {
+ return
+ }
+
+ event.stopPropagation()// stopPropagation/preventDefault both added to support up/down keys without scrolling the page
+ event.preventDefault()
+ const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key)
+ const nextActiveElement = getNextActiveElement(this._getChildren().filter(element => !isDisabled(element)), event.target, isNext, true)
+
+ if (nextActiveElement) {
+ nextActiveElement.focus({ preventScroll: true })
+ Tab.getOrCreateInstance(nextActiveElement).show()
+ }
+ }
+
+ _getChildren() { // collection of inner elements
+ return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent)
+ }
+
+ _getActiveElem() {
+ return this._getChildren().find(child => this._elemIsActive(child)) || null
+ }
+
+ _setInitialAttributes(parent, children) {
+ this._setAttributeIfNotExists(parent, 'role', 'tablist')
+
+ for (const child of children) {
+ this._setInitialAttributesOnChild(child)
+ }
+ }
+
+ _setInitialAttributesOnChild(child) {
+ child = this._getInnerElement(child)
+ const isActive = this._elemIsActive(child)
+ const outerElem = this._getOuterElement(child)
+ child.setAttribute('aria-selected', isActive)
+
+ if (outerElem !== child) {
+ this._setAttributeIfNotExists(outerElem, 'role', 'presentation')
+ }
+
+ if (!isActive) {
+ child.setAttribute('tabindex', '-1')
+ }
+
+ this._setAttributeIfNotExists(child, 'role', 'tab')
+
+ // set attributes to the related panel too
+ this._setInitialAttributesOnTargetPanel(child)
+ }
+
+ _setInitialAttributesOnTargetPanel(child) {
+ const target = getElementFromSelector(child)
+
+ if (!target) {
+ return
+ }
+
+ this._setAttributeIfNotExists(target, 'role', 'tabpanel')
+
+ if (child.id) {
+ this._setAttributeIfNotExists(target, 'aria-labelledby', `#${child.id}`)
+ }
+ }
+
+ _toggleDropDown(element, open) {
+ const outerElem = this._getOuterElement(element)
+ if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
+ return
+ }
+
+ const toggle = (selector, className) => {
+ const element = SelectorEngine.findOne(selector, outerElem)
+ if (element) {
+ element.classList.toggle(className, open)
+ }
+ }
+
+ toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE)
+ toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW)
+ outerElem.setAttribute('aria-expanded', open)
+ }
+
+ _setAttributeIfNotExists(element, attribute, value) {
+ if (!element.hasAttribute(attribute)) {
+ element.setAttribute(attribute, value)
+ }
+ }
+
+ _elemIsActive(elem) {
+ return elem.classList.contains(CLASS_NAME_ACTIVE)
+ }
+
+ // Try to get the inner element (usually the .nav-link)
+ _getInnerElement(elem) {
+ return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem)
+ }
+
+ // Try to get the outer element (usually the .nav-item)
+ _getOuterElement(elem) {
+ return elem.closest(SELECTOR_OUTER) || elem
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Tab.getOrCreateInstance(this)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
+ if (['A', 'AREA'].includes(this.tagName)) {
+ event.preventDefault()
+ }
+
+ if (isDisabled(this)) {
+ return
+ }
+
+ Tab.getOrCreateInstance(this).show()
+})
+
+/**
+ * Initialize on focus
+ */
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+ for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
+ Tab.getOrCreateInstance(element)
+ }
+})
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Tab)
+
+export default Tab
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/toast.js b/cao_sunyata/static/libs/bootstrap/js/src/toast.js
new file mode 100644
index 0000000..a7fe775
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/toast.js
@@ -0,0 +1,225 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): toast.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { defineJQueryPlugin, reflow } from './util/index'
+import EventHandler from './dom/event-handler'
+import BaseComponent from './base-component'
+import { enableDismissTrigger } from './util/component-functions'
+
+/**
+ * Constants
+ */
+
+const NAME = 'toast'
+const DATA_KEY = 'bs.toast'
+const EVENT_KEY = `.${DATA_KEY}`
+
+const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`
+const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`
+const EVENT_FOCUSIN = `focusin${EVENT_KEY}`
+const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`
+const EVENT_HIDE = `hide${EVENT_KEY}`
+const EVENT_HIDDEN = `hidden${EVENT_KEY}`
+const EVENT_SHOW = `show${EVENT_KEY}`
+const EVENT_SHOWN = `shown${EVENT_KEY}`
+
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_HIDE = 'hide' // @deprecated - kept here only for backwards compatibility
+const CLASS_NAME_SHOW = 'show'
+const CLASS_NAME_SHOWING = 'showing'
+
+const DefaultType = {
+ animation: 'boolean',
+ autohide: 'boolean',
+ delay: 'number'
+}
+
+const Default = {
+ animation: true,
+ autohide: true,
+ delay: 5000
+}
+
+/**
+ * Class definition
+ */
+
+class Toast extends BaseComponent {
+ constructor(element, config) {
+ super(element, config)
+
+ this._timeout = null
+ this._hasMouseInteraction = false
+ this._hasKeyboardInteraction = false
+ this._setListeners()
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ show() {
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW)
+
+ if (showEvent.defaultPrevented) {
+ return
+ }
+
+ this._clearTimeout()
+
+ if (this._config.animation) {
+ this._element.classList.add(CLASS_NAME_FADE)
+ }
+
+ const complete = () => {
+ this._element.classList.remove(CLASS_NAME_SHOWING)
+ EventHandler.trigger(this._element, EVENT_SHOWN)
+
+ this._maybeScheduleHide()
+ }
+
+ this._element.classList.remove(CLASS_NAME_HIDE) // @deprecated
+ reflow(this._element)
+ this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING)
+
+ this._queueCallback(complete, this._element, this._config.animation)
+ }
+
+ hide() {
+ if (!this.isShown()) {
+ return
+ }
+
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE)
+
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ const complete = () => {
+ this._element.classList.add(CLASS_NAME_HIDE) // @deprecated
+ this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW)
+ EventHandler.trigger(this._element, EVENT_HIDDEN)
+ }
+
+ this._element.classList.add(CLASS_NAME_SHOWING)
+ this._queueCallback(complete, this._element, this._config.animation)
+ }
+
+ dispose() {
+ this._clearTimeout()
+
+ if (this.isShown()) {
+ this._element.classList.remove(CLASS_NAME_SHOW)
+ }
+
+ super.dispose()
+ }
+
+ isShown() {
+ return this._element.classList.contains(CLASS_NAME_SHOW)
+ }
+
+ // Private
+
+ _maybeScheduleHide() {
+ if (!this._config.autohide) {
+ return
+ }
+
+ if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
+ return
+ }
+
+ this._timeout = setTimeout(() => {
+ this.hide()
+ }, this._config.delay)
+ }
+
+ _onInteraction(event, isInteracting) {
+ switch (event.type) {
+ case 'mouseover':
+ case 'mouseout': {
+ this._hasMouseInteraction = isInteracting
+ break
+ }
+
+ case 'focusin':
+ case 'focusout': {
+ this._hasKeyboardInteraction = isInteracting
+ break
+ }
+
+ default: {
+ break
+ }
+ }
+
+ if (isInteracting) {
+ this._clearTimeout()
+ return
+ }
+
+ const nextElement = event.relatedTarget
+ if (this._element === nextElement || this._element.contains(nextElement)) {
+ return
+ }
+
+ this._maybeScheduleHide()
+ }
+
+ _setListeners() {
+ EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true))
+ EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false))
+ EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true))
+ EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false))
+ }
+
+ _clearTimeout() {
+ clearTimeout(this._timeout)
+ this._timeout = null
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Toast.getOrCreateInstance(this, config)
+
+ if (typeof config === 'string') {
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config](this)
+ }
+ })
+ }
+}
+
+/**
+ * Data API implementation
+ */
+
+enableDismissTrigger(Toast)
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Toast)
+
+export default Toast
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/tooltip.js b/cao_sunyata/static/libs/bootstrap/js/src/tooltip.js
new file mode 100644
index 0000000..748a0e1
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/tooltip.js
@@ -0,0 +1,633 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): tooltip.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import * as Popper from '@popperjs/core'
+import { defineJQueryPlugin, findShadowRoot, getElement, getUID, isRTL, noop } from './util/index'
+import { DefaultAllowlist } from './util/sanitizer'
+import EventHandler from './dom/event-handler'
+import Manipulator from './dom/manipulator'
+import BaseComponent from './base-component'
+import TemplateFactory from './util/template-factory'
+
+/**
+ * Constants
+ */
+
+const NAME = 'tooltip'
+const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn'])
+
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_MODAL = 'modal'
+const CLASS_NAME_SHOW = 'show'
+
+const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'
+const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`
+
+const EVENT_MODAL_HIDE = 'hide.bs.modal'
+
+const TRIGGER_HOVER = 'hover'
+const TRIGGER_FOCUS = 'focus'
+const TRIGGER_CLICK = 'click'
+const TRIGGER_MANUAL = 'manual'
+
+const EVENT_HIDE = 'hide'
+const EVENT_HIDDEN = 'hidden'
+const EVENT_SHOW = 'show'
+const EVENT_SHOWN = 'shown'
+const EVENT_INSERTED = 'inserted'
+const EVENT_CLICK = 'click'
+const EVENT_FOCUSIN = 'focusin'
+const EVENT_FOCUSOUT = 'focusout'
+const EVENT_MOUSEENTER = 'mouseenter'
+const EVENT_MOUSELEAVE = 'mouseleave'
+
+const AttachmentMap = {
+ AUTO: 'auto',
+ TOP: 'top',
+ RIGHT: isRTL() ? 'left' : 'right',
+ BOTTOM: 'bottom',
+ LEFT: isRTL() ? 'right' : 'left'
+}
+
+const Default = {
+ allowList: DefaultAllowlist,
+ animation: true,
+ boundary: 'clippingParents',
+ container: false,
+ customClass: '',
+ delay: 0,
+ fallbackPlacements: ['top', 'right', 'bottom', 'left'],
+ html: false,
+ offset: [0, 0],
+ placement: 'top',
+ popperConfig: null,
+ sanitize: true,
+ sanitizeFn: null,
+ selector: false,
+ template: '',
+ title: '',
+ trigger: 'hover focus'
+}
+
+const DefaultType = {
+ allowList: 'object',
+ animation: 'boolean',
+ boundary: '(string|element)',
+ container: '(string|element|boolean)',
+ customClass: '(string|function)',
+ delay: '(number|object)',
+ fallbackPlacements: 'array',
+ html: 'boolean',
+ offset: '(array|string|function)',
+ placement: '(string|function)',
+ popperConfig: '(null|object|function)',
+ sanitize: 'boolean',
+ sanitizeFn: '(null|function)',
+ selector: '(string|boolean)',
+ template: 'string',
+ title: '(string|element|function)',
+ trigger: 'string'
+}
+
+/**
+ * Class definition
+ */
+
+class Tooltip extends BaseComponent {
+ constructor(element, config) {
+ if (typeof Popper === 'undefined') {
+ throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)')
+ }
+
+ super(element, config)
+
+ // Private
+ this._isEnabled = true
+ this._timeout = 0
+ this._isHovered = null
+ this._activeTrigger = {}
+ this._popper = null
+ this._templateFactory = null
+ this._newContent = null
+
+ // Protected
+ this.tip = null
+
+ this._setListeners()
+
+ if (!this._config.selector) {
+ this._fixTitle()
+ }
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ enable() {
+ this._isEnabled = true
+ }
+
+ disable() {
+ this._isEnabled = false
+ }
+
+ toggleEnabled() {
+ this._isEnabled = !this._isEnabled
+ }
+
+ toggle() {
+ if (!this._isEnabled) {
+ return
+ }
+
+ this._activeTrigger.click = !this._activeTrigger.click
+ if (this._isShown()) {
+ this._leave()
+ return
+ }
+
+ this._enter()
+ }
+
+ dispose() {
+ clearTimeout(this._timeout)
+
+ EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler)
+
+ if (this._element.getAttribute('data-bs-original-title')) {
+ this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'))
+ }
+
+ this._disposePopper()
+ super.dispose()
+ }
+
+ show() {
+ if (this._element.style.display === 'none') {
+ throw new Error('Please use show on visible elements')
+ }
+
+ if (!(this._isWithContent() && this._isEnabled)) {
+ return
+ }
+
+ const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW))
+ const shadowRoot = findShadowRoot(this._element)
+ const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element)
+
+ if (showEvent.defaultPrevented || !isInTheDom) {
+ return
+ }
+
+ // todo v6 remove this OR make it optional
+ this._disposePopper()
+
+ const tip = this._getTipElement()
+
+ this._element.setAttribute('aria-describedby', tip.getAttribute('id'))
+
+ const { container } = this._config
+
+ if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
+ container.append(tip)
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED))
+ }
+
+ this._popper = this._createPopper(tip)
+
+ tip.classList.add(CLASS_NAME_SHOW)
+
+ // If this is a touch-enabled device we add extra
+ // empty mouseover listeners to the body's immediate children;
+ // only needed because of broken event delegation on iOS
+ // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
+ if ('ontouchstart' in document.documentElement) {
+ for (const element of [].concat(...document.body.children)) {
+ EventHandler.on(element, 'mouseover', noop)
+ }
+ }
+
+ const complete = () => {
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN))
+
+ if (this._isHovered === false) {
+ this._leave()
+ }
+
+ this._isHovered = false
+ }
+
+ this._queueCallback(complete, this.tip, this._isAnimated())
+ }
+
+ hide() {
+ if (!this._isShown()) {
+ return
+ }
+
+ const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE))
+ if (hideEvent.defaultPrevented) {
+ return
+ }
+
+ const tip = this._getTipElement()
+ tip.classList.remove(CLASS_NAME_SHOW)
+
+ // If this is a touch-enabled device we remove the extra
+ // empty mouseover listeners we added for iOS support
+ if ('ontouchstart' in document.documentElement) {
+ for (const element of [].concat(...document.body.children)) {
+ EventHandler.off(element, 'mouseover', noop)
+ }
+ }
+
+ this._activeTrigger[TRIGGER_CLICK] = false
+ this._activeTrigger[TRIGGER_FOCUS] = false
+ this._activeTrigger[TRIGGER_HOVER] = false
+ this._isHovered = null // it is a trick to support manual triggering
+
+ const complete = () => {
+ if (this._isWithActiveTrigger()) {
+ return
+ }
+
+ if (!this._isHovered) {
+ this._disposePopper()
+ }
+
+ this._element.removeAttribute('aria-describedby')
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN))
+ }
+
+ this._queueCallback(complete, this.tip, this._isAnimated())
+ }
+
+ update() {
+ if (this._popper) {
+ this._popper.update()
+ }
+ }
+
+ // Protected
+ _isWithContent() {
+ return Boolean(this._getTitle())
+ }
+
+ _getTipElement() {
+ if (!this.tip) {
+ this.tip = this._createTipElement(this._newContent || this._getContentForTemplate())
+ }
+
+ return this.tip
+ }
+
+ _createTipElement(content) {
+ const tip = this._getTemplateFactory(content).toHtml()
+
+ // todo: remove this check on v6
+ if (!tip) {
+ return null
+ }
+
+ tip.classList.remove(CLASS_NAME_FADE, CLASS_NAME_SHOW)
+ // todo: on v6 the following can be achieved with CSS only
+ tip.classList.add(`bs-${this.constructor.NAME}-auto`)
+
+ const tipId = getUID(this.constructor.NAME).toString()
+
+ tip.setAttribute('id', tipId)
+
+ if (this._isAnimated()) {
+ tip.classList.add(CLASS_NAME_FADE)
+ }
+
+ return tip
+ }
+
+ setContent(content) {
+ this._newContent = content
+ if (this._isShown()) {
+ this._disposePopper()
+ this.show()
+ }
+ }
+
+ _getTemplateFactory(content) {
+ if (this._templateFactory) {
+ this._templateFactory.changeContent(content)
+ } else {
+ this._templateFactory = new TemplateFactory({
+ ...this._config,
+ // the `content` var has to be after `this._config`
+ // to override config.content in case of popover
+ content,
+ extraClass: this._resolvePossibleFunction(this._config.customClass)
+ })
+ }
+
+ return this._templateFactory
+ }
+
+ _getContentForTemplate() {
+ return {
+ [SELECTOR_TOOLTIP_INNER]: this._getTitle()
+ }
+ }
+
+ _getTitle() {
+ return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title')
+ }
+
+ // Private
+ _initializeOnDelegatedTarget(event) {
+ return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig())
+ }
+
+ _isAnimated() {
+ return this._config.animation || (this.tip && this.tip.classList.contains(CLASS_NAME_FADE))
+ }
+
+ _isShown() {
+ return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW)
+ }
+
+ _createPopper(tip) {
+ const placement = typeof this._config.placement === 'function' ?
+ this._config.placement.call(this, tip, this._element) :
+ this._config.placement
+ const attachment = AttachmentMap[placement.toUpperCase()]
+ return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment))
+ }
+
+ _getOffset() {
+ const { offset } = this._config
+
+ if (typeof offset === 'string') {
+ return offset.split(',').map(value => Number.parseInt(value, 10))
+ }
+
+ if (typeof offset === 'function') {
+ return popperData => offset(popperData, this._element)
+ }
+
+ return offset
+ }
+
+ _resolvePossibleFunction(arg) {
+ return typeof arg === 'function' ? arg.call(this._element) : arg
+ }
+
+ _getPopperConfig(attachment) {
+ const defaultBsPopperConfig = {
+ placement: attachment,
+ modifiers: [
+ {
+ name: 'flip',
+ options: {
+ fallbackPlacements: this._config.fallbackPlacements
+ }
+ },
+ {
+ name: 'offset',
+ options: {
+ offset: this._getOffset()
+ }
+ },
+ {
+ name: 'preventOverflow',
+ options: {
+ boundary: this._config.boundary
+ }
+ },
+ {
+ name: 'arrow',
+ options: {
+ element: `.${this.constructor.NAME}-arrow`
+ }
+ },
+ {
+ name: 'preSetPlacement',
+ enabled: true,
+ phase: 'beforeMain',
+ fn: data => {
+ // Pre-set Popper's placement attribute in order to read the arrow sizes properly.
+ // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement
+ this._getTipElement().setAttribute('data-popper-placement', data.state.placement)
+ }
+ }
+ ]
+ }
+
+ return {
+ ...defaultBsPopperConfig,
+ ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
+ }
+ }
+
+ _setListeners() {
+ const triggers = this._config.trigger.split(' ')
+
+ for (const trigger of triggers) {
+ if (trigger === 'click') {
+ EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK), this._config.selector, event => {
+ const context = this._initializeOnDelegatedTarget(event)
+ context.toggle()
+ })
+ } else if (trigger !== TRIGGER_MANUAL) {
+ const eventIn = trigger === TRIGGER_HOVER ?
+ this.constructor.eventName(EVENT_MOUSEENTER) :
+ this.constructor.eventName(EVENT_FOCUSIN)
+ const eventOut = trigger === TRIGGER_HOVER ?
+ this.constructor.eventName(EVENT_MOUSELEAVE) :
+ this.constructor.eventName(EVENT_FOCUSOUT)
+
+ EventHandler.on(this._element, eventIn, this._config.selector, event => {
+ const context = this._initializeOnDelegatedTarget(event)
+ context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true
+ context._enter()
+ })
+ EventHandler.on(this._element, eventOut, this._config.selector, event => {
+ const context = this._initializeOnDelegatedTarget(event)
+ context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] =
+ context._element.contains(event.relatedTarget)
+
+ context._leave()
+ })
+ }
+ }
+
+ this._hideModalHandler = () => {
+ if (this._element) {
+ this.hide()
+ }
+ }
+
+ EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler)
+ }
+
+ _fixTitle() {
+ const title = this._element.getAttribute('title')
+
+ if (!title) {
+ return
+ }
+
+ if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {
+ this._element.setAttribute('aria-label', title)
+ }
+
+ this._element.setAttribute('data-bs-original-title', title) // DO NOT USE IT. Is only for backwards compatibility
+ this._element.removeAttribute('title')
+ }
+
+ _enter() {
+ if (this._isShown() || this._isHovered) {
+ this._isHovered = true
+ return
+ }
+
+ this._isHovered = true
+
+ this._setTimeout(() => {
+ if (this._isHovered) {
+ this.show()
+ }
+ }, this._config.delay.show)
+ }
+
+ _leave() {
+ if (this._isWithActiveTrigger()) {
+ return
+ }
+
+ this._isHovered = false
+
+ this._setTimeout(() => {
+ if (!this._isHovered) {
+ this.hide()
+ }
+ }, this._config.delay.hide)
+ }
+
+ _setTimeout(handler, timeout) {
+ clearTimeout(this._timeout)
+ this._timeout = setTimeout(handler, timeout)
+ }
+
+ _isWithActiveTrigger() {
+ return Object.values(this._activeTrigger).includes(true)
+ }
+
+ _getConfig(config) {
+ const dataAttributes = Manipulator.getDataAttributes(this._element)
+
+ for (const dataAttribute of Object.keys(dataAttributes)) {
+ if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
+ delete dataAttributes[dataAttribute]
+ }
+ }
+
+ config = {
+ ...dataAttributes,
+ ...(typeof config === 'object' && config ? config : {})
+ }
+ config = this._mergeConfigObj(config)
+ config = this._configAfterMerge(config)
+ this._typeCheckConfig(config)
+ return config
+ }
+
+ _configAfterMerge(config) {
+ config.container = config.container === false ? document.body : getElement(config.container)
+
+ if (typeof config.delay === 'number') {
+ config.delay = {
+ show: config.delay,
+ hide: config.delay
+ }
+ }
+
+ if (typeof config.title === 'number') {
+ config.title = config.title.toString()
+ }
+
+ if (typeof config.content === 'number') {
+ config.content = config.content.toString()
+ }
+
+ return config
+ }
+
+ _getDelegateConfig() {
+ const config = {}
+
+ for (const key in this._config) {
+ if (this.constructor.Default[key] !== this._config[key]) {
+ config[key] = this._config[key]
+ }
+ }
+
+ config.selector = false
+ config.trigger = 'manual'
+
+ // In the future can be replaced with:
+ // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
+ // `Object.fromEntries(keysWithDifferentValues)`
+ return config
+ }
+
+ _disposePopper() {
+ if (this._popper) {
+ this._popper.destroy()
+ this._popper = null
+ }
+
+ if (this.tip) {
+ this.tip.remove()
+ this.tip = null
+ }
+ }
+
+ // Static
+ static jQueryInterface(config) {
+ return this.each(function () {
+ const data = Tooltip.getOrCreateInstance(this, config)
+
+ if (typeof config !== 'string') {
+ return
+ }
+
+ if (typeof data[config] === 'undefined') {
+ throw new TypeError(`No method named "${config}"`)
+ }
+
+ data[config]()
+ })
+ }
+}
+
+/**
+ * jQuery
+ */
+
+defineJQueryPlugin(Tooltip)
+
+export default Tooltip
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/backdrop.js b/cao_sunyata/static/libs/bootstrap/js/src/util/backdrop.js
new file mode 100644
index 0000000..78279e0
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/backdrop.js
@@ -0,0 +1,149 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/backdrop.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import EventHandler from '../dom/event-handler'
+import { execute, executeAfterTransition, getElement, reflow } from './index'
+import Config from './config'
+
+/**
+ * Constants
+ */
+
+const NAME = 'backdrop'
+const CLASS_NAME_FADE = 'fade'
+const CLASS_NAME_SHOW = 'show'
+const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`
+
+const Default = {
+ className: 'modal-backdrop',
+ clickCallback: null,
+ isAnimated: false,
+ isVisible: true, // if false, we use the backdrop helper without adding any element to the dom
+ rootElement: 'body' // give the choice to place backdrop under different elements
+}
+
+const DefaultType = {
+ className: 'string',
+ clickCallback: '(function|null)',
+ isAnimated: 'boolean',
+ isVisible: 'boolean',
+ rootElement: '(element|string)'
+}
+
+/**
+ * Class definition
+ */
+
+class Backdrop extends Config {
+ constructor(config) {
+ super()
+ this._config = this._getConfig(config)
+ this._isAppended = false
+ this._element = null
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ show(callback) {
+ if (!this._config.isVisible) {
+ execute(callback)
+ return
+ }
+
+ this._append()
+
+ const element = this._getElement()
+ if (this._config.isAnimated) {
+ reflow(element)
+ }
+
+ element.classList.add(CLASS_NAME_SHOW)
+
+ this._emulateAnimation(() => {
+ execute(callback)
+ })
+ }
+
+ hide(callback) {
+ if (!this._config.isVisible) {
+ execute(callback)
+ return
+ }
+
+ this._getElement().classList.remove(CLASS_NAME_SHOW)
+
+ this._emulateAnimation(() => {
+ this.dispose()
+ execute(callback)
+ })
+ }
+
+ dispose() {
+ if (!this._isAppended) {
+ return
+ }
+
+ EventHandler.off(this._element, EVENT_MOUSEDOWN)
+
+ this._element.remove()
+ this._isAppended = false
+ }
+
+ // Private
+ _getElement() {
+ if (!this._element) {
+ const backdrop = document.createElement('div')
+ backdrop.className = this._config.className
+ if (this._config.isAnimated) {
+ backdrop.classList.add(CLASS_NAME_FADE)
+ }
+
+ this._element = backdrop
+ }
+
+ return this._element
+ }
+
+ _configAfterMerge(config) {
+ // use getElement() with the default "body" to get a fresh Element on each instantiation
+ config.rootElement = getElement(config.rootElement)
+ return config
+ }
+
+ _append() {
+ if (this._isAppended) {
+ return
+ }
+
+ const element = this._getElement()
+ this._config.rootElement.append(element)
+
+ EventHandler.on(element, EVENT_MOUSEDOWN, () => {
+ execute(this._config.clickCallback)
+ })
+
+ this._isAppended = true
+ }
+
+ _emulateAnimation(callback) {
+ executeAfterTransition(callback, this._getElement(), this._config.isAnimated)
+ }
+}
+
+export default Backdrop
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/component-functions.js b/cao_sunyata/static/libs/bootstrap/js/src/util/component-functions.js
new file mode 100644
index 0000000..c2f99cc
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/component-functions.js
@@ -0,0 +1,34 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/component-functions.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import EventHandler from '../dom/event-handler'
+import { getElementFromSelector, isDisabled } from './index'
+
+const enableDismissTrigger = (component, method = 'hide') => {
+ const clickEvent = `click.dismiss${component.EVENT_KEY}`
+ const name = component.NAME
+
+ EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
+ if (['A', 'AREA'].includes(this.tagName)) {
+ event.preventDefault()
+ }
+
+ if (isDisabled(this)) {
+ return
+ }
+
+ const target = getElementFromSelector(this) || this.closest(`.${name}`)
+ const instance = component.getOrCreateInstance(target)
+
+ // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
+ instance[method]()
+ })
+}
+
+export {
+ enableDismissTrigger
+}
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/config.js b/cao_sunyata/static/libs/bootstrap/js/src/util/config.js
new file mode 100644
index 0000000..1205905
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/config.js
@@ -0,0 +1,66 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/config.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { isElement, toType } from './index'
+import Manipulator from '../dom/manipulator'
+
+/**
+ * Class definition
+ */
+
+class Config {
+ // Getters
+ static get Default() {
+ return {}
+ }
+
+ static get DefaultType() {
+ return {}
+ }
+
+ static get NAME() {
+ throw new Error('You have to implement the static method "NAME", for each component!')
+ }
+
+ _getConfig(config) {
+ config = this._mergeConfigObj(config)
+ config = this._configAfterMerge(config)
+ this._typeCheckConfig(config)
+ return config
+ }
+
+ _configAfterMerge(config) {
+ return config
+ }
+
+ _mergeConfigObj(config, element) {
+ const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {} // try to parse
+
+ return {
+ ...this.constructor.Default,
+ ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
+ ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),
+ ...(typeof config === 'object' ? config : {})
+ }
+ }
+
+ _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
+ for (const property of Object.keys(configTypes)) {
+ const expectedTypes = configTypes[property]
+ const value = config[property]
+ const valueType = isElement(value) ? 'element' : toType(value)
+
+ if (!new RegExp(expectedTypes).test(valueType)) {
+ throw new TypeError(
+ `${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
+ )
+ }
+ }
+ }
+}
+
+export default Config
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/focustrap.js b/cao_sunyata/static/libs/bootstrap/js/src/util/focustrap.js
new file mode 100644
index 0000000..ef69166
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/focustrap.js
@@ -0,0 +1,115 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/focustrap.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import EventHandler from '../dom/event-handler'
+import SelectorEngine from '../dom/selector-engine'
+import Config from './config'
+
+/**
+ * Constants
+ */
+
+const NAME = 'focustrap'
+const DATA_KEY = 'bs.focustrap'
+const EVENT_KEY = `.${DATA_KEY}`
+const EVENT_FOCUSIN = `focusin${EVENT_KEY}`
+const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY}`
+
+const TAB_KEY = 'Tab'
+const TAB_NAV_FORWARD = 'forward'
+const TAB_NAV_BACKWARD = 'backward'
+
+const Default = {
+ autofocus: true,
+ trapElement: null // The element to trap focus inside of
+}
+
+const DefaultType = {
+ autofocus: 'boolean',
+ trapElement: 'element'
+}
+
+/**
+ * Class definition
+ */
+
+class FocusTrap extends Config {
+ constructor(config) {
+ super()
+ this._config = this._getConfig(config)
+ this._isActive = false
+ this._lastTabNavDirection = null
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ activate() {
+ if (this._isActive) {
+ return
+ }
+
+ if (this._config.autofocus) {
+ this._config.trapElement.focus()
+ }
+
+ EventHandler.off(document, EVENT_KEY) // guard against infinite focus loop
+ EventHandler.on(document, EVENT_FOCUSIN, event => this._handleFocusin(event))
+ EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event))
+
+ this._isActive = true
+ }
+
+ deactivate() {
+ if (!this._isActive) {
+ return
+ }
+
+ this._isActive = false
+ EventHandler.off(document, EVENT_KEY)
+ }
+
+ // Private
+ _handleFocusin(event) {
+ const { trapElement } = this._config
+
+ if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
+ return
+ }
+
+ const elements = SelectorEngine.focusableChildren(trapElement)
+
+ if (elements.length === 0) {
+ trapElement.focus()
+ } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
+ elements[elements.length - 1].focus()
+ } else {
+ elements[0].focus()
+ }
+ }
+
+ _handleKeydown(event) {
+ if (event.key !== TAB_KEY) {
+ return
+ }
+
+ this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD
+ }
+}
+
+export default FocusTrap
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/index.js b/cao_sunyata/static/libs/bootstrap/js/src/util/index.js
new file mode 100644
index 0000000..297e571
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/index.js
@@ -0,0 +1,336 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/index.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+const MAX_UID = 1_000_000
+const MILLISECONDS_MULTIPLIER = 1000
+const TRANSITION_END = 'transitionend'
+
+// Shout-out Angus Croll (https://goo.gl/pxwQGp)
+const toType = object => {
+ if (object === null || object === undefined) {
+ return `${object}`
+ }
+
+ return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase()
+}
+
+/**
+ * Public Util API
+ */
+
+const getUID = prefix => {
+ do {
+ prefix += Math.floor(Math.random() * MAX_UID)
+ } while (document.getElementById(prefix))
+
+ return prefix
+}
+
+const getSelector = element => {
+ let selector = element.getAttribute('data-bs-target')
+
+ if (!selector || selector === '#') {
+ let hrefAttribute = element.getAttribute('href')
+
+ // The only valid content that could double as a selector are IDs or classes,
+ // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
+ // `document.querySelector` will rightfully complain it is invalid.
+ // See https://github.com/twbs/bootstrap/issues/32273
+ if (!hrefAttribute || (!hrefAttribute.includes('#') && !hrefAttribute.startsWith('.'))) {
+ return null
+ }
+
+ // Just in case some CMS puts out a full URL with the anchor appended
+ if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
+ hrefAttribute = `#${hrefAttribute.split('#')[1]}`
+ }
+
+ selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null
+ }
+
+ return selector
+}
+
+const getSelectorFromElement = element => {
+ const selector = getSelector(element)
+
+ if (selector) {
+ return document.querySelector(selector) ? selector : null
+ }
+
+ return null
+}
+
+const getElementFromSelector = element => {
+ const selector = getSelector(element)
+
+ return selector ? document.querySelector(selector) : null
+}
+
+const getTransitionDurationFromElement = element => {
+ if (!element) {
+ return 0
+ }
+
+ // Get transition-duration of the element
+ let { transitionDuration, transitionDelay } = window.getComputedStyle(element)
+
+ const floatTransitionDuration = Number.parseFloat(transitionDuration)
+ const floatTransitionDelay = Number.parseFloat(transitionDelay)
+
+ // Return 0 if element or transition duration is not found
+ if (!floatTransitionDuration && !floatTransitionDelay) {
+ return 0
+ }
+
+ // If multiple durations are defined, take the first
+ transitionDuration = transitionDuration.split(',')[0]
+ transitionDelay = transitionDelay.split(',')[0]
+
+ return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER
+}
+
+const triggerTransitionEnd = element => {
+ element.dispatchEvent(new Event(TRANSITION_END))
+}
+
+const isElement = object => {
+ if (!object || typeof object !== 'object') {
+ return false
+ }
+
+ if (typeof object.jquery !== 'undefined') {
+ object = object[0]
+ }
+
+ return typeof object.nodeType !== 'undefined'
+}
+
+const getElement = object => {
+ // it's a jQuery object or a node element
+ if (isElement(object)) {
+ return object.jquery ? object[0] : object
+ }
+
+ if (typeof object === 'string' && object.length > 0) {
+ return document.querySelector(object)
+ }
+
+ return null
+}
+
+const isVisible = element => {
+ if (!isElement(element) || element.getClientRects().length === 0) {
+ return false
+ }
+
+ const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'
+ // Handle `details` element as its content may falsie appear visible when it is closed
+ const closedDetails = element.closest('details:not([open])')
+
+ if (!closedDetails) {
+ return elementIsVisible
+ }
+
+ if (closedDetails !== element) {
+ const summary = element.closest('summary')
+ if (summary && summary.parentNode !== closedDetails) {
+ return false
+ }
+
+ if (summary === null) {
+ return false
+ }
+ }
+
+ return elementIsVisible
+}
+
+const isDisabled = element => {
+ if (!element || element.nodeType !== Node.ELEMENT_NODE) {
+ return true
+ }
+
+ if (element.classList.contains('disabled')) {
+ return true
+ }
+
+ if (typeof element.disabled !== 'undefined') {
+ return element.disabled
+ }
+
+ return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'
+}
+
+const findShadowRoot = element => {
+ if (!document.documentElement.attachShadow) {
+ return null
+ }
+
+ // Can find the shadow root otherwise it'll return the document
+ if (typeof element.getRootNode === 'function') {
+ const root = element.getRootNode()
+ return root instanceof ShadowRoot ? root : null
+ }
+
+ if (element instanceof ShadowRoot) {
+ return element
+ }
+
+ // when we don't find a shadow root
+ if (!element.parentNode) {
+ return null
+ }
+
+ return findShadowRoot(element.parentNode)
+}
+
+const noop = () => {}
+
+/**
+ * Trick to restart an element's animation
+ *
+ * @param {HTMLElement} element
+ * @return void
+ *
+ * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
+ */
+const reflow = element => {
+ element.offsetHeight // eslint-disable-line no-unused-expressions
+}
+
+const getjQuery = () => {
+ if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
+ return window.jQuery
+ }
+
+ return null
+}
+
+const DOMContentLoadedCallbacks = []
+
+const onDOMContentLoaded = callback => {
+ if (document.readyState === 'loading') {
+ // add listener on the first call when the document is in loading state
+ if (!DOMContentLoadedCallbacks.length) {
+ document.addEventListener('DOMContentLoaded', () => {
+ for (const callback of DOMContentLoadedCallbacks) {
+ callback()
+ }
+ })
+ }
+
+ DOMContentLoadedCallbacks.push(callback)
+ } else {
+ callback()
+ }
+}
+
+const isRTL = () => document.documentElement.dir === 'rtl'
+
+const defineJQueryPlugin = plugin => {
+ onDOMContentLoaded(() => {
+ const $ = getjQuery()
+ /* istanbul ignore if */
+ if ($) {
+ const name = plugin.NAME
+ const JQUERY_NO_CONFLICT = $.fn[name]
+ $.fn[name] = plugin.jQueryInterface
+ $.fn[name].Constructor = plugin
+ $.fn[name].noConflict = () => {
+ $.fn[name] = JQUERY_NO_CONFLICT
+ return plugin.jQueryInterface
+ }
+ }
+ })
+}
+
+const execute = callback => {
+ if (typeof callback === 'function') {
+ callback()
+ }
+}
+
+const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
+ if (!waitForTransition) {
+ execute(callback)
+ return
+ }
+
+ const durationPadding = 5
+ const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding
+
+ let called = false
+
+ const handler = ({ target }) => {
+ if (target !== transitionElement) {
+ return
+ }
+
+ called = true
+ transitionElement.removeEventListener(TRANSITION_END, handler)
+ execute(callback)
+ }
+
+ transitionElement.addEventListener(TRANSITION_END, handler)
+ setTimeout(() => {
+ if (!called) {
+ triggerTransitionEnd(transitionElement)
+ }
+ }, emulatedDuration)
+}
+
+/**
+ * Return the previous/next element of a list.
+ *
+ * @param {array} list The list of elements
+ * @param activeElement The active element
+ * @param shouldGetNext Choose to get next or previous element
+ * @param isCycleAllowed
+ * @return {Element|elem} The proper element
+ */
+const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
+ const listLength = list.length
+ let index = list.indexOf(activeElement)
+
+ // if the element does not exist in the list return an element
+ // depending on the direction and if cycle is allowed
+ if (index === -1) {
+ return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]
+ }
+
+ index += shouldGetNext ? 1 : -1
+
+ if (isCycleAllowed) {
+ index = (index + listLength) % listLength
+ }
+
+ return list[Math.max(0, Math.min(index, listLength - 1))]
+}
+
+export {
+ defineJQueryPlugin,
+ execute,
+ executeAfterTransition,
+ findShadowRoot,
+ getElement,
+ getElementFromSelector,
+ getjQuery,
+ getNextActiveElement,
+ getSelectorFromElement,
+ getTransitionDurationFromElement,
+ getUID,
+ isDisabled,
+ isElement,
+ isRTL,
+ isVisible,
+ noop,
+ onDOMContentLoaded,
+ reflow,
+ triggerTransitionEnd,
+ toType
+}
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/sanitizer.js b/cao_sunyata/static/libs/bootstrap/js/src/util/sanitizer.js
new file mode 100644
index 0000000..5328691
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/sanitizer.js
@@ -0,0 +1,118 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/sanitizer.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+const uriAttributes = new Set([
+ 'background',
+ 'cite',
+ 'href',
+ 'itemtype',
+ 'longdesc',
+ 'poster',
+ 'src',
+ 'xlink:href'
+])
+
+const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i
+
+/**
+ * A pattern that recognizes a commonly useful subset of URLs that are safe.
+ *
+ * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
+ */
+const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i
+
+/**
+ * A pattern that matches safe data URLs. Only matches image, video and audio types.
+ *
+ * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
+ */
+const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i
+
+const allowedAttribute = (attribute, allowedAttributeList) => {
+ const attributeName = attribute.nodeName.toLowerCase()
+
+ if (allowedAttributeList.includes(attributeName)) {
+ if (uriAttributes.has(attributeName)) {
+ return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue))
+ }
+
+ return true
+ }
+
+ // Check if a regular expression validates the attribute.
+ return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp)
+ .some(regex => regex.test(attributeName))
+}
+
+export const DefaultAllowlist = {
+ // Global attributes allowed on any supplied element below.
+ '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
+ a: ['target', 'href', 'title', 'rel'],
+ area: [],
+ b: [],
+ br: [],
+ col: [],
+ code: [],
+ div: [],
+ em: [],
+ hr: [],
+ h1: [],
+ h2: [],
+ h3: [],
+ h4: [],
+ h5: [],
+ h6: [],
+ i: [],
+ img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
+ li: [],
+ ol: [],
+ p: [],
+ pre: [],
+ s: [],
+ small: [],
+ span: [],
+ sub: [],
+ sup: [],
+ strong: [],
+ u: [],
+ ul: []
+}
+
+export function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
+ if (!unsafeHtml.length) {
+ return unsafeHtml
+ }
+
+ if (sanitizeFunction && typeof sanitizeFunction === 'function') {
+ return sanitizeFunction(unsafeHtml)
+ }
+
+ const domParser = new window.DOMParser()
+ const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html')
+ const elements = [].concat(...createdDocument.body.querySelectorAll('*'))
+
+ for (const element of elements) {
+ const elementName = element.nodeName.toLowerCase()
+
+ if (!Object.keys(allowList).includes(elementName)) {
+ element.remove()
+
+ continue
+ }
+
+ const attributeList = [].concat(...element.attributes)
+ const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || [])
+
+ for (const attribute of attributeList) {
+ if (!allowedAttribute(attribute, allowedAttributes)) {
+ element.removeAttribute(attribute.nodeName)
+ }
+ }
+ }
+
+ return createdDocument.body.innerHTML
+}
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/scrollbar.js b/cao_sunyata/static/libs/bootstrap/js/src/util/scrollbar.js
new file mode 100644
index 0000000..5cac7b6
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/scrollbar.js
@@ -0,0 +1,114 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/scrollBar.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import SelectorEngine from '../dom/selector-engine'
+import Manipulator from '../dom/manipulator'
+import { isElement } from './index'
+
+/**
+ * Constants
+ */
+
+const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'
+const SELECTOR_STICKY_CONTENT = '.sticky-top'
+const PROPERTY_PADDING = 'padding-right'
+const PROPERTY_MARGIN = 'margin-right'
+
+/**
+ * Class definition
+ */
+
+class ScrollBarHelper {
+ constructor() {
+ this._element = document.body
+ }
+
+ // Public
+ getWidth() {
+ // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
+ const documentWidth = document.documentElement.clientWidth
+ return Math.abs(window.innerWidth - documentWidth)
+ }
+
+ hide() {
+ const width = this.getWidth()
+ this._disableOverFlow()
+ // give padding to element to balance the hidden scrollbar width
+ this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
+ // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
+ this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
+ this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width)
+ }
+
+ reset() {
+ this._resetElementAttributes(this._element, 'overflow')
+ this._resetElementAttributes(this._element, PROPERTY_PADDING)
+ this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING)
+ this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN)
+ }
+
+ isOverflowing() {
+ return this.getWidth() > 0
+ }
+
+ // Private
+ _disableOverFlow() {
+ this._saveInitialAttribute(this._element, 'overflow')
+ this._element.style.overflow = 'hidden'
+ }
+
+ _setElementAttributes(selector, styleProperty, callback) {
+ const scrollbarWidth = this.getWidth()
+ const manipulationCallBack = element => {
+ if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
+ return
+ }
+
+ this._saveInitialAttribute(element, styleProperty)
+ const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty)
+ element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`)
+ }
+
+ this._applyManipulationCallback(selector, manipulationCallBack)
+ }
+
+ _saveInitialAttribute(element, styleProperty) {
+ const actualValue = element.style.getPropertyValue(styleProperty)
+ if (actualValue) {
+ Manipulator.setDataAttribute(element, styleProperty, actualValue)
+ }
+ }
+
+ _resetElementAttributes(selector, styleProperty) {
+ const manipulationCallBack = element => {
+ const value = Manipulator.getDataAttribute(element, styleProperty)
+ // We only want to remove the property if the value is `null`; the value can also be zero
+ if (value === null) {
+ element.style.removeProperty(styleProperty)
+ return
+ }
+
+ Manipulator.removeDataAttribute(element, styleProperty)
+ element.style.setProperty(styleProperty, value)
+ }
+
+ this._applyManipulationCallback(selector, manipulationCallBack)
+ }
+
+ _applyManipulationCallback(selector, callBack) {
+ if (isElement(selector)) {
+ callBack(selector)
+ return
+ }
+
+ for (const sel of SelectorEngine.find(selector, this._element)) {
+ callBack(sel)
+ }
+ }
+}
+
+export default ScrollBarHelper
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/swipe.js b/cao_sunyata/static/libs/bootstrap/js/src/util/swipe.js
new file mode 100644
index 0000000..7126360
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/swipe.js
@@ -0,0 +1,146 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/swipe.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import Config from './config'
+import EventHandler from '../dom/event-handler'
+import { execute } from './index'
+
+/**
+ * Constants
+ */
+
+const NAME = 'swipe'
+const EVENT_KEY = '.bs.swipe'
+const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`
+const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`
+const EVENT_TOUCHEND = `touchend${EVENT_KEY}`
+const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`
+const EVENT_POINTERUP = `pointerup${EVENT_KEY}`
+const POINTER_TYPE_TOUCH = 'touch'
+const POINTER_TYPE_PEN = 'pen'
+const CLASS_NAME_POINTER_EVENT = 'pointer-event'
+const SWIPE_THRESHOLD = 40
+
+const Default = {
+ endCallback: null,
+ leftCallback: null,
+ rightCallback: null
+}
+
+const DefaultType = {
+ endCallback: '(function|null)',
+ leftCallback: '(function|null)',
+ rightCallback: '(function|null)'
+}
+
+/**
+ * Class definition
+ */
+
+class Swipe extends Config {
+ constructor(element, config) {
+ super()
+ this._element = element
+
+ if (!element || !Swipe.isSupported()) {
+ return
+ }
+
+ this._config = this._getConfig(config)
+ this._deltaX = 0
+ this._supportPointerEvents = Boolean(window.PointerEvent)
+ this._initEvents()
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ dispose() {
+ EventHandler.off(this._element, EVENT_KEY)
+ }
+
+ // Private
+ _start(event) {
+ if (!this._supportPointerEvents) {
+ this._deltaX = event.touches[0].clientX
+
+ return
+ }
+
+ if (this._eventIsPointerPenTouch(event)) {
+ this._deltaX = event.clientX
+ }
+ }
+
+ _end(event) {
+ if (this._eventIsPointerPenTouch(event)) {
+ this._deltaX = event.clientX - this._deltaX
+ }
+
+ this._handleSwipe()
+ execute(this._config.endCallback)
+ }
+
+ _move(event) {
+ this._deltaX = event.touches && event.touches.length > 1 ?
+ 0 :
+ event.touches[0].clientX - this._deltaX
+ }
+
+ _handleSwipe() {
+ const absDeltaX = Math.abs(this._deltaX)
+
+ if (absDeltaX <= SWIPE_THRESHOLD) {
+ return
+ }
+
+ const direction = absDeltaX / this._deltaX
+
+ this._deltaX = 0
+
+ if (!direction) {
+ return
+ }
+
+ execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback)
+ }
+
+ _initEvents() {
+ if (this._supportPointerEvents) {
+ EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event))
+ EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event))
+
+ this._element.classList.add(CLASS_NAME_POINTER_EVENT)
+ } else {
+ EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event))
+ EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event))
+ EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event))
+ }
+ }
+
+ _eventIsPointerPenTouch(event) {
+ return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
+ }
+
+ // Static
+ static isSupported() {
+ return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0
+ }
+}
+
+export default Swipe
diff --git a/cao_sunyata/static/libs/bootstrap/js/src/util/template-factory.js b/cao_sunyata/static/libs/bootstrap/js/src/util/template-factory.js
new file mode 100644
index 0000000..cf402fa
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/src/util/template-factory.js
@@ -0,0 +1,160 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.2.3): util/template-factory.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { DefaultAllowlist, sanitizeHtml } from './sanitizer'
+import { getElement, isElement } from '../util/index'
+import SelectorEngine from '../dom/selector-engine'
+import Config from './config'
+
+/**
+ * Constants
+ */
+
+const NAME = 'TemplateFactory'
+
+const Default = {
+ allowList: DefaultAllowlist,
+ content: {}, // { selector : text , selector2 : text2 , }
+ extraClass: '',
+ html: false,
+ sanitize: true,
+ sanitizeFn: null,
+ template: '
'
+}
+
+const DefaultType = {
+ allowList: 'object',
+ content: 'object',
+ extraClass: '(string|function)',
+ html: 'boolean',
+ sanitize: 'boolean',
+ sanitizeFn: '(null|function)',
+ template: 'string'
+}
+
+const DefaultContentType = {
+ entry: '(string|element|function|null)',
+ selector: '(string|element)'
+}
+
+/**
+ * Class definition
+ */
+
+class TemplateFactory extends Config {
+ constructor(config) {
+ super()
+ this._config = this._getConfig(config)
+ }
+
+ // Getters
+ static get Default() {
+ return Default
+ }
+
+ static get DefaultType() {
+ return DefaultType
+ }
+
+ static get NAME() {
+ return NAME
+ }
+
+ // Public
+ getContent() {
+ return Object.values(this._config.content)
+ .map(config => this._resolvePossibleFunction(config))
+ .filter(Boolean)
+ }
+
+ hasContent() {
+ return this.getContent().length > 0
+ }
+
+ changeContent(content) {
+ this._checkContent(content)
+ this._config.content = { ...this._config.content, ...content }
+ return this
+ }
+
+ toHtml() {
+ const templateWrapper = document.createElement('div')
+ templateWrapper.innerHTML = this._maybeSanitize(this._config.template)
+
+ for (const [selector, text] of Object.entries(this._config.content)) {
+ this._setContent(templateWrapper, text, selector)
+ }
+
+ const template = templateWrapper.children[0]
+ const extraClass = this._resolvePossibleFunction(this._config.extraClass)
+
+ if (extraClass) {
+ template.classList.add(...extraClass.split(' '))
+ }
+
+ return template
+ }
+
+ // Private
+ _typeCheckConfig(config) {
+ super._typeCheckConfig(config)
+ this._checkContent(config.content)
+ }
+
+ _checkContent(arg) {
+ for (const [selector, content] of Object.entries(arg)) {
+ super._typeCheckConfig({ selector, entry: content }, DefaultContentType)
+ }
+ }
+
+ _setContent(template, content, selector) {
+ const templateElement = SelectorEngine.findOne(selector, template)
+
+ if (!templateElement) {
+ return
+ }
+
+ content = this._resolvePossibleFunction(content)
+
+ if (!content) {
+ templateElement.remove()
+ return
+ }
+
+ if (isElement(content)) {
+ this._putElementInTemplate(getElement(content), templateElement)
+ return
+ }
+
+ if (this._config.html) {
+ templateElement.innerHTML = this._maybeSanitize(content)
+ return
+ }
+
+ templateElement.textContent = content
+ }
+
+ _maybeSanitize(arg) {
+ return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg
+ }
+
+ _resolvePossibleFunction(arg) {
+ return typeof arg === 'function' ? arg(this) : arg
+ }
+
+ _putElementInTemplate(element, templateElement) {
+ if (this._config.html) {
+ templateElement.innerHTML = ''
+ templateElement.append(element)
+ return
+ }
+
+ templateElement.textContent = element.textContent
+ }
+}
+
+export default TemplateFactory
diff --git a/cao_sunyata/static/libs/bootstrap/js/tests/README.md b/cao_sunyata/static/libs/bootstrap/js/tests/README.md
new file mode 100644
index 0000000..79d05d4
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/tests/README.md
@@ -0,0 +1,73 @@
+## How does Bootstrap's test suite work?
+
+Bootstrap uses [Jasmine](https://jasmine.github.io/). Each plugin has a file dedicated to its tests in `tests/unit/.spec.js`.
+
+- `visual/` contains "visual" tests which are run interactively in real browsers and require manual verification by humans.
+
+To run the unit test suite via [Karma](https://karma-runner.github.io/), run `npm run js-test`.
+To run the unit test suite via [Karma](https://karma-runner.github.io/) and debug, run `npm run js-debug`.
+
+## How do I add a new unit test?
+
+1. Locate and open the file dedicated to the plugin which you need to add tests to (`tests/unit/.spec.js`).
+2. Review the [Jasmine API Documentation](https://jasmine.github.io/pages/docs_home.html) and use the existing tests as references for how to structure your new tests.
+3. Write the necessary unit test(s) for the new or revised functionality.
+4. Run `npm run js-test` to see the results of your newly-added test(s).
+
+**Note:** Your new unit tests should fail before your changes are applied to the plugin, and should pass after your changes are applied to the plugin.
+
+## What should a unit test look like?
+
+- Each test should have a unique name clearly stating what unit is being tested.
+- Each test should be in the corresponding `describe`.
+- Each test should test only one unit per test, although one test can include several assertions. Create multiple tests for multiple units of functionality.
+- Each test should use [`expect`](https://jasmine.github.io/api/edge/matchers.html) to ensure something is expected.
+- Each test should follow the project's [JavaScript Code Guidelines](https://github.com/twbs/bootstrap/blob/main/.github/CONTRIBUTING.md#js)
+
+## Code coverage
+
+Currently we're aiming for at least 90% test coverage for our code. To ensure your changes meet or exceed this limit, run `npm run js-test-karma` and open the file in `js/coverage/lcov-report/index.html` to see the code coverage for each plugin. See more details when you select a plugin and ensure your change is fully covered by unit tests.
+
+### Example tests
+
+```js
+// Synchronous test
+describe('getInstance', () => {
+ it('should return null if there is no instance', () => {
+ // Make assertion
+ expect(Tab.getInstance(fixtureEl)).toBeNull()
+ })
+
+ it('should return this instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const divEl = fixtureEl.querySelector('div')
+ const tab = new Tab(divEl)
+
+ // Make assertion
+ expect(Tab.getInstance(divEl)).toEqual(tab)
+ })
+})
+
+// Asynchronous test
+it('should show a tooltip without the animation', () => {
+ return new Promise(resolve => {
+ fixtureEl.innerHTML = 'Hello, world!
+
+
+
+
Hello, world!
+
+
+
+ Tooltip on top
+
+
+
+
+
+
+
+
+
+
+
First slide label
+
Nulla vitae elit libero, a pharetra augue mollis interdum.
+
+
+
+
+
+
Second slide label
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+
+
+
+
+
+
Third slide label
+
Praesent commodo cursus magna, vel scelerisque nisl consectetur.
+
+
+
+
+
+ Previous
+
+
+ Next
+
+
+
+
'
+
+ const alertEl = fixtureEl.querySelector('.alert')
+ const alertBySelector = new Alert('.alert')
+ const alertByElement = new Alert(alertEl)
+
+ expect(alertBySelector._element).toEqual(alertEl)
+ expect(alertByElement._element).toEqual(alertEl)
+ })
+
+ it('should return version', () => {
+ expect(Alert.VERSION).toEqual(jasmine.any(String))
+ })
+
+ describe('DATA_KEY', () => {
+ it('should return plugin data key', () => {
+ expect(Alert.DATA_KEY).toEqual('bs.alert')
+ })
+ })
+
+ describe('data-api', () => {
+ it('should close an alert without instantiating it manually', () => {
+ fixtureEl.innerHTML = [
+ '',
+ ' x ',
+ '
'
+ ].join('')
+
+ const button = document.querySelector('button')
+
+ button.click()
+ expect(document.querySelectorAll('.alert')).toHaveSize(0)
+ })
+
+ it('should close an alert without instantiating it manually with the parent selector', () => {
+ fixtureEl.innerHTML = [
+ '',
+ ' x ',
+ '
'
+ ].join('')
+
+ const button = document.querySelector('button')
+
+ button.click()
+ expect(document.querySelectorAll('.alert')).toHaveSize(0)
+ })
+ })
+
+ describe('close', () => {
+ it('should close an alert', () => {
+ return new Promise(resolve => {
+ const spy = jasmine.createSpy('spy', getTransitionDurationFromElement)
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = document.querySelector('.alert')
+ const alert = new Alert(alertEl)
+
+ alertEl.addEventListener('closed.bs.alert', () => {
+ expect(document.querySelectorAll('.alert')).toHaveSize(0)
+ expect(spy).not.toHaveBeenCalled()
+ resolve()
+ })
+
+ alert.close()
+ })
+ })
+
+ it('should close alert with fade class', () => {
+ return new Promise(resolve => {
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = document.querySelector('.alert')
+ const alert = new Alert(alertEl)
+
+ alertEl.addEventListener('transitionend', () => {
+ expect().nothing()
+ })
+
+ alertEl.addEventListener('closed.bs.alert', () => {
+ expect(document.querySelectorAll('.alert')).toHaveSize(0)
+ resolve()
+ })
+
+ alert.close()
+ })
+ })
+
+ it('should not remove alert if close event is prevented', () => {
+ return new Promise((resolve, reject) => {
+ fixtureEl.innerHTML = '
'
+
+ const getAlert = () => document.querySelector('.alert')
+ const alertEl = getAlert()
+ const alert = new Alert(alertEl)
+
+ alertEl.addEventListener('close.bs.alert', event => {
+ event.preventDefault()
+ setTimeout(() => {
+ expect(getAlert()).not.toBeNull()
+ resolve()
+ }, 10)
+ })
+
+ alertEl.addEventListener('closed.bs.alert', () => {
+ reject(new Error('should not fire closed event'))
+ })
+
+ alert.close()
+ })
+ })
+ })
+
+ describe('dispose', () => {
+ it('should dispose an alert', () => {
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = document.querySelector('.alert')
+ const alert = new Alert(alertEl)
+
+ expect(Alert.getInstance(alertEl)).not.toBeNull()
+
+ alert.dispose()
+
+ expect(Alert.getInstance(alertEl)).toBeNull()
+ })
+ })
+
+ describe('jQueryInterface', () => {
+ it('should handle config passed and toggle existing alert', () => {
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = fixtureEl.querySelector('.alert')
+ const alert = new Alert(alertEl)
+
+ const spy = spyOn(alert, 'close')
+
+ jQueryMock.fn.alert = Alert.jQueryInterface
+ jQueryMock.elements = [alertEl]
+
+ jQueryMock.fn.alert.call(jQueryMock, 'close')
+
+ expect(spy).toHaveBeenCalled()
+ })
+
+ it('should create new alert instance and call close', () => {
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = fixtureEl.querySelector('.alert')
+
+ jQueryMock.fn.alert = Alert.jQueryInterface
+ jQueryMock.elements = [alertEl]
+
+ expect(Alert.getInstance(alertEl)).toBeNull()
+ jQueryMock.fn.alert.call(jQueryMock, 'close')
+
+ expect(fixtureEl.querySelector('.alert')).toBeNull()
+ })
+
+ it('should just create an alert instance without calling close', () => {
+ fixtureEl.innerHTML = '
'
+
+ const alertEl = fixtureEl.querySelector('.alert')
+
+ jQueryMock.fn.alert = Alert.jQueryInterface
+ jQueryMock.elements = [alertEl]
+
+ jQueryMock.fn.alert.call(jQueryMock)
+
+ expect(Alert.getInstance(alertEl)).not.toBeNull()
+ expect(fixtureEl.querySelector('.alert')).not.toBeNull()
+ })
+
+ it('should throw an error on undefined method', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+ const action = 'undefinedMethod'
+
+ jQueryMock.fn.alert = Alert.jQueryInterface
+ jQueryMock.elements = [div]
+
+ expect(() => {
+ jQueryMock.fn.alert.call(jQueryMock, action)
+ }).toThrowError(TypeError, `No method named "${action}"`)
+ })
+
+ it('should throw an error on protected method', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+ const action = '_getConfig'
+
+ jQueryMock.fn.alert = Alert.jQueryInterface
+ jQueryMock.elements = [div]
+
+ expect(() => {
+ jQueryMock.fn.alert.call(jQueryMock, action)
+ }).toThrowError(TypeError, `No method named "${action}"`)
+ })
+ })
+
+ describe('getInstance', () => {
+ it('should return alert instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+ const alert = new Alert(div)
+
+ expect(Alert.getInstance(div)).toEqual(alert)
+ expect(Alert.getInstance(div)).toBeInstanceOf(Alert)
+ })
+
+ it('should return null when there is no alert instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+
+ expect(Alert.getInstance(div)).toBeNull()
+ })
+ })
+
+ describe('getOrCreateInstance', () => {
+ it('should return alert instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+ const alert = new Alert(div)
+
+ expect(Alert.getOrCreateInstance(div)).toEqual(alert)
+ expect(Alert.getInstance(div)).toEqual(Alert.getOrCreateInstance(div, {}))
+ expect(Alert.getOrCreateInstance(div)).toBeInstanceOf(Alert)
+ })
+
+ it('should return new instance when there is no alert instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+
+ expect(Alert.getInstance(div)).toBeNull()
+ expect(Alert.getOrCreateInstance(div)).toBeInstanceOf(Alert)
+ })
+ })
+})
diff --git a/cao_sunyata/static/libs/bootstrap/js/tests/unit/base-component.spec.js b/cao_sunyata/static/libs/bootstrap/js/tests/unit/base-component.spec.js
new file mode 100644
index 0000000..b2352d6
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/tests/unit/base-component.spec.js
@@ -0,0 +1,168 @@
+import BaseComponent from '../../src/base-component'
+import { clearFixture, getFixture } from '../helpers/fixture'
+import EventHandler from '../../src/dom/event-handler'
+import { noop } from '../../src/util'
+
+class DummyClass extends BaseComponent {
+ constructor(element) {
+ super(element)
+
+ EventHandler.on(this._element, `click${DummyClass.EVENT_KEY}`, noop)
+ }
+
+ static get NAME() {
+ return 'dummy'
+ }
+}
+
+describe('Base Component', () => {
+ let fixtureEl
+ const name = 'dummy'
+ let element
+ let instance
+ const createInstance = () => {
+ fixtureEl.innerHTML = '
'
+ element = fixtureEl.querySelector('#foo')
+ instance = new DummyClass(element)
+ }
+
+ beforeAll(() => {
+ fixtureEl = getFixture()
+ })
+
+ afterEach(() => {
+ clearFixture()
+ })
+
+ describe('Static Methods', () => {
+ describe('VERSION', () => {
+ it('should return version', () => {
+ expect(DummyClass.VERSION).toEqual(jasmine.any(String))
+ })
+ })
+
+ describe('DATA_KEY', () => {
+ it('should return plugin data key', () => {
+ expect(DummyClass.DATA_KEY).toEqual(`bs.${name}`)
+ })
+ })
+
+ describe('NAME', () => {
+ it('should throw an Error if it is not initialized', () => {
+ expect(() => {
+ // eslint-disable-next-line no-unused-expressions
+ BaseComponent.NAME
+ }).toThrowError(Error)
+ })
+
+ it('should return plugin NAME', () => {
+ expect(DummyClass.NAME).toEqual(name)
+ })
+ })
+
+ describe('EVENT_KEY', () => {
+ it('should return plugin event key', () => {
+ expect(DummyClass.EVENT_KEY).toEqual(`.bs.${name}`)
+ })
+ })
+ })
+
+ describe('Public Methods', () => {
+ describe('constructor', () => {
+ it('should accept element, either passed as a CSS selector or DOM element', () => {
+ fixtureEl.innerHTML = [
+ '
',
+ '
'
+ ].join('')
+
+ const el = fixtureEl.querySelector('#foo')
+ const elInstance = new DummyClass(el)
+ const selectorInstance = new DummyClass('#bar')
+
+ expect(elInstance._element).toEqual(el)
+ expect(selectorInstance._element).toEqual(fixtureEl.querySelector('#bar'))
+ })
+
+ it('should not initialize and add element record to Data (caching), if argument `element` is not an HTML element', () => {
+ fixtureEl.innerHTML = ''
+
+ const el = fixtureEl.querySelector('#foo')
+ const elInstance = new DummyClass(el)
+ const selectorInstance = new DummyClass('#bar')
+
+ expect(elInstance._element).not.toBeDefined()
+ expect(selectorInstance._element).not.toBeDefined()
+ })
+ })
+
+ describe('dispose', () => {
+ it('should dispose an component', () => {
+ createInstance()
+ expect(DummyClass.getInstance(element)).not.toBeNull()
+
+ instance.dispose()
+
+ expect(DummyClass.getInstance(element)).toBeNull()
+ expect(instance._element).toBeNull()
+ })
+
+ it('should de-register element event listeners', () => {
+ createInstance()
+ const spy = spyOn(EventHandler, 'off')
+
+ instance.dispose()
+
+ expect(spy).toHaveBeenCalledWith(element, DummyClass.EVENT_KEY)
+ })
+ })
+
+ describe('getInstance', () => {
+ it('should return an instance', () => {
+ createInstance()
+
+ expect(DummyClass.getInstance(element)).toEqual(instance)
+ expect(DummyClass.getInstance(element)).toBeInstanceOf(DummyClass)
+ })
+
+ it('should accept element, either passed as a CSS selector, jQuery element, or DOM element', () => {
+ createInstance()
+
+ expect(DummyClass.getInstance('#foo')).toEqual(instance)
+ expect(DummyClass.getInstance(element)).toEqual(instance)
+
+ const fakejQueryObject = {
+ 0: element,
+ jquery: 'foo'
+ }
+
+ expect(DummyClass.getInstance(fakejQueryObject)).toEqual(instance)
+ })
+
+ it('should return null when there is no instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+
+ expect(DummyClass.getInstance(div)).toBeNull()
+ })
+ })
+
+ describe('getOrCreateInstance', () => {
+ it('should return an instance', () => {
+ createInstance()
+
+ expect(DummyClass.getOrCreateInstance(element)).toEqual(instance)
+ expect(DummyClass.getInstance(element)).toEqual(DummyClass.getOrCreateInstance(element, {}))
+ expect(DummyClass.getOrCreateInstance(element)).toBeInstanceOf(DummyClass)
+ })
+
+ it('should return new instance when there is no alert instance', () => {
+ fixtureEl.innerHTML = '
'
+ element = fixtureEl.querySelector('#foo')
+
+ expect(DummyClass.getInstance(element)).toBeNull()
+ expect(DummyClass.getOrCreateInstance(element)).toBeInstanceOf(DummyClass)
+ })
+ })
+ })
+})
diff --git a/cao_sunyata/static/libs/bootstrap/js/tests/unit/button.spec.js b/cao_sunyata/static/libs/bootstrap/js/tests/unit/button.spec.js
new file mode 100644
index 0000000..09ed17e
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/tests/unit/button.spec.js
@@ -0,0 +1,183 @@
+import Button from '../../src/button'
+import { getFixture, clearFixture, jQueryMock } from '../helpers/fixture'
+
+describe('Button', () => {
+ let fixtureEl
+
+ beforeAll(() => {
+ fixtureEl = getFixture()
+ })
+
+ afterEach(() => {
+ clearFixture()
+ })
+
+ it('should take care of element either passed as a CSS selector or DOM element', () => {
+ fixtureEl.innerHTML = 'Placeholder '
+ const buttonEl = fixtureEl.querySelector('[data-bs-toggle="button"]')
+ const buttonBySelector = new Button('[data-bs-toggle="button"]')
+ const buttonByElement = new Button(buttonEl)
+
+ expect(buttonBySelector._element).toEqual(buttonEl)
+ expect(buttonByElement._element).toEqual(buttonEl)
+ })
+
+ describe('VERSION', () => {
+ it('should return plugin version', () => {
+ expect(Button.VERSION).toEqual(jasmine.any(String))
+ })
+ })
+
+ describe('DATA_KEY', () => {
+ it('should return plugin data key', () => {
+ expect(Button.DATA_KEY).toEqual('bs.button')
+ })
+ })
+
+ describe('data-api', () => {
+ it('should toggle active class on click', () => {
+ fixtureEl.innerHTML = [
+ 'btn ',
+ '
'
+
+ const div = fixtureEl.querySelector('div')
+ const button = new Button(div)
+
+ expect(Button.getInstance(div)).toEqual(button)
+ expect(Button.getInstance(div)).toBeInstanceOf(Button)
+ })
+
+ it('should return null when there is no button instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+
+ expect(Button.getInstance(div)).toBeNull()
+ })
+ })
+
+ describe('getOrCreateInstance', () => {
+ it('should return button instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+ const button = new Button(div)
+
+ expect(Button.getOrCreateInstance(div)).toEqual(button)
+ expect(Button.getInstance(div)).toEqual(Button.getOrCreateInstance(div, {}))
+ expect(Button.getOrCreateInstance(div)).toBeInstanceOf(Button)
+ })
+
+ it('should return new instance when there is no button instance', () => {
+ fixtureEl.innerHTML = '
'
+
+ const div = fixtureEl.querySelector('div')
+
+ expect(Button.getInstance(div)).toBeNull()
+ expect(Button.getOrCreateInstance(div)).toBeInstanceOf(Button)
+ })
+ })
+})
diff --git a/cao_sunyata/static/libs/bootstrap/js/tests/unit/carousel.spec.js b/cao_sunyata/static/libs/bootstrap/js/tests/unit/carousel.spec.js
new file mode 100644
index 0000000..d951bd5
--- /dev/null
+++ b/cao_sunyata/static/libs/bootstrap/js/tests/unit/carousel.spec.js
@@ -0,0 +1,1570 @@
+import Carousel from '../../src/carousel'
+import EventHandler from '../../src/dom/event-handler'
+import { clearFixture, createEvent, getFixture, jQueryMock } from '../helpers/fixture'
+import { isRTL, noop } from '../../src/util/index'
+import Swipe from '../../src/util/swipe'
+
+describe('Carousel', () => {
+ const { Simulator, PointerEvent } = window
+ const originWinPointerEvent = PointerEvent
+ const supportPointerEvent = Boolean(PointerEvent)
+
+ const cssStyleCarousel = '.carousel.pointer-event { touch-action: none; }'
+
+ const stylesCarousel = document.createElement('style')
+ stylesCarousel.type = 'text/css'
+ stylesCarousel.append(document.createTextNode(cssStyleCarousel))
+
+ const clearPointerEvents = () => {
+ window.PointerEvent = null
+ }
+
+ const restorePointerEvents = () => {
+ window.PointerEvent = originWinPointerEvent
+ }
+
+ let fixtureEl
+
+ beforeAll(() => {
+ fixtureEl = getFixture()
+ })
+
+ afterEach(() => {
+ clearFixture()
+ })
+
+ describe('VERSION', () => {
+ it('should return plugin version', () => {
+ expect(Carousel.VERSION).toEqual(jasmine.any(String))
+ })
+ })
+
+ describe('Default', () => {
+ it('should return plugin default config', () => {
+ expect(Carousel.Default).toEqual(jasmine.any(Object))
+ })
+ })
+
+ describe('DATA_KEY', () => {
+ it('should return plugin data key', () => {
+ expect(Carousel.DATA_KEY).toEqual('bs.carousel')
+ })
+ })
+
+ describe('constructor', () => {
+ it('should take care of element either passed as a CSS selector or DOM element', () => {
+ fixtureEl.innerHTML = '
'
+
+ const carouselEl = fixtureEl.querySelector('#myCarousel')
+ const carouselBySelector = new Carousel('#myCarousel')
+ const carouselByElement = new Carousel(carouselEl)
+
+ expect(carouselBySelector._element).toEqual(carouselEl)
+ expect(carouselByElement._element).toEqual(carouselEl)
+ })
+
+ it('should start cycling if `ride`===`carousel`', () => {
+ fixtureEl.innerHTML = '
'
+
+ const carousel = new Carousel('#myCarousel')
+ expect(carousel._interval).not.toBeNull()
+ })
+
+ it('should not start cycling if `ride`!==`carousel`', () => {
+ fixtureEl.innerHTML = '
'
+
+ const carousel = new Carousel('#myCarousel')
+ expect(carousel._interval).toBeNull()
+ })
+
+ it('should go to next item if right arrow key is pressed', () => {
+ return new Promise(resolve => {
+ fixtureEl.innerHTML = [
+ '',
+ '
',
+ '
item 1
',
+ '
item 2
',
+ '
item 3
',
+ '
',
+ '
',
+ '
',
+ '
item 1
',
+ '
item 2
',
+ '
',
+ '
',
+ '
',
+ '
item 1
',
+ '
item 2
',
+ '
',
+ '
',
+ '
',
+ '
item 1
',
+ '
item 2
',
+ '
item 3
',
+ '
',
+ '
',
+ '
',
+ '
item 1
',
+ '
item 2
',
+ '
item 3
',
+ '
',
+ '
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
](http://godban.github.io/browsers-support-badges/)
](http://godban.github.io/browsers-support-badges/)
](http://godban.github.io/browsers-support-badges/)
](http://godban.github.io/browsers-support-badges/)
](http://godban.github.io/browsers-support-badges/)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+