From c179b3413583e713c61fd67514232ac32657838a Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 7 Apr 2022 10:27:46 -0400 Subject: [PATCH 01/82] - starting 4.1.0 dev --- NEMO/tests/test_closures.py | 8 ++++---- setup.py | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/NEMO/tests/test_closures.py b/NEMO/tests/test_closures.py index 73c220c6..3175adb2 100644 --- a/NEMO/tests/test_closures.py +++ b/NEMO/tests/test_closures.py @@ -1,9 +1,9 @@ from datetime import timedelta -from django.core.exceptions import ValidationError from django.test import TestCase from django.utils import timezone +from NEMO.admin import ClosureAdminForm from NEMO.models import Alert, Closure, ClosureTime, Customization, EmailLog, User from NEMO.utilities import EmailCategory from NEMO.views.calendar import do_create_closure_alerts @@ -19,9 +19,9 @@ def setUp(self): def testAlertNoTemplate(self): # Try creating an alert with days_before set but no alert template (should fail) - with self.assertRaises(ValidationError) as cm: - Closure(name="Closure fail", alert_days_before=0).full_clean() - self.assertIn("alert_template", cm.exception.error_dict) + closure_admin = ClosureAdminForm({"name": "Closure fail", "alert_days_before": 1}) + self.assertFalse(closure_admin.is_valid()) + self.assertIn("alert_template", closure_admin.errors) def testClosureNoAlerts(self): # Create closure with no alert days before diff --git a/setup.py b/setup.py index a43c5dde..c003bf78 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ setup( name='NEMO', - version='4.0.0', + version='4.1.0.dev', python_requires='>=3.7', packages=find_packages(exclude=['NEMO.tests','NEMO.tests.*']), include_package_data=True, From e24e96c428c23b43537ea1f4e2ea9c3edfadb1de Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 7 Apr 2022 17:46:46 -0400 Subject: [PATCH 02/82] - added version number to login page --- NEMO/templates/login.html | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/NEMO/templates/login.html b/NEMO/templates/login.html index cb7ff900..8115acab 100644 --- a/NEMO/templates/login.html +++ b/NEMO/templates/login.html @@ -70,6 +70,7 @@ {{ login_banner|safe }} {% endif %} + {% include 'base/footer.html' %} + \ No newline at end of file From 2f43446c80f9ab607268f5835d97a2744f92e47b Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 14 Apr 2022 13:17:51 -0400 Subject: [PATCH 03/82] - fixed closures not respecting staff_absent flag on staff status calendar - closures not including full day (starts or end at 12pm for exemple) will now show as partial closures on the staff calendar --- NEMO/templates/status_dashboard/staff.html | 5 ++++- NEMO/views/status_dashboard.py | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/NEMO/templates/status_dashboard/staff.html b/NEMO/templates/status_dashboard/staff.html index aa468864..a0649562 100644 --- a/NEMO/templates/status_dashboard/staff.html +++ b/NEMO/templates/status_dashboard/staff.html @@ -1,4 +1,5 @@ {% load custom_tags_and_filters %} +{% load tz %}
Staff availability is highlighted in green
@@ -67,7 +68,8 @@ {% for day in days %} {% with staff_available=staff.weekly_availability|get_item:day.weekday staff_absent=staff_absences|get_item:staff.id|get_item:day.day closure_time=closure_times|get_item:day.day %} - + {% with start_closure_time=closure_time.start_time|localtime end_closure_time=closure_time.end_time|localtime %} + {% if closure_time %} {% with custom_data_template="" %}
Closed
@@ -82,6 +84,7 @@
 
{% endif %} + {% endwith %} {% endwith %} {% endfor %} diff --git a/NEMO/views/status_dashboard.py b/NEMO/views/status_dashboard.py index 33b7cbb8..3d611ba0 100644 --- a/NEMO/views/status_dashboard.py +++ b/NEMO/views/status_dashboard.py @@ -219,7 +219,7 @@ def staff_absences_dict(staffs, days, start, end): def closures_dict(days, start, end): dictionary = {} - closure_times = ClosureTime.objects.filter(start_time__lte=end, end_time__gte=start) + closure_times = ClosureTime.objects.filter(start_time__lte=end, end_time__gte=start, closure__staff_absent=True) for closure_time in closure_times: for day in days: if as_timezone(closure_time.start_time).date() <= day.date() <= as_timezone(closure_time.end_time).date(): From 74c46d5dab541d0a1b392ca12d016651abdd22f8 Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 18 Apr 2022 16:13:51 -0400 Subject: [PATCH 04/82] - fixed format_datetime not checking the right type of datetime --- NEMO/decorators.py | 2 +- NEMO/migrations/0038_version_4_0_0.py | 4 ++-- NEMO/utilities.py | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/NEMO/decorators.py b/NEMO/decorators.py index 5ea4c493..12608f86 100644 --- a/NEMO/decorators.py +++ b/NEMO/decorators.py @@ -21,7 +21,7 @@ def disable_session_expiry_refresh(f): return f -# Use this decorator on a function to make a call to said function asynchronous +# Use this decorator on a function to make a call to that function asynchronously # The function will be run in a separate thread, and the current execution will continue def postpone(function): def decorator(*arguments, **named_arguments): diff --git a/NEMO/migrations/0038_version_4_0_0.py b/NEMO/migrations/0038_version_4_0_0.py index 3ffb26bb..33fb2546 100644 --- a/NEMO/migrations/0038_version_4_0_0.py +++ b/NEMO/migrations/0038_version_4_0_0.py @@ -14,13 +14,13 @@ class Migration(migrations.Migration): def new_version_news(apps, schema_editor): create_news_for_version(apps, "4.0.0", "") - def add_web_relay_x_series(apps, schema_editor): + def add_modbus_tcp_interlock_category(apps, schema_editor): InterlockCardCategory = apps.get_model("NEMO", "InterlockCardCategory") InterlockCardCategory.objects.create(name="ModbusTcp", key="modbus_tcp") operations = [ migrations.RunPython(new_version_news), - migrations.RunPython(add_web_relay_x_series), + migrations.RunPython(add_modbus_tcp_interlock_category), migrations.AlterField( model_name='interlock', name='channel', diff --git a/NEMO/utilities.py b/NEMO/utilities.py index dfccac49..91789490 100644 --- a/NEMO/utilities.py +++ b/NEMO/utilities.py @@ -244,9 +244,9 @@ def format_daterange(start_time, end_time, dt_format="DATETIME_FORMAT", d_format def format_datetime(universal_time=None, df=None, as_current_timezone=True, use_l10n=None) -> str: this_time = universal_time if universal_time else timezone.now() if as_current_timezone else datetime.now() local_time = as_timezone(this_time) if as_current_timezone else this_time - if isinstance(universal_time, time): + if isinstance(local_time, time): return time_format(local_time, df or "TIME_FORMAT", use_l10n) - elif isinstance(universal_time, datetime): + elif isinstance(local_time, datetime): return date_format(local_time, df or "DATETIME_FORMAT", use_l10n) return date_format(local_time, df or "DATE_FORMAT", use_l10n) From 61dd8adcb60210c32a8e11c05aaabf389ec23ebb Mon Sep 17 00:00:00 2001 From: mrampant Date: Wed, 20 Apr 2022 17:34:45 -0400 Subject: [PATCH 05/82] - added default auto field to splash_pad_settings.py --- resources/splash_pad_settings.py | 1 + 1 file changed, 1 insertion(+) diff --git a/resources/splash_pad_settings.py b/resources/splash_pad_settings.py index 9bfbfdca..4a5867f0 100644 --- a/resources/splash_pad_settings.py +++ b/resources/splash_pad_settings.py @@ -1,5 +1,6 @@ DEBUG = True FIXTURE_DIRS = ['/nemo/'] +DEFAULT_AUTO_FIELD = 'django.db.models.AutoField' AUTH_USER_MODEL = 'NEMO.User' WSGI_APPLICATION = 'NEMO.wsgi.application' ROOT_URLCONF = 'NEMO.urls' From 299ce9f643b82c89072e03592597b71c6382547a Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 21 Apr 2022 14:10:59 -0400 Subject: [PATCH 06/82] - removing unit from interlock modbus calls --- NEMO/interlocks.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/NEMO/interlocks.py b/NEMO/interlocks.py index 6573713e..02720636 100644 --- a/NEMO/interlocks.py +++ b/NEMO/interlocks.py @@ -381,11 +381,11 @@ def setRelayState(cls, interlock: Interlock_model, state: {0, 1}) -> Interlock_m coil = interlock.channel client = ModbusTcpClient(interlock.card.server, port=interlock.card.port) client.connect() - write_reply = client.write_coil(coil, state, unit=1) + write_reply = client.write_coil(coil, state) if write_reply.isError(): raise Exception(str(write_reply)) sleep(0.3) - read_reply = client.read_coils(coil, 1, unit=1) + read_reply = client.read_coils(coil, 1) if read_reply.isError(): raise Exception(str(read_reply)) state = read_reply.bits[0] From acc2a9ff62b0ff6c04e1a60e995956943c281072 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 21 Apr 2022 14:11:32 -0400 Subject: [PATCH 07/82] - updated python version 3.6 -> 3.7 in setup.py --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c003bf78..aa2bb5a9 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ 'License :: Public Domain', 'Natural Language :: English', 'Operating System :: OS Independent', - 'Programming Language :: Python :: 3.6', + 'Programming Language :: Python :: 3.7', ], install_requires=[ 'cryptography==36.0.2', From 8f27f178535a2d1d523e39cd034ef8b297e42baa Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 21 Apr 2022 14:12:31 -0400 Subject: [PATCH 08/82] - updated set interval js method to return the interval handle --- NEMO/static/nemo.js | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/NEMO/static/nemo.js b/NEMO/static/nemo.js index 3f40145f..09aa2605 100644 --- a/NEMO/static/nemo.js +++ b/NEMO/static/nemo.js @@ -2,15 +2,16 @@ String.prototype.capitalize = function() { return this.charAt(0).toUpperCase() + this.slice(1); } -// This function allows to make regular interval calls to a function only when the tab/window is visible. +// This function allows making regular interval calls to a function only when the tab/window is visible. // It also gets called when the tab/window becomes visible (changing tabs, minimizing window etc.) +// It returns the interval handle function set_interval_when_visible(doc, function_to_repeat, time) { doc.addEventListener("visibilitychange", function() { function_to_repeat(); }); - setInterval(function() + return setInterval(function() { if (!doc.hidden) function_to_repeat(); }, time) From 6baddd7994bcef55c699f75cd18f0a234100688e Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 21 Apr 2022 14:16:30 -0400 Subject: [PATCH 09/82] - initial commit of internal sensor plugin - allows creating sensors to collect data from (temperature, gas etc.) - added sensor card, categories and data models - added basic view with table and chart (using chart.js) --- NEMO/apps/sensors/__init__.py | 0 NEMO/apps/sensors/admin.py | 109 + NEMO/apps/sensors/evaluators.py | 71 + NEMO/apps/sensors/management/__init__.py | 0 .../sensors/management/commands/__init__.py | 0 .../management/commands/manage_sensor_data.py | 10 + NEMO/apps/sensors/migrations/0001_initial.py | 106 + NEMO/apps/sensors/migrations/__init__.py | 0 NEMO/apps/sensors/models.py | 148 + NEMO/apps/sensors/sensors.py | 96 + NEMO/apps/sensors/static/sensors/chart.js | 13269 ++++++++++++++++ .../static/sensors/chartjs-adapter-moment.js | 8 + .../templates/sensors/sensor_data.html | 149 + .../sensors/templates/sensors/sensors.html | 33 + NEMO/apps/sensors/urls.py | 10 + NEMO/apps/sensors/views.py | 69 + NEMO/tests/test_sensors.py | 20 + 17 files changed, 14098 insertions(+) create mode 100644 NEMO/apps/sensors/__init__.py create mode 100644 NEMO/apps/sensors/admin.py create mode 100644 NEMO/apps/sensors/evaluators.py create mode 100644 NEMO/apps/sensors/management/__init__.py create mode 100644 NEMO/apps/sensors/management/commands/__init__.py create mode 100644 NEMO/apps/sensors/management/commands/manage_sensor_data.py create mode 100644 NEMO/apps/sensors/migrations/0001_initial.py create mode 100644 NEMO/apps/sensors/migrations/__init__.py create mode 100644 NEMO/apps/sensors/models.py create mode 100644 NEMO/apps/sensors/sensors.py create mode 100644 NEMO/apps/sensors/static/sensors/chart.js create mode 100644 NEMO/apps/sensors/static/sensors/chartjs-adapter-moment.js create mode 100644 NEMO/apps/sensors/templates/sensors/sensor_data.html create mode 100644 NEMO/apps/sensors/templates/sensors/sensors.html create mode 100644 NEMO/apps/sensors/urls.py create mode 100644 NEMO/apps/sensors/views.py create mode 100644 NEMO/tests/test_sensors.py diff --git a/NEMO/apps/sensors/__init__.py b/NEMO/apps/sensors/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/NEMO/apps/sensors/admin.py b/NEMO/apps/sensors/admin.py new file mode 100644 index 00000000..f37b4b0d --- /dev/null +++ b/NEMO/apps/sensors/admin.py @@ -0,0 +1,109 @@ +from django import forms +from django.contrib import admin, messages +from django.contrib.admin import register +from django.contrib.admin.decorators import display + +from NEMO.apps.sensors.models import Sensor, SensorCard, SensorCardCategory, SensorCategory, SensorData + + +def read_selected_sensors(model_admin, request, queryset): + for sensor in queryset: + try: + sensor.read_data(raise_exception=True) + messages.success(request, f"Read command has been sent to {sensor}") + except Exception as error: + messages.error(request, f"Command could not be sent to {sensor} due to the following error: {str(error)}") + + +class SensorCardAdminForm(forms.ModelForm): + class Meta: + model = SensorCard + widgets = {"password": forms.PasswordInput(render_value=True)} + fields = "__all__" + + def clean(self): + if any(self.errors): + return + cleaned_data = super().clean() + category = cleaned_data["category"] + from NEMO.apps.sensors import sensors + + sensors.get(category).clean_sensor_card(self) + return cleaned_data + + +@register(SensorCard) +class SensorCardAdmin(admin.ModelAdmin): + form = SensorCardAdminForm + list_display = ("name", "enabled", "server", "port", "number", "category", "even_port", "odd_port") + + +class SensorAdminForm(forms.ModelForm): + class Meta: + model = Sensor + fields = "__all__" + + def clean(self): + if any(self.errors): + return + cleaned_data = super().clean() + + card = ( + self.cleaned_data["sensor_card"] + if "sensor_card" in self.cleaned_data + else self.cleaned_data["interlock_card"] + ) + if card: + category = card.category + from NEMO.apps.sensors import sensors + + sensors.get(category).clean_sensor(self) + return cleaned_data + + +@register(SensorCategory) +class SensorCategoryAdmin(admin.ModelAdmin): + list_display = ("name",) + + +@register(Sensor) +class SensorAdmin(admin.ModelAdmin): + form = SensorAdminForm + list_display = ( + "id", + "name", + "card", + "get_card_enabled", + "sensor_category", + "unit_id", + "read_address", + "number_of_values", + "read_frequency", + "get_last_read", + ) + actions = [read_selected_sensors] + + @display(boolean=True, ordering="sensor_card__enabled", description="Card Enabled") + def get_card_enabled(self, obj: Sensor): + return obj.card.enabled + + @display(description="Last read") + def get_last_read(self, obj: Sensor): + last_data_point = obj.last_data_point() + return last_data_point.value if last_data_point else "" + + +@register(SensorCardCategory) +class SensorCardCategoryAdmin(admin.ModelAdmin): + list_display = ("name",) + + +@register(SensorData) +class SensorDataAdmin(admin.ModelAdmin): + list_display = ("created_date", "sensor", "value", "get_display_value") + date_hierarchy = "created_date" + list_filter = ("sensor",) + + @display(ordering="sensor__data_prefix", description="Display value") + def get_display_value(self, obj: SensorData): + return obj.display_value() diff --git a/NEMO/apps/sensors/evaluators.py b/NEMO/apps/sensors/evaluators.py new file mode 100644 index 00000000..8a6a695f --- /dev/null +++ b/NEMO/apps/sensors/evaluators.py @@ -0,0 +1,71 @@ +import ast +import operator +from _ast import BinOp, Name, NameConstant, Num, Slice, Subscript, UnaryOp + +# supported operators +base_operators = { + ast.Add: operator.add, + ast.Sub: operator.sub, + ast.Mult: operator.mul, + ast.Div: operator.truediv, + ast.Pow: operator.pow, + ast.BitXor: operator.xor, + ast.USub: operator.neg, + ast.mod: operator.mod, +} + + +class BasicEvaluatorVisitor(ast.NodeVisitor): + def __init__(self, **kwargs): + self._variables = kwargs + + def visit_Name(self, node: Name): + return self._variables[node.id] + + def visit_Num(self, node: Num): + return node.n + + def visit_NameConstant(self, node: NameConstant): + return node.value + + def visit_UnaryOp(self, node: UnaryOp): + val = self.visit(node.operand) + return base_operators[type(node.op)](val) + + def visit_BinOp(self, node: BinOp): + lhs = self.visit(node.left) + rhs = self.visit(node.right) + return base_operators[type(node.op)](lhs, rhs) + + def visit_Subscript(self, node: Subscript): + val = self.visit(node.value) + index = self.visit(node.slice) + try: + return val[index] + except AttributeError: + return self.generic_visit(node) + + def visit_Index(self, node, **kwargs): + """df.index[4]""" + return self.visit(node.value) + + def visit_Slice(self, node: Slice): + lower = node.lower + if lower is not None: + lower = self.visit(lower) + upper = node.upper + if upper is not None: + upper = self.visit(upper) + step = node.step + if step is not None: + step = self.visit(step) + + return slice(lower, upper, step) + + def generic_visit(self, node): + raise ValueError("malformed node or string: " + repr(node)) + + +def evaluate_expression(expr, **kwargs): + v = BasicEvaluatorVisitor(**kwargs) + return v.visit(ast.parse(expr, mode="eval").body) diff --git a/NEMO/apps/sensors/management/__init__.py b/NEMO/apps/sensors/management/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/NEMO/apps/sensors/management/commands/__init__.py b/NEMO/apps/sensors/management/commands/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/NEMO/apps/sensors/management/commands/manage_sensor_data.py b/NEMO/apps/sensors/management/commands/manage_sensor_data.py new file mode 100644 index 00000000..5bdb44a7 --- /dev/null +++ b/NEMO/apps/sensors/management/commands/manage_sensor_data.py @@ -0,0 +1,10 @@ +from django.core.management import BaseCommand + +from NEMO.apps.sensors.views import do_manage_sensor_data + + +class Command(BaseCommand): + help = "Run every minute to read and manage sensors data." + + def handle(self, *args, **options): + do_manage_sensor_data(asynchronous=False) diff --git a/NEMO/apps/sensors/migrations/0001_initial.py b/NEMO/apps/sensors/migrations/0001_initial.py new file mode 100644 index 00000000..4074b437 --- /dev/null +++ b/NEMO/apps/sensors/migrations/0001_initial.py @@ -0,0 +1,106 @@ +# Generated by Django 3.2.12 on 2022-04-18 14:37 + +import django.core.validators +import django.db.models.deletion +from django.db import migrations, models + + +class Migration(migrations.Migration): + + initial = True + + dependencies = [ + ('NEMO', '0038_version_4_0_0'), + ] + + def add_modbus_tcp_sensor_category(apps, schema_editor): + SensorCardCategory = apps.get_model("sensors", "SensorCardCategory") + SensorCardCategory.objects.create(name="ModbusTcp", key="modbus_tcp") + + operations = [ + migrations.CreateModel( + name='Sensor', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.CharField(max_length=200)), + ('data_prefix', models.CharField(blank=True, max_length=100, null=True)), + ('data_suffix', models.CharField(blank=True, max_length=100, null=True)), + ('unit_id', models.PositiveIntegerField(blank=True, null=True)), + ('read_address', models.PositiveIntegerField(blank=True, null=True)), + ('number_of_values', models.PositiveIntegerField(blank=True, null=True, validators=[django.core.validators.MinValueValidator(1)])), + ('formula', models.TextField(blank=True, help_text='Enter a formula to compute for this sensor values. The list of registers read is available as variable registers', null=True)), + ('read_frequency', models.PositiveIntegerField(default=5, help_text='Enter the read frequency in minutes. Every 2 hours = 120, etc. Max value is 1440 min (24hrs).', validators=[django.core.validators.MaxValueValidator(1440), django.core.validators.MinValueValidator(1)])), + ], + ), + migrations.CreateModel( + name='SensorCardCategory', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.CharField(help_text='The name for this sensor card category', max_length=200)), + ('key', models.CharField(help_text='The key to identify this sensor card category by in sensors.py', max_length=100)), + ], + options={ + 'verbose_name_plural': 'Sensor card categories', + 'ordering': ['name'], + }, + ), + migrations.CreateModel( + name='SensorCategory', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.CharField(help_text='The name for this sensor category', max_length=200)), + ], + options={ + 'verbose_name_plural': 'Sensor categories', + 'ordering': ['name'], + }, + ), + migrations.CreateModel( + name='SensorData', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('created_date', models.DateTimeField(auto_now_add=True)), + ('value', models.BigIntegerField()), + ('sensor', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='sensors.sensor')), + ], + options={ + 'verbose_name_plural': 'Sensor data', + 'ordering': ['-created_date'], + }, + ), + migrations.CreateModel( + name='SensorCard', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.CharField(max_length=200)), + ('server', models.CharField(max_length=200)), + ('port', models.PositiveIntegerField()), + ('number', models.PositiveIntegerField(blank=True, null=True)), + ('even_port', models.PositiveIntegerField(blank=True, null=True)), + ('odd_port', models.PositiveIntegerField(blank=True, null=True)), + ('username', models.CharField(blank=True, max_length=100, null=True)), + ('password', models.CharField(blank=True, max_length=100, null=True)), + ('enabled', models.BooleanField(default=True)), + ('category', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='sensors.sensorcardcategory')), + ], + options={ + 'ordering': ['server', 'number'], + }, + ), + migrations.AddField( + model_name='sensor', + name='sensor_category', + field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='sensors.sensorcategory'), + ), + migrations.AddField( + model_name='sensor', + name='interlock_card', + field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='NEMO.interlockcard'), + ), + migrations.AddField( + model_name='sensor', + name='sensor_card', + field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='sensors.sensorcard'), + ), + migrations.RunPython(add_modbus_tcp_sensor_category), + ] diff --git a/NEMO/apps/sensors/migrations/__init__.py b/NEMO/apps/sensors/migrations/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/NEMO/apps/sensors/models.py b/NEMO/apps/sensors/models.py new file mode 100644 index 00000000..5a131944 --- /dev/null +++ b/NEMO/apps/sensors/models.py @@ -0,0 +1,148 @@ +import random +from logging import getLogger + +from django.core.exceptions import ValidationError +from django.core.validators import MaxValueValidator, MinValueValidator +from django.db import models +from django.utils.safestring import mark_safe + +from NEMO.apps.sensors.evaluators import evaluate_expression +from NEMO.models import InterlockCard + +models_logger = getLogger(__name__) + + +class SensorCardCategory(models.Model): + name = models.CharField(max_length=200, help_text="The name for this sensor card category") + key = models.CharField(max_length=100, help_text="The key to identify this sensor card category by in sensors.py") + + class Meta: + verbose_name_plural = "Sensor card categories" + ordering = ["name"] + + def __str__(self): + return str(self.name) + + +class SensorCard(models.Model): + name = models.CharField(max_length=200) + server = models.CharField(max_length=200) + port = models.PositiveIntegerField() + number = models.PositiveIntegerField(blank=True, null=True) + even_port = models.PositiveIntegerField(blank=True, null=True) + odd_port = models.PositiveIntegerField(blank=True, null=True) + category = models.ForeignKey(SensorCardCategory, on_delete=models.CASCADE) + username = models.CharField(max_length=100, blank=True, null=True) + password = models.CharField(max_length=100, blank=True, null=True) + enabled = models.BooleanField(blank=False, null=False, default=True) + + class Meta: + ordering = ["server", "number"] + + def __str__(self): + card_name = self.name + ": " if self.name else "" + return card_name + str(self.server) + (", card " + str(self.number) if self.number else "") + + +class SensorCategory(models.Model): + name = models.CharField(max_length=200, help_text="The name for this sensor category") + + class Meta: + verbose_name_plural = "Sensor categories" + ordering = ["name"] + + def __str__(self): + return str(self.name) + + +class Sensor(models.Model): + name = models.CharField(max_length=200) + sensor_card = models.ForeignKey(SensorCard, blank=True, null=True, on_delete=models.CASCADE) + interlock_card = models.ForeignKey(InterlockCard, blank=True, null=True, on_delete=models.CASCADE) + sensor_category = models.ForeignKey(SensorCategory, blank=True, null=True, on_delete=models.SET_NULL) + data_prefix = models.CharField(blank=True, null=True, max_length=100) + data_suffix = models.CharField(blank=True, null=True, max_length=100) + unit_id = models.PositiveIntegerField(null=True, blank=True) + read_address = models.PositiveIntegerField(null=True, blank=True) + number_of_values = models.PositiveIntegerField(null=True, blank=True, validators=[MinValueValidator(1)]) + formula = models.TextField( + null=True, + blank=True, + help_text=mark_safe( + "Enter a formula to compute for this sensor values. The list of registers read is available as variable registers" + ), + ) + read_frequency = models.PositiveIntegerField( + default=5, + validators=[MaxValueValidator(1440), MinValueValidator(1)], + help_text="Enter the read frequency in minutes. Every 2 hours = 120, etc. Max value is 1440 min (24hrs).", + ) + + @property + def card(self): + return self.sensor_card or self.interlock_card + + def read_data(self, raise_exception=False): + from NEMO.apps.sensors import sensors + + sensors.get(self.card.category, raise_exception).read_values(self, raise_exception) + + def last_data_point(self): + return SensorData.objects.filter(sensor=self).latest("created_date") + + def evaluate(self, registers, raise_exception=True): + try: + if self.formula: + return evaluate_expression(self.formula, registers=registers) + else: + return next(iter(registers or []), None) + except Exception as e: + models_logger.warning(e) + if raise_exception: + raise + + def clean(self): + if not self.sensor_card and not self.interlock_card: + raise ValidationError({"sensor_card": "Please select either a sensor or interlock card"}) + if self.sensor_card or self.interlock_card: + from NEMO.apps.sensors import sensors + + try: + sensors.get(self.card.category, raise_exception=True) + except Exception as e: + key = "sensor_card" if self.sensor_card else "interlock_card" + raise ValidationError({key: str(e)}) + if ( + not self.formula + and self.read_address is not None + and self.number_of_values is not None + and self.number_of_values > 1 + ): + raise ValidationError({"formula": "This field is required when reading multiple values"}) + if self.formula: + registers = [] + if self.read_address is not None and self.number_of_values: + for i in range(self.number_of_values): + registers.append(random.randint(0, 1000)) + else: + registers = [random.randint(0, 1000)] + try: + evaluate_expression(self.formula, registers=registers) + except Exception as e: + raise ValidationError({"formula": str(e)}) + + def __str__(self): + return self.name + + +class SensorData(models.Model): + sensor = models.ForeignKey(Sensor, on_delete=models.CASCADE) + created_date = models.DateTimeField(auto_now_add=True) + value = models.BigIntegerField() + + def display_value(self): + return f"{self.sensor.data_prefix + ' ' if self.sensor.data_prefix else ''}{self.value}{' ' + self.sensor.data_suffix if self.sensor.data_suffix else ''}" + + class Meta: + verbose_name_plural = "Sensor data" + ordering = ["-created_date"] diff --git a/NEMO/apps/sensors/sensors.py b/NEMO/apps/sensors/sensors.py new file mode 100644 index 00000000..50381b6a --- /dev/null +++ b/NEMO/apps/sensors/sensors.py @@ -0,0 +1,96 @@ +from abc import ABC, abstractmethod +from logging import getLogger +from typing import Dict, List + +from django.core.exceptions import ValidationError +from django.utils.translation import gettext_lazy as _ +from pymodbus.client.sync import ModbusTcpClient + +from NEMO.apps.sensors.admin import SensorAdminForm, SensorCardAdminForm +from NEMO.apps.sensors.models import Sensor as Sensor_model, SensorCardCategory, SensorData + +sensors_logger = getLogger(__name__) + + +class Sensor(ABC): + """ + This interface allows for customization of Sensors features. + The only method that has to be implemented is the abstract method "do_read_values" + + The method "clean_sensor_card" can be implemented to set validation rules for the sensor card with the same category + + The sensor type should be set at the end of this file in the dictionary. The key is the key from SensorCardCategory, the value is the Sensor implementation. + """ + + def clean_sensor_card(self, sensor_card_form: SensorCardAdminForm): + pass + + def clean_sensor(self, sensor_form: SensorAdminForm): + pass + + def read_values(self, sensor: Sensor_model, raise_exception=False): + if not sensor.card.enabled: + sensors_logger.warning(f"{sensor.name} sensor interface mocked out because sensor card is disabled.") + return True + + error_message = "" + data_value = None + try: + registers = self.do_read_values(sensor) + data_value = sensor.evaluate(registers=registers) + except Exception as error: + sensors_logger.error(error) + error_message = str(error) + if raise_exception: + raise + + if not error_message and data_value: + SensorData.objects.create(sensor=sensor, value=data_value) + + @abstractmethod + def do_read_values(self, sensor: Sensor_model) -> List: + pass + + +class ModbusTcpSensor(Sensor): + def clean_sensor(self, sensor_form: SensorAdminForm): + read_address = sensor_form.cleaned_data["read_address"] + number_of_values = sensor_form.cleaned_data["number_of_values"] + error = {} + if not read_address: + error["read_address"] = _("This field is required.") + if not number_of_values: + error["number_of_values"] = _("This field is required.") + if error: + raise ValidationError(error) + + def do_read_values(self, sensor: Sensor_model) -> List: + client = ModbusTcpClient(sensor.card.server, port=sensor.card.port) + client.connect() + kwargs = {"unit": sensor.unit_id} if sensor.unit_id is not None else {} + read_response = client.read_holding_registers(sensor.read_address, sensor.number_of_values, **kwargs) + if read_response.isError(): + raise Exception(str(read_response)) + return read_response.registers + + +class NoOpSensor(Sensor): + def do_read_values(self, sensor: Sensor_model) -> List: + pass + + +def get(category: SensorCardCategory, raise_exception=False): + """ Returns the corresponding sensor implementation, and raises an exception if not found. """ + sensor_impl = sensors.get(category.key, False) + if not sensor_impl: + if raise_exception: + raise Exception( + f"There is no sensor implementation for category: {category.name}. Please add one in sensors.py" + ) + else: + return NoOpSensor() + else: + return sensor_impl + + +sensors: Dict[str, Sensor] = {"modbus_tcp": ModbusTcpSensor()} diff --git a/NEMO/apps/sensors/static/sensors/chart.js b/NEMO/apps/sensors/static/sensors/chart.js new file mode 100644 index 00000000..58990616 --- /dev/null +++ b/NEMO/apps/sensors/static/sensors/chart.js @@ -0,0 +1,13269 @@ +/*! + * Chart.js v3.7.1 + * https://www.chartjs.org + * (c) 2022 Chart.js Contributors + * Released under the MIT License + */ +(function (global, factory) { +typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : +typeof define === 'function' && define.amd ? define(factory) : +(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Chart = factory()); +})(this, (function () { 'use strict'; + +function fontString(pixelSize, fontStyle, fontFamily) { + return fontStyle + ' ' + pixelSize + 'px ' + fontFamily; +} +const requestAnimFrame = (function() { + if (typeof window === 'undefined') { + return function(callback) { + return callback(); + }; + } + return window.requestAnimationFrame; +}()); +function throttled(fn, thisArg, updateFn) { + const updateArgs = updateFn || ((args) => Array.prototype.slice.call(args)); + let ticking = false; + let args = []; + return function(...rest) { + args = updateArgs(rest); + if (!ticking) { + ticking = true; + requestAnimFrame.call(window, () => { + ticking = false; + fn.apply(thisArg, args); + }); + } + }; +} +function debounce(fn, delay) { + let timeout; + return function(...args) { + if (delay) { + clearTimeout(timeout); + timeout = setTimeout(fn, delay, args); + } else { + fn.apply(this, args); + } + return delay; + }; +} +const _toLeftRightCenter = (align) => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center'; +const _alignStartEnd = (align, start, end) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2; +const _textX = (align, left, right, rtl) => { + const check = rtl ? 'left' : 'right'; + return align === check ? right : align === 'center' ? (left + right) / 2 : left; +}; + +class Animator { + constructor() { + this._request = null; + this._charts = new Map(); + this._running = false; + this._lastDate = undefined; + } + _notify(chart, anims, date, type) { + const callbacks = anims.listeners[type]; + const numSteps = anims.duration; + callbacks.forEach(fn => fn({ + chart, + initial: anims.initial, + numSteps, + currentStep: Math.min(date - anims.start, numSteps) + })); + } + _refresh() { + if (this._request) { + return; + } + this._running = true; + this._request = requestAnimFrame.call(window, () => { + this._update(); + this._request = null; + if (this._running) { + this._refresh(); + } + }); + } + _update(date = Date.now()) { + let remaining = 0; + this._charts.forEach((anims, chart) => { + if (!anims.running || !anims.items.length) { + return; + } + const items = anims.items; + let i = items.length - 1; + let draw = false; + let item; + for (; i >= 0; --i) { + item = items[i]; + if (item._active) { + if (item._total > anims.duration) { + anims.duration = item._total; + } + item.tick(date); + draw = true; + } else { + items[i] = items[items.length - 1]; + items.pop(); + } + } + if (draw) { + chart.draw(); + this._notify(chart, anims, date, 'progress'); + } + if (!items.length) { + anims.running = false; + this._notify(chart, anims, date, 'complete'); + anims.initial = false; + } + remaining += items.length; + }); + this._lastDate = date; + if (remaining === 0) { + this._running = false; + } + } + _getAnims(chart) { + const charts = this._charts; + let anims = charts.get(chart); + if (!anims) { + anims = { + running: false, + initial: true, + items: [], + listeners: { + complete: [], + progress: [] + } + }; + charts.set(chart, anims); + } + return anims; + } + listen(chart, event, cb) { + this._getAnims(chart).listeners[event].push(cb); + } + add(chart, items) { + if (!items || !items.length) { + return; + } + this._getAnims(chart).items.push(...items); + } + has(chart) { + return this._getAnims(chart).items.length > 0; + } + start(chart) { + const anims = this._charts.get(chart); + if (!anims) { + return; + } + anims.running = true; + anims.start = Date.now(); + anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0); + this._refresh(); + } + running(chart) { + if (!this._running) { + return false; + } + const anims = this._charts.get(chart); + if (!anims || !anims.running || !anims.items.length) { + return false; + } + return true; + } + stop(chart) { + const anims = this._charts.get(chart); + if (!anims || !anims.items.length) { + return; + } + const items = anims.items; + let i = items.length - 1; + for (; i >= 0; --i) { + items[i].cancel(); + } + anims.items = []; + this._notify(chart, anims, Date.now(), 'complete'); + } + remove(chart) { + return this._charts.delete(chart); + } +} +var animator = new Animator(); + +/*! + * @kurkle/color v0.1.9 + * https://github.com/kurkle/color#readme + * (c) 2020 Jukka Kurkela + * Released under the MIT License + */ +const map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15}; +const hex = '0123456789ABCDEF'; +const h1 = (b) => hex[b & 0xF]; +const h2 = (b) => hex[(b & 0xF0) >> 4] + hex[b & 0xF]; +const eq = (b) => (((b & 0xF0) >> 4) === (b & 0xF)); +function isShort(v) { + return eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a); +} +function hexParse(str) { + var len = str.length; + var ret; + if (str[0] === '#') { + if (len === 4 || len === 5) { + ret = { + r: 255 & map$1[str[1]] * 17, + g: 255 & map$1[str[2]] * 17, + b: 255 & map$1[str[3]] * 17, + a: len === 5 ? map$1[str[4]] * 17 : 255 + }; + } else if (len === 7 || len === 9) { + ret = { + r: map$1[str[1]] << 4 | map$1[str[2]], + g: map$1[str[3]] << 4 | map$1[str[4]], + b: map$1[str[5]] << 4 | map$1[str[6]], + a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255 + }; + } + } + return ret; +} +function hexString(v) { + var f = isShort(v) ? h1 : h2; + return v + ? '#' + f(v.r) + f(v.g) + f(v.b) + (v.a < 255 ? f(v.a) : '') + : v; +} +function round(v) { + return v + 0.5 | 0; +} +const lim = (v, l, h) => Math.max(Math.min(v, h), l); +function p2b(v) { + return lim(round(v * 2.55), 0, 255); +} +function n2b(v) { + return lim(round(v * 255), 0, 255); +} +function b2n(v) { + return lim(round(v / 2.55) / 100, 0, 1); +} +function n2p(v) { + return lim(round(v * 100), 0, 100); +} +const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/; +function rgbParse(str) { + const m = RGB_RE.exec(str); + let a = 255; + let r, g, b; + if (!m) { + return; + } + if (m[7] !== r) { + const v = +m[7]; + a = 255 & (m[8] ? p2b(v) : v * 255); + } + r = +m[1]; + g = +m[3]; + b = +m[5]; + r = 255 & (m[2] ? p2b(r) : r); + g = 255 & (m[4] ? p2b(g) : g); + b = 255 & (m[6] ? p2b(b) : b); + return { + r: r, + g: g, + b: b, + a: a + }; +} +function rgbString(v) { + return v && ( + v.a < 255 + ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})` + : `rgb(${v.r}, ${v.g}, ${v.b})` + ); +} +const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/; +function hsl2rgbn(h, s, l) { + const a = s * Math.min(l, 1 - l); + const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1); + return [f(0), f(8), f(4)]; +} +function hsv2rgbn(h, s, v) { + const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0); + return [f(5), f(3), f(1)]; +} +function hwb2rgbn(h, w, b) { + const rgb = hsl2rgbn(h, 1, 0.5); + let i; + if (w + b > 1) { + i = 1 / (w + b); + w *= i; + b *= i; + } + for (i = 0; i < 3; i++) { + rgb[i] *= 1 - w - b; + rgb[i] += w; + } + return rgb; +} +function rgb2hsl(v) { + const range = 255; + const r = v.r / range; + const g = v.g / range; + const b = v.b / range; + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + const l = (max + min) / 2; + let h, s, d; + if (max !== min) { + d = max - min; + s = l > 0.5 ? d / (2 - max - min) : d / (max + min); + h = max === r + ? ((g - b) / d) + (g < b ? 6 : 0) + : max === g + ? (b - r) / d + 2 + : (r - g) / d + 4; + h = h * 60 + 0.5; + } + return [h | 0, s || 0, l]; +} +function calln(f, a, b, c) { + return ( + Array.isArray(a) + ? f(a[0], a[1], a[2]) + : f(a, b, c) + ).map(n2b); +} +function hsl2rgb(h, s, l) { + return calln(hsl2rgbn, h, s, l); +} +function hwb2rgb(h, w, b) { + return calln(hwb2rgbn, h, w, b); +} +function hsv2rgb(h, s, v) { + return calln(hsv2rgbn, h, s, v); +} +function hue(h) { + return (h % 360 + 360) % 360; +} +function hueParse(str) { + const m = HUE_RE.exec(str); + let a = 255; + let v; + if (!m) { + return; + } + if (m[5] !== v) { + a = m[6] ? p2b(+m[5]) : n2b(+m[5]); + } + const h = hue(+m[2]); + const p1 = +m[3] / 100; + const p2 = +m[4] / 100; + if (m[1] === 'hwb') { + v = hwb2rgb(h, p1, p2); + } else if (m[1] === 'hsv') { + v = hsv2rgb(h, p1, p2); + } else { + v = hsl2rgb(h, p1, p2); + } + return { + r: v[0], + g: v[1], + b: v[2], + a: a + }; +} +function rotate(v, deg) { + var h = rgb2hsl(v); + h[0] = hue(h[0] + deg); + h = hsl2rgb(h); + v.r = h[0]; + v.g = h[1]; + v.b = h[2]; +} +function hslString(v) { + if (!v) { + return; + } + const a = rgb2hsl(v); + const h = a[0]; + const s = n2p(a[1]); + const l = n2p(a[2]); + return v.a < 255 + ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})` + : `hsl(${h}, ${s}%, ${l}%)`; +} +const map$1$1 = { + x: 'dark', + Z: 'light', + Y: 're', + X: 'blu', + W: 'gr', + V: 'medium', + U: 'slate', + A: 'ee', + T: 'ol', + S: 'or', + B: 'ra', + C: 'lateg', + D: 'ights', + R: 'in', + Q: 'turquois', + E: 'hi', + P: 'ro', + O: 'al', + N: 'le', + M: 'de', + L: 'yello', + F: 'en', + K: 'ch', + G: 'arks', + H: 'ea', + I: 'ightg', + J: 'wh' +}; +const names = { + OiceXe: 'f0f8ff', + antiquewEte: 'faebd7', + aqua: 'ffff', + aquamarRe: '7fffd4', + azuY: 'f0ffff', + beige: 'f5f5dc', + bisque: 'ffe4c4', + black: '0', + blanKedOmond: 'ffebcd', + Xe: 'ff', + XeviTet: '8a2be2', + bPwn: 'a52a2a', + burlywood: 'deb887', + caMtXe: '5f9ea0', + KartYuse: '7fff00', + KocTate: 'd2691e', + cSO: 'ff7f50', + cSnflowerXe: '6495ed', + cSnsilk: 'fff8dc', + crimson: 'dc143c', + cyan: 'ffff', + xXe: '8b', + xcyan: '8b8b', + xgTMnPd: 'b8860b', + xWay: 'a9a9a9', + xgYF: '6400', + xgYy: 'a9a9a9', + xkhaki: 'bdb76b', + xmagFta: '8b008b', + xTivegYF: '556b2f', + xSange: 'ff8c00', + xScEd: '9932cc', + xYd: '8b0000', + xsOmon: 'e9967a', + xsHgYF: '8fbc8f', + xUXe: '483d8b', + xUWay: '2f4f4f', + xUgYy: '2f4f4f', + xQe: 'ced1', + xviTet: '9400d3', + dAppRk: 'ff1493', + dApskyXe: 'bfff', + dimWay: '696969', + dimgYy: '696969', + dodgerXe: '1e90ff', + fiYbrick: 'b22222', + flSOwEte: 'fffaf0', + foYstWAn: '228b22', + fuKsia: 'ff00ff', + gaRsbSo: 'dcdcdc', + ghostwEte: 'f8f8ff', + gTd: 'ffd700', + gTMnPd: 'daa520', + Way: '808080', + gYF: '8000', + gYFLw: 'adff2f', + gYy: '808080', + honeyMw: 'f0fff0', + hotpRk: 'ff69b4', + RdianYd: 'cd5c5c', + Rdigo: '4b0082', + ivSy: 'fffff0', + khaki: 'f0e68c', + lavFMr: 'e6e6fa', + lavFMrXsh: 'fff0f5', + lawngYF: '7cfc00', + NmoncEffon: 'fffacd', + ZXe: 'add8e6', + ZcSO: 'f08080', + Zcyan: 'e0ffff', + ZgTMnPdLw: 'fafad2', + ZWay: 'd3d3d3', + ZgYF: '90ee90', + ZgYy: 'd3d3d3', + ZpRk: 'ffb6c1', + ZsOmon: 'ffa07a', + ZsHgYF: '20b2aa', + ZskyXe: '87cefa', + ZUWay: '778899', + ZUgYy: '778899', + ZstAlXe: 'b0c4de', + ZLw: 'ffffe0', + lime: 'ff00', + limegYF: '32cd32', + lRF: 'faf0e6', + magFta: 'ff00ff', + maPon: '800000', + VaquamarRe: '66cdaa', + VXe: 'cd', + VScEd: 'ba55d3', + VpurpN: '9370db', + VsHgYF: '3cb371', + VUXe: '7b68ee', + VsprRggYF: 'fa9a', + VQe: '48d1cc', + VviTetYd: 'c71585', + midnightXe: '191970', + mRtcYam: 'f5fffa', + mistyPse: 'ffe4e1', + moccasR: 'ffe4b5', + navajowEte: 'ffdead', + navy: '80', + Tdlace: 'fdf5e6', + Tive: '808000', + TivedBb: '6b8e23', + Sange: 'ffa500', + SangeYd: 'ff4500', + ScEd: 'da70d6', + pOegTMnPd: 'eee8aa', + pOegYF: '98fb98', + pOeQe: 'afeeee', + pOeviTetYd: 'db7093', + papayawEp: 'ffefd5', + pHKpuff: 'ffdab9', + peru: 'cd853f', + pRk: 'ffc0cb', + plum: 'dda0dd', + powMrXe: 'b0e0e6', + purpN: '800080', + YbeccapurpN: '663399', + Yd: 'ff0000', + Psybrown: 'bc8f8f', + PyOXe: '4169e1', + saddNbPwn: '8b4513', + sOmon: 'fa8072', + sandybPwn: 'f4a460', + sHgYF: '2e8b57', + sHshell: 'fff5ee', + siFna: 'a0522d', + silver: 'c0c0c0', + skyXe: '87ceeb', + UXe: '6a5acd', + UWay: '708090', + UgYy: '708090', + snow: 'fffafa', + sprRggYF: 'ff7f', + stAlXe: '4682b4', + tan: 'd2b48c', + teO: '8080', + tEstN: 'd8bfd8', + tomato: 'ff6347', + Qe: '40e0d0', + viTet: 'ee82ee', + JHt: 'f5deb3', + wEte: 'ffffff', + wEtesmoke: 'f5f5f5', + Lw: 'ffff00', + LwgYF: '9acd32' +}; +function unpack() { + const unpacked = {}; + const keys = Object.keys(names); + const tkeys = Object.keys(map$1$1); + let i, j, k, ok, nk; + for (i = 0; i < keys.length; i++) { + ok = nk = keys[i]; + for (j = 0; j < tkeys.length; j++) { + k = tkeys[j]; + nk = nk.replace(k, map$1$1[k]); + } + k = parseInt(names[ok], 16); + unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF]; + } + return unpacked; +} +let names$1; +function nameParse(str) { + if (!names$1) { + names$1 = unpack(); + names$1.transparent = [0, 0, 0, 0]; + } + const a = names$1[str.toLowerCase()]; + return a && { + r: a[0], + g: a[1], + b: a[2], + a: a.length === 4 ? a[3] : 255 + }; +} +function modHSL(v, i, ratio) { + if (v) { + let tmp = rgb2hsl(v); + tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1)); + tmp = hsl2rgb(tmp); + v.r = tmp[0]; + v.g = tmp[1]; + v.b = tmp[2]; + } +} +function clone$1(v, proto) { + return v ? Object.assign(proto || {}, v) : v; +} +function fromObject(input) { + var v = {r: 0, g: 0, b: 0, a: 255}; + if (Array.isArray(input)) { + if (input.length >= 3) { + v = {r: input[0], g: input[1], b: input[2], a: 255}; + if (input.length > 3) { + v.a = n2b(input[3]); + } + } + } else { + v = clone$1(input, {r: 0, g: 0, b: 0, a: 1}); + v.a = n2b(v.a); + } + return v; +} +function functionParse(str) { + if (str.charAt(0) === 'r') { + return rgbParse(str); + } + return hueParse(str); +} +class Color { + constructor(input) { + if (input instanceof Color) { + return input; + } + const type = typeof input; + let v; + if (type === 'object') { + v = fromObject(input); + } else if (type === 'string') { + v = hexParse(input) || nameParse(input) || functionParse(input); + } + this._rgb = v; + this._valid = !!v; + } + get valid() { + return this._valid; + } + get rgb() { + var v = clone$1(this._rgb); + if (v) { + v.a = b2n(v.a); + } + return v; + } + set rgb(obj) { + this._rgb = fromObject(obj); + } + rgbString() { + return this._valid ? rgbString(this._rgb) : this._rgb; + } + hexString() { + return this._valid ? hexString(this._rgb) : this._rgb; + } + hslString() { + return this._valid ? hslString(this._rgb) : this._rgb; + } + mix(color, weight) { + const me = this; + if (color) { + const c1 = me.rgb; + const c2 = color.rgb; + let w2; + const p = weight === w2 ? 0.5 : weight; + const w = 2 * p - 1; + const a = c1.a - c2.a; + const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0; + w2 = 1 - w1; + c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5; + c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5; + c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5; + c1.a = p * c1.a + (1 - p) * c2.a; + me.rgb = c1; + } + return me; + } + clone() { + return new Color(this.rgb); + } + alpha(a) { + this._rgb.a = n2b(a); + return this; + } + clearer(ratio) { + const rgb = this._rgb; + rgb.a *= 1 - ratio; + return this; + } + greyscale() { + const rgb = this._rgb; + const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11); + rgb.r = rgb.g = rgb.b = val; + return this; + } + opaquer(ratio) { + const rgb = this._rgb; + rgb.a *= 1 + ratio; + return this; + } + negate() { + const v = this._rgb; + v.r = 255 - v.r; + v.g = 255 - v.g; + v.b = 255 - v.b; + return this; + } + lighten(ratio) { + modHSL(this._rgb, 2, ratio); + return this; + } + darken(ratio) { + modHSL(this._rgb, 2, -ratio); + return this; + } + saturate(ratio) { + modHSL(this._rgb, 1, ratio); + return this; + } + desaturate(ratio) { + modHSL(this._rgb, 1, -ratio); + return this; + } + rotate(deg) { + rotate(this._rgb, deg); + return this; + } +} +function index_esm(input) { + return new Color(input); +} + +const isPatternOrGradient = (value) => value instanceof CanvasGradient || value instanceof CanvasPattern; +function color(value) { + return isPatternOrGradient(value) ? value : index_esm(value); +} +function getHoverColor(value) { + return isPatternOrGradient(value) + ? value + : index_esm(value).saturate(0.5).darken(0.1).hexString(); +} + +function noop() {} +const uid = (function() { + let id = 0; + return function() { + return id++; + }; +}()); +function isNullOrUndef(value) { + return value === null || typeof value === 'undefined'; +} +function isArray(value) { + if (Array.isArray && Array.isArray(value)) { + return true; + } + const type = Object.prototype.toString.call(value); + if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') { + return true; + } + return false; +} +function isObject(value) { + return value !== null && Object.prototype.toString.call(value) === '[object Object]'; +} +const isNumberFinite = (value) => (typeof value === 'number' || value instanceof Number) && isFinite(+value); +function finiteOrDefault(value, defaultValue) { + return isNumberFinite(value) ? value : defaultValue; +} +function valueOrDefault(value, defaultValue) { + return typeof value === 'undefined' ? defaultValue : value; +} +const toPercentage = (value, dimension) => + typeof value === 'string' && value.endsWith('%') ? + parseFloat(value) / 100 + : value / dimension; +const toDimension = (value, dimension) => + typeof value === 'string' && value.endsWith('%') ? + parseFloat(value) / 100 * dimension + : +value; +function callback(fn, args, thisArg) { + if (fn && typeof fn.call === 'function') { + return fn.apply(thisArg, args); + } +} +function each(loopable, fn, thisArg, reverse) { + let i, len, keys; + if (isArray(loopable)) { + len = loopable.length; + if (reverse) { + for (i = len - 1; i >= 0; i--) { + fn.call(thisArg, loopable[i], i); + } + } else { + for (i = 0; i < len; i++) { + fn.call(thisArg, loopable[i], i); + } + } + } else if (isObject(loopable)) { + keys = Object.keys(loopable); + len = keys.length; + for (i = 0; i < len; i++) { + fn.call(thisArg, loopable[keys[i]], keys[i]); + } + } +} +function _elementsEqual(a0, a1) { + let i, ilen, v0, v1; + if (!a0 || !a1 || a0.length !== a1.length) { + return false; + } + for (i = 0, ilen = a0.length; i < ilen; ++i) { + v0 = a0[i]; + v1 = a1[i]; + if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) { + return false; + } + } + return true; +} +function clone(source) { + if (isArray(source)) { + return source.map(clone); + } + if (isObject(source)) { + const target = Object.create(null); + const keys = Object.keys(source); + const klen = keys.length; + let k = 0; + for (; k < klen; ++k) { + target[keys[k]] = clone(source[keys[k]]); + } + return target; + } + return source; +} +function isValidKey(key) { + return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1; +} +function _merger(key, target, source, options) { + if (!isValidKey(key)) { + return; + } + const tval = target[key]; + const sval = source[key]; + if (isObject(tval) && isObject(sval)) { + merge(tval, sval, options); + } else { + target[key] = clone(sval); + } +} +function merge(target, source, options) { + const sources = isArray(source) ? source : [source]; + const ilen = sources.length; + if (!isObject(target)) { + return target; + } + options = options || {}; + const merger = options.merger || _merger; + for (let i = 0; i < ilen; ++i) { + source = sources[i]; + if (!isObject(source)) { + continue; + } + const keys = Object.keys(source); + for (let k = 0, klen = keys.length; k < klen; ++k) { + merger(keys[k], target, source, options); + } + } + return target; +} +function mergeIf(target, source) { + return merge(target, source, {merger: _mergerIf}); +} +function _mergerIf(key, target, source) { + if (!isValidKey(key)) { + return; + } + const tval = target[key]; + const sval = source[key]; + if (isObject(tval) && isObject(sval)) { + mergeIf(tval, sval); + } else if (!Object.prototype.hasOwnProperty.call(target, key)) { + target[key] = clone(sval); + } +} +function _deprecated(scope, value, previous, current) { + if (value !== undefined) { + console.warn(scope + ': "' + previous + + '" is deprecated. Please use "' + current + '" instead'); + } +} +const emptyString = ''; +const dot = '.'; +function indexOfDotOrLength(key, start) { + const idx = key.indexOf(dot, start); + return idx === -1 ? key.length : idx; +} +function resolveObjectKey(obj, key) { + if (key === emptyString) { + return obj; + } + let pos = 0; + let idx = indexOfDotOrLength(key, pos); + while (obj && idx > pos) { + obj = obj[key.substr(pos, idx - pos)]; + pos = idx + 1; + idx = indexOfDotOrLength(key, pos); + } + return obj; +} +function _capitalize(str) { + return str.charAt(0).toUpperCase() + str.slice(1); +} +const defined = (value) => typeof value !== 'undefined'; +const isFunction = (value) => typeof value === 'function'; +const setsEqual = (a, b) => { + if (a.size !== b.size) { + return false; + } + for (const item of a) { + if (!b.has(item)) { + return false; + } + } + return true; +}; +function _isClickEvent(e) { + return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu'; +} + +const overrides = Object.create(null); +const descriptors = Object.create(null); +function getScope$1(node, key) { + if (!key) { + return node; + } + const keys = key.split('.'); + for (let i = 0, n = keys.length; i < n; ++i) { + const k = keys[i]; + node = node[k] || (node[k] = Object.create(null)); + } + return node; +} +function set(root, scope, values) { + if (typeof scope === 'string') { + return merge(getScope$1(root, scope), values); + } + return merge(getScope$1(root, ''), scope); +} +class Defaults { + constructor(_descriptors) { + this.animation = undefined; + this.backgroundColor = 'rgba(0,0,0,0.1)'; + this.borderColor = 'rgba(0,0,0,0.1)'; + this.color = '#666'; + this.datasets = {}; + this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio(); + this.elements = {}; + this.events = [ + 'mousemove', + 'mouseout', + 'click', + 'touchstart', + 'touchmove' + ]; + this.font = { + family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif", + size: 12, + style: 'normal', + lineHeight: 1.2, + weight: null + }; + this.hover = {}; + this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor); + this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor); + this.hoverColor = (ctx, options) => getHoverColor(options.color); + this.indexAxis = 'x'; + this.interaction = { + mode: 'nearest', + intersect: true + }; + this.maintainAspectRatio = true; + this.onHover = null; + this.onClick = null; + this.parsing = true; + this.plugins = {}; + this.responsive = true; + this.scale = undefined; + this.scales = {}; + this.showLine = true; + this.drawActiveElementsOnTop = true; + this.describe(_descriptors); + } + set(scope, values) { + return set(this, scope, values); + } + get(scope) { + return getScope$1(this, scope); + } + describe(scope, values) { + return set(descriptors, scope, values); + } + override(scope, values) { + return set(overrides, scope, values); + } + route(scope, name, targetScope, targetName) { + const scopeObject = getScope$1(this, scope); + const targetScopeObject = getScope$1(this, targetScope); + const privateName = '_' + name; + Object.defineProperties(scopeObject, { + [privateName]: { + value: scopeObject[name], + writable: true + }, + [name]: { + enumerable: true, + get() { + const local = this[privateName]; + const target = targetScopeObject[targetName]; + if (isObject(local)) { + return Object.assign({}, target, local); + } + return valueOrDefault(local, target); + }, + set(value) { + this[privateName] = value; + } + } + }); + } +} +var defaults = new Defaults({ + _scriptable: (name) => !name.startsWith('on'), + _indexable: (name) => name !== 'events', + hover: { + _fallback: 'interaction' + }, + interaction: { + _scriptable: false, + _indexable: false, + } +}); + +const PI = Math.PI; +const TAU = 2 * PI; +const PITAU = TAU + PI; +const INFINITY = Number.POSITIVE_INFINITY; +const RAD_PER_DEG = PI / 180; +const HALF_PI = PI / 2; +const QUARTER_PI = PI / 4; +const TWO_THIRDS_PI = PI * 2 / 3; +const log10 = Math.log10; +const sign = Math.sign; +function niceNum(range) { + const roundedRange = Math.round(range); + range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range; + const niceRange = Math.pow(10, Math.floor(log10(range))); + const fraction = range / niceRange; + const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10; + return niceFraction * niceRange; +} +function _factorize(value) { + const result = []; + const sqrt = Math.sqrt(value); + let i; + for (i = 1; i < sqrt; i++) { + if (value % i === 0) { + result.push(i); + result.push(value / i); + } + } + if (sqrt === (sqrt | 0)) { + result.push(sqrt); + } + result.sort((a, b) => a - b).pop(); + return result; +} +function isNumber(n) { + return !isNaN(parseFloat(n)) && isFinite(n); +} +function almostEquals(x, y, epsilon) { + return Math.abs(x - y) < epsilon; +} +function almostWhole(x, epsilon) { + const rounded = Math.round(x); + return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x); +} +function _setMinAndMaxByKey(array, target, property) { + let i, ilen, value; + for (i = 0, ilen = array.length; i < ilen; i++) { + value = array[i][property]; + if (!isNaN(value)) { + target.min = Math.min(target.min, value); + target.max = Math.max(target.max, value); + } + } +} +function toRadians(degrees) { + return degrees * (PI / 180); +} +function toDegrees(radians) { + return radians * (180 / PI); +} +function _decimalPlaces(x) { + if (!isNumberFinite(x)) { + return; + } + let e = 1; + let p = 0; + while (Math.round(x * e) / e !== x) { + e *= 10; + p++; + } + return p; +} +function getAngleFromPoint(centrePoint, anglePoint) { + const distanceFromXCenter = anglePoint.x - centrePoint.x; + const distanceFromYCenter = anglePoint.y - centrePoint.y; + const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter); + let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter); + if (angle < (-0.5 * PI)) { + angle += TAU; + } + return { + angle, + distance: radialDistanceFromCenter + }; +} +function distanceBetweenPoints(pt1, pt2) { + return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2)); +} +function _angleDiff(a, b) { + return (a - b + PITAU) % TAU - PI; +} +function _normalizeAngle(a) { + return (a % TAU + TAU) % TAU; +} +function _angleBetween(angle, start, end, sameAngleIsFullCircle) { + const a = _normalizeAngle(angle); + const s = _normalizeAngle(start); + const e = _normalizeAngle(end); + const angleToStart = _normalizeAngle(s - a); + const angleToEnd = _normalizeAngle(e - a); + const startToAngle = _normalizeAngle(a - s); + const endToAngle = _normalizeAngle(a - e); + return a === s || a === e || (sameAngleIsFullCircle && s === e) + || (angleToStart > angleToEnd && startToAngle < endToAngle); +} +function _limitValue(value, min, max) { + return Math.max(min, Math.min(max, value)); +} +function _int16Range(value) { + return _limitValue(value, -32768, 32767); +} +function _isBetween(value, start, end, epsilon = 1e-6) { + return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon; +} + +function toFontString(font) { + if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) { + return null; + } + return (font.style ? font.style + ' ' : '') + + (font.weight ? font.weight + ' ' : '') + + font.size + 'px ' + + font.family; +} +function _measureText(ctx, data, gc, longest, string) { + let textWidth = data[string]; + if (!textWidth) { + textWidth = data[string] = ctx.measureText(string).width; + gc.push(string); + } + if (textWidth > longest) { + longest = textWidth; + } + return longest; +} +function _longestText(ctx, font, arrayOfThings, cache) { + cache = cache || {}; + let data = cache.data = cache.data || {}; + let gc = cache.garbageCollect = cache.garbageCollect || []; + if (cache.font !== font) { + data = cache.data = {}; + gc = cache.garbageCollect = []; + cache.font = font; + } + ctx.save(); + ctx.font = font; + let longest = 0; + const ilen = arrayOfThings.length; + let i, j, jlen, thing, nestedThing; + for (i = 0; i < ilen; i++) { + thing = arrayOfThings[i]; + if (thing !== undefined && thing !== null && isArray(thing) !== true) { + longest = _measureText(ctx, data, gc, longest, thing); + } else if (isArray(thing)) { + for (j = 0, jlen = thing.length; j < jlen; j++) { + nestedThing = thing[j]; + if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) { + longest = _measureText(ctx, data, gc, longest, nestedThing); + } + } + } + } + ctx.restore(); + const gcLen = gc.length / 2; + if (gcLen > arrayOfThings.length) { + for (i = 0; i < gcLen; i++) { + delete data[gc[i]]; + } + gc.splice(0, gcLen); + } + return longest; +} +function _alignPixel(chart, pixel, width) { + const devicePixelRatio = chart.currentDevicePixelRatio; + const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0; + return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth; +} +function clearCanvas(canvas, ctx) { + ctx = ctx || canvas.getContext('2d'); + ctx.save(); + ctx.resetTransform(); + ctx.clearRect(0, 0, canvas.width, canvas.height); + ctx.restore(); +} +function drawPoint(ctx, options, x, y) { + let type, xOffset, yOffset, size, cornerRadius; + const style = options.pointStyle; + const rotation = options.rotation; + const radius = options.radius; + let rad = (rotation || 0) * RAD_PER_DEG; + if (style && typeof style === 'object') { + type = style.toString(); + if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') { + ctx.save(); + ctx.translate(x, y); + ctx.rotate(rad); + ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height); + ctx.restore(); + return; + } + } + if (isNaN(radius) || radius <= 0) { + return; + } + ctx.beginPath(); + switch (style) { + default: + ctx.arc(x, y, radius, 0, TAU); + ctx.closePath(); + break; + case 'triangle': + ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + rad += TWO_THIRDS_PI; + ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + rad += TWO_THIRDS_PI; + ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + ctx.closePath(); + break; + case 'rectRounded': + cornerRadius = radius * 0.516; + size = radius - cornerRadius; + xOffset = Math.cos(rad + QUARTER_PI) * size; + yOffset = Math.sin(rad + QUARTER_PI) * size; + ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI); + ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad); + ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI); + ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI); + ctx.closePath(); + break; + case 'rect': + if (!rotation) { + size = Math.SQRT1_2 * radius; + ctx.rect(x - size, y - size, 2 * size, 2 * size); + break; + } + rad += QUARTER_PI; + case 'rectRot': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + yOffset, y - xOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.lineTo(x - yOffset, y + xOffset); + ctx.closePath(); + break; + case 'crossRot': + rad += QUARTER_PI; + case 'cross': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + break; + case 'star': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + rad += QUARTER_PI; + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + break; + case 'line': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + break; + case 'dash': + ctx.moveTo(x, y); + ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius); + break; + } + ctx.fill(); + if (options.borderWidth > 0) { + ctx.stroke(); + } +} +function _isPointInArea(point, area, margin) { + margin = margin || 0.5; + return !area || (point && point.x > area.left - margin && point.x < area.right + margin && + point.y > area.top - margin && point.y < area.bottom + margin); +} +function clipArea(ctx, area) { + ctx.save(); + ctx.beginPath(); + ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top); + ctx.clip(); +} +function unclipArea(ctx) { + ctx.restore(); +} +function _steppedLineTo(ctx, previous, target, flip, mode) { + if (!previous) { + return ctx.lineTo(target.x, target.y); + } + if (mode === 'middle') { + const midpoint = (previous.x + target.x) / 2.0; + ctx.lineTo(midpoint, previous.y); + ctx.lineTo(midpoint, target.y); + } else if (mode === 'after' !== !!flip) { + ctx.lineTo(previous.x, target.y); + } else { + ctx.lineTo(target.x, previous.y); + } + ctx.lineTo(target.x, target.y); +} +function _bezierCurveTo(ctx, previous, target, flip) { + if (!previous) { + return ctx.lineTo(target.x, target.y); + } + ctx.bezierCurveTo( + flip ? previous.cp1x : previous.cp2x, + flip ? previous.cp1y : previous.cp2y, + flip ? target.cp2x : target.cp1x, + flip ? target.cp2y : target.cp1y, + target.x, + target.y); +} +function renderText(ctx, text, x, y, font, opts = {}) { + const lines = isArray(text) ? text : [text]; + const stroke = opts.strokeWidth > 0 && opts.strokeColor !== ''; + let i, line; + ctx.save(); + ctx.font = font.string; + setRenderOpts(ctx, opts); + for (i = 0; i < lines.length; ++i) { + line = lines[i]; + if (stroke) { + if (opts.strokeColor) { + ctx.strokeStyle = opts.strokeColor; + } + if (!isNullOrUndef(opts.strokeWidth)) { + ctx.lineWidth = opts.strokeWidth; + } + ctx.strokeText(line, x, y, opts.maxWidth); + } + ctx.fillText(line, x, y, opts.maxWidth); + decorateText(ctx, x, y, line, opts); + y += font.lineHeight; + } + ctx.restore(); +} +function setRenderOpts(ctx, opts) { + if (opts.translation) { + ctx.translate(opts.translation[0], opts.translation[1]); + } + if (!isNullOrUndef(opts.rotation)) { + ctx.rotate(opts.rotation); + } + if (opts.color) { + ctx.fillStyle = opts.color; + } + if (opts.textAlign) { + ctx.textAlign = opts.textAlign; + } + if (opts.textBaseline) { + ctx.textBaseline = opts.textBaseline; + } +} +function decorateText(ctx, x, y, line, opts) { + if (opts.strikethrough || opts.underline) { + const metrics = ctx.measureText(line); + const left = x - metrics.actualBoundingBoxLeft; + const right = x + metrics.actualBoundingBoxRight; + const top = y - metrics.actualBoundingBoxAscent; + const bottom = y + metrics.actualBoundingBoxDescent; + const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom; + ctx.strokeStyle = ctx.fillStyle; + ctx.beginPath(); + ctx.lineWidth = opts.decorationWidth || 2; + ctx.moveTo(left, yDecoration); + ctx.lineTo(right, yDecoration); + ctx.stroke(); + } +} +function addRoundedRectPath(ctx, rect) { + const {x, y, w, h, radius} = rect; + ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true); + ctx.lineTo(x, y + h - radius.bottomLeft); + ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true); + ctx.lineTo(x + w - radius.bottomRight, y + h); + ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true); + ctx.lineTo(x + w, y + radius.topRight); + ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true); + ctx.lineTo(x + radius.topLeft, y); +} + +function _lookup(table, value, cmp) { + cmp = cmp || ((index) => table[index] < value); + let hi = table.length - 1; + let lo = 0; + let mid; + while (hi - lo > 1) { + mid = (lo + hi) >> 1; + if (cmp(mid)) { + lo = mid; + } else { + hi = mid; + } + } + return {lo, hi}; +} +const _lookupByKey = (table, key, value) => + _lookup(table, value, index => table[index][key] < value); +const _rlookupByKey = (table, key, value) => + _lookup(table, value, index => table[index][key] >= value); +function _filterBetween(values, min, max) { + let start = 0; + let end = values.length; + while (start < end && values[start] < min) { + start++; + } + while (end > start && values[end - 1] > max) { + end--; + } + return start > 0 || end < values.length + ? values.slice(start, end) + : values; +} +const arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift']; +function listenArrayEvents(array, listener) { + if (array._chartjs) { + array._chartjs.listeners.push(listener); + return; + } + Object.defineProperty(array, '_chartjs', { + configurable: true, + enumerable: false, + value: { + listeners: [listener] + } + }); + arrayEvents.forEach((key) => { + const method = '_onData' + _capitalize(key); + const base = array[key]; + Object.defineProperty(array, key, { + configurable: true, + enumerable: false, + value(...args) { + const res = base.apply(this, args); + array._chartjs.listeners.forEach((object) => { + if (typeof object[method] === 'function') { + object[method](...args); + } + }); + return res; + } + }); + }); +} +function unlistenArrayEvents(array, listener) { + const stub = array._chartjs; + if (!stub) { + return; + } + const listeners = stub.listeners; + const index = listeners.indexOf(listener); + if (index !== -1) { + listeners.splice(index, 1); + } + if (listeners.length > 0) { + return; + } + arrayEvents.forEach((key) => { + delete array[key]; + }); + delete array._chartjs; +} +function _arrayUnique(items) { + const set = new Set(); + let i, ilen; + for (i = 0, ilen = items.length; i < ilen; ++i) { + set.add(items[i]); + } + if (set.size === ilen) { + return items; + } + return Array.from(set); +} + +function _isDomSupported() { + return typeof window !== 'undefined' && typeof document !== 'undefined'; +} +function _getParentNode(domNode) { + let parent = domNode.parentNode; + if (parent && parent.toString() === '[object ShadowRoot]') { + parent = parent.host; + } + return parent; +} +function parseMaxStyle(styleValue, node, parentProperty) { + let valueInPixels; + if (typeof styleValue === 'string') { + valueInPixels = parseInt(styleValue, 10); + if (styleValue.indexOf('%') !== -1) { + valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty]; + } + } else { + valueInPixels = styleValue; + } + return valueInPixels; +} +const getComputedStyle = (element) => window.getComputedStyle(element, null); +function getStyle(el, property) { + return getComputedStyle(el).getPropertyValue(property); +} +const positions = ['top', 'right', 'bottom', 'left']; +function getPositionedStyle(styles, style, suffix) { + const result = {}; + suffix = suffix ? '-' + suffix : ''; + for (let i = 0; i < 4; i++) { + const pos = positions[i]; + result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0; + } + result.width = result.left + result.right; + result.height = result.top + result.bottom; + return result; +} +const useOffsetPos = (x, y, target) => (x > 0 || y > 0) && (!target || !target.shadowRoot); +function getCanvasPosition(evt, canvas) { + const e = evt.native || evt; + const touches = e.touches; + const source = touches && touches.length ? touches[0] : e; + const {offsetX, offsetY} = source; + let box = false; + let x, y; + if (useOffsetPos(offsetX, offsetY, e.target)) { + x = offsetX; + y = offsetY; + } else { + const rect = canvas.getBoundingClientRect(); + x = source.clientX - rect.left; + y = source.clientY - rect.top; + box = true; + } + return {x, y, box}; +} +function getRelativePosition$1(evt, chart) { + const {canvas, currentDevicePixelRatio} = chart; + const style = getComputedStyle(canvas); + const borderBox = style.boxSizing === 'border-box'; + const paddings = getPositionedStyle(style, 'padding'); + const borders = getPositionedStyle(style, 'border', 'width'); + const {x, y, box} = getCanvasPosition(evt, canvas); + const xOffset = paddings.left + (box && borders.left); + const yOffset = paddings.top + (box && borders.top); + let {width, height} = chart; + if (borderBox) { + width -= paddings.width + borders.width; + height -= paddings.height + borders.height; + } + return { + x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio), + y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio) + }; +} +function getContainerSize(canvas, width, height) { + let maxWidth, maxHeight; + if (width === undefined || height === undefined) { + const container = _getParentNode(canvas); + if (!container) { + width = canvas.clientWidth; + height = canvas.clientHeight; + } else { + const rect = container.getBoundingClientRect(); + const containerStyle = getComputedStyle(container); + const containerBorder = getPositionedStyle(containerStyle, 'border', 'width'); + const containerPadding = getPositionedStyle(containerStyle, 'padding'); + width = rect.width - containerPadding.width - containerBorder.width; + height = rect.height - containerPadding.height - containerBorder.height; + maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth'); + maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight'); + } + } + return { + width, + height, + maxWidth: maxWidth || INFINITY, + maxHeight: maxHeight || INFINITY + }; +} +const round1 = v => Math.round(v * 10) / 10; +function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) { + const style = getComputedStyle(canvas); + const margins = getPositionedStyle(style, 'margin'); + const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY; + const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY; + const containerSize = getContainerSize(canvas, bbWidth, bbHeight); + let {width, height} = containerSize; + if (style.boxSizing === 'content-box') { + const borders = getPositionedStyle(style, 'border', 'width'); + const paddings = getPositionedStyle(style, 'padding'); + width -= paddings.width + borders.width; + height -= paddings.height + borders.height; + } + width = Math.max(0, width - margins.width); + height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height); + width = round1(Math.min(width, maxWidth, containerSize.maxWidth)); + height = round1(Math.min(height, maxHeight, containerSize.maxHeight)); + if (width && !height) { + height = round1(width / 2); + } + return { + width, + height + }; +} +function retinaScale(chart, forceRatio, forceStyle) { + const pixelRatio = forceRatio || 1; + const deviceHeight = Math.floor(chart.height * pixelRatio); + const deviceWidth = Math.floor(chart.width * pixelRatio); + chart.height = deviceHeight / pixelRatio; + chart.width = deviceWidth / pixelRatio; + const canvas = chart.canvas; + if (canvas.style && (forceStyle || (!canvas.style.height && !canvas.style.width))) { + canvas.style.height = `${chart.height}px`; + canvas.style.width = `${chart.width}px`; + } + if (chart.currentDevicePixelRatio !== pixelRatio + || canvas.height !== deviceHeight + || canvas.width !== deviceWidth) { + chart.currentDevicePixelRatio = pixelRatio; + canvas.height = deviceHeight; + canvas.width = deviceWidth; + chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0); + return true; + } + return false; +} +const supportsEventListenerOptions = (function() { + let passiveSupported = false; + try { + const options = { + get passive() { + passiveSupported = true; + return false; + } + }; + window.addEventListener('test', null, options); + window.removeEventListener('test', null, options); + } catch (e) { + } + return passiveSupported; +}()); +function readUsedSize(element, property) { + const value = getStyle(element, property); + const matches = value && value.match(/^(\d+)(\.\d+)?px$/); + return matches ? +matches[1] : undefined; +} + +function getRelativePosition(e, chart) { + if ('native' in e) { + return { + x: e.x, + y: e.y + }; + } + return getRelativePosition$1(e, chart); +} +function evaluateAllVisibleItems(chart, handler) { + const metasets = chart.getSortedVisibleDatasetMetas(); + let index, data, element; + for (let i = 0, ilen = metasets.length; i < ilen; ++i) { + ({index, data} = metasets[i]); + for (let j = 0, jlen = data.length; j < jlen; ++j) { + element = data[j]; + if (!element.skip) { + handler(element, index, j); + } + } + } +} +function binarySearch(metaset, axis, value, intersect) { + const {controller, data, _sorted} = metaset; + const iScale = controller._cachedMeta.iScale; + if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) { + const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey; + if (!intersect) { + return lookupMethod(data, axis, value); + } else if (controller._sharedOptions) { + const el = data[0]; + const range = typeof el.getRange === 'function' && el.getRange(axis); + if (range) { + const start = lookupMethod(data, axis, value - range); + const end = lookupMethod(data, axis, value + range); + return {lo: start.lo, hi: end.hi}; + } + } + } + return {lo: 0, hi: data.length - 1}; +} +function optimizedEvaluateItems(chart, axis, position, handler, intersect) { + const metasets = chart.getSortedVisibleDatasetMetas(); + const value = position[axis]; + for (let i = 0, ilen = metasets.length; i < ilen; ++i) { + const {index, data} = metasets[i]; + const {lo, hi} = binarySearch(metasets[i], axis, value, intersect); + for (let j = lo; j <= hi; ++j) { + const element = data[j]; + if (!element.skip) { + handler(element, index, j); + } + } + } +} +function getDistanceMetricForAxis(axis) { + const useX = axis.indexOf('x') !== -1; + const useY = axis.indexOf('y') !== -1; + return function(pt1, pt2) { + const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0; + const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0; + return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2)); + }; +} +function getIntersectItems(chart, position, axis, useFinalPosition) { + const items = []; + if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) { + return items; + } + const evaluationFunc = function(element, datasetIndex, index) { + if (element.inRange(position.x, position.y, useFinalPosition)) { + items.push({element, datasetIndex, index}); + } + }; + optimizedEvaluateItems(chart, axis, position, evaluationFunc, true); + return items; +} +function getNearestRadialItems(chart, position, axis, useFinalPosition) { + let items = []; + function evaluationFunc(element, datasetIndex, index) { + const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition); + const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y}); + if (_angleBetween(angle, startAngle, endAngle)) { + items.push({element, datasetIndex, index}); + } + } + optimizedEvaluateItems(chart, axis, position, evaluationFunc); + return items; +} +function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition) { + let items = []; + const distanceMetric = getDistanceMetricForAxis(axis); + let minDistance = Number.POSITIVE_INFINITY; + function evaluationFunc(element, datasetIndex, index) { + const inRange = element.inRange(position.x, position.y, useFinalPosition); + if (intersect && !inRange) { + return; + } + const center = element.getCenterPoint(useFinalPosition); + const pointInArea = _isPointInArea(center, chart.chartArea, chart._minPadding); + if (!pointInArea && !inRange) { + return; + } + const distance = distanceMetric(position, center); + if (distance < minDistance) { + items = [{element, datasetIndex, index}]; + minDistance = distance; + } else if (distance === minDistance) { + items.push({element, datasetIndex, index}); + } + } + optimizedEvaluateItems(chart, axis, position, evaluationFunc); + return items; +} +function getNearestItems(chart, position, axis, intersect, useFinalPosition) { + if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) { + return []; + } + return axis === 'r' && !intersect + ? getNearestRadialItems(chart, position, axis, useFinalPosition) + : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition); +} +function getAxisItems(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const items = []; + const axis = options.axis; + const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange'; + let intersectsItem = false; + evaluateAllVisibleItems(chart, (element, datasetIndex, index) => { + if (element[rangeMethod](position[axis], useFinalPosition)) { + items.push({element, datasetIndex, index}); + } + if (element.inRange(position.x, position.y, useFinalPosition)) { + intersectsItem = true; + } + }); + if (options.intersect && !intersectsItem) { + return []; + } + return items; +} +var Interaction = { + modes: { + index(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'x'; + const items = options.intersect + ? getIntersectItems(chart, position, axis, useFinalPosition) + : getNearestItems(chart, position, axis, false, useFinalPosition); + const elements = []; + if (!items.length) { + return []; + } + chart.getSortedVisibleDatasetMetas().forEach((meta) => { + const index = items[0].index; + const element = meta.data[index]; + if (element && !element.skip) { + elements.push({element, datasetIndex: meta.index, index}); + } + }); + return elements; + }, + dataset(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + let items = options.intersect + ? getIntersectItems(chart, position, axis, useFinalPosition) : + getNearestItems(chart, position, axis, false, useFinalPosition); + if (items.length > 0) { + const datasetIndex = items[0].datasetIndex; + const data = chart.getDatasetMeta(datasetIndex).data; + items = []; + for (let i = 0; i < data.length; ++i) { + items.push({element: data[i], datasetIndex, index: i}); + } + } + return items; + }, + point(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + return getIntersectItems(chart, position, axis, useFinalPosition); + }, + nearest(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + return getNearestItems(chart, position, axis, options.intersect, useFinalPosition); + }, + x(chart, e, options, useFinalPosition) { + return getAxisItems(chart, e, {axis: 'x', intersect: options.intersect}, useFinalPosition); + }, + y(chart, e, options, useFinalPosition) { + return getAxisItems(chart, e, {axis: 'y', intersect: options.intersect}, useFinalPosition); + } + } +}; + +const LINE_HEIGHT = new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/); +const FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/); +function toLineHeight(value, size) { + const matches = ('' + value).match(LINE_HEIGHT); + if (!matches || matches[1] === 'normal') { + return size * 1.2; + } + value = +matches[2]; + switch (matches[3]) { + case 'px': + return value; + case '%': + value /= 100; + break; + } + return size * value; +} +const numberOrZero = v => +v || 0; +function _readValueToProps(value, props) { + const ret = {}; + const objProps = isObject(props); + const keys = objProps ? Object.keys(props) : props; + const read = isObject(value) + ? objProps + ? prop => valueOrDefault(value[prop], value[props[prop]]) + : prop => value[prop] + : () => value; + for (const prop of keys) { + ret[prop] = numberOrZero(read(prop)); + } + return ret; +} +function toTRBL(value) { + return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', left: 'x'}); +} +function toTRBLCorners(value) { + return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']); +} +function toPadding(value) { + const obj = toTRBL(value); + obj.width = obj.left + obj.right; + obj.height = obj.top + obj.bottom; + return obj; +} +function toFont(options, fallback) { + options = options || {}; + fallback = fallback || defaults.font; + let size = valueOrDefault(options.size, fallback.size); + if (typeof size === 'string') { + size = parseInt(size, 10); + } + let style = valueOrDefault(options.style, fallback.style); + if (style && !('' + style).match(FONT_STYLE)) { + console.warn('Invalid font style specified: "' + style + '"'); + style = ''; + } + const font = { + family: valueOrDefault(options.family, fallback.family), + lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size), + size, + style, + weight: valueOrDefault(options.weight, fallback.weight), + string: '' + }; + font.string = toFontString(font); + return font; +} +function resolve(inputs, context, index, info) { + let cacheable = true; + let i, ilen, value; + for (i = 0, ilen = inputs.length; i < ilen; ++i) { + value = inputs[i]; + if (value === undefined) { + continue; + } + if (context !== undefined && typeof value === 'function') { + value = value(context); + cacheable = false; + } + if (index !== undefined && isArray(value)) { + value = value[index % value.length]; + cacheable = false; + } + if (value !== undefined) { + if (info && !cacheable) { + info.cacheable = false; + } + return value; + } + } +} +function _addGrace(minmax, grace, beginAtZero) { + const {min, max} = minmax; + const change = toDimension(grace, (max - min) / 2); + const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add; + return { + min: keepZero(min, -Math.abs(change)), + max: keepZero(max, change) + }; +} +function createContext(parentContext, context) { + return Object.assign(Object.create(parentContext), context); +} + +const STATIC_POSITIONS = ['left', 'top', 'right', 'bottom']; +function filterByPosition(array, position) { + return array.filter(v => v.pos === position); +} +function filterDynamicPositionByAxis(array, axis) { + return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis); +} +function sortByWeight(array, reverse) { + return array.sort((a, b) => { + const v0 = reverse ? b : a; + const v1 = reverse ? a : b; + return v0.weight === v1.weight ? + v0.index - v1.index : + v0.weight - v1.weight; + }); +} +function wrapBoxes(boxes) { + const layoutBoxes = []; + let i, ilen, box, pos, stack, stackWeight; + for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) { + box = boxes[i]; + ({position: pos, options: {stack, stackWeight = 1}} = box); + layoutBoxes.push({ + index: i, + box, + pos, + horizontal: box.isHorizontal(), + weight: box.weight, + stack: stack && (pos + stack), + stackWeight + }); + } + return layoutBoxes; +} +function buildStacks(layouts) { + const stacks = {}; + for (const wrap of layouts) { + const {stack, pos, stackWeight} = wrap; + if (!stack || !STATIC_POSITIONS.includes(pos)) { + continue; + } + const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0}); + _stack.count++; + _stack.weight += stackWeight; + } + return stacks; +} +function setLayoutDims(layouts, params) { + const stacks = buildStacks(layouts); + const {vBoxMaxWidth, hBoxMaxHeight} = params; + let i, ilen, layout; + for (i = 0, ilen = layouts.length; i < ilen; ++i) { + layout = layouts[i]; + const {fullSize} = layout.box; + const stack = stacks[layout.stack]; + const factor = stack && layout.stackWeight / stack.weight; + if (layout.horizontal) { + layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth; + layout.height = hBoxMaxHeight; + } else { + layout.width = vBoxMaxWidth; + layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight; + } + } + return stacks; +} +function buildLayoutBoxes(boxes) { + const layoutBoxes = wrapBoxes(boxes); + const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true); + const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true); + const right = sortByWeight(filterByPosition(layoutBoxes, 'right')); + const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true); + const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom')); + const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x'); + const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y'); + return { + fullSize, + leftAndTop: left.concat(top), + rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal), + chartArea: filterByPosition(layoutBoxes, 'chartArea'), + vertical: left.concat(right).concat(centerVertical), + horizontal: top.concat(bottom).concat(centerHorizontal) + }; +} +function getCombinedMax(maxPadding, chartArea, a, b) { + return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]); +} +function updateMaxPadding(maxPadding, boxPadding) { + maxPadding.top = Math.max(maxPadding.top, boxPadding.top); + maxPadding.left = Math.max(maxPadding.left, boxPadding.left); + maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom); + maxPadding.right = Math.max(maxPadding.right, boxPadding.right); +} +function updateDims(chartArea, params, layout, stacks) { + const {pos, box} = layout; + const maxPadding = chartArea.maxPadding; + if (!isObject(pos)) { + if (layout.size) { + chartArea[pos] -= layout.size; + } + const stack = stacks[layout.stack] || {size: 0, count: 1}; + stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width); + layout.size = stack.size / stack.count; + chartArea[pos] += layout.size; + } + if (box.getPadding) { + updateMaxPadding(maxPadding, box.getPadding()); + } + const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right')); + const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom')); + const widthChanged = newWidth !== chartArea.w; + const heightChanged = newHeight !== chartArea.h; + chartArea.w = newWidth; + chartArea.h = newHeight; + return layout.horizontal + ? {same: widthChanged, other: heightChanged} + : {same: heightChanged, other: widthChanged}; +} +function handleMaxPadding(chartArea) { + const maxPadding = chartArea.maxPadding; + function updatePos(pos) { + const change = Math.max(maxPadding[pos] - chartArea[pos], 0); + chartArea[pos] += change; + return change; + } + chartArea.y += updatePos('top'); + chartArea.x += updatePos('left'); + updatePos('right'); + updatePos('bottom'); +} +function getMargins(horizontal, chartArea) { + const maxPadding = chartArea.maxPadding; + function marginForPositions(positions) { + const margin = {left: 0, top: 0, right: 0, bottom: 0}; + positions.forEach((pos) => { + margin[pos] = Math.max(chartArea[pos], maxPadding[pos]); + }); + return margin; + } + return horizontal + ? marginForPositions(['left', 'right']) + : marginForPositions(['top', 'bottom']); +} +function fitBoxes(boxes, chartArea, params, stacks) { + const refitBoxes = []; + let i, ilen, layout, box, refit, changed; + for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) { + layout = boxes[i]; + box = layout.box; + box.update( + layout.width || chartArea.w, + layout.height || chartArea.h, + getMargins(layout.horizontal, chartArea) + ); + const {same, other} = updateDims(chartArea, params, layout, stacks); + refit |= same && refitBoxes.length; + changed = changed || other; + if (!box.fullSize) { + refitBoxes.push(layout); + } + } + return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed; +} +function setBoxDims(box, left, top, width, height) { + box.top = top; + box.left = left; + box.right = left + width; + box.bottom = top + height; + box.width = width; + box.height = height; +} +function placeBoxes(boxes, chartArea, params, stacks) { + const userPadding = params.padding; + let {x, y} = chartArea; + for (const layout of boxes) { + const box = layout.box; + const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1}; + const weight = (layout.stackWeight / stack.weight) || 1; + if (layout.horizontal) { + const width = chartArea.w * weight; + const height = stack.size || box.height; + if (defined(stack.start)) { + y = stack.start; + } + if (box.fullSize) { + setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height); + } else { + setBoxDims(box, chartArea.left + stack.placed, y, width, height); + } + stack.start = y; + stack.placed += width; + y = box.bottom; + } else { + const height = chartArea.h * weight; + const width = stack.size || box.width; + if (defined(stack.start)) { + x = stack.start; + } + if (box.fullSize) { + setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top); + } else { + setBoxDims(box, x, chartArea.top + stack.placed, width, height); + } + stack.start = x; + stack.placed += height; + x = box.right; + } + } + chartArea.x = x; + chartArea.y = y; +} +defaults.set('layout', { + autoPadding: true, + padding: { + top: 0, + right: 0, + bottom: 0, + left: 0 + } +}); +var layouts = { + addBox(chart, item) { + if (!chart.boxes) { + chart.boxes = []; + } + item.fullSize = item.fullSize || false; + item.position = item.position || 'top'; + item.weight = item.weight || 0; + item._layers = item._layers || function() { + return [{ + z: 0, + draw(chartArea) { + item.draw(chartArea); + } + }]; + }; + chart.boxes.push(item); + }, + removeBox(chart, layoutItem) { + const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1; + if (index !== -1) { + chart.boxes.splice(index, 1); + } + }, + configure(chart, item, options) { + item.fullSize = options.fullSize; + item.position = options.position; + item.weight = options.weight; + }, + update(chart, width, height, minPadding) { + if (!chart) { + return; + } + const padding = toPadding(chart.options.layout.padding); + const availableWidth = Math.max(width - padding.width, 0); + const availableHeight = Math.max(height - padding.height, 0); + const boxes = buildLayoutBoxes(chart.boxes); + const verticalBoxes = boxes.vertical; + const horizontalBoxes = boxes.horizontal; + each(chart.boxes, box => { + if (typeof box.beforeLayout === 'function') { + box.beforeLayout(); + } + }); + const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) => + wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1; + const params = Object.freeze({ + outerWidth: width, + outerHeight: height, + padding, + availableWidth, + availableHeight, + vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount, + hBoxMaxHeight: availableHeight / 2 + }); + const maxPadding = Object.assign({}, padding); + updateMaxPadding(maxPadding, toPadding(minPadding)); + const chartArea = Object.assign({ + maxPadding, + w: availableWidth, + h: availableHeight, + x: padding.left, + y: padding.top + }, padding); + const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params); + fitBoxes(boxes.fullSize, chartArea, params, stacks); + fitBoxes(verticalBoxes, chartArea, params, stacks); + if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) { + fitBoxes(verticalBoxes, chartArea, params, stacks); + } + handleMaxPadding(chartArea); + placeBoxes(boxes.leftAndTop, chartArea, params, stacks); + chartArea.x += chartArea.w; + chartArea.y += chartArea.h; + placeBoxes(boxes.rightAndBottom, chartArea, params, stacks); + chart.chartArea = { + left: chartArea.left, + top: chartArea.top, + right: chartArea.left + chartArea.w, + bottom: chartArea.top + chartArea.h, + height: chartArea.h, + width: chartArea.w, + }; + each(boxes.chartArea, (layout) => { + const box = layout.box; + Object.assign(box, chart.chartArea); + box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0}); + }); + } +}; + +function _createResolver(scopes, prefixes = [''], rootScopes = scopes, fallback, getTarget = () => scopes[0]) { + if (!defined(fallback)) { + fallback = _resolve('_fallback', scopes); + } + const cache = { + [Symbol.toStringTag]: 'Object', + _cacheable: true, + _scopes: scopes, + _rootScopes: rootScopes, + _fallback: fallback, + _getTarget: getTarget, + override: (scope) => _createResolver([scope, ...scopes], prefixes, rootScopes, fallback), + }; + return new Proxy(cache, { + deleteProperty(target, prop) { + delete target[prop]; + delete target._keys; + delete scopes[0][prop]; + return true; + }, + get(target, prop) { + return _cached(target, prop, + () => _resolveWithPrefixes(prop, prefixes, scopes, target)); + }, + getOwnPropertyDescriptor(target, prop) { + return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop); + }, + getPrototypeOf() { + return Reflect.getPrototypeOf(scopes[0]); + }, + has(target, prop) { + return getKeysFromAllScopes(target).includes(prop); + }, + ownKeys(target) { + return getKeysFromAllScopes(target); + }, + set(target, prop, value) { + const storage = target._storage || (target._storage = getTarget()); + target[prop] = storage[prop] = value; + delete target._keys; + return true; + } + }); +} +function _attachContext(proxy, context, subProxy, descriptorDefaults) { + const cache = { + _cacheable: false, + _proxy: proxy, + _context: context, + _subProxy: subProxy, + _stack: new Set(), + _descriptors: _descriptors(proxy, descriptorDefaults), + setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults), + override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults) + }; + return new Proxy(cache, { + deleteProperty(target, prop) { + delete target[prop]; + delete proxy[prop]; + return true; + }, + get(target, prop, receiver) { + return _cached(target, prop, + () => _resolveWithContext(target, prop, receiver)); + }, + getOwnPropertyDescriptor(target, prop) { + return target._descriptors.allKeys + ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined + : Reflect.getOwnPropertyDescriptor(proxy, prop); + }, + getPrototypeOf() { + return Reflect.getPrototypeOf(proxy); + }, + has(target, prop) { + return Reflect.has(proxy, prop); + }, + ownKeys() { + return Reflect.ownKeys(proxy); + }, + set(target, prop, value) { + proxy[prop] = value; + delete target[prop]; + return true; + } + }); +} +function _descriptors(proxy, defaults = {scriptable: true, indexable: true}) { + const {_scriptable = defaults.scriptable, _indexable = defaults.indexable, _allKeys = defaults.allKeys} = proxy; + return { + allKeys: _allKeys, + scriptable: _scriptable, + indexable: _indexable, + isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable, + isIndexable: isFunction(_indexable) ? _indexable : () => _indexable + }; +} +const readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name; +const needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' && + (Object.getPrototypeOf(value) === null || value.constructor === Object); +function _cached(target, prop, resolve) { + if (Object.prototype.hasOwnProperty.call(target, prop)) { + return target[prop]; + } + const value = resolve(); + target[prop] = value; + return value; +} +function _resolveWithContext(target, prop, receiver) { + const {_proxy, _context, _subProxy, _descriptors: descriptors} = target; + let value = _proxy[prop]; + if (isFunction(value) && descriptors.isScriptable(prop)) { + value = _resolveScriptable(prop, value, target, receiver); + } + if (isArray(value) && value.length) { + value = _resolveArray(prop, value, target, descriptors.isIndexable); + } + if (needsSubResolver(prop, value)) { + value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors); + } + return value; +} +function _resolveScriptable(prop, value, target, receiver) { + const {_proxy, _context, _subProxy, _stack} = target; + if (_stack.has(prop)) { + throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop); + } + _stack.add(prop); + value = value(_context, _subProxy || receiver); + _stack.delete(prop); + if (needsSubResolver(prop, value)) { + value = createSubResolver(_proxy._scopes, _proxy, prop, value); + } + return value; +} +function _resolveArray(prop, value, target, isIndexable) { + const {_proxy, _context, _subProxy, _descriptors: descriptors} = target; + if (defined(_context.index) && isIndexable(prop)) { + value = value[_context.index % value.length]; + } else if (isObject(value[0])) { + const arr = value; + const scopes = _proxy._scopes.filter(s => s !== arr); + value = []; + for (const item of arr) { + const resolver = createSubResolver(scopes, _proxy, prop, item); + value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors)); + } + } + return value; +} +function resolveFallback(fallback, prop, value) { + return isFunction(fallback) ? fallback(prop, value) : fallback; +} +const getScope = (key, parent) => key === true ? parent + : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined; +function addScopes(set, parentScopes, key, parentFallback, value) { + for (const parent of parentScopes) { + const scope = getScope(key, parent); + if (scope) { + set.add(scope); + const fallback = resolveFallback(scope._fallback, key, value); + if (defined(fallback) && fallback !== key && fallback !== parentFallback) { + return fallback; + } + } else if (scope === false && defined(parentFallback) && key !== parentFallback) { + return null; + } + } + return false; +} +function createSubResolver(parentScopes, resolver, prop, value) { + const rootScopes = resolver._rootScopes; + const fallback = resolveFallback(resolver._fallback, prop, value); + const allScopes = [...parentScopes, ...rootScopes]; + const set = new Set(); + set.add(value); + let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value); + if (key === null) { + return false; + } + if (defined(fallback) && fallback !== prop) { + key = addScopesFromKey(set, allScopes, fallback, key, value); + if (key === null) { + return false; + } + } + return _createResolver(Array.from(set), [''], rootScopes, fallback, + () => subGetTarget(resolver, prop, value)); +} +function addScopesFromKey(set, allScopes, key, fallback, item) { + while (key) { + key = addScopes(set, allScopes, key, fallback, item); + } + return key; +} +function subGetTarget(resolver, prop, value) { + const parent = resolver._getTarget(); + if (!(prop in parent)) { + parent[prop] = {}; + } + const target = parent[prop]; + if (isArray(target) && isObject(value)) { + return value; + } + return target; +} +function _resolveWithPrefixes(prop, prefixes, scopes, proxy) { + let value; + for (const prefix of prefixes) { + value = _resolve(readKey(prefix, prop), scopes); + if (defined(value)) { + return needsSubResolver(prop, value) + ? createSubResolver(scopes, proxy, prop, value) + : value; + } + } +} +function _resolve(key, scopes) { + for (const scope of scopes) { + if (!scope) { + continue; + } + const value = scope[key]; + if (defined(value)) { + return value; + } + } +} +function getKeysFromAllScopes(target) { + let keys = target._keys; + if (!keys) { + keys = target._keys = resolveKeysFromAllScopes(target._scopes); + } + return keys; +} +function resolveKeysFromAllScopes(scopes) { + const set = new Set(); + for (const scope of scopes) { + for (const key of Object.keys(scope).filter(k => !k.startsWith('_'))) { + set.add(key); + } + } + return Array.from(set); +} + +const EPSILON = Number.EPSILON || 1e-14; +const getPoint = (points, i) => i < points.length && !points[i].skip && points[i]; +const getValueAxis = (indexAxis) => indexAxis === 'x' ? 'y' : 'x'; +function splineCurve(firstPoint, middlePoint, afterPoint, t) { + const previous = firstPoint.skip ? middlePoint : firstPoint; + const current = middlePoint; + const next = afterPoint.skip ? middlePoint : afterPoint; + const d01 = distanceBetweenPoints(current, previous); + const d12 = distanceBetweenPoints(next, current); + let s01 = d01 / (d01 + d12); + let s12 = d12 / (d01 + d12); + s01 = isNaN(s01) ? 0 : s01; + s12 = isNaN(s12) ? 0 : s12; + const fa = t * s01; + const fb = t * s12; + return { + previous: { + x: current.x - fa * (next.x - previous.x), + y: current.y - fa * (next.y - previous.y) + }, + next: { + x: current.x + fb * (next.x - previous.x), + y: current.y + fb * (next.y - previous.y) + } + }; +} +function monotoneAdjust(points, deltaK, mK) { + const pointsLen = points.length; + let alphaK, betaK, tauK, squaredMagnitude, pointCurrent; + let pointAfter = getPoint(points, 0); + for (let i = 0; i < pointsLen - 1; ++i) { + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent || !pointAfter) { + continue; + } + if (almostEquals(deltaK[i], 0, EPSILON)) { + mK[i] = mK[i + 1] = 0; + continue; + } + alphaK = mK[i] / deltaK[i]; + betaK = mK[i + 1] / deltaK[i]; + squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2); + if (squaredMagnitude <= 9) { + continue; + } + tauK = 3 / Math.sqrt(squaredMagnitude); + mK[i] = alphaK * tauK * deltaK[i]; + mK[i + 1] = betaK * tauK * deltaK[i]; + } +} +function monotoneCompute(points, mK, indexAxis = 'x') { + const valueAxis = getValueAxis(indexAxis); + const pointsLen = points.length; + let delta, pointBefore, pointCurrent; + let pointAfter = getPoint(points, 0); + for (let i = 0; i < pointsLen; ++i) { + pointBefore = pointCurrent; + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent) { + continue; + } + const iPixel = pointCurrent[indexAxis]; + const vPixel = pointCurrent[valueAxis]; + if (pointBefore) { + delta = (iPixel - pointBefore[indexAxis]) / 3; + pointCurrent[`cp1${indexAxis}`] = iPixel - delta; + pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i]; + } + if (pointAfter) { + delta = (pointAfter[indexAxis] - iPixel) / 3; + pointCurrent[`cp2${indexAxis}`] = iPixel + delta; + pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i]; + } + } +} +function splineCurveMonotone(points, indexAxis = 'x') { + const valueAxis = getValueAxis(indexAxis); + const pointsLen = points.length; + const deltaK = Array(pointsLen).fill(0); + const mK = Array(pointsLen); + let i, pointBefore, pointCurrent; + let pointAfter = getPoint(points, 0); + for (i = 0; i < pointsLen; ++i) { + pointBefore = pointCurrent; + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent) { + continue; + } + if (pointAfter) { + const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis]; + deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0; + } + mK[i] = !pointBefore ? deltaK[i] + : !pointAfter ? deltaK[i - 1] + : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0 + : (deltaK[i - 1] + deltaK[i]) / 2; + } + monotoneAdjust(points, deltaK, mK); + monotoneCompute(points, mK, indexAxis); +} +function capControlPoint(pt, min, max) { + return Math.max(Math.min(pt, max), min); +} +function capBezierPoints(points, area) { + let i, ilen, point, inArea, inAreaPrev; + let inAreaNext = _isPointInArea(points[0], area); + for (i = 0, ilen = points.length; i < ilen; ++i) { + inAreaPrev = inArea; + inArea = inAreaNext; + inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area); + if (!inArea) { + continue; + } + point = points[i]; + if (inAreaPrev) { + point.cp1x = capControlPoint(point.cp1x, area.left, area.right); + point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom); + } + if (inAreaNext) { + point.cp2x = capControlPoint(point.cp2x, area.left, area.right); + point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom); + } + } +} +function _updateBezierControlPoints(points, options, area, loop, indexAxis) { + let i, ilen, point, controlPoints; + if (options.spanGaps) { + points = points.filter((pt) => !pt.skip); + } + if (options.cubicInterpolationMode === 'monotone') { + splineCurveMonotone(points, indexAxis); + } else { + let prev = loop ? points[points.length - 1] : points[0]; + for (i = 0, ilen = points.length; i < ilen; ++i) { + point = points[i]; + controlPoints = splineCurve( + prev, + point, + points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], + options.tension + ); + point.cp1x = controlPoints.previous.x; + point.cp1y = controlPoints.previous.y; + point.cp2x = controlPoints.next.x; + point.cp2y = controlPoints.next.y; + prev = point; + } + } + if (options.capBezierPoints) { + capBezierPoints(points, area); + } +} + +const atEdge = (t) => t === 0 || t === 1; +const elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p)); +const elasticOut = (t, s, p) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1; +const effects = { + linear: t => t, + easeInQuad: t => t * t, + easeOutQuad: t => -t * (t - 2), + easeInOutQuad: t => ((t /= 0.5) < 1) + ? 0.5 * t * t + : -0.5 * ((--t) * (t - 2) - 1), + easeInCubic: t => t * t * t, + easeOutCubic: t => (t -= 1) * t * t + 1, + easeInOutCubic: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t + : 0.5 * ((t -= 2) * t * t + 2), + easeInQuart: t => t * t * t * t, + easeOutQuart: t => -((t -= 1) * t * t * t - 1), + easeInOutQuart: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t * t + : -0.5 * ((t -= 2) * t * t * t - 2), + easeInQuint: t => t * t * t * t * t, + easeOutQuint: t => (t -= 1) * t * t * t * t + 1, + easeInOutQuint: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t * t * t + : 0.5 * ((t -= 2) * t * t * t * t + 2), + easeInSine: t => -Math.cos(t * HALF_PI) + 1, + easeOutSine: t => Math.sin(t * HALF_PI), + easeInOutSine: t => -0.5 * (Math.cos(PI * t) - 1), + easeInExpo: t => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)), + easeOutExpo: t => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1, + easeInOutExpo: t => atEdge(t) ? t : t < 0.5 + ? 0.5 * Math.pow(2, 10 * (t * 2 - 1)) + : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2), + easeInCirc: t => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1), + easeOutCirc: t => Math.sqrt(1 - (t -= 1) * t), + easeInOutCirc: t => ((t /= 0.5) < 1) + ? -0.5 * (Math.sqrt(1 - t * t) - 1) + : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1), + easeInElastic: t => atEdge(t) ? t : elasticIn(t, 0.075, 0.3), + easeOutElastic: t => atEdge(t) ? t : elasticOut(t, 0.075, 0.3), + easeInOutElastic(t) { + const s = 0.1125; + const p = 0.45; + return atEdge(t) ? t : + t < 0.5 + ? 0.5 * elasticIn(t * 2, s, p) + : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p); + }, + easeInBack(t) { + const s = 1.70158; + return t * t * ((s + 1) * t - s); + }, + easeOutBack(t) { + const s = 1.70158; + return (t -= 1) * t * ((s + 1) * t + s) + 1; + }, + easeInOutBack(t) { + let s = 1.70158; + if ((t /= 0.5) < 1) { + return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)); + } + return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2); + }, + easeInBounce: t => 1 - effects.easeOutBounce(1 - t), + easeOutBounce(t) { + const m = 7.5625; + const d = 2.75; + if (t < (1 / d)) { + return m * t * t; + } + if (t < (2 / d)) { + return m * (t -= (1.5 / d)) * t + 0.75; + } + if (t < (2.5 / d)) { + return m * (t -= (2.25 / d)) * t + 0.9375; + } + return m * (t -= (2.625 / d)) * t + 0.984375; + }, + easeInOutBounce: t => (t < 0.5) + ? effects.easeInBounce(t * 2) * 0.5 + : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5, +}; + +function _pointInLine(p1, p2, t, mode) { + return { + x: p1.x + t * (p2.x - p1.x), + y: p1.y + t * (p2.y - p1.y) + }; +} +function _steppedInterpolation(p1, p2, t, mode) { + return { + x: p1.x + t * (p2.x - p1.x), + y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y + : mode === 'after' ? t < 1 ? p1.y : p2.y + : t > 0 ? p2.y : p1.y + }; +} +function _bezierInterpolation(p1, p2, t, mode) { + const cp1 = {x: p1.cp2x, y: p1.cp2y}; + const cp2 = {x: p2.cp1x, y: p2.cp1y}; + const a = _pointInLine(p1, cp1, t); + const b = _pointInLine(cp1, cp2, t); + const c = _pointInLine(cp2, p2, t); + const d = _pointInLine(a, b, t); + const e = _pointInLine(b, c, t); + return _pointInLine(d, e, t); +} + +const intlCache = new Map(); +function getNumberFormat(locale, options) { + options = options || {}; + const cacheKey = locale + JSON.stringify(options); + let formatter = intlCache.get(cacheKey); + if (!formatter) { + formatter = new Intl.NumberFormat(locale, options); + intlCache.set(cacheKey, formatter); + } + return formatter; +} +function formatNumber(num, locale, options) { + return getNumberFormat(locale, options).format(num); +} + +const getRightToLeftAdapter = function(rectX, width) { + return { + x(x) { + return rectX + rectX + width - x; + }, + setWidth(w) { + width = w; + }, + textAlign(align) { + if (align === 'center') { + return align; + } + return align === 'right' ? 'left' : 'right'; + }, + xPlus(x, value) { + return x - value; + }, + leftForLtr(x, itemWidth) { + return x - itemWidth; + }, + }; +}; +const getLeftToRightAdapter = function() { + return { + x(x) { + return x; + }, + setWidth(w) { + }, + textAlign(align) { + return align; + }, + xPlus(x, value) { + return x + value; + }, + leftForLtr(x, _itemWidth) { + return x; + }, + }; +}; +function getRtlAdapter(rtl, rectX, width) { + return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter(); +} +function overrideTextDirection(ctx, direction) { + let style, original; + if (direction === 'ltr' || direction === 'rtl') { + style = ctx.canvas.style; + original = [ + style.getPropertyValue('direction'), + style.getPropertyPriority('direction'), + ]; + style.setProperty('direction', direction, 'important'); + ctx.prevTextDirection = original; + } +} +function restoreTextDirection(ctx, original) { + if (original !== undefined) { + delete ctx.prevTextDirection; + ctx.canvas.style.setProperty('direction', original[0], original[1]); + } +} + +function propertyFn(property) { + if (property === 'angle') { + return { + between: _angleBetween, + compare: _angleDiff, + normalize: _normalizeAngle, + }; + } + return { + between: _isBetween, + compare: (a, b) => a - b, + normalize: x => x + }; +} +function normalizeSegment({start, end, count, loop, style}) { + return { + start: start % count, + end: end % count, + loop: loop && (end - start + 1) % count === 0, + style + }; +} +function getSegment(segment, points, bounds) { + const {property, start: startBound, end: endBound} = bounds; + const {between, normalize} = propertyFn(property); + const count = points.length; + let {start, end, loop} = segment; + let i, ilen; + if (loop) { + start += count; + end += count; + for (i = 0, ilen = count; i < ilen; ++i) { + if (!between(normalize(points[start % count][property]), startBound, endBound)) { + break; + } + start--; + end--; + } + start %= count; + end %= count; + } + if (end < start) { + end += count; + } + return {start, end, loop, style: segment.style}; +} +function _boundSegment(segment, points, bounds) { + if (!bounds) { + return [segment]; + } + const {property, start: startBound, end: endBound} = bounds; + const count = points.length; + const {compare, between, normalize} = propertyFn(property); + const {start, end, loop, style} = getSegment(segment, points, bounds); + const result = []; + let inside = false; + let subStart = null; + let value, point, prevValue; + const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0; + const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value); + const shouldStart = () => inside || startIsBefore(); + const shouldStop = () => !inside || endIsBefore(); + for (let i = start, prev = start; i <= end; ++i) { + point = points[i % count]; + if (point.skip) { + continue; + } + value = normalize(point[property]); + if (value === prevValue) { + continue; + } + inside = between(value, startBound, endBound); + if (subStart === null && shouldStart()) { + subStart = compare(value, startBound) === 0 ? i : prev; + } + if (subStart !== null && shouldStop()) { + result.push(normalizeSegment({start: subStart, end: i, loop, count, style})); + subStart = null; + } + prev = i; + prevValue = value; + } + if (subStart !== null) { + result.push(normalizeSegment({start: subStart, end, loop, count, style})); + } + return result; +} +function _boundSegments(line, bounds) { + const result = []; + const segments = line.segments; + for (let i = 0; i < segments.length; i++) { + const sub = _boundSegment(segments[i], line.points, bounds); + if (sub.length) { + result.push(...sub); + } + } + return result; +} +function findStartAndEnd(points, count, loop, spanGaps) { + let start = 0; + let end = count - 1; + if (loop && !spanGaps) { + while (start < count && !points[start].skip) { + start++; + } + } + while (start < count && points[start].skip) { + start++; + } + start %= count; + if (loop) { + end += start; + } + while (end > start && points[end % count].skip) { + end--; + } + end %= count; + return {start, end}; +} +function solidSegments(points, start, max, loop) { + const count = points.length; + const result = []; + let last = start; + let prev = points[start]; + let end; + for (end = start + 1; end <= max; ++end) { + const cur = points[end % count]; + if (cur.skip || cur.stop) { + if (!prev.skip) { + loop = false; + result.push({start: start % count, end: (end - 1) % count, loop}); + start = last = cur.stop ? end : null; + } + } else { + last = end; + if (prev.skip) { + start = end; + } + } + prev = cur; + } + if (last !== null) { + result.push({start: start % count, end: last % count, loop}); + } + return result; +} +function _computeSegments(line, segmentOptions) { + const points = line.points; + const spanGaps = line.options.spanGaps; + const count = points.length; + if (!count) { + return []; + } + const loop = !!line._loop; + const {start, end} = findStartAndEnd(points, count, loop, spanGaps); + if (spanGaps === true) { + return splitByStyles(line, [{start, end, loop}], points, segmentOptions); + } + const max = end < start ? end + count : end; + const completeLoop = !!line._fullLoop && start === 0 && end === count - 1; + return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions); +} +function splitByStyles(line, segments, points, segmentOptions) { + if (!segmentOptions || !segmentOptions.setContext || !points) { + return segments; + } + return doSplitByStyles(line, segments, points, segmentOptions); +} +function doSplitByStyles(line, segments, points, segmentOptions) { + const chartContext = line._chart.getContext(); + const baseStyle = readStyle(line.options); + const {_datasetIndex: datasetIndex, options: {spanGaps}} = line; + const count = points.length; + const result = []; + let prevStyle = baseStyle; + let start = segments[0].start; + let i = start; + function addStyle(s, e, l, st) { + const dir = spanGaps ? -1 : 1; + if (s === e) { + return; + } + s += count; + while (points[s % count].skip) { + s -= dir; + } + while (points[e % count].skip) { + e += dir; + } + if (s % count !== e % count) { + result.push({start: s % count, end: e % count, loop: l, style: st}); + prevStyle = st; + start = e % count; + } + } + for (const segment of segments) { + start = spanGaps ? start : segment.start; + let prev = points[start % count]; + let style; + for (i = start + 1; i <= segment.end; i++) { + const pt = points[i % count]; + style = readStyle(segmentOptions.setContext(createContext(chartContext, { + type: 'segment', + p0: prev, + p1: pt, + p0DataIndex: (i - 1) % count, + p1DataIndex: i % count, + datasetIndex + }))); + if (styleChanged(style, prevStyle)) { + addStyle(start, i - 1, segment.loop, prevStyle); + } + prev = pt; + prevStyle = style; + } + if (start < i - 1) { + addStyle(start, i - 1, segment.loop, prevStyle); + } + } + return result; +} +function readStyle(options) { + return { + backgroundColor: options.backgroundColor, + borderCapStyle: options.borderCapStyle, + borderDash: options.borderDash, + borderDashOffset: options.borderDashOffset, + borderJoinStyle: options.borderJoinStyle, + borderWidth: options.borderWidth, + borderColor: options.borderColor + }; +} +function styleChanged(style, prevStyle) { + return prevStyle && JSON.stringify(style) !== JSON.stringify(prevStyle); +} + +var helpers = /*#__PURE__*/Object.freeze({ +__proto__: null, +easingEffects: effects, +color: color, +getHoverColor: getHoverColor, +noop: noop, +uid: uid, +isNullOrUndef: isNullOrUndef, +isArray: isArray, +isObject: isObject, +isFinite: isNumberFinite, +finiteOrDefault: finiteOrDefault, +valueOrDefault: valueOrDefault, +toPercentage: toPercentage, +toDimension: toDimension, +callback: callback, +each: each, +_elementsEqual: _elementsEqual, +clone: clone, +_merger: _merger, +merge: merge, +mergeIf: mergeIf, +_mergerIf: _mergerIf, +_deprecated: _deprecated, +resolveObjectKey: resolveObjectKey, +_capitalize: _capitalize, +defined: defined, +isFunction: isFunction, +setsEqual: setsEqual, +_isClickEvent: _isClickEvent, +toFontString: toFontString, +_measureText: _measureText, +_longestText: _longestText, +_alignPixel: _alignPixel, +clearCanvas: clearCanvas, +drawPoint: drawPoint, +_isPointInArea: _isPointInArea, +clipArea: clipArea, +unclipArea: unclipArea, +_steppedLineTo: _steppedLineTo, +_bezierCurveTo: _bezierCurveTo, +renderText: renderText, +addRoundedRectPath: addRoundedRectPath, +_lookup: _lookup, +_lookupByKey: _lookupByKey, +_rlookupByKey: _rlookupByKey, +_filterBetween: _filterBetween, +listenArrayEvents: listenArrayEvents, +unlistenArrayEvents: unlistenArrayEvents, +_arrayUnique: _arrayUnique, +_createResolver: _createResolver, +_attachContext: _attachContext, +_descriptors: _descriptors, +splineCurve: splineCurve, +splineCurveMonotone: splineCurveMonotone, +_updateBezierControlPoints: _updateBezierControlPoints, +_isDomSupported: _isDomSupported, +_getParentNode: _getParentNode, +getStyle: getStyle, +getRelativePosition: getRelativePosition$1, +getMaximumSize: getMaximumSize, +retinaScale: retinaScale, +supportsEventListenerOptions: supportsEventListenerOptions, +readUsedSize: readUsedSize, +fontString: fontString, +requestAnimFrame: requestAnimFrame, +throttled: throttled, +debounce: debounce, +_toLeftRightCenter: _toLeftRightCenter, +_alignStartEnd: _alignStartEnd, +_textX: _textX, +_pointInLine: _pointInLine, +_steppedInterpolation: _steppedInterpolation, +_bezierInterpolation: _bezierInterpolation, +formatNumber: formatNumber, +toLineHeight: toLineHeight, +_readValueToProps: _readValueToProps, +toTRBL: toTRBL, +toTRBLCorners: toTRBLCorners, +toPadding: toPadding, +toFont: toFont, +resolve: resolve, +_addGrace: _addGrace, +createContext: createContext, +PI: PI, +TAU: TAU, +PITAU: PITAU, +INFINITY: INFINITY, +RAD_PER_DEG: RAD_PER_DEG, +HALF_PI: HALF_PI, +QUARTER_PI: QUARTER_PI, +TWO_THIRDS_PI: TWO_THIRDS_PI, +log10: log10, +sign: sign, +niceNum: niceNum, +_factorize: _factorize, +isNumber: isNumber, +almostEquals: almostEquals, +almostWhole: almostWhole, +_setMinAndMaxByKey: _setMinAndMaxByKey, +toRadians: toRadians, +toDegrees: toDegrees, +_decimalPlaces: _decimalPlaces, +getAngleFromPoint: getAngleFromPoint, +distanceBetweenPoints: distanceBetweenPoints, +_angleDiff: _angleDiff, +_normalizeAngle: _normalizeAngle, +_angleBetween: _angleBetween, +_limitValue: _limitValue, +_int16Range: _int16Range, +_isBetween: _isBetween, +getRtlAdapter: getRtlAdapter, +overrideTextDirection: overrideTextDirection, +restoreTextDirection: restoreTextDirection, +_boundSegment: _boundSegment, +_boundSegments: _boundSegments, +_computeSegments: _computeSegments +}); + +class BasePlatform { + acquireContext(canvas, aspectRatio) {} + releaseContext(context) { + return false; + } + addEventListener(chart, type, listener) {} + removeEventListener(chart, type, listener) {} + getDevicePixelRatio() { + return 1; + } + getMaximumSize(element, width, height, aspectRatio) { + width = Math.max(0, width || element.width); + height = height || element.height; + return { + width, + height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height) + }; + } + isAttached(canvas) { + return true; + } + updateConfig(config) { + } +} + +class BasicPlatform extends BasePlatform { + acquireContext(item) { + return item && item.getContext && item.getContext('2d') || null; + } + updateConfig(config) { + config.options.animation = false; + } +} + +const EXPANDO_KEY = '$chartjs'; +const EVENT_TYPES = { + touchstart: 'mousedown', + touchmove: 'mousemove', + touchend: 'mouseup', + pointerenter: 'mouseenter', + pointerdown: 'mousedown', + pointermove: 'mousemove', + pointerup: 'mouseup', + pointerleave: 'mouseout', + pointerout: 'mouseout' +}; +const isNullOrEmpty = value => value === null || value === ''; +function initCanvas(canvas, aspectRatio) { + const style = canvas.style; + const renderHeight = canvas.getAttribute('height'); + const renderWidth = canvas.getAttribute('width'); + canvas[EXPANDO_KEY] = { + initial: { + height: renderHeight, + width: renderWidth, + style: { + display: style.display, + height: style.height, + width: style.width + } + } + }; + style.display = style.display || 'block'; + style.boxSizing = style.boxSizing || 'border-box'; + if (isNullOrEmpty(renderWidth)) { + const displayWidth = readUsedSize(canvas, 'width'); + if (displayWidth !== undefined) { + canvas.width = displayWidth; + } + } + if (isNullOrEmpty(renderHeight)) { + if (canvas.style.height === '') { + canvas.height = canvas.width / (aspectRatio || 2); + } else { + const displayHeight = readUsedSize(canvas, 'height'); + if (displayHeight !== undefined) { + canvas.height = displayHeight; + } + } + } + return canvas; +} +const eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false; +function addListener(node, type, listener) { + node.addEventListener(type, listener, eventListenerOptions); +} +function removeListener(chart, type, listener) { + chart.canvas.removeEventListener(type, listener, eventListenerOptions); +} +function fromNativeEvent(event, chart) { + const type = EVENT_TYPES[event.type] || event.type; + const {x, y} = getRelativePosition$1(event, chart); + return { + type, + chart, + native: event, + x: x !== undefined ? x : null, + y: y !== undefined ? y : null, + }; +} +function nodeListContains(nodeList, canvas) { + for (const node of nodeList) { + if (node === canvas || node.contains(canvas)) { + return true; + } + } +} +function createAttachObserver(chart, type, listener) { + const canvas = chart.canvas; + const observer = new MutationObserver(entries => { + let trigger = false; + for (const entry of entries) { + trigger = trigger || nodeListContains(entry.addedNodes, canvas); + trigger = trigger && !nodeListContains(entry.removedNodes, canvas); + } + if (trigger) { + listener(); + } + }); + observer.observe(document, {childList: true, subtree: true}); + return observer; +} +function createDetachObserver(chart, type, listener) { + const canvas = chart.canvas; + const observer = new MutationObserver(entries => { + let trigger = false; + for (const entry of entries) { + trigger = trigger || nodeListContains(entry.removedNodes, canvas); + trigger = trigger && !nodeListContains(entry.addedNodes, canvas); + } + if (trigger) { + listener(); + } + }); + observer.observe(document, {childList: true, subtree: true}); + return observer; +} +const drpListeningCharts = new Map(); +let oldDevicePixelRatio = 0; +function onWindowResize() { + const dpr = window.devicePixelRatio; + if (dpr === oldDevicePixelRatio) { + return; + } + oldDevicePixelRatio = dpr; + drpListeningCharts.forEach((resize, chart) => { + if (chart.currentDevicePixelRatio !== dpr) { + resize(); + } + }); +} +function listenDevicePixelRatioChanges(chart, resize) { + if (!drpListeningCharts.size) { + window.addEventListener('resize', onWindowResize); + } + drpListeningCharts.set(chart, resize); +} +function unlistenDevicePixelRatioChanges(chart) { + drpListeningCharts.delete(chart); + if (!drpListeningCharts.size) { + window.removeEventListener('resize', onWindowResize); + } +} +function createResizeObserver(chart, type, listener) { + const canvas = chart.canvas; + const container = canvas && _getParentNode(canvas); + if (!container) { + return; + } + const resize = throttled((width, height) => { + const w = container.clientWidth; + listener(width, height); + if (w < container.clientWidth) { + listener(); + } + }, window); + const observer = new ResizeObserver(entries => { + const entry = entries[0]; + const width = entry.contentRect.width; + const height = entry.contentRect.height; + if (width === 0 && height === 0) { + return; + } + resize(width, height); + }); + observer.observe(container); + listenDevicePixelRatioChanges(chart, resize); + return observer; +} +function releaseObserver(chart, type, observer) { + if (observer) { + observer.disconnect(); + } + if (type === 'resize') { + unlistenDevicePixelRatioChanges(chart); + } +} +function createProxyAndListen(chart, type, listener) { + const canvas = chart.canvas; + const proxy = throttled((event) => { + if (chart.ctx !== null) { + listener(fromNativeEvent(event, chart)); + } + }, chart, (args) => { + const event = args[0]; + return [event, event.offsetX, event.offsetY]; + }); + addListener(canvas, type, proxy); + return proxy; +} +class DomPlatform extends BasePlatform { + acquireContext(canvas, aspectRatio) { + const context = canvas && canvas.getContext && canvas.getContext('2d'); + if (context && context.canvas === canvas) { + initCanvas(canvas, aspectRatio); + return context; + } + return null; + } + releaseContext(context) { + const canvas = context.canvas; + if (!canvas[EXPANDO_KEY]) { + return false; + } + const initial = canvas[EXPANDO_KEY].initial; + ['height', 'width'].forEach((prop) => { + const value = initial[prop]; + if (isNullOrUndef(value)) { + canvas.removeAttribute(prop); + } else { + canvas.setAttribute(prop, value); + } + }); + const style = initial.style || {}; + Object.keys(style).forEach((key) => { + canvas.style[key] = style[key]; + }); + canvas.width = canvas.width; + delete canvas[EXPANDO_KEY]; + return true; + } + addEventListener(chart, type, listener) { + this.removeEventListener(chart, type); + const proxies = chart.$proxies || (chart.$proxies = {}); + const handlers = { + attach: createAttachObserver, + detach: createDetachObserver, + resize: createResizeObserver + }; + const handler = handlers[type] || createProxyAndListen; + proxies[type] = handler(chart, type, listener); + } + removeEventListener(chart, type) { + const proxies = chart.$proxies || (chart.$proxies = {}); + const proxy = proxies[type]; + if (!proxy) { + return; + } + const handlers = { + attach: releaseObserver, + detach: releaseObserver, + resize: releaseObserver + }; + const handler = handlers[type] || removeListener; + handler(chart, type, proxy); + proxies[type] = undefined; + } + getDevicePixelRatio() { + return window.devicePixelRatio; + } + getMaximumSize(canvas, width, height, aspectRatio) { + return getMaximumSize(canvas, width, height, aspectRatio); + } + isAttached(canvas) { + const container = _getParentNode(canvas); + return !!(container && container.isConnected); + } +} + +function _detectPlatform(canvas) { + if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) { + return BasicPlatform; + } + return DomPlatform; +} + +var platforms = /*#__PURE__*/Object.freeze({ +__proto__: null, +_detectPlatform: _detectPlatform, +BasePlatform: BasePlatform, +BasicPlatform: BasicPlatform, +DomPlatform: DomPlatform +}); + +const transparent = 'transparent'; +const interpolators = { + boolean(from, to, factor) { + return factor > 0.5 ? to : from; + }, + color(from, to, factor) { + const c0 = color(from || transparent); + const c1 = c0.valid && color(to || transparent); + return c1 && c1.valid + ? c1.mix(c0, factor).hexString() + : to; + }, + number(from, to, factor) { + return from + (to - from) * factor; + } +}; +class Animation { + constructor(cfg, target, prop, to) { + const currentValue = target[prop]; + to = resolve([cfg.to, to, currentValue, cfg.from]); + const from = resolve([cfg.from, currentValue, to]); + this._active = true; + this._fn = cfg.fn || interpolators[cfg.type || typeof from]; + this._easing = effects[cfg.easing] || effects.linear; + this._start = Math.floor(Date.now() + (cfg.delay || 0)); + this._duration = this._total = Math.floor(cfg.duration); + this._loop = !!cfg.loop; + this._target = target; + this._prop = prop; + this._from = from; + this._to = to; + this._promises = undefined; + } + active() { + return this._active; + } + update(cfg, to, date) { + if (this._active) { + this._notify(false); + const currentValue = this._target[this._prop]; + const elapsed = date - this._start; + const remain = this._duration - elapsed; + this._start = date; + this._duration = Math.floor(Math.max(remain, cfg.duration)); + this._total += elapsed; + this._loop = !!cfg.loop; + this._to = resolve([cfg.to, to, currentValue, cfg.from]); + this._from = resolve([cfg.from, currentValue, to]); + } + } + cancel() { + if (this._active) { + this.tick(Date.now()); + this._active = false; + this._notify(false); + } + } + tick(date) { + const elapsed = date - this._start; + const duration = this._duration; + const prop = this._prop; + const from = this._from; + const loop = this._loop; + const to = this._to; + let factor; + this._active = from !== to && (loop || (elapsed < duration)); + if (!this._active) { + this._target[prop] = to; + this._notify(true); + return; + } + if (elapsed < 0) { + this._target[prop] = from; + return; + } + factor = (elapsed / duration) % 2; + factor = loop && factor > 1 ? 2 - factor : factor; + factor = this._easing(Math.min(1, Math.max(0, factor))); + this._target[prop] = this._fn(from, to, factor); + } + wait() { + const promises = this._promises || (this._promises = []); + return new Promise((res, rej) => { + promises.push({res, rej}); + }); + } + _notify(resolved) { + const method = resolved ? 'res' : 'rej'; + const promises = this._promises || []; + for (let i = 0; i < promises.length; i++) { + promises[i][method](); + } + } +} + +const numbers = ['x', 'y', 'borderWidth', 'radius', 'tension']; +const colors = ['color', 'borderColor', 'backgroundColor']; +defaults.set('animation', { + delay: undefined, + duration: 1000, + easing: 'easeOutQuart', + fn: undefined, + from: undefined, + loop: undefined, + to: undefined, + type: undefined, +}); +const animationOptions = Object.keys(defaults.animation); +defaults.describe('animation', { + _fallback: false, + _indexable: false, + _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn', +}); +defaults.set('animations', { + colors: { + type: 'color', + properties: colors + }, + numbers: { + type: 'number', + properties: numbers + }, +}); +defaults.describe('animations', { + _fallback: 'animation', +}); +defaults.set('transitions', { + active: { + animation: { + duration: 400 + } + }, + resize: { + animation: { + duration: 0 + } + }, + show: { + animations: { + colors: { + from: 'transparent' + }, + visible: { + type: 'boolean', + duration: 0 + }, + } + }, + hide: { + animations: { + colors: { + to: 'transparent' + }, + visible: { + type: 'boolean', + easing: 'linear', + fn: v => v | 0 + }, + } + } +}); +class Animations { + constructor(chart, config) { + this._chart = chart; + this._properties = new Map(); + this.configure(config); + } + configure(config) { + if (!isObject(config)) { + return; + } + const animatedProps = this._properties; + Object.getOwnPropertyNames(config).forEach(key => { + const cfg = config[key]; + if (!isObject(cfg)) { + return; + } + const resolved = {}; + for (const option of animationOptions) { + resolved[option] = cfg[option]; + } + (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => { + if (prop === key || !animatedProps.has(prop)) { + animatedProps.set(prop, resolved); + } + }); + }); + } + _animateOptions(target, values) { + const newOptions = values.options; + const options = resolveTargetOptions(target, newOptions); + if (!options) { + return []; + } + const animations = this._createAnimations(options, newOptions); + if (newOptions.$shared) { + awaitAll(target.options.$animations, newOptions).then(() => { + target.options = newOptions; + }, () => { + }); + } + return animations; + } + _createAnimations(target, values) { + const animatedProps = this._properties; + const animations = []; + const running = target.$animations || (target.$animations = {}); + const props = Object.keys(values); + const date = Date.now(); + let i; + for (i = props.length - 1; i >= 0; --i) { + const prop = props[i]; + if (prop.charAt(0) === '$') { + continue; + } + if (prop === 'options') { + animations.push(...this._animateOptions(target, values)); + continue; + } + const value = values[prop]; + let animation = running[prop]; + const cfg = animatedProps.get(prop); + if (animation) { + if (cfg && animation.active()) { + animation.update(cfg, value, date); + continue; + } else { + animation.cancel(); + } + } + if (!cfg || !cfg.duration) { + target[prop] = value; + continue; + } + running[prop] = animation = new Animation(cfg, target, prop, value); + animations.push(animation); + } + return animations; + } + update(target, values) { + if (this._properties.size === 0) { + Object.assign(target, values); + return; + } + const animations = this._createAnimations(target, values); + if (animations.length) { + animator.add(this._chart, animations); + return true; + } + } +} +function awaitAll(animations, properties) { + const running = []; + const keys = Object.keys(properties); + for (let i = 0; i < keys.length; i++) { + const anim = animations[keys[i]]; + if (anim && anim.active()) { + running.push(anim.wait()); + } + } + return Promise.all(running); +} +function resolveTargetOptions(target, newOptions) { + if (!newOptions) { + return; + } + let options = target.options; + if (!options) { + target.options = newOptions; + return; + } + if (options.$shared) { + target.options = options = Object.assign({}, options, {$shared: false, $animations: {}}); + } + return options; +} + +function scaleClip(scale, allowedOverflow) { + const opts = scale && scale.options || {}; + const reverse = opts.reverse; + const min = opts.min === undefined ? allowedOverflow : 0; + const max = opts.max === undefined ? allowedOverflow : 0; + return { + start: reverse ? max : min, + end: reverse ? min : max + }; +} +function defaultClip(xScale, yScale, allowedOverflow) { + if (allowedOverflow === false) { + return false; + } + const x = scaleClip(xScale, allowedOverflow); + const y = scaleClip(yScale, allowedOverflow); + return { + top: y.end, + right: x.end, + bottom: y.start, + left: x.start + }; +} +function toClip(value) { + let t, r, b, l; + if (isObject(value)) { + t = value.top; + r = value.right; + b = value.bottom; + l = value.left; + } else { + t = r = b = l = value; + } + return { + top: t, + right: r, + bottom: b, + left: l, + disabled: value === false + }; +} +function getSortedDatasetIndices(chart, filterVisible) { + const keys = []; + const metasets = chart._getSortedDatasetMetas(filterVisible); + let i, ilen; + for (i = 0, ilen = metasets.length; i < ilen; ++i) { + keys.push(metasets[i].index); + } + return keys; +} +function applyStack(stack, value, dsIndex, options = {}) { + const keys = stack.keys; + const singleMode = options.mode === 'single'; + let i, ilen, datasetIndex, otherValue; + if (value === null) { + return; + } + for (i = 0, ilen = keys.length; i < ilen; ++i) { + datasetIndex = +keys[i]; + if (datasetIndex === dsIndex) { + if (options.all) { + continue; + } + break; + } + otherValue = stack.values[datasetIndex]; + if (isNumberFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) { + value += otherValue; + } + } + return value; +} +function convertObjectDataToArray(data) { + const keys = Object.keys(data); + const adata = new Array(keys.length); + let i, ilen, key; + for (i = 0, ilen = keys.length; i < ilen; ++i) { + key = keys[i]; + adata[i] = { + x: key, + y: data[key] + }; + } + return adata; +} +function isStacked(scale, meta) { + const stacked = scale && scale.options.stacked; + return stacked || (stacked === undefined && meta.stack !== undefined); +} +function getStackKey(indexScale, valueScale, meta) { + return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`; +} +function getUserBounds(scale) { + const {min, max, minDefined, maxDefined} = scale.getUserBounds(); + return { + min: minDefined ? min : Number.NEGATIVE_INFINITY, + max: maxDefined ? max : Number.POSITIVE_INFINITY + }; +} +function getOrCreateStack(stacks, stackKey, indexValue) { + const subStack = stacks[stackKey] || (stacks[stackKey] = {}); + return subStack[indexValue] || (subStack[indexValue] = {}); +} +function getLastIndexInStack(stack, vScale, positive, type) { + for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) { + const value = stack[meta.index]; + if ((positive && value > 0) || (!positive && value < 0)) { + return meta.index; + } + } + return null; +} +function updateStacks(controller, parsed) { + const {chart, _cachedMeta: meta} = controller; + const stacks = chart._stacks || (chart._stacks = {}); + const {iScale, vScale, index: datasetIndex} = meta; + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const key = getStackKey(iScale, vScale, meta); + const ilen = parsed.length; + let stack; + for (let i = 0; i < ilen; ++i) { + const item = parsed[i]; + const {[iAxis]: index, [vAxis]: value} = item; + const itemStacks = item._stacks || (item._stacks = {}); + stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index); + stack[datasetIndex] = value; + stack._top = getLastIndexInStack(stack, vScale, true, meta.type); + stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type); + } +} +function getFirstScaleId(chart, axis) { + const scales = chart.scales; + return Object.keys(scales).filter(key => scales[key].axis === axis).shift(); +} +function createDatasetContext(parent, index) { + return createContext(parent, + { + active: false, + dataset: undefined, + datasetIndex: index, + index, + mode: 'default', + type: 'dataset' + } + ); +} +function createDataContext(parent, index, element) { + return createContext(parent, { + active: false, + dataIndex: index, + parsed: undefined, + raw: undefined, + element, + index, + mode: 'default', + type: 'data' + }); +} +function clearStacks(meta, items) { + const datasetIndex = meta.controller.index; + const axis = meta.vScale && meta.vScale.axis; + if (!axis) { + return; + } + items = items || meta._parsed; + for (const parsed of items) { + const stacks = parsed._stacks; + if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) { + return; + } + delete stacks[axis][datasetIndex]; + } +} +const isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none'; +const cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached); +const createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked + && {keys: getSortedDatasetIndices(chart, true), values: null}; +class DatasetController { + constructor(chart, datasetIndex) { + this.chart = chart; + this._ctx = chart.ctx; + this.index = datasetIndex; + this._cachedDataOpts = {}; + this._cachedMeta = this.getMeta(); + this._type = this._cachedMeta.type; + this.options = undefined; + this._parsing = false; + this._data = undefined; + this._objectData = undefined; + this._sharedOptions = undefined; + this._drawStart = undefined; + this._drawCount = undefined; + this.enableOptionSharing = false; + this.$context = undefined; + this._syncList = []; + this.initialize(); + } + initialize() { + const meta = this._cachedMeta; + this.configure(); + this.linkScales(); + meta._stacked = isStacked(meta.vScale, meta); + this.addElements(); + } + updateIndex(datasetIndex) { + if (this.index !== datasetIndex) { + clearStacks(this._cachedMeta); + } + this.index = datasetIndex; + } + linkScales() { + const chart = this.chart; + const meta = this._cachedMeta; + const dataset = this.getDataset(); + const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y; + const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x')); + const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y')); + const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r')); + const indexAxis = meta.indexAxis; + const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid); + const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid); + meta.xScale = this.getScaleForId(xid); + meta.yScale = this.getScaleForId(yid); + meta.rScale = this.getScaleForId(rid); + meta.iScale = this.getScaleForId(iid); + meta.vScale = this.getScaleForId(vid); + } + getDataset() { + return this.chart.data.datasets[this.index]; + } + getMeta() { + return this.chart.getDatasetMeta(this.index); + } + getScaleForId(scaleID) { + return this.chart.scales[scaleID]; + } + _getOtherScale(scale) { + const meta = this._cachedMeta; + return scale === meta.iScale + ? meta.vScale + : meta.iScale; + } + reset() { + this._update('reset'); + } + _destroy() { + const meta = this._cachedMeta; + if (this._data) { + unlistenArrayEvents(this._data, this); + } + if (meta._stacked) { + clearStacks(meta); + } + } + _dataCheck() { + const dataset = this.getDataset(); + const data = dataset.data || (dataset.data = []); + const _data = this._data; + if (isObject(data)) { + this._data = convertObjectDataToArray(data); + } else if (_data !== data) { + if (_data) { + unlistenArrayEvents(_data, this); + const meta = this._cachedMeta; + clearStacks(meta); + meta._parsed = []; + } + if (data && Object.isExtensible(data)) { + listenArrayEvents(data, this); + } + this._syncList = []; + this._data = data; + } + } + addElements() { + const meta = this._cachedMeta; + this._dataCheck(); + if (this.datasetElementType) { + meta.dataset = new this.datasetElementType(); + } + } + buildOrUpdateElements(resetNewElements) { + const meta = this._cachedMeta; + const dataset = this.getDataset(); + let stackChanged = false; + this._dataCheck(); + const oldStacked = meta._stacked; + meta._stacked = isStacked(meta.vScale, meta); + if (meta.stack !== dataset.stack) { + stackChanged = true; + clearStacks(meta); + meta.stack = dataset.stack; + } + this._resyncElements(resetNewElements); + if (stackChanged || oldStacked !== meta._stacked) { + updateStacks(this, meta._parsed); + } + } + configure() { + const config = this.chart.config; + const scopeKeys = config.datasetScopeKeys(this._type); + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true); + this.options = config.createResolver(scopes, this.getContext()); + this._parsing = this.options.parsing; + this._cachedDataOpts = {}; + } + parse(start, count) { + const {_cachedMeta: meta, _data: data} = this; + const {iScale, _stacked} = meta; + const iAxis = iScale.axis; + let sorted = start === 0 && count === data.length ? true : meta._sorted; + let prev = start > 0 && meta._parsed[start - 1]; + let i, cur, parsed; + if (this._parsing === false) { + meta._parsed = data; + meta._sorted = true; + parsed = data; + } else { + if (isArray(data[start])) { + parsed = this.parseArrayData(meta, data, start, count); + } else if (isObject(data[start])) { + parsed = this.parseObjectData(meta, data, start, count); + } else { + parsed = this.parsePrimitiveData(meta, data, start, count); + } + const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]); + for (i = 0; i < count; ++i) { + meta._parsed[i + start] = cur = parsed[i]; + if (sorted) { + if (isNotInOrderComparedToPrev()) { + sorted = false; + } + prev = cur; + } + } + meta._sorted = sorted; + } + if (_stacked) { + updateStacks(this, parsed); + } + } + parsePrimitiveData(meta, data, start, count) { + const {iScale, vScale} = meta; + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const labels = iScale.getLabels(); + const singleScale = iScale === vScale; + const parsed = new Array(count); + let i, ilen, index; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + parsed[i] = { + [iAxis]: singleScale || iScale.parse(labels[index], index), + [vAxis]: vScale.parse(data[index], index) + }; + } + return parsed; + } + parseArrayData(meta, data, start, count) { + const {xScale, yScale} = meta; + const parsed = new Array(count); + let i, ilen, index, item; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + item = data[index]; + parsed[i] = { + x: xScale.parse(item[0], index), + y: yScale.parse(item[1], index) + }; + } + return parsed; + } + parseObjectData(meta, data, start, count) { + const {xScale, yScale} = meta; + const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing; + const parsed = new Array(count); + let i, ilen, index, item; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + item = data[index]; + parsed[i] = { + x: xScale.parse(resolveObjectKey(item, xAxisKey), index), + y: yScale.parse(resolveObjectKey(item, yAxisKey), index) + }; + } + return parsed; + } + getParsed(index) { + return this._cachedMeta._parsed[index]; + } + getDataElement(index) { + return this._cachedMeta.data[index]; + } + applyStack(scale, parsed, mode) { + const chart = this.chart; + const meta = this._cachedMeta; + const value = parsed[scale.axis]; + const stack = { + keys: getSortedDatasetIndices(chart, true), + values: parsed._stacks[scale.axis] + }; + return applyStack(stack, value, meta.index, {mode}); + } + updateRangeFromParsed(range, scale, parsed, stack) { + const parsedValue = parsed[scale.axis]; + let value = parsedValue === null ? NaN : parsedValue; + const values = stack && parsed._stacks[scale.axis]; + if (stack && values) { + stack.values = values; + value = applyStack(stack, parsedValue, this._cachedMeta.index); + } + range.min = Math.min(range.min, value); + range.max = Math.max(range.max, value); + } + getMinMax(scale, canStack) { + const meta = this._cachedMeta; + const _parsed = meta._parsed; + const sorted = meta._sorted && scale === meta.iScale; + const ilen = _parsed.length; + const otherScale = this._getOtherScale(scale); + const stack = createStack(canStack, meta, this.chart); + const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY}; + const {min: otherMin, max: otherMax} = getUserBounds(otherScale); + let i, parsed; + function _skip() { + parsed = _parsed[i]; + const otherValue = parsed[otherScale.axis]; + return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue; + } + for (i = 0; i < ilen; ++i) { + if (_skip()) { + continue; + } + this.updateRangeFromParsed(range, scale, parsed, stack); + if (sorted) { + break; + } + } + if (sorted) { + for (i = ilen - 1; i >= 0; --i) { + if (_skip()) { + continue; + } + this.updateRangeFromParsed(range, scale, parsed, stack); + break; + } + } + return range; + } + getAllParsedValues(scale) { + const parsed = this._cachedMeta._parsed; + const values = []; + let i, ilen, value; + for (i = 0, ilen = parsed.length; i < ilen; ++i) { + value = parsed[i][scale.axis]; + if (isNumberFinite(value)) { + values.push(value); + } + } + return values; + } + getMaxOverflow() { + return false; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const iScale = meta.iScale; + const vScale = meta.vScale; + const parsed = this.getParsed(index); + return { + label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '', + value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : '' + }; + } + _update(mode) { + const meta = this._cachedMeta; + this.update(mode || 'default'); + meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow()))); + } + update(mode) {} + draw() { + const ctx = this._ctx; + const chart = this.chart; + const meta = this._cachedMeta; + const elements = meta.data || []; + const area = chart.chartArea; + const active = []; + const start = this._drawStart || 0; + const count = this._drawCount || (elements.length - start); + const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop; + let i; + if (meta.dataset) { + meta.dataset.draw(ctx, area, start, count); + } + for (i = start; i < start + count; ++i) { + const element = elements[i]; + if (element.hidden) { + continue; + } + if (element.active && drawActiveElementsOnTop) { + active.push(element); + } else { + element.draw(ctx, area); + } + } + for (i = 0; i < active.length; ++i) { + active[i].draw(ctx, area); + } + } + getStyle(index, active) { + const mode = active ? 'active' : 'default'; + return index === undefined && this._cachedMeta.dataset + ? this.resolveDatasetElementOptions(mode) + : this.resolveDataElementOptions(index || 0, mode); + } + getContext(index, active, mode) { + const dataset = this.getDataset(); + let context; + if (index >= 0 && index < this._cachedMeta.data.length) { + const element = this._cachedMeta.data[index]; + context = element.$context || + (element.$context = createDataContext(this.getContext(), index, element)); + context.parsed = this.getParsed(index); + context.raw = dataset.data[index]; + context.index = context.dataIndex = index; + } else { + context = this.$context || + (this.$context = createDatasetContext(this.chart.getContext(), this.index)); + context.dataset = dataset; + context.index = context.datasetIndex = this.index; + } + context.active = !!active; + context.mode = mode; + return context; + } + resolveDatasetElementOptions(mode) { + return this._resolveElementOptions(this.datasetElementType.id, mode); + } + resolveDataElementOptions(index, mode) { + return this._resolveElementOptions(this.dataElementType.id, mode, index); + } + _resolveElementOptions(elementType, mode = 'default', index) { + const active = mode === 'active'; + const cache = this._cachedDataOpts; + const cacheKey = elementType + '-' + mode; + const cached = cache[cacheKey]; + const sharing = this.enableOptionSharing && defined(index); + if (cached) { + return cloneIfNotShared(cached, sharing); + } + const config = this.chart.config; + const scopeKeys = config.datasetElementScopeKeys(this._type, elementType); + const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, '']; + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys); + const names = Object.keys(defaults.elements[elementType]); + const context = () => this.getContext(index, active); + const values = config.resolveNamedOptions(scopes, names, context, prefixes); + if (values.$shared) { + values.$shared = sharing; + cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing)); + } + return values; + } + _resolveAnimations(index, transition, active) { + const chart = this.chart; + const cache = this._cachedDataOpts; + const cacheKey = `animation-${transition}`; + const cached = cache[cacheKey]; + if (cached) { + return cached; + } + let options; + if (chart.options.animation !== false) { + const config = this.chart.config; + const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition); + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys); + options = config.createResolver(scopes, this.getContext(index, active, transition)); + } + const animations = new Animations(chart, options && options.animations); + if (options && options._cacheable) { + cache[cacheKey] = Object.freeze(animations); + } + return animations; + } + getSharedOptions(options) { + if (!options.$shared) { + return; + } + return this._sharedOptions || (this._sharedOptions = Object.assign({}, options)); + } + includeOptions(mode, sharedOptions) { + return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled; + } + updateElement(element, index, properties, mode) { + if (isDirectUpdateMode(mode)) { + Object.assign(element, properties); + } else { + this._resolveAnimations(index, mode).update(element, properties); + } + } + updateSharedOptions(sharedOptions, mode, newOptions) { + if (sharedOptions && !isDirectUpdateMode(mode)) { + this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions); + } + } + _setStyle(element, index, mode, active) { + element.active = active; + const options = this.getStyle(index, active); + this._resolveAnimations(index, mode, active).update(element, { + options: (!active && this.getSharedOptions(options)) || options + }); + } + removeHoverStyle(element, datasetIndex, index) { + this._setStyle(element, index, 'active', false); + } + setHoverStyle(element, datasetIndex, index) { + this._setStyle(element, index, 'active', true); + } + _removeDatasetHoverStyle() { + const element = this._cachedMeta.dataset; + if (element) { + this._setStyle(element, undefined, 'active', false); + } + } + _setDatasetHoverStyle() { + const element = this._cachedMeta.dataset; + if (element) { + this._setStyle(element, undefined, 'active', true); + } + } + _resyncElements(resetNewElements) { + const data = this._data; + const elements = this._cachedMeta.data; + for (const [method, arg1, arg2] of this._syncList) { + this[method](arg1, arg2); + } + this._syncList = []; + const numMeta = elements.length; + const numData = data.length; + const count = Math.min(numData, numMeta); + if (count) { + this.parse(0, count); + } + if (numData > numMeta) { + this._insertElements(numMeta, numData - numMeta, resetNewElements); + } else if (numData < numMeta) { + this._removeElements(numData, numMeta - numData); + } + } + _insertElements(start, count, resetNewElements = true) { + const meta = this._cachedMeta; + const data = meta.data; + const end = start + count; + let i; + const move = (arr) => { + arr.length += count; + for (i = arr.length - 1; i >= end; i--) { + arr[i] = arr[i - count]; + } + }; + move(data); + for (i = start; i < end; ++i) { + data[i] = new this.dataElementType(); + } + if (this._parsing) { + move(meta._parsed); + } + this.parse(start, count); + if (resetNewElements) { + this.updateElements(data, start, count, 'reset'); + } + } + updateElements(element, start, count, mode) {} + _removeElements(start, count) { + const meta = this._cachedMeta; + if (this._parsing) { + const removed = meta._parsed.splice(start, count); + if (meta._stacked) { + clearStacks(meta, removed); + } + } + meta.data.splice(start, count); + } + _sync(args) { + if (this._parsing) { + this._syncList.push(args); + } else { + const [method, arg1, arg2] = args; + this[method](arg1, arg2); + } + this.chart._dataChanges.push([this.index, ...args]); + } + _onDataPush() { + const count = arguments.length; + this._sync(['_insertElements', this.getDataset().data.length - count, count]); + } + _onDataPop() { + this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]); + } + _onDataShift() { + this._sync(['_removeElements', 0, 1]); + } + _onDataSplice(start, count) { + if (count) { + this._sync(['_removeElements', start, count]); + } + const newCount = arguments.length - 2; + if (newCount) { + this._sync(['_insertElements', start, newCount]); + } + } + _onDataUnshift() { + this._sync(['_insertElements', 0, arguments.length]); + } +} +DatasetController.defaults = {}; +DatasetController.prototype.datasetElementType = null; +DatasetController.prototype.dataElementType = null; + +class Element { + constructor() { + this.x = undefined; + this.y = undefined; + this.active = false; + this.options = undefined; + this.$animations = undefined; + } + tooltipPosition(useFinalPosition) { + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return {x, y}; + } + hasValue() { + return isNumber(this.x) && isNumber(this.y); + } + getProps(props, final) { + const anims = this.$animations; + if (!final || !anims) { + return this; + } + const ret = {}; + props.forEach(prop => { + ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop]; + }); + return ret; + } +} +Element.defaults = {}; +Element.defaultRoutes = undefined; + +const formatters = { + values(value) { + return isArray(value) ? value : '' + value; + }, + numeric(tickValue, index, ticks) { + if (tickValue === 0) { + return '0'; + } + const locale = this.chart.options.locale; + let notation; + let delta = tickValue; + if (ticks.length > 1) { + const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value)); + if (maxTick < 1e-4 || maxTick > 1e+15) { + notation = 'scientific'; + } + delta = calculateDelta(tickValue, ticks); + } + const logDelta = log10(Math.abs(delta)); + const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0); + const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal}; + Object.assign(options, this.options.ticks.format); + return formatNumber(tickValue, locale, options); + }, + logarithmic(tickValue, index, ticks) { + if (tickValue === 0) { + return '0'; + } + const remain = tickValue / (Math.pow(10, Math.floor(log10(tickValue)))); + if (remain === 1 || remain === 2 || remain === 5) { + return formatters.numeric.call(this, tickValue, index, ticks); + } + return ''; + } +}; +function calculateDelta(tickValue, ticks) { + let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value; + if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) { + delta = tickValue - Math.floor(tickValue); + } + return delta; +} +var Ticks = {formatters}; + +defaults.set('scale', { + display: true, + offset: false, + reverse: false, + beginAtZero: false, + bounds: 'ticks', + grace: 0, + grid: { + display: true, + lineWidth: 1, + drawBorder: true, + drawOnChartArea: true, + drawTicks: true, + tickLength: 8, + tickWidth: (_ctx, options) => options.lineWidth, + tickColor: (_ctx, options) => options.color, + offset: false, + borderDash: [], + borderDashOffset: 0.0, + borderWidth: 1 + }, + title: { + display: false, + text: '', + padding: { + top: 4, + bottom: 4 + } + }, + ticks: { + minRotation: 0, + maxRotation: 50, + mirror: false, + textStrokeWidth: 0, + textStrokeColor: '', + padding: 3, + display: true, + autoSkip: true, + autoSkipPadding: 3, + labelOffset: 0, + callback: Ticks.formatters.values, + minor: {}, + major: {}, + align: 'center', + crossAlign: 'near', + showLabelBackdrop: false, + backdropColor: 'rgba(255, 255, 255, 0.75)', + backdropPadding: 2, + } +}); +defaults.route('scale.ticks', 'color', '', 'color'); +defaults.route('scale.grid', 'color', '', 'borderColor'); +defaults.route('scale.grid', 'borderColor', '', 'borderColor'); +defaults.route('scale.title', 'color', '', 'color'); +defaults.describe('scale', { + _fallback: false, + _scriptable: (name) => !name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser', + _indexable: (name) => name !== 'borderDash' && name !== 'tickBorderDash', +}); +defaults.describe('scales', { + _fallback: 'scale', +}); +defaults.describe('scale.ticks', { + _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback', + _indexable: (name) => name !== 'backdropPadding', +}); + +function autoSkip(scale, ticks) { + const tickOpts = scale.options.ticks; + const ticksLimit = tickOpts.maxTicksLimit || determineMaxTicks(scale); + const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : []; + const numMajorIndices = majorIndices.length; + const first = majorIndices[0]; + const last = majorIndices[numMajorIndices - 1]; + const newTicks = []; + if (numMajorIndices > ticksLimit) { + skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit); + return newTicks; + } + const spacing = calculateSpacing(majorIndices, ticks, ticksLimit); + if (numMajorIndices > 0) { + let i, ilen; + const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null; + skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first); + for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) { + skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]); + } + skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing); + return newTicks; + } + skip(ticks, newTicks, spacing); + return newTicks; +} +function determineMaxTicks(scale) { + const offset = scale.options.offset; + const tickLength = scale._tickSize(); + const maxScale = scale._length / tickLength + (offset ? 0 : 1); + const maxChart = scale._maxLength / tickLength; + return Math.floor(Math.min(maxScale, maxChart)); +} +function calculateSpacing(majorIndices, ticks, ticksLimit) { + const evenMajorSpacing = getEvenSpacing(majorIndices); + const spacing = ticks.length / ticksLimit; + if (!evenMajorSpacing) { + return Math.max(spacing, 1); + } + const factors = _factorize(evenMajorSpacing); + for (let i = 0, ilen = factors.length - 1; i < ilen; i++) { + const factor = factors[i]; + if (factor > spacing) { + return factor; + } + } + return Math.max(spacing, 1); +} +function getMajorIndices(ticks) { + const result = []; + let i, ilen; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + if (ticks[i].major) { + result.push(i); + } + } + return result; +} +function skipMajors(ticks, newTicks, majorIndices, spacing) { + let count = 0; + let next = majorIndices[0]; + let i; + spacing = Math.ceil(spacing); + for (i = 0; i < ticks.length; i++) { + if (i === next) { + newTicks.push(ticks[i]); + count++; + next = majorIndices[count * spacing]; + } + } +} +function skip(ticks, newTicks, spacing, majorStart, majorEnd) { + const start = valueOrDefault(majorStart, 0); + const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length); + let count = 0; + let length, i, next; + spacing = Math.ceil(spacing); + if (majorEnd) { + length = majorEnd - majorStart; + spacing = length / Math.floor(length / spacing); + } + next = start; + while (next < 0) { + count++; + next = Math.round(start + count * spacing); + } + for (i = Math.max(start, 0); i < end; i++) { + if (i === next) { + newTicks.push(ticks[i]); + count++; + next = Math.round(start + count * spacing); + } + } +} +function getEvenSpacing(arr) { + const len = arr.length; + let i, diff; + if (len < 2) { + return false; + } + for (diff = arr[0], i = 1; i < len; ++i) { + if (arr[i] - arr[i - 1] !== diff) { + return false; + } + } + return diff; +} + +const reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align; +const offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset; +function sample(arr, numItems) { + const result = []; + const increment = arr.length / numItems; + const len = arr.length; + let i = 0; + for (; i < len; i += increment) { + result.push(arr[Math.floor(i)]); + } + return result; +} +function getPixelForGridLine(scale, index, offsetGridLines) { + const length = scale.ticks.length; + const validIndex = Math.min(index, length - 1); + const start = scale._startPixel; + const end = scale._endPixel; + const epsilon = 1e-6; + let lineValue = scale.getPixelForTick(validIndex); + let offset; + if (offsetGridLines) { + if (length === 1) { + offset = Math.max(lineValue - start, end - lineValue); + } else if (index === 0) { + offset = (scale.getPixelForTick(1) - lineValue) / 2; + } else { + offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2; + } + lineValue += validIndex < index ? offset : -offset; + if (lineValue < start - epsilon || lineValue > end + epsilon) { + return; + } + } + return lineValue; +} +function garbageCollect(caches, length) { + each(caches, (cache) => { + const gc = cache.gc; + const gcLen = gc.length / 2; + let i; + if (gcLen > length) { + for (i = 0; i < gcLen; ++i) { + delete cache.data[gc[i]]; + } + gc.splice(0, gcLen); + } + }); +} +function getTickMarkLength(options) { + return options.drawTicks ? options.tickLength : 0; +} +function getTitleHeight(options, fallback) { + if (!options.display) { + return 0; + } + const font = toFont(options.font, fallback); + const padding = toPadding(options.padding); + const lines = isArray(options.text) ? options.text.length : 1; + return (lines * font.lineHeight) + padding.height; +} +function createScaleContext(parent, scale) { + return createContext(parent, { + scale, + type: 'scale' + }); +} +function createTickContext(parent, index, tick) { + return createContext(parent, { + tick, + index, + type: 'tick' + }); +} +function titleAlign(align, position, reverse) { + let ret = _toLeftRightCenter(align); + if ((reverse && position !== 'right') || (!reverse && position === 'right')) { + ret = reverseAlign(ret); + } + return ret; +} +function titleArgs(scale, offset, position, align) { + const {top, left, bottom, right, chart} = scale; + const {chartArea, scales} = chart; + let rotation = 0; + let maxWidth, titleX, titleY; + const height = bottom - top; + const width = right - left; + if (scale.isHorizontal()) { + titleX = _alignStartEnd(align, left, right); + if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + titleY = scales[positionAxisID].getPixelForValue(value) + height - offset; + } else if (position === 'center') { + titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset; + } else { + titleY = offsetFromEdge(scale, position, offset); + } + maxWidth = right - left; + } else { + if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + titleX = scales[positionAxisID].getPixelForValue(value) - width + offset; + } else if (position === 'center') { + titleX = (chartArea.left + chartArea.right) / 2 - width + offset; + } else { + titleX = offsetFromEdge(scale, position, offset); + } + titleY = _alignStartEnd(align, bottom, top); + rotation = position === 'left' ? -HALF_PI : HALF_PI; + } + return {titleX, titleY, maxWidth, rotation}; +} +class Scale extends Element { + constructor(cfg) { + super(); + this.id = cfg.id; + this.type = cfg.type; + this.options = undefined; + this.ctx = cfg.ctx; + this.chart = cfg.chart; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.width = undefined; + this.height = undefined; + this._margins = { + left: 0, + right: 0, + top: 0, + bottom: 0 + }; + this.maxWidth = undefined; + this.maxHeight = undefined; + this.paddingTop = undefined; + this.paddingBottom = undefined; + this.paddingLeft = undefined; + this.paddingRight = undefined; + this.axis = undefined; + this.labelRotation = undefined; + this.min = undefined; + this.max = undefined; + this._range = undefined; + this.ticks = []; + this._gridLineItems = null; + this._labelItems = null; + this._labelSizes = null; + this._length = 0; + this._maxLength = 0; + this._longestTextCache = {}; + this._startPixel = undefined; + this._endPixel = undefined; + this._reversePixels = false; + this._userMax = undefined; + this._userMin = undefined; + this._suggestedMax = undefined; + this._suggestedMin = undefined; + this._ticksLength = 0; + this._borderValue = 0; + this._cache = {}; + this._dataLimitsCached = false; + this.$context = undefined; + } + init(options) { + this.options = options.setContext(this.getContext()); + this.axis = options.axis; + this._userMin = this.parse(options.min); + this._userMax = this.parse(options.max); + this._suggestedMin = this.parse(options.suggestedMin); + this._suggestedMax = this.parse(options.suggestedMax); + } + parse(raw, index) { + return raw; + } + getUserBounds() { + let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this; + _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY); + _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY); + _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY); + _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY); + return { + min: finiteOrDefault(_userMin, _suggestedMin), + max: finiteOrDefault(_userMax, _suggestedMax), + minDefined: isNumberFinite(_userMin), + maxDefined: isNumberFinite(_userMax) + }; + } + getMinMax(canStack) { + let {min, max, minDefined, maxDefined} = this.getUserBounds(); + let range; + if (minDefined && maxDefined) { + return {min, max}; + } + const metas = this.getMatchingVisibleMetas(); + for (let i = 0, ilen = metas.length; i < ilen; ++i) { + range = metas[i].controller.getMinMax(this, canStack); + if (!minDefined) { + min = Math.min(min, range.min); + } + if (!maxDefined) { + max = Math.max(max, range.max); + } + } + min = maxDefined && min > max ? max : min; + max = minDefined && min > max ? min : max; + return { + min: finiteOrDefault(min, finiteOrDefault(max, min)), + max: finiteOrDefault(max, finiteOrDefault(min, max)) + }; + } + getPadding() { + return { + left: this.paddingLeft || 0, + top: this.paddingTop || 0, + right: this.paddingRight || 0, + bottom: this.paddingBottom || 0 + }; + } + getTicks() { + return this.ticks; + } + getLabels() { + const data = this.chart.data; + return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || []; + } + beforeLayout() { + this._cache = {}; + this._dataLimitsCached = false; + } + beforeUpdate() { + callback(this.options.beforeUpdate, [this]); + } + update(maxWidth, maxHeight, margins) { + const {beginAtZero, grace, ticks: tickOpts} = this.options; + const sampleSize = tickOpts.sampleSize; + this.beforeUpdate(); + this.maxWidth = maxWidth; + this.maxHeight = maxHeight; + this._margins = margins = Object.assign({ + left: 0, + right: 0, + top: 0, + bottom: 0 + }, margins); + this.ticks = null; + this._labelSizes = null; + this._gridLineItems = null; + this._labelItems = null; + this.beforeSetDimensions(); + this.setDimensions(); + this.afterSetDimensions(); + this._maxLength = this.isHorizontal() + ? this.width + margins.left + margins.right + : this.height + margins.top + margins.bottom; + if (!this._dataLimitsCached) { + this.beforeDataLimits(); + this.determineDataLimits(); + this.afterDataLimits(); + this._range = _addGrace(this, grace, beginAtZero); + this._dataLimitsCached = true; + } + this.beforeBuildTicks(); + this.ticks = this.buildTicks() || []; + this.afterBuildTicks(); + const samplingEnabled = sampleSize < this.ticks.length; + this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks); + this.configure(); + this.beforeCalculateLabelRotation(); + this.calculateLabelRotation(); + this.afterCalculateLabelRotation(); + if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) { + this.ticks = autoSkip(this, this.ticks); + this._labelSizes = null; + } + if (samplingEnabled) { + this._convertTicksToLabels(this.ticks); + } + this.beforeFit(); + this.fit(); + this.afterFit(); + this.afterUpdate(); + } + configure() { + let reversePixels = this.options.reverse; + let startPixel, endPixel; + if (this.isHorizontal()) { + startPixel = this.left; + endPixel = this.right; + } else { + startPixel = this.top; + endPixel = this.bottom; + reversePixels = !reversePixels; + } + this._startPixel = startPixel; + this._endPixel = endPixel; + this._reversePixels = reversePixels; + this._length = endPixel - startPixel; + this._alignToPixels = this.options.alignToPixels; + } + afterUpdate() { + callback(this.options.afterUpdate, [this]); + } + beforeSetDimensions() { + callback(this.options.beforeSetDimensions, [this]); + } + setDimensions() { + if (this.isHorizontal()) { + this.width = this.maxWidth; + this.left = 0; + this.right = this.width; + } else { + this.height = this.maxHeight; + this.top = 0; + this.bottom = this.height; + } + this.paddingLeft = 0; + this.paddingTop = 0; + this.paddingRight = 0; + this.paddingBottom = 0; + } + afterSetDimensions() { + callback(this.options.afterSetDimensions, [this]); + } + _callHooks(name) { + this.chart.notifyPlugins(name, this.getContext()); + callback(this.options[name], [this]); + } + beforeDataLimits() { + this._callHooks('beforeDataLimits'); + } + determineDataLimits() {} + afterDataLimits() { + this._callHooks('afterDataLimits'); + } + beforeBuildTicks() { + this._callHooks('beforeBuildTicks'); + } + buildTicks() { + return []; + } + afterBuildTicks() { + this._callHooks('afterBuildTicks'); + } + beforeTickToLabelConversion() { + callback(this.options.beforeTickToLabelConversion, [this]); + } + generateTickLabels(ticks) { + const tickOpts = this.options.ticks; + let i, ilen, tick; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + tick = ticks[i]; + tick.label = callback(tickOpts.callback, [tick.value, i, ticks], this); + } + } + afterTickToLabelConversion() { + callback(this.options.afterTickToLabelConversion, [this]); + } + beforeCalculateLabelRotation() { + callback(this.options.beforeCalculateLabelRotation, [this]); + } + calculateLabelRotation() { + const options = this.options; + const tickOpts = options.ticks; + const numTicks = this.ticks.length; + const minRotation = tickOpts.minRotation || 0; + const maxRotation = tickOpts.maxRotation; + let labelRotation = minRotation; + let tickWidth, maxHeight, maxLabelDiagonal; + if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) { + this.labelRotation = minRotation; + return; + } + const labelSizes = this._getLabelSizes(); + const maxLabelWidth = labelSizes.widest.width; + const maxLabelHeight = labelSizes.highest.height; + const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth); + tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1); + if (maxLabelWidth + 6 > tickWidth) { + tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1)); + maxHeight = this.maxHeight - getTickMarkLength(options.grid) + - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font); + maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight); + labelRotation = toDegrees(Math.min( + Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), + Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1)) + )); + labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation)); + } + this.labelRotation = labelRotation; + } + afterCalculateLabelRotation() { + callback(this.options.afterCalculateLabelRotation, [this]); + } + beforeFit() { + callback(this.options.beforeFit, [this]); + } + fit() { + const minSize = { + width: 0, + height: 0 + }; + const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this; + const display = this._isVisible(); + const isHorizontal = this.isHorizontal(); + if (display) { + const titleHeight = getTitleHeight(titleOpts, chart.options.font); + if (isHorizontal) { + minSize.width = this.maxWidth; + minSize.height = getTickMarkLength(gridOpts) + titleHeight; + } else { + minSize.height = this.maxHeight; + minSize.width = getTickMarkLength(gridOpts) + titleHeight; + } + if (tickOpts.display && this.ticks.length) { + const {first, last, widest, highest} = this._getLabelSizes(); + const tickPadding = tickOpts.padding * 2; + const angleRadians = toRadians(this.labelRotation); + const cos = Math.cos(angleRadians); + const sin = Math.sin(angleRadians); + if (isHorizontal) { + const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height; + minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding); + } else { + const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height; + minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding); + } + this._calculatePadding(first, last, sin, cos); + } + } + this._handleMargins(); + if (isHorizontal) { + this.width = this._length = chart.width - this._margins.left - this._margins.right; + this.height = minSize.height; + } else { + this.width = minSize.width; + this.height = this._length = chart.height - this._margins.top - this._margins.bottom; + } + } + _calculatePadding(first, last, sin, cos) { + const {ticks: {align, padding}, position} = this.options; + const isRotated = this.labelRotation !== 0; + const labelsBelowTicks = position !== 'top' && this.axis === 'x'; + if (this.isHorizontal()) { + const offsetLeft = this.getPixelForTick(0) - this.left; + const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1); + let paddingLeft = 0; + let paddingRight = 0; + if (isRotated) { + if (labelsBelowTicks) { + paddingLeft = cos * first.width; + paddingRight = sin * last.height; + } else { + paddingLeft = sin * first.height; + paddingRight = cos * last.width; + } + } else if (align === 'start') { + paddingRight = last.width; + } else if (align === 'end') { + paddingLeft = first.width; + } else { + paddingLeft = first.width / 2; + paddingRight = last.width / 2; + } + this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0); + this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0); + } else { + let paddingTop = last.height / 2; + let paddingBottom = first.height / 2; + if (align === 'start') { + paddingTop = 0; + paddingBottom = first.height; + } else if (align === 'end') { + paddingTop = last.height; + paddingBottom = 0; + } + this.paddingTop = paddingTop + padding; + this.paddingBottom = paddingBottom + padding; + } + } + _handleMargins() { + if (this._margins) { + this._margins.left = Math.max(this.paddingLeft, this._margins.left); + this._margins.top = Math.max(this.paddingTop, this._margins.top); + this._margins.right = Math.max(this.paddingRight, this._margins.right); + this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom); + } + } + afterFit() { + callback(this.options.afterFit, [this]); + } + isHorizontal() { + const {axis, position} = this.options; + return position === 'top' || position === 'bottom' || axis === 'x'; + } + isFullSize() { + return this.options.fullSize; + } + _convertTicksToLabels(ticks) { + this.beforeTickToLabelConversion(); + this.generateTickLabels(ticks); + let i, ilen; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + if (isNullOrUndef(ticks[i].label)) { + ticks.splice(i, 1); + ilen--; + i--; + } + } + this.afterTickToLabelConversion(); + } + _getLabelSizes() { + let labelSizes = this._labelSizes; + if (!labelSizes) { + const sampleSize = this.options.ticks.sampleSize; + let ticks = this.ticks; + if (sampleSize < ticks.length) { + ticks = sample(ticks, sampleSize); + } + this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length); + } + return labelSizes; + } + _computeLabelSizes(ticks, length) { + const {ctx, _longestTextCache: caches} = this; + const widths = []; + const heights = []; + let widestLabelSize = 0; + let highestLabelSize = 0; + let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel; + for (i = 0; i < length; ++i) { + label = ticks[i].label; + tickFont = this._resolveTickFontOptions(i); + ctx.font = fontString = tickFont.string; + cache = caches[fontString] = caches[fontString] || {data: {}, gc: []}; + lineHeight = tickFont.lineHeight; + width = height = 0; + if (!isNullOrUndef(label) && !isArray(label)) { + width = _measureText(ctx, cache.data, cache.gc, width, label); + height = lineHeight; + } else if (isArray(label)) { + for (j = 0, jlen = label.length; j < jlen; ++j) { + nestedLabel = label[j]; + if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) { + width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel); + height += lineHeight; + } + } + } + widths.push(width); + heights.push(height); + widestLabelSize = Math.max(width, widestLabelSize); + highestLabelSize = Math.max(height, highestLabelSize); + } + garbageCollect(caches, length); + const widest = widths.indexOf(widestLabelSize); + const highest = heights.indexOf(highestLabelSize); + const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0}); + return { + first: valueAt(0), + last: valueAt(length - 1), + widest: valueAt(widest), + highest: valueAt(highest), + widths, + heights, + }; + } + getLabelForValue(value) { + return value; + } + getPixelForValue(value, index) { + return NaN; + } + getValueForPixel(pixel) {} + getPixelForTick(index) { + const ticks = this.ticks; + if (index < 0 || index > ticks.length - 1) { + return null; + } + return this.getPixelForValue(ticks[index].value); + } + getPixelForDecimal(decimal) { + if (this._reversePixels) { + decimal = 1 - decimal; + } + const pixel = this._startPixel + decimal * this._length; + return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel); + } + getDecimalForPixel(pixel) { + const decimal = (pixel - this._startPixel) / this._length; + return this._reversePixels ? 1 - decimal : decimal; + } + getBasePixel() { + return this.getPixelForValue(this.getBaseValue()); + } + getBaseValue() { + const {min, max} = this; + return min < 0 && max < 0 ? max : + min > 0 && max > 0 ? min : + 0; + } + getContext(index) { + const ticks = this.ticks || []; + if (index >= 0 && index < ticks.length) { + const tick = ticks[index]; + return tick.$context || + (tick.$context = createTickContext(this.getContext(), index, tick)); + } + return this.$context || + (this.$context = createScaleContext(this.chart.getContext(), this)); + } + _tickSize() { + const optionTicks = this.options.ticks; + const rot = toRadians(this.labelRotation); + const cos = Math.abs(Math.cos(rot)); + const sin = Math.abs(Math.sin(rot)); + const labelSizes = this._getLabelSizes(); + const padding = optionTicks.autoSkipPadding || 0; + const w = labelSizes ? labelSizes.widest.width + padding : 0; + const h = labelSizes ? labelSizes.highest.height + padding : 0; + return this.isHorizontal() + ? h * cos > w * sin ? w / cos : h / sin + : h * sin < w * cos ? h / cos : w / sin; + } + _isVisible() { + const display = this.options.display; + if (display !== 'auto') { + return !!display; + } + return this.getMatchingVisibleMetas().length > 0; + } + _computeGridLineItems(chartArea) { + const axis = this.axis; + const chart = this.chart; + const options = this.options; + const {grid, position} = options; + const offset = grid.offset; + const isHorizontal = this.isHorizontal(); + const ticks = this.ticks; + const ticksLength = ticks.length + (offset ? 1 : 0); + const tl = getTickMarkLength(grid); + const items = []; + const borderOpts = grid.setContext(this.getContext()); + const axisWidth = borderOpts.drawBorder ? borderOpts.borderWidth : 0; + const axisHalfWidth = axisWidth / 2; + const alignBorderValue = function(pixel) { + return _alignPixel(chart, pixel, axisWidth); + }; + let borderValue, i, lineValue, alignedLineValue; + let tx1, ty1, tx2, ty2, x1, y1, x2, y2; + if (position === 'top') { + borderValue = alignBorderValue(this.bottom); + ty1 = this.bottom - tl; + ty2 = borderValue - axisHalfWidth; + y1 = alignBorderValue(chartArea.top) + axisHalfWidth; + y2 = chartArea.bottom; + } else if (position === 'bottom') { + borderValue = alignBorderValue(this.top); + y1 = chartArea.top; + y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth; + ty1 = borderValue + axisHalfWidth; + ty2 = this.top + tl; + } else if (position === 'left') { + borderValue = alignBorderValue(this.right); + tx1 = this.right - tl; + tx2 = borderValue - axisHalfWidth; + x1 = alignBorderValue(chartArea.left) + axisHalfWidth; + x2 = chartArea.right; + } else if (position === 'right') { + borderValue = alignBorderValue(this.left); + x1 = chartArea.left; + x2 = alignBorderValue(chartArea.right) - axisHalfWidth; + tx1 = borderValue + axisHalfWidth; + tx2 = this.left + tl; + } else if (axis === 'x') { + if (position === 'center') { + borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5); + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value)); + } + y1 = chartArea.top; + y2 = chartArea.bottom; + ty1 = borderValue + axisHalfWidth; + ty2 = ty1 + tl; + } else if (axis === 'y') { + if (position === 'center') { + borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2); + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value)); + } + tx1 = borderValue - axisHalfWidth; + tx2 = tx1 - tl; + x1 = chartArea.left; + x2 = chartArea.right; + } + const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength); + const step = Math.max(1, Math.ceil(ticksLength / limit)); + for (i = 0; i < ticksLength; i += step) { + const optsAtIndex = grid.setContext(this.getContext(i)); + const lineWidth = optsAtIndex.lineWidth; + const lineColor = optsAtIndex.color; + const borderDash = grid.borderDash || []; + const borderDashOffset = optsAtIndex.borderDashOffset; + const tickWidth = optsAtIndex.tickWidth; + const tickColor = optsAtIndex.tickColor; + const tickBorderDash = optsAtIndex.tickBorderDash || []; + const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset; + lineValue = getPixelForGridLine(this, i, offset); + if (lineValue === undefined) { + continue; + } + alignedLineValue = _alignPixel(chart, lineValue, lineWidth); + if (isHorizontal) { + tx1 = tx2 = x1 = x2 = alignedLineValue; + } else { + ty1 = ty2 = y1 = y2 = alignedLineValue; + } + items.push({ + tx1, + ty1, + tx2, + ty2, + x1, + y1, + x2, + y2, + width: lineWidth, + color: lineColor, + borderDash, + borderDashOffset, + tickWidth, + tickColor, + tickBorderDash, + tickBorderDashOffset, + }); + } + this._ticksLength = ticksLength; + this._borderValue = borderValue; + return items; + } + _computeLabelItems(chartArea) { + const axis = this.axis; + const options = this.options; + const {position, ticks: optionTicks} = options; + const isHorizontal = this.isHorizontal(); + const ticks = this.ticks; + const {align, crossAlign, padding, mirror} = optionTicks; + const tl = getTickMarkLength(options.grid); + const tickAndPadding = tl + padding; + const hTickAndPadding = mirror ? -padding : tickAndPadding; + const rotation = -toRadians(this.labelRotation); + const items = []; + let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset; + let textBaseline = 'middle'; + if (position === 'top') { + y = this.bottom - hTickAndPadding; + textAlign = this._getXAxisLabelAlignment(); + } else if (position === 'bottom') { + y = this.top + hTickAndPadding; + textAlign = this._getXAxisLabelAlignment(); + } else if (position === 'left') { + const ret = this._getYAxisLabelAlignment(tl); + textAlign = ret.textAlign; + x = ret.x; + } else if (position === 'right') { + const ret = this._getYAxisLabelAlignment(tl); + textAlign = ret.textAlign; + x = ret.x; + } else if (axis === 'x') { + if (position === 'center') { + y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding; + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding; + } + textAlign = this._getXAxisLabelAlignment(); + } else if (axis === 'y') { + if (position === 'center') { + x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding; + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + x = this.chart.scales[positionAxisID].getPixelForValue(value); + } + textAlign = this._getYAxisLabelAlignment(tl).textAlign; + } + if (axis === 'y') { + if (align === 'start') { + textBaseline = 'top'; + } else if (align === 'end') { + textBaseline = 'bottom'; + } + } + const labelSizes = this._getLabelSizes(); + for (i = 0, ilen = ticks.length; i < ilen; ++i) { + tick = ticks[i]; + label = tick.label; + const optsAtIndex = optionTicks.setContext(this.getContext(i)); + pixel = this.getPixelForTick(i) + optionTicks.labelOffset; + font = this._resolveTickFontOptions(i); + lineHeight = font.lineHeight; + lineCount = isArray(label) ? label.length : 1; + const halfCount = lineCount / 2; + const color = optsAtIndex.color; + const strokeColor = optsAtIndex.textStrokeColor; + const strokeWidth = optsAtIndex.textStrokeWidth; + if (isHorizontal) { + x = pixel; + if (position === 'top') { + if (crossAlign === 'near' || rotation !== 0) { + textOffset = -lineCount * lineHeight + lineHeight / 2; + } else if (crossAlign === 'center') { + textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight; + } else { + textOffset = -labelSizes.highest.height + lineHeight / 2; + } + } else { + if (crossAlign === 'near' || rotation !== 0) { + textOffset = lineHeight / 2; + } else if (crossAlign === 'center') { + textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight; + } else { + textOffset = labelSizes.highest.height - lineCount * lineHeight; + } + } + if (mirror) { + textOffset *= -1; + } + } else { + y = pixel; + textOffset = (1 - lineCount) * lineHeight / 2; + } + let backdrop; + if (optsAtIndex.showLabelBackdrop) { + const labelPadding = toPadding(optsAtIndex.backdropPadding); + const height = labelSizes.heights[i]; + const width = labelSizes.widths[i]; + let top = y + textOffset - labelPadding.top; + let left = x - labelPadding.left; + switch (textBaseline) { + case 'middle': + top -= height / 2; + break; + case 'bottom': + top -= height; + break; + } + switch (textAlign) { + case 'center': + left -= width / 2; + break; + case 'right': + left -= width; + break; + } + backdrop = { + left, + top, + width: width + labelPadding.width, + height: height + labelPadding.height, + color: optsAtIndex.backdropColor, + }; + } + items.push({ + rotation, + label, + font, + color, + strokeColor, + strokeWidth, + textOffset, + textAlign, + textBaseline, + translation: [x, y], + backdrop, + }); + } + return items; + } + _getXAxisLabelAlignment() { + const {position, ticks} = this.options; + const rotation = -toRadians(this.labelRotation); + if (rotation) { + return position === 'top' ? 'left' : 'right'; + } + let align = 'center'; + if (ticks.align === 'start') { + align = 'left'; + } else if (ticks.align === 'end') { + align = 'right'; + } + return align; + } + _getYAxisLabelAlignment(tl) { + const {position, ticks: {crossAlign, mirror, padding}} = this.options; + const labelSizes = this._getLabelSizes(); + const tickAndPadding = tl + padding; + const widest = labelSizes.widest.width; + let textAlign; + let x; + if (position === 'left') { + if (mirror) { + x = this.right + padding; + if (crossAlign === 'near') { + textAlign = 'left'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x += (widest / 2); + } else { + textAlign = 'right'; + x += widest; + } + } else { + x = this.right - tickAndPadding; + if (crossAlign === 'near') { + textAlign = 'right'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x -= (widest / 2); + } else { + textAlign = 'left'; + x = this.left; + } + } + } else if (position === 'right') { + if (mirror) { + x = this.left + padding; + if (crossAlign === 'near') { + textAlign = 'right'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x -= (widest / 2); + } else { + textAlign = 'left'; + x -= widest; + } + } else { + x = this.left + tickAndPadding; + if (crossAlign === 'near') { + textAlign = 'left'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x += widest / 2; + } else { + textAlign = 'right'; + x = this.right; + } + } + } else { + textAlign = 'right'; + } + return {textAlign, x}; + } + _computeLabelArea() { + if (this.options.ticks.mirror) { + return; + } + const chart = this.chart; + const position = this.options.position; + if (position === 'left' || position === 'right') { + return {top: 0, left: this.left, bottom: chart.height, right: this.right}; + } if (position === 'top' || position === 'bottom') { + return {top: this.top, left: 0, bottom: this.bottom, right: chart.width}; + } + } + drawBackground() { + const {ctx, options: {backgroundColor}, left, top, width, height} = this; + if (backgroundColor) { + ctx.save(); + ctx.fillStyle = backgroundColor; + ctx.fillRect(left, top, width, height); + ctx.restore(); + } + } + getLineWidthForValue(value) { + const grid = this.options.grid; + if (!this._isVisible() || !grid.display) { + return 0; + } + const ticks = this.ticks; + const index = ticks.findIndex(t => t.value === value); + if (index >= 0) { + const opts = grid.setContext(this.getContext(index)); + return opts.lineWidth; + } + return 0; + } + drawGrid(chartArea) { + const grid = this.options.grid; + const ctx = this.ctx; + const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea)); + let i, ilen; + const drawLine = (p1, p2, style) => { + if (!style.width || !style.color) { + return; + } + ctx.save(); + ctx.lineWidth = style.width; + ctx.strokeStyle = style.color; + ctx.setLineDash(style.borderDash || []); + ctx.lineDashOffset = style.borderDashOffset; + ctx.beginPath(); + ctx.moveTo(p1.x, p1.y); + ctx.lineTo(p2.x, p2.y); + ctx.stroke(); + ctx.restore(); + }; + if (grid.display) { + for (i = 0, ilen = items.length; i < ilen; ++i) { + const item = items[i]; + if (grid.drawOnChartArea) { + drawLine( + {x: item.x1, y: item.y1}, + {x: item.x2, y: item.y2}, + item + ); + } + if (grid.drawTicks) { + drawLine( + {x: item.tx1, y: item.ty1}, + {x: item.tx2, y: item.ty2}, + { + color: item.tickColor, + width: item.tickWidth, + borderDash: item.tickBorderDash, + borderDashOffset: item.tickBorderDashOffset + } + ); + } + } + } + } + drawBorder() { + const {chart, ctx, options: {grid}} = this; + const borderOpts = grid.setContext(this.getContext()); + const axisWidth = grid.drawBorder ? borderOpts.borderWidth : 0; + if (!axisWidth) { + return; + } + const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth; + const borderValue = this._borderValue; + let x1, x2, y1, y2; + if (this.isHorizontal()) { + x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2; + x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2; + y1 = y2 = borderValue; + } else { + y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2; + y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2; + x1 = x2 = borderValue; + } + ctx.save(); + ctx.lineWidth = borderOpts.borderWidth; + ctx.strokeStyle = borderOpts.borderColor; + ctx.beginPath(); + ctx.moveTo(x1, y1); + ctx.lineTo(x2, y2); + ctx.stroke(); + ctx.restore(); + } + drawLabels(chartArea) { + const optionTicks = this.options.ticks; + if (!optionTicks.display) { + return; + } + const ctx = this.ctx; + const area = this._computeLabelArea(); + if (area) { + clipArea(ctx, area); + } + const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea)); + let i, ilen; + for (i = 0, ilen = items.length; i < ilen; ++i) { + const item = items[i]; + const tickFont = item.font; + const label = item.label; + if (item.backdrop) { + ctx.fillStyle = item.backdrop.color; + ctx.fillRect(item.backdrop.left, item.backdrop.top, item.backdrop.width, item.backdrop.height); + } + let y = item.textOffset; + renderText(ctx, label, 0, y, tickFont, item); + } + if (area) { + unclipArea(ctx); + } + } + drawTitle() { + const {ctx, options: {position, title, reverse}} = this; + if (!title.display) { + return; + } + const font = toFont(title.font); + const padding = toPadding(title.padding); + const align = title.align; + let offset = font.lineHeight / 2; + if (position === 'bottom' || position === 'center' || isObject(position)) { + offset += padding.bottom; + if (isArray(title.text)) { + offset += font.lineHeight * (title.text.length - 1); + } + } else { + offset += padding.top; + } + const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align); + renderText(ctx, title.text, 0, 0, font, { + color: title.color, + maxWidth, + rotation, + textAlign: titleAlign(align, position, reverse), + textBaseline: 'middle', + translation: [titleX, titleY], + }); + } + draw(chartArea) { + if (!this._isVisible()) { + return; + } + this.drawBackground(); + this.drawGrid(chartArea); + this.drawBorder(); + this.drawTitle(); + this.drawLabels(chartArea); + } + _layers() { + const opts = this.options; + const tz = opts.ticks && opts.ticks.z || 0; + const gz = valueOrDefault(opts.grid && opts.grid.z, -1); + if (!this._isVisible() || this.draw !== Scale.prototype.draw) { + return [{ + z: tz, + draw: (chartArea) => { + this.draw(chartArea); + } + }]; + } + return [{ + z: gz, + draw: (chartArea) => { + this.drawBackground(); + this.drawGrid(chartArea); + this.drawTitle(); + } + }, { + z: gz + 1, + draw: () => { + this.drawBorder(); + } + }, { + z: tz, + draw: (chartArea) => { + this.drawLabels(chartArea); + } + }]; + } + getMatchingVisibleMetas(type) { + const metas = this.chart.getSortedVisibleDatasetMetas(); + const axisID = this.axis + 'AxisID'; + const result = []; + let i, ilen; + for (i = 0, ilen = metas.length; i < ilen; ++i) { + const meta = metas[i]; + if (meta[axisID] === this.id && (!type || meta.type === type)) { + result.push(meta); + } + } + return result; + } + _resolveTickFontOptions(index) { + const opts = this.options.ticks.setContext(this.getContext(index)); + return toFont(opts.font); + } + _maxDigits() { + const fontSize = this._resolveTickFontOptions(0).lineHeight; + return (this.isHorizontal() ? this.width : this.height) / fontSize; + } +} + +class TypedRegistry { + constructor(type, scope, override) { + this.type = type; + this.scope = scope; + this.override = override; + this.items = Object.create(null); + } + isForType(type) { + return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype); + } + register(item) { + const proto = Object.getPrototypeOf(item); + let parentScope; + if (isIChartComponent(proto)) { + parentScope = this.register(proto); + } + const items = this.items; + const id = item.id; + const scope = this.scope + '.' + id; + if (!id) { + throw new Error('class does not have id: ' + item); + } + if (id in items) { + return scope; + } + items[id] = item; + registerDefaults(item, scope, parentScope); + if (this.override) { + defaults.override(item.id, item.overrides); + } + return scope; + } + get(id) { + return this.items[id]; + } + unregister(item) { + const items = this.items; + const id = item.id; + const scope = this.scope; + if (id in items) { + delete items[id]; + } + if (scope && id in defaults[scope]) { + delete defaults[scope][id]; + if (this.override) { + delete overrides[id]; + } + } + } +} +function registerDefaults(item, scope, parentScope) { + const itemDefaults = merge(Object.create(null), [ + parentScope ? defaults.get(parentScope) : {}, + defaults.get(scope), + item.defaults + ]); + defaults.set(scope, itemDefaults); + if (item.defaultRoutes) { + routeDefaults(scope, item.defaultRoutes); + } + if (item.descriptors) { + defaults.describe(scope, item.descriptors); + } +} +function routeDefaults(scope, routes) { + Object.keys(routes).forEach(property => { + const propertyParts = property.split('.'); + const sourceName = propertyParts.pop(); + const sourceScope = [scope].concat(propertyParts).join('.'); + const parts = routes[property].split('.'); + const targetName = parts.pop(); + const targetScope = parts.join('.'); + defaults.route(sourceScope, sourceName, targetScope, targetName); + }); +} +function isIChartComponent(proto) { + return 'id' in proto && 'defaults' in proto; +} + +class Registry { + constructor() { + this.controllers = new TypedRegistry(DatasetController, 'datasets', true); + this.elements = new TypedRegistry(Element, 'elements'); + this.plugins = new TypedRegistry(Object, 'plugins'); + this.scales = new TypedRegistry(Scale, 'scales'); + this._typedRegistries = [this.controllers, this.scales, this.elements]; + } + add(...args) { + this._each('register', args); + } + remove(...args) { + this._each('unregister', args); + } + addControllers(...args) { + this._each('register', args, this.controllers); + } + addElements(...args) { + this._each('register', args, this.elements); + } + addPlugins(...args) { + this._each('register', args, this.plugins); + } + addScales(...args) { + this._each('register', args, this.scales); + } + getController(id) { + return this._get(id, this.controllers, 'controller'); + } + getElement(id) { + return this._get(id, this.elements, 'element'); + } + getPlugin(id) { + return this._get(id, this.plugins, 'plugin'); + } + getScale(id) { + return this._get(id, this.scales, 'scale'); + } + removeControllers(...args) { + this._each('unregister', args, this.controllers); + } + removeElements(...args) { + this._each('unregister', args, this.elements); + } + removePlugins(...args) { + this._each('unregister', args, this.plugins); + } + removeScales(...args) { + this._each('unregister', args, this.scales); + } + _each(method, args, typedRegistry) { + [...args].forEach(arg => { + const reg = typedRegistry || this._getRegistryForType(arg); + if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) { + this._exec(method, reg, arg); + } else { + each(arg, item => { + const itemReg = typedRegistry || this._getRegistryForType(item); + this._exec(method, itemReg, item); + }); + } + }); + } + _exec(method, registry, component) { + const camelMethod = _capitalize(method); + callback(component['before' + camelMethod], [], component); + registry[method](component); + callback(component['after' + camelMethod], [], component); + } + _getRegistryForType(type) { + for (let i = 0; i < this._typedRegistries.length; i++) { + const reg = this._typedRegistries[i]; + if (reg.isForType(type)) { + return reg; + } + } + return this.plugins; + } + _get(id, typedRegistry, type) { + const item = typedRegistry.get(id); + if (item === undefined) { + throw new Error('"' + id + '" is not a registered ' + type + '.'); + } + return item; + } +} +var registry = new Registry(); + +class PluginService { + constructor() { + this._init = []; + } + notify(chart, hook, args, filter) { + if (hook === 'beforeInit') { + this._init = this._createDescriptors(chart, true); + this._notify(this._init, chart, 'install'); + } + const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart); + const result = this._notify(descriptors, chart, hook, args); + if (hook === 'afterDestroy') { + this._notify(descriptors, chart, 'stop'); + this._notify(this._init, chart, 'uninstall'); + } + return result; + } + _notify(descriptors, chart, hook, args) { + args = args || {}; + for (const descriptor of descriptors) { + const plugin = descriptor.plugin; + const method = plugin[hook]; + const params = [chart, args, descriptor.options]; + if (callback(method, params, plugin) === false && args.cancelable) { + return false; + } + } + return true; + } + invalidate() { + if (!isNullOrUndef(this._cache)) { + this._oldCache = this._cache; + this._cache = undefined; + } + } + _descriptors(chart) { + if (this._cache) { + return this._cache; + } + const descriptors = this._cache = this._createDescriptors(chart); + this._notifyStateChanges(chart); + return descriptors; + } + _createDescriptors(chart, all) { + const config = chart && chart.config; + const options = valueOrDefault(config.options && config.options.plugins, {}); + const plugins = allPlugins(config); + return options === false && !all ? [] : createDescriptors(chart, plugins, options, all); + } + _notifyStateChanges(chart) { + const previousDescriptors = this._oldCache || []; + const descriptors = this._cache; + const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id)); + this._notify(diff(previousDescriptors, descriptors), chart, 'stop'); + this._notify(diff(descriptors, previousDescriptors), chart, 'start'); + } +} +function allPlugins(config) { + const plugins = []; + const keys = Object.keys(registry.plugins.items); + for (let i = 0; i < keys.length; i++) { + plugins.push(registry.getPlugin(keys[i])); + } + const local = config.plugins || []; + for (let i = 0; i < local.length; i++) { + const plugin = local[i]; + if (plugins.indexOf(plugin) === -1) { + plugins.push(plugin); + } + } + return plugins; +} +function getOpts(options, all) { + if (!all && options === false) { + return null; + } + if (options === true) { + return {}; + } + return options; +} +function createDescriptors(chart, plugins, options, all) { + const result = []; + const context = chart.getContext(); + for (let i = 0; i < plugins.length; i++) { + const plugin = plugins[i]; + const id = plugin.id; + const opts = getOpts(options[id], all); + if (opts === null) { + continue; + } + result.push({ + plugin, + options: pluginOpts(chart.config, plugin, opts, context) + }); + } + return result; +} +function pluginOpts(config, plugin, opts, context) { + const keys = config.pluginScopeKeys(plugin); + const scopes = config.getOptionScopes(opts, keys); + return config.createResolver(scopes, context, [''], {scriptable: false, indexable: false, allKeys: true}); +} + +function getIndexAxis(type, options) { + const datasetDefaults = defaults.datasets[type] || {}; + const datasetOptions = (options.datasets || {})[type] || {}; + return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x'; +} +function getAxisFromDefaultScaleID(id, indexAxis) { + let axis = id; + if (id === '_index_') { + axis = indexAxis; + } else if (id === '_value_') { + axis = indexAxis === 'x' ? 'y' : 'x'; + } + return axis; +} +function getDefaultScaleIDFromAxis(axis, indexAxis) { + return axis === indexAxis ? '_index_' : '_value_'; +} +function axisFromPosition(position) { + if (position === 'top' || position === 'bottom') { + return 'x'; + } + if (position === 'left' || position === 'right') { + return 'y'; + } +} +function determineAxis(id, scaleOptions) { + if (id === 'x' || id === 'y') { + return id; + } + return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase(); +} +function mergeScaleConfig(config, options) { + const chartDefaults = overrides[config.type] || {scales: {}}; + const configScales = options.scales || {}; + const chartIndexAxis = getIndexAxis(config.type, options); + const firstIDs = Object.create(null); + const scales = Object.create(null); + Object.keys(configScales).forEach(id => { + const scaleConf = configScales[id]; + if (!isObject(scaleConf)) { + return console.error(`Invalid scale configuration for scale: ${id}`); + } + if (scaleConf._proxy) { + return console.warn(`Ignoring resolver passed as options for scale: ${id}`); + } + const axis = determineAxis(id, scaleConf); + const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis); + const defaultScaleOptions = chartDefaults.scales || {}; + firstIDs[axis] = firstIDs[axis] || id; + scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]); + }); + config.data.datasets.forEach(dataset => { + const type = dataset.type || config.type; + const indexAxis = dataset.indexAxis || getIndexAxis(type, options); + const datasetDefaults = overrides[type] || {}; + const defaultScaleOptions = datasetDefaults.scales || {}; + Object.keys(defaultScaleOptions).forEach(defaultID => { + const axis = getAxisFromDefaultScaleID(defaultID, indexAxis); + const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis; + scales[id] = scales[id] || Object.create(null); + mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]); + }); + }); + Object.keys(scales).forEach(key => { + const scale = scales[key]; + mergeIf(scale, [defaults.scales[scale.type], defaults.scale]); + }); + return scales; +} +function initOptions(config) { + const options = config.options || (config.options = {}); + options.plugins = valueOrDefault(options.plugins, {}); + options.scales = mergeScaleConfig(config, options); +} +function initData(data) { + data = data || {}; + data.datasets = data.datasets || []; + data.labels = data.labels || []; + return data; +} +function initConfig(config) { + config = config || {}; + config.data = initData(config.data); + initOptions(config); + return config; +} +const keyCache = new Map(); +const keysCached = new Set(); +function cachedKeys(cacheKey, generate) { + let keys = keyCache.get(cacheKey); + if (!keys) { + keys = generate(); + keyCache.set(cacheKey, keys); + keysCached.add(keys); + } + return keys; +} +const addIfFound = (set, obj, key) => { + const opts = resolveObjectKey(obj, key); + if (opts !== undefined) { + set.add(opts); + } +}; +class Config { + constructor(config) { + this._config = initConfig(config); + this._scopeCache = new Map(); + this._resolverCache = new Map(); + } + get platform() { + return this._config.platform; + } + get type() { + return this._config.type; + } + set type(type) { + this._config.type = type; + } + get data() { + return this._config.data; + } + set data(data) { + this._config.data = initData(data); + } + get options() { + return this._config.options; + } + set options(options) { + this._config.options = options; + } + get plugins() { + return this._config.plugins; + } + update() { + const config = this._config; + this.clearCache(); + initOptions(config); + } + clearCache() { + this._scopeCache.clear(); + this._resolverCache.clear(); + } + datasetScopeKeys(datasetType) { + return cachedKeys(datasetType, + () => [[ + `datasets.${datasetType}`, + '' + ]]); + } + datasetAnimationScopeKeys(datasetType, transition) { + return cachedKeys(`${datasetType}.transition.${transition}`, + () => [ + [ + `datasets.${datasetType}.transitions.${transition}`, + `transitions.${transition}`, + ], + [ + `datasets.${datasetType}`, + '' + ] + ]); + } + datasetElementScopeKeys(datasetType, elementType) { + return cachedKeys(`${datasetType}-${elementType}`, + () => [[ + `datasets.${datasetType}.elements.${elementType}`, + `datasets.${datasetType}`, + `elements.${elementType}`, + '' + ]]); + } + pluginScopeKeys(plugin) { + const id = plugin.id; + const type = this.type; + return cachedKeys(`${type}-plugin-${id}`, + () => [[ + `plugins.${id}`, + ...plugin.additionalOptionScopes || [], + ]]); + } + _cachedScopes(mainScope, resetCache) { + const _scopeCache = this._scopeCache; + let cache = _scopeCache.get(mainScope); + if (!cache || resetCache) { + cache = new Map(); + _scopeCache.set(mainScope, cache); + } + return cache; + } + getOptionScopes(mainScope, keyLists, resetCache) { + const {options, type} = this; + const cache = this._cachedScopes(mainScope, resetCache); + const cached = cache.get(keyLists); + if (cached) { + return cached; + } + const scopes = new Set(); + keyLists.forEach(keys => { + if (mainScope) { + scopes.add(mainScope); + keys.forEach(key => addIfFound(scopes, mainScope, key)); + } + keys.forEach(key => addIfFound(scopes, options, key)); + keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key)); + keys.forEach(key => addIfFound(scopes, defaults, key)); + keys.forEach(key => addIfFound(scopes, descriptors, key)); + }); + const array = Array.from(scopes); + if (array.length === 0) { + array.push(Object.create(null)); + } + if (keysCached.has(keyLists)) { + cache.set(keyLists, array); + } + return array; + } + chartOptionScopes() { + const {options, type} = this; + return [ + options, + overrides[type] || {}, + defaults.datasets[type] || {}, + {type}, + defaults, + descriptors + ]; + } + resolveNamedOptions(scopes, names, context, prefixes = ['']) { + const result = {$shared: true}; + const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes); + let options = resolver; + if (needContext(resolver, names)) { + result.$shared = false; + context = isFunction(context) ? context() : context; + const subResolver = this.createResolver(scopes, context, subPrefixes); + options = _attachContext(resolver, context, subResolver); + } + for (const prop of names) { + result[prop] = options[prop]; + } + return result; + } + createResolver(scopes, context, prefixes = [''], descriptorDefaults) { + const {resolver} = getResolver(this._resolverCache, scopes, prefixes); + return isObject(context) + ? _attachContext(resolver, context, undefined, descriptorDefaults) + : resolver; + } +} +function getResolver(resolverCache, scopes, prefixes) { + let cache = resolverCache.get(scopes); + if (!cache) { + cache = new Map(); + resolverCache.set(scopes, cache); + } + const cacheKey = prefixes.join(); + let cached = cache.get(cacheKey); + if (!cached) { + const resolver = _createResolver(scopes, prefixes); + cached = { + resolver, + subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover')) + }; + cache.set(cacheKey, cached); + } + return cached; +} +const hasFunction = value => isObject(value) + && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false); +function needContext(proxy, names) { + const {isScriptable, isIndexable} = _descriptors(proxy); + for (const prop of names) { + const scriptable = isScriptable(prop); + const indexable = isIndexable(prop); + const value = (indexable || scriptable) && proxy[prop]; + if ((scriptable && (isFunction(value) || hasFunction(value))) + || (indexable && isArray(value))) { + return true; + } + } + return false; +} + +var version = "3.7.1"; + +const KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea']; +function positionIsHorizontal(position, axis) { + return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x'); +} +function compare2Level(l1, l2) { + return function(a, b) { + return a[l1] === b[l1] + ? a[l2] - b[l2] + : a[l1] - b[l1]; + }; +} +function onAnimationsComplete(context) { + const chart = context.chart; + const animationOptions = chart.options.animation; + chart.notifyPlugins('afterRender'); + callback(animationOptions && animationOptions.onComplete, [context], chart); +} +function onAnimationProgress(context) { + const chart = context.chart; + const animationOptions = chart.options.animation; + callback(animationOptions && animationOptions.onProgress, [context], chart); +} +function getCanvas(item) { + if (_isDomSupported() && typeof item === 'string') { + item = document.getElementById(item); + } else if (item && item.length) { + item = item[0]; + } + if (item && item.canvas) { + item = item.canvas; + } + return item; +} +const instances = {}; +const getChart = (key) => { + const canvas = getCanvas(key); + return Object.values(instances).filter((c) => c.canvas === canvas).pop(); +}; +function moveNumericKeys(obj, start, move) { + const keys = Object.keys(obj); + for (const key of keys) { + const intKey = +key; + if (intKey >= start) { + const value = obj[key]; + delete obj[key]; + if (move > 0 || intKey > start) { + obj[intKey + move] = value; + } + } + } +} +function determineLastEvent(e, lastEvent, inChartArea, isClick) { + if (!inChartArea || e.type === 'mouseout') { + return null; + } + if (isClick) { + return lastEvent; + } + return e; +} +class Chart { + constructor(item, userConfig) { + const config = this.config = new Config(userConfig); + const initialCanvas = getCanvas(item); + const existingChart = getChart(initialCanvas); + if (existingChart) { + throw new Error( + 'Canvas is already in use. Chart with ID \'' + existingChart.id + '\'' + + ' must be destroyed before the canvas can be reused.' + ); + } + const options = config.createResolver(config.chartOptionScopes(), this.getContext()); + this.platform = new (config.platform || _detectPlatform(initialCanvas))(); + this.platform.updateConfig(config); + const context = this.platform.acquireContext(initialCanvas, options.aspectRatio); + const canvas = context && context.canvas; + const height = canvas && canvas.height; + const width = canvas && canvas.width; + this.id = uid(); + this.ctx = context; + this.canvas = canvas; + this.width = width; + this.height = height; + this._options = options; + this._aspectRatio = this.aspectRatio; + this._layers = []; + this._metasets = []; + this._stacks = undefined; + this.boxes = []; + this.currentDevicePixelRatio = undefined; + this.chartArea = undefined; + this._active = []; + this._lastEvent = undefined; + this._listeners = {}; + this._responsiveListeners = undefined; + this._sortedMetasets = []; + this.scales = {}; + this._plugins = new PluginService(); + this.$proxies = {}; + this._hiddenIndices = {}; + this.attached = false; + this._animationsDisabled = undefined; + this.$context = undefined; + this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0); + this._dataChanges = []; + instances[this.id] = this; + if (!context || !canvas) { + console.error("Failed to create chart: can't acquire context from the given item"); + return; + } + animator.listen(this, 'complete', onAnimationsComplete); + animator.listen(this, 'progress', onAnimationProgress); + this._initialize(); + if (this.attached) { + this.update(); + } + } + get aspectRatio() { + const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this; + if (!isNullOrUndef(aspectRatio)) { + return aspectRatio; + } + if (maintainAspectRatio && _aspectRatio) { + return _aspectRatio; + } + return height ? width / height : null; + } + get data() { + return this.config.data; + } + set data(data) { + this.config.data = data; + } + get options() { + return this._options; + } + set options(options) { + this.config.options = options; + } + _initialize() { + this.notifyPlugins('beforeInit'); + if (this.options.responsive) { + this.resize(); + } else { + retinaScale(this, this.options.devicePixelRatio); + } + this.bindEvents(); + this.notifyPlugins('afterInit'); + return this; + } + clear() { + clearCanvas(this.canvas, this.ctx); + return this; + } + stop() { + animator.stop(this); + return this; + } + resize(width, height) { + if (!animator.running(this)) { + this._resize(width, height); + } else { + this._resizeBeforeDraw = {width, height}; + } + } + _resize(width, height) { + const options = this.options; + const canvas = this.canvas; + const aspectRatio = options.maintainAspectRatio && this.aspectRatio; + const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio); + const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio(); + const mode = this.width ? 'resize' : 'attach'; + this.width = newSize.width; + this.height = newSize.height; + this._aspectRatio = this.aspectRatio; + if (!retinaScale(this, newRatio, true)) { + return; + } + this.notifyPlugins('resize', {size: newSize}); + callback(options.onResize, [this, newSize], this); + if (this.attached) { + if (this._doResize(mode)) { + this.render(); + } + } + } + ensureScalesHaveIDs() { + const options = this.options; + const scalesOptions = options.scales || {}; + each(scalesOptions, (axisOptions, axisID) => { + axisOptions.id = axisID; + }); + } + buildOrUpdateScales() { + const options = this.options; + const scaleOpts = options.scales; + const scales = this.scales; + const updated = Object.keys(scales).reduce((obj, id) => { + obj[id] = false; + return obj; + }, {}); + let items = []; + if (scaleOpts) { + items = items.concat( + Object.keys(scaleOpts).map((id) => { + const scaleOptions = scaleOpts[id]; + const axis = determineAxis(id, scaleOptions); + const isRadial = axis === 'r'; + const isHorizontal = axis === 'x'; + return { + options: scaleOptions, + dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left', + dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear' + }; + }) + ); + } + each(items, (item) => { + const scaleOptions = item.options; + const id = scaleOptions.id; + const axis = determineAxis(id, scaleOptions); + const scaleType = valueOrDefault(scaleOptions.type, item.dtype); + if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) { + scaleOptions.position = item.dposition; + } + updated[id] = true; + let scale = null; + if (id in scales && scales[id].type === scaleType) { + scale = scales[id]; + } else { + const scaleClass = registry.getScale(scaleType); + scale = new scaleClass({ + id, + type: scaleType, + ctx: this.ctx, + chart: this + }); + scales[scale.id] = scale; + } + scale.init(scaleOptions, options); + }); + each(updated, (hasUpdated, id) => { + if (!hasUpdated) { + delete scales[id]; + } + }); + each(scales, (scale) => { + layouts.configure(this, scale, scale.options); + layouts.addBox(this, scale); + }); + } + _updateMetasets() { + const metasets = this._metasets; + const numData = this.data.datasets.length; + const numMeta = metasets.length; + metasets.sort((a, b) => a.index - b.index); + if (numMeta > numData) { + for (let i = numData; i < numMeta; ++i) { + this._destroyDatasetMeta(i); + } + metasets.splice(numData, numMeta - numData); + } + this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index')); + } + _removeUnreferencedMetasets() { + const {_metasets: metasets, data: {datasets}} = this; + if (metasets.length > datasets.length) { + delete this._stacks; + } + metasets.forEach((meta, index) => { + if (datasets.filter(x => x === meta._dataset).length === 0) { + this._destroyDatasetMeta(index); + } + }); + } + buildOrUpdateControllers() { + const newControllers = []; + const datasets = this.data.datasets; + let i, ilen; + this._removeUnreferencedMetasets(); + for (i = 0, ilen = datasets.length; i < ilen; i++) { + const dataset = datasets[i]; + let meta = this.getDatasetMeta(i); + const type = dataset.type || this.config.type; + if (meta.type && meta.type !== type) { + this._destroyDatasetMeta(i); + meta = this.getDatasetMeta(i); + } + meta.type = type; + meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options); + meta.order = dataset.order || 0; + meta.index = i; + meta.label = '' + dataset.label; + meta.visible = this.isDatasetVisible(i); + if (meta.controller) { + meta.controller.updateIndex(i); + meta.controller.linkScales(); + } else { + const ControllerClass = registry.getController(type); + const {datasetElementType, dataElementType} = defaults.datasets[type]; + Object.assign(ControllerClass.prototype, { + dataElementType: registry.getElement(dataElementType), + datasetElementType: datasetElementType && registry.getElement(datasetElementType) + }); + meta.controller = new ControllerClass(this, i); + newControllers.push(meta.controller); + } + } + this._updateMetasets(); + return newControllers; + } + _resetElements() { + each(this.data.datasets, (dataset, datasetIndex) => { + this.getDatasetMeta(datasetIndex).controller.reset(); + }, this); + } + reset() { + this._resetElements(); + this.notifyPlugins('reset'); + } + update(mode) { + const config = this.config; + config.update(); + const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext()); + const animsDisabled = this._animationsDisabled = !options.animation; + this._updateScales(); + this._checkEventBindings(); + this._updateHiddenIndices(); + this._plugins.invalidate(); + if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) { + return; + } + const newControllers = this.buildOrUpdateControllers(); + this.notifyPlugins('beforeElementsUpdate'); + let minPadding = 0; + for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) { + const {controller} = this.getDatasetMeta(i); + const reset = !animsDisabled && newControllers.indexOf(controller) === -1; + controller.buildOrUpdateElements(reset); + minPadding = Math.max(+controller.getMaxOverflow(), minPadding); + } + minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0; + this._updateLayout(minPadding); + if (!animsDisabled) { + each(newControllers, (controller) => { + controller.reset(); + }); + } + this._updateDatasets(mode); + this.notifyPlugins('afterUpdate', {mode}); + this._layers.sort(compare2Level('z', '_idx')); + const {_active, _lastEvent} = this; + if (_lastEvent) { + this._eventHandler(_lastEvent, true); + } else if (_active.length) { + this._updateHoverStyles(_active, _active, true); + } + this.render(); + } + _updateScales() { + each(this.scales, (scale) => { + layouts.removeBox(this, scale); + }); + this.ensureScalesHaveIDs(); + this.buildOrUpdateScales(); + } + _checkEventBindings() { + const options = this.options; + const existingEvents = new Set(Object.keys(this._listeners)); + const newEvents = new Set(options.events); + if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) { + this.unbindEvents(); + this.bindEvents(); + } + } + _updateHiddenIndices() { + const {_hiddenIndices} = this; + const changes = this._getUniformDataChanges() || []; + for (const {method, start, count} of changes) { + const move = method === '_removeElements' ? -count : count; + moveNumericKeys(_hiddenIndices, start, move); + } + } + _getUniformDataChanges() { + const _dataChanges = this._dataChanges; + if (!_dataChanges || !_dataChanges.length) { + return; + } + this._dataChanges = []; + const datasetCount = this.data.datasets.length; + const makeSet = (idx) => new Set( + _dataChanges + .filter(c => c[0] === idx) + .map((c, i) => i + ',' + c.splice(1).join(',')) + ); + const changeSet = makeSet(0); + for (let i = 1; i < datasetCount; i++) { + if (!setsEqual(changeSet, makeSet(i))) { + return; + } + } + return Array.from(changeSet) + .map(c => c.split(',')) + .map(a => ({method: a[1], start: +a[2], count: +a[3]})); + } + _updateLayout(minPadding) { + if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) { + return; + } + layouts.update(this, this.width, this.height, minPadding); + const area = this.chartArea; + const noArea = area.width <= 0 || area.height <= 0; + this._layers = []; + each(this.boxes, (box) => { + if (noArea && box.position === 'chartArea') { + return; + } + if (box.configure) { + box.configure(); + } + this._layers.push(...box._layers()); + }, this); + this._layers.forEach((item, index) => { + item._idx = index; + }); + this.notifyPlugins('afterLayout'); + } + _updateDatasets(mode) { + if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) { + return; + } + for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this.getDatasetMeta(i).controller.configure(); + } + for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode); + } + this.notifyPlugins('afterDatasetsUpdate', {mode}); + } + _updateDataset(index, mode) { + const meta = this.getDatasetMeta(index); + const args = {meta, index, mode, cancelable: true}; + if (this.notifyPlugins('beforeDatasetUpdate', args) === false) { + return; + } + meta.controller._update(mode); + args.cancelable = false; + this.notifyPlugins('afterDatasetUpdate', args); + } + render() { + if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) { + return; + } + if (animator.has(this)) { + if (this.attached && !animator.running(this)) { + animator.start(this); + } + } else { + this.draw(); + onAnimationsComplete({chart: this}); + } + } + draw() { + let i; + if (this._resizeBeforeDraw) { + const {width, height} = this._resizeBeforeDraw; + this._resize(width, height); + this._resizeBeforeDraw = null; + } + this.clear(); + if (this.width <= 0 || this.height <= 0) { + return; + } + if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) { + return; + } + const layers = this._layers; + for (i = 0; i < layers.length && layers[i].z <= 0; ++i) { + layers[i].draw(this.chartArea); + } + this._drawDatasets(); + for (; i < layers.length; ++i) { + layers[i].draw(this.chartArea); + } + this.notifyPlugins('afterDraw'); + } + _getSortedDatasetMetas(filterVisible) { + const metasets = this._sortedMetasets; + const result = []; + let i, ilen; + for (i = 0, ilen = metasets.length; i < ilen; ++i) { + const meta = metasets[i]; + if (!filterVisible || meta.visible) { + result.push(meta); + } + } + return result; + } + getSortedVisibleDatasetMetas() { + return this._getSortedDatasetMetas(true); + } + _drawDatasets() { + if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) { + return; + } + const metasets = this.getSortedVisibleDatasetMetas(); + for (let i = metasets.length - 1; i >= 0; --i) { + this._drawDataset(metasets[i]); + } + this.notifyPlugins('afterDatasetsDraw'); + } + _drawDataset(meta) { + const ctx = this.ctx; + const clip = meta._clip; + const useClip = !clip.disabled; + const area = this.chartArea; + const args = { + meta, + index: meta.index, + cancelable: true + }; + if (this.notifyPlugins('beforeDatasetDraw', args) === false) { + return; + } + if (useClip) { + clipArea(ctx, { + left: clip.left === false ? 0 : area.left - clip.left, + right: clip.right === false ? this.width : area.right + clip.right, + top: clip.top === false ? 0 : area.top - clip.top, + bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom + }); + } + meta.controller.draw(); + if (useClip) { + unclipArea(ctx); + } + args.cancelable = false; + this.notifyPlugins('afterDatasetDraw', args); + } + getElementsAtEventForMode(e, mode, options, useFinalPosition) { + const method = Interaction.modes[mode]; + if (typeof method === 'function') { + return method(this, e, options, useFinalPosition); + } + return []; + } + getDatasetMeta(datasetIndex) { + const dataset = this.data.datasets[datasetIndex]; + const metasets = this._metasets; + let meta = metasets.filter(x => x && x._dataset === dataset).pop(); + if (!meta) { + meta = { + type: null, + data: [], + dataset: null, + controller: null, + hidden: null, + xAxisID: null, + yAxisID: null, + order: dataset && dataset.order || 0, + index: datasetIndex, + _dataset: dataset, + _parsed: [], + _sorted: false + }; + metasets.push(meta); + } + return meta; + } + getContext() { + return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'})); + } + getVisibleDatasetCount() { + return this.getSortedVisibleDatasetMetas().length; + } + isDatasetVisible(datasetIndex) { + const dataset = this.data.datasets[datasetIndex]; + if (!dataset) { + return false; + } + const meta = this.getDatasetMeta(datasetIndex); + return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden; + } + setDatasetVisibility(datasetIndex, visible) { + const meta = this.getDatasetMeta(datasetIndex); + meta.hidden = !visible; + } + toggleDataVisibility(index) { + this._hiddenIndices[index] = !this._hiddenIndices[index]; + } + getDataVisibility(index) { + return !this._hiddenIndices[index]; + } + _updateVisibility(datasetIndex, dataIndex, visible) { + const mode = visible ? 'show' : 'hide'; + const meta = this.getDatasetMeta(datasetIndex); + const anims = meta.controller._resolveAnimations(undefined, mode); + if (defined(dataIndex)) { + meta.data[dataIndex].hidden = !visible; + this.update(); + } else { + this.setDatasetVisibility(datasetIndex, visible); + anims.update(meta, {visible}); + this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined); + } + } + hide(datasetIndex, dataIndex) { + this._updateVisibility(datasetIndex, dataIndex, false); + } + show(datasetIndex, dataIndex) { + this._updateVisibility(datasetIndex, dataIndex, true); + } + _destroyDatasetMeta(datasetIndex) { + const meta = this._metasets[datasetIndex]; + if (meta && meta.controller) { + meta.controller._destroy(); + } + delete this._metasets[datasetIndex]; + } + _stop() { + let i, ilen; + this.stop(); + animator.remove(this); + for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this._destroyDatasetMeta(i); + } + } + destroy() { + this.notifyPlugins('beforeDestroy'); + const {canvas, ctx} = this; + this._stop(); + this.config.clearCache(); + if (canvas) { + this.unbindEvents(); + clearCanvas(canvas, ctx); + this.platform.releaseContext(ctx); + this.canvas = null; + this.ctx = null; + } + this.notifyPlugins('destroy'); + delete instances[this.id]; + this.notifyPlugins('afterDestroy'); + } + toBase64Image(...args) { + return this.canvas.toDataURL(...args); + } + bindEvents() { + this.bindUserEvents(); + if (this.options.responsive) { + this.bindResponsiveEvents(); + } else { + this.attached = true; + } + } + bindUserEvents() { + const listeners = this._listeners; + const platform = this.platform; + const _add = (type, listener) => { + platform.addEventListener(this, type, listener); + listeners[type] = listener; + }; + const listener = (e, x, y) => { + e.offsetX = x; + e.offsetY = y; + this._eventHandler(e); + }; + each(this.options.events, (type) => _add(type, listener)); + } + bindResponsiveEvents() { + if (!this._responsiveListeners) { + this._responsiveListeners = {}; + } + const listeners = this._responsiveListeners; + const platform = this.platform; + const _add = (type, listener) => { + platform.addEventListener(this, type, listener); + listeners[type] = listener; + }; + const _remove = (type, listener) => { + if (listeners[type]) { + platform.removeEventListener(this, type, listener); + delete listeners[type]; + } + }; + const listener = (width, height) => { + if (this.canvas) { + this.resize(width, height); + } + }; + let detached; + const attached = () => { + _remove('attach', attached); + this.attached = true; + this.resize(); + _add('resize', listener); + _add('detach', detached); + }; + detached = () => { + this.attached = false; + _remove('resize', listener); + this._stop(); + this._resize(0, 0); + _add('attach', attached); + }; + if (platform.isAttached(this.canvas)) { + attached(); + } else { + detached(); + } + } + unbindEvents() { + each(this._listeners, (listener, type) => { + this.platform.removeEventListener(this, type, listener); + }); + this._listeners = {}; + each(this._responsiveListeners, (listener, type) => { + this.platform.removeEventListener(this, type, listener); + }); + this._responsiveListeners = undefined; + } + updateHoverStyle(items, mode, enabled) { + const prefix = enabled ? 'set' : 'remove'; + let meta, item, i, ilen; + if (mode === 'dataset') { + meta = this.getDatasetMeta(items[0].datasetIndex); + meta.controller['_' + prefix + 'DatasetHoverStyle'](); + } + for (i = 0, ilen = items.length; i < ilen; ++i) { + item = items[i]; + const controller = item && this.getDatasetMeta(item.datasetIndex).controller; + if (controller) { + controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index); + } + } + } + getActiveElements() { + return this._active || []; + } + setActiveElements(activeElements) { + const lastActive = this._active || []; + const active = activeElements.map(({datasetIndex, index}) => { + const meta = this.getDatasetMeta(datasetIndex); + if (!meta) { + throw new Error('No dataset found at index ' + datasetIndex); + } + return { + datasetIndex, + element: meta.data[index], + index, + }; + }); + const changed = !_elementsEqual(active, lastActive); + if (changed) { + this._active = active; + this._lastEvent = null; + this._updateHoverStyles(active, lastActive); + } + } + notifyPlugins(hook, args, filter) { + return this._plugins.notify(this, hook, args, filter); + } + _updateHoverStyles(active, lastActive, replay) { + const hoverOptions = this.options.hover; + const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index)); + const deactivated = diff(lastActive, active); + const activated = replay ? active : diff(active, lastActive); + if (deactivated.length) { + this.updateHoverStyle(deactivated, hoverOptions.mode, false); + } + if (activated.length && hoverOptions.mode) { + this.updateHoverStyle(activated, hoverOptions.mode, true); + } + } + _eventHandler(e, replay) { + const args = { + event: e, + replay, + cancelable: true, + inChartArea: _isPointInArea(e, this.chartArea, this._minPadding) + }; + const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type); + if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) { + return; + } + const changed = this._handleEvent(e, replay, args.inChartArea); + args.cancelable = false; + this.notifyPlugins('afterEvent', args, eventFilter); + if (changed || args.changed) { + this.render(); + } + return this; + } + _handleEvent(e, replay, inChartArea) { + const {_active: lastActive = [], options} = this; + const useFinalPosition = replay; + const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition); + const isClick = _isClickEvent(e); + const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick); + if (inChartArea) { + this._lastEvent = null; + callback(options.onHover, [e, active, this], this); + if (isClick) { + callback(options.onClick, [e, active, this], this); + } + } + const changed = !_elementsEqual(active, lastActive); + if (changed || replay) { + this._active = active; + this._updateHoverStyles(active, lastActive, replay); + } + this._lastEvent = lastEvent; + return changed; + } + _getActiveElements(e, lastActive, inChartArea, useFinalPosition) { + if (e.type === 'mouseout') { + return []; + } + if (!inChartArea) { + return lastActive; + } + const hoverOptions = this.options.hover; + return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition); + } +} +const invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate()); +const enumerable = true; +Object.defineProperties(Chart, { + defaults: { + enumerable, + value: defaults + }, + instances: { + enumerable, + value: instances + }, + overrides: { + enumerable, + value: overrides + }, + registry: { + enumerable, + value: registry + }, + version: { + enumerable, + value: version + }, + getChart: { + enumerable, + value: getChart + }, + register: { + enumerable, + value: (...items) => { + registry.add(...items); + invalidatePlugins(); + } + }, + unregister: { + enumerable, + value: (...items) => { + registry.remove(...items); + invalidatePlugins(); + } + } +}); + +function abstract() { + throw new Error('This method is not implemented: Check that a complete date adapter is provided.'); +} +class DateAdapter { + constructor(options) { + this.options = options || {}; + } + formats() { + return abstract(); + } + parse(value, format) { + return abstract(); + } + format(timestamp, format) { + return abstract(); + } + add(timestamp, amount, unit) { + return abstract(); + } + diff(a, b, unit) { + return abstract(); + } + startOf(timestamp, unit, weekday) { + return abstract(); + } + endOf(timestamp, unit) { + return abstract(); + } +} +DateAdapter.override = function(members) { + Object.assign(DateAdapter.prototype, members); +}; +var _adapters = { + _date: DateAdapter +}; + +function getAllScaleValues(scale, type) { + if (!scale._cache.$bar) { + const visibleMetas = scale.getMatchingVisibleMetas(type); + let values = []; + for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) { + values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale)); + } + scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b)); + } + return scale._cache.$bar; +} +function computeMinSampleSize(meta) { + const scale = meta.iScale; + const values = getAllScaleValues(scale, meta.type); + let min = scale._length; + let i, ilen, curr, prev; + const updateMinAndPrev = () => { + if (curr === 32767 || curr === -32768) { + return; + } + if (defined(prev)) { + min = Math.min(min, Math.abs(curr - prev) || min); + } + prev = curr; + }; + for (i = 0, ilen = values.length; i < ilen; ++i) { + curr = scale.getPixelForValue(values[i]); + updateMinAndPrev(); + } + prev = undefined; + for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) { + curr = scale.getPixelForTick(i); + updateMinAndPrev(); + } + return min; +} +function computeFitCategoryTraits(index, ruler, options, stackCount) { + const thickness = options.barThickness; + let size, ratio; + if (isNullOrUndef(thickness)) { + size = ruler.min * options.categoryPercentage; + ratio = options.barPercentage; + } else { + size = thickness * stackCount; + ratio = 1; + } + return { + chunk: size / stackCount, + ratio, + start: ruler.pixels[index] - (size / 2) + }; +} +function computeFlexCategoryTraits(index, ruler, options, stackCount) { + const pixels = ruler.pixels; + const curr = pixels[index]; + let prev = index > 0 ? pixels[index - 1] : null; + let next = index < pixels.length - 1 ? pixels[index + 1] : null; + const percent = options.categoryPercentage; + if (prev === null) { + prev = curr - (next === null ? ruler.end - ruler.start : next - curr); + } + if (next === null) { + next = curr + curr - prev; + } + const start = curr - (curr - Math.min(prev, next)) / 2 * percent; + const size = Math.abs(next - prev) / 2 * percent; + return { + chunk: size / stackCount, + ratio: options.barPercentage, + start + }; +} +function parseFloatBar(entry, item, vScale, i) { + const startValue = vScale.parse(entry[0], i); + const endValue = vScale.parse(entry[1], i); + const min = Math.min(startValue, endValue); + const max = Math.max(startValue, endValue); + let barStart = min; + let barEnd = max; + if (Math.abs(min) > Math.abs(max)) { + barStart = max; + barEnd = min; + } + item[vScale.axis] = barEnd; + item._custom = { + barStart, + barEnd, + start: startValue, + end: endValue, + min, + max + }; +} +function parseValue(entry, item, vScale, i) { + if (isArray(entry)) { + parseFloatBar(entry, item, vScale, i); + } else { + item[vScale.axis] = vScale.parse(entry, i); + } + return item; +} +function parseArrayOrPrimitive(meta, data, start, count) { + const iScale = meta.iScale; + const vScale = meta.vScale; + const labels = iScale.getLabels(); + const singleScale = iScale === vScale; + const parsed = []; + let i, ilen, item, entry; + for (i = start, ilen = start + count; i < ilen; ++i) { + entry = data[i]; + item = {}; + item[iScale.axis] = singleScale || iScale.parse(labels[i], i); + parsed.push(parseValue(entry, item, vScale, i)); + } + return parsed; +} +function isFloatBar(custom) { + return custom && custom.barStart !== undefined && custom.barEnd !== undefined; +} +function barSign(size, vScale, actualBase) { + if (size !== 0) { + return sign(size); + } + return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1); +} +function borderProps(properties) { + let reverse, start, end, top, bottom; + if (properties.horizontal) { + reverse = properties.base > properties.x; + start = 'left'; + end = 'right'; + } else { + reverse = properties.base < properties.y; + start = 'bottom'; + end = 'top'; + } + if (reverse) { + top = 'end'; + bottom = 'start'; + } else { + top = 'start'; + bottom = 'end'; + } + return {start, end, reverse, top, bottom}; +} +function setBorderSkipped(properties, options, stack, index) { + let edge = options.borderSkipped; + const res = {}; + if (!edge) { + properties.borderSkipped = res; + return; + } + const {start, end, reverse, top, bottom} = borderProps(properties); + if (edge === 'middle' && stack) { + properties.enableBorderRadius = true; + if ((stack._top || 0) === index) { + edge = top; + } else if ((stack._bottom || 0) === index) { + edge = bottom; + } else { + res[parseEdge(bottom, start, end, reverse)] = true; + edge = top; + } + } + res[parseEdge(edge, start, end, reverse)] = true; + properties.borderSkipped = res; +} +function parseEdge(edge, a, b, reverse) { + if (reverse) { + edge = swap(edge, a, b); + edge = startEnd(edge, b, a); + } else { + edge = startEnd(edge, a, b); + } + return edge; +} +function swap(orig, v1, v2) { + return orig === v1 ? v2 : orig === v2 ? v1 : orig; +} +function startEnd(v, start, end) { + return v === 'start' ? start : v === 'end' ? end : v; +} +function setInflateAmount(properties, {inflateAmount}, ratio) { + properties.inflateAmount = inflateAmount === 'auto' + ? ratio === 1 ? 0.33 : 0 + : inflateAmount; +} +class BarController extends DatasetController { + parsePrimitiveData(meta, data, start, count) { + return parseArrayOrPrimitive(meta, data, start, count); + } + parseArrayData(meta, data, start, count) { + return parseArrayOrPrimitive(meta, data, start, count); + } + parseObjectData(meta, data, start, count) { + const {iScale, vScale} = meta; + const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing; + const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey; + const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey; + const parsed = []; + let i, ilen, item, obj; + for (i = start, ilen = start + count; i < ilen; ++i) { + obj = data[i]; + item = {}; + item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i); + parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i)); + } + return parsed; + } + updateRangeFromParsed(range, scale, parsed, stack) { + super.updateRangeFromParsed(range, scale, parsed, stack); + const custom = parsed._custom; + if (custom && scale === this._cachedMeta.vScale) { + range.min = Math.min(range.min, custom.min); + range.max = Math.max(range.max, custom.max); + } + } + getMaxOverflow() { + return 0; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const {iScale, vScale} = meta; + const parsed = this.getParsed(index); + const custom = parsed._custom; + const value = isFloatBar(custom) + ? '[' + custom.start + ', ' + custom.end + ']' + : '' + vScale.getLabelForValue(parsed[vScale.axis]); + return { + label: '' + iScale.getLabelForValue(parsed[iScale.axis]), + value + }; + } + initialize() { + this.enableOptionSharing = true; + super.initialize(); + const meta = this._cachedMeta; + meta.stack = this.getDataset().stack; + } + update(mode) { + const meta = this._cachedMeta; + this.updateElements(meta.data, 0, meta.data.length, mode); + } + updateElements(bars, start, count, mode) { + const reset = mode === 'reset'; + const {index, _cachedMeta: {vScale}} = this; + const base = vScale.getBasePixel(); + const horizontal = vScale.isHorizontal(); + const ruler = this._getRuler(); + const firstOpts = this.resolveDataElementOptions(start, mode); + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions); + this.updateSharedOptions(sharedOptions, mode, firstOpts); + for (let i = start; i < start + count; i++) { + const parsed = this.getParsed(i); + const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i); + const ipixels = this._calculateBarIndexPixels(i, ruler); + const stack = (parsed._stacks || {})[vScale.axis]; + const properties = { + horizontal, + base: vpixels.base, + enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom), + x: horizontal ? vpixels.head : ipixels.center, + y: horizontal ? ipixels.center : vpixels.head, + height: horizontal ? ipixels.size : Math.abs(vpixels.size), + width: horizontal ? Math.abs(vpixels.size) : ipixels.size + }; + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode); + } + const options = properties.options || bars[i].options; + setBorderSkipped(properties, options, stack, index); + setInflateAmount(properties, options, ruler.ratio); + this.updateElement(bars[i], i, properties, mode); + } + } + _getStacks(last, dataIndex) { + const meta = this._cachedMeta; + const iScale = meta.iScale; + const metasets = iScale.getMatchingVisibleMetas(this._type); + const stacked = iScale.options.stacked; + const ilen = metasets.length; + const stacks = []; + let i, item; + for (i = 0; i < ilen; ++i) { + item = metasets[i]; + if (!item.controller.options.grouped) { + continue; + } + if (typeof dataIndex !== 'undefined') { + const val = item.controller.getParsed(dataIndex)[ + item.controller._cachedMeta.vScale.axis + ]; + if (isNullOrUndef(val) || isNaN(val)) { + continue; + } + } + if (stacked === false || stacks.indexOf(item.stack) === -1 || + (stacked === undefined && item.stack === undefined)) { + stacks.push(item.stack); + } + if (item.index === last) { + break; + } + } + if (!stacks.length) { + stacks.push(undefined); + } + return stacks; + } + _getStackCount(index) { + return this._getStacks(undefined, index).length; + } + _getStackIndex(datasetIndex, name, dataIndex) { + const stacks = this._getStacks(datasetIndex, dataIndex); + const index = (name !== undefined) + ? stacks.indexOf(name) + : -1; + return (index === -1) + ? stacks.length - 1 + : index; + } + _getRuler() { + const opts = this.options; + const meta = this._cachedMeta; + const iScale = meta.iScale; + const pixels = []; + let i, ilen; + for (i = 0, ilen = meta.data.length; i < ilen; ++i) { + pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i)); + } + const barThickness = opts.barThickness; + const min = barThickness || computeMinSampleSize(meta); + return { + min, + pixels, + start: iScale._startPixel, + end: iScale._endPixel, + stackCount: this._getStackCount(), + scale: iScale, + grouped: opts.grouped, + ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage + }; + } + _calculateBarValuePixels(index) { + const {_cachedMeta: {vScale, _stacked}, options: {base: baseValue, minBarLength}} = this; + const actualBase = baseValue || 0; + const parsed = this.getParsed(index); + const custom = parsed._custom; + const floating = isFloatBar(custom); + let value = parsed[vScale.axis]; + let start = 0; + let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value; + let head, size; + if (length !== value) { + start = length - value; + length = value; + } + if (floating) { + value = custom.barStart; + length = custom.barEnd - custom.barStart; + if (value !== 0 && sign(value) !== sign(custom.barEnd)) { + start = 0; + } + start += value; + } + const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start; + let base = vScale.getPixelForValue(startValue); + if (this.chart.getDataVisibility(index)) { + head = vScale.getPixelForValue(start + length); + } else { + head = base; + } + size = head - base; + if (Math.abs(size) < minBarLength) { + size = barSign(size, vScale, actualBase) * minBarLength; + if (value === actualBase) { + base -= size / 2; + } + head = base + size; + } + if (base === vScale.getPixelForValue(actualBase)) { + const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2; + base += halfGrid; + size -= halfGrid; + } + return { + size, + base, + head, + center: head + size / 2 + }; + } + _calculateBarIndexPixels(index, ruler) { + const scale = ruler.scale; + const options = this.options; + const skipNull = options.skipNull; + const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity); + let center, size; + if (ruler.grouped) { + const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount; + const range = options.barThickness === 'flex' + ? computeFlexCategoryTraits(index, ruler, options, stackCount) + : computeFitCategoryTraits(index, ruler, options, stackCount); + const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined); + center = range.start + (range.chunk * stackIndex) + (range.chunk / 2); + size = Math.min(maxBarThickness, range.chunk * range.ratio); + } else { + center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index); + size = Math.min(maxBarThickness, ruler.min * ruler.ratio); + } + return { + base: center - size / 2, + head: center + size / 2, + center, + size + }; + } + draw() { + const meta = this._cachedMeta; + const vScale = meta.vScale; + const rects = meta.data; + const ilen = rects.length; + let i = 0; + for (; i < ilen; ++i) { + if (this.getParsed(i)[vScale.axis] !== null) { + rects[i].draw(this._ctx); + } + } + } +} +BarController.id = 'bar'; +BarController.defaults = { + datasetElementType: false, + dataElementType: 'bar', + categoryPercentage: 0.8, + barPercentage: 0.9, + grouped: true, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'base', 'width', 'height'] + } + } +}; +BarController.overrides = { + scales: { + _index_: { + type: 'category', + offset: true, + grid: { + offset: true + } + }, + _value_: { + type: 'linear', + beginAtZero: true, + } + } +}; + +class BubbleController extends DatasetController { + initialize() { + this.enableOptionSharing = true; + super.initialize(); + } + parsePrimitiveData(meta, data, start, count) { + const parsed = super.parsePrimitiveData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + parsed[i]._custom = this.resolveDataElementOptions(i + start).radius; + } + return parsed; + } + parseArrayData(meta, data, start, count) { + const parsed = super.parseArrayData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + const item = data[start + i]; + parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius); + } + return parsed; + } + parseObjectData(meta, data, start, count) { + const parsed = super.parseObjectData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + const item = data[start + i]; + parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius); + } + return parsed; + } + getMaxOverflow() { + const data = this._cachedMeta.data; + let max = 0; + for (let i = data.length - 1; i >= 0; --i) { + max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2); + } + return max > 0 && max; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const {xScale, yScale} = meta; + const parsed = this.getParsed(index); + const x = xScale.getLabelForValue(parsed.x); + const y = yScale.getLabelForValue(parsed.y); + const r = parsed._custom; + return { + label: meta.label, + value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')' + }; + } + update(mode) { + const points = this._cachedMeta.data; + this.updateElements(points, 0, points.length, mode); + } + updateElements(points, start, count, mode) { + const reset = mode === 'reset'; + const {iScale, vScale} = this._cachedMeta; + const firstOpts = this.resolveDataElementOptions(start, mode); + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions); + const iAxis = iScale.axis; + const vAxis = vScale.axis; + for (let i = start; i < start + count; i++) { + const point = points[i]; + const parsed = !reset && this.getParsed(i); + const properties = {}; + const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]); + const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]); + properties.skip = isNaN(iPixel) || isNaN(vPixel); + if (includeOptions) { + properties.options = this.resolveDataElementOptions(i, point.active ? 'active' : mode); + if (reset) { + properties.options.radius = 0; + } + } + this.updateElement(point, i, properties, mode); + } + this.updateSharedOptions(sharedOptions, mode, firstOpts); + } + resolveDataElementOptions(index, mode) { + const parsed = this.getParsed(index); + let values = super.resolveDataElementOptions(index, mode); + if (values.$shared) { + values = Object.assign({}, values, {$shared: false}); + } + const radius = values.radius; + if (mode !== 'active') { + values.radius = 0; + } + values.radius += valueOrDefault(parsed && parsed._custom, radius); + return values; + } +} +BubbleController.id = 'bubble'; +BubbleController.defaults = { + datasetElementType: false, + dataElementType: 'point', + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'borderWidth', 'radius'] + } + } +}; +BubbleController.overrides = { + scales: { + x: { + type: 'linear' + }, + y: { + type: 'linear' + } + }, + plugins: { + tooltip: { + callbacks: { + title() { + return ''; + } + } + } + } +}; + +function getRatioAndOffset(rotation, circumference, cutout) { + let ratioX = 1; + let ratioY = 1; + let offsetX = 0; + let offsetY = 0; + if (circumference < TAU) { + const startAngle = rotation; + const endAngle = startAngle + circumference; + const startX = Math.cos(startAngle); + const startY = Math.sin(startAngle); + const endX = Math.cos(endAngle); + const endY = Math.sin(endAngle); + const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout); + const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout); + const maxX = calcMax(0, startX, endX); + const maxY = calcMax(HALF_PI, startY, endY); + const minX = calcMin(PI, startX, endX); + const minY = calcMin(PI + HALF_PI, startY, endY); + ratioX = (maxX - minX) / 2; + ratioY = (maxY - minY) / 2; + offsetX = -(maxX + minX) / 2; + offsetY = -(maxY + minY) / 2; + } + return {ratioX, ratioY, offsetX, offsetY}; +} +class DoughnutController extends DatasetController { + constructor(chart, datasetIndex) { + super(chart, datasetIndex); + this.enableOptionSharing = true; + this.innerRadius = undefined; + this.outerRadius = undefined; + this.offsetX = undefined; + this.offsetY = undefined; + } + linkScales() {} + parse(start, count) { + const data = this.getDataset().data; + const meta = this._cachedMeta; + if (this._parsing === false) { + meta._parsed = data; + } else { + let getter = (i) => +data[i]; + if (isObject(data[start])) { + const {key = 'value'} = this._parsing; + getter = (i) => +resolveObjectKey(data[i], key); + } + let i, ilen; + for (i = start, ilen = start + count; i < ilen; ++i) { + meta._parsed[i] = getter(i); + } + } + } + _getRotation() { + return toRadians(this.options.rotation - 90); + } + _getCircumference() { + return toRadians(this.options.circumference); + } + _getRotationExtents() { + let min = TAU; + let max = -TAU; + for (let i = 0; i < this.chart.data.datasets.length; ++i) { + if (this.chart.isDatasetVisible(i)) { + const controller = this.chart.getDatasetMeta(i).controller; + const rotation = controller._getRotation(); + const circumference = controller._getCircumference(); + min = Math.min(min, rotation); + max = Math.max(max, rotation + circumference); + } + } + return { + rotation: min, + circumference: max - min, + }; + } + update(mode) { + const chart = this.chart; + const {chartArea} = chart; + const meta = this._cachedMeta; + const arcs = meta.data; + const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing; + const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0); + const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1); + const chartWeight = this._getRingWeight(this.index); + const {circumference, rotation} = this._getRotationExtents(); + const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout); + const maxWidth = (chartArea.width - spacing) / ratioX; + const maxHeight = (chartArea.height - spacing) / ratioY; + const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0); + const outerRadius = toDimension(this.options.radius, maxRadius); + const innerRadius = Math.max(outerRadius * cutout, 0); + const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal(); + this.offsetX = offsetX * outerRadius; + this.offsetY = offsetY * outerRadius; + meta.total = this.calculateTotal(); + this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index); + this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0); + this.updateElements(arcs, 0, arcs.length, mode); + } + _circumference(i, reset) { + const opts = this.options; + const meta = this._cachedMeta; + const circumference = this._getCircumference(); + if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) { + return 0; + } + return this.calculateCircumference(meta._parsed[i] * circumference / TAU); + } + updateElements(arcs, start, count, mode) { + const reset = mode === 'reset'; + const chart = this.chart; + const chartArea = chart.chartArea; + const opts = chart.options; + const animationOpts = opts.animation; + const centerX = (chartArea.left + chartArea.right) / 2; + const centerY = (chartArea.top + chartArea.bottom) / 2; + const animateScale = reset && animationOpts.animateScale; + const innerRadius = animateScale ? 0 : this.innerRadius; + const outerRadius = animateScale ? 0 : this.outerRadius; + const firstOpts = this.resolveDataElementOptions(start, mode); + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions); + let startAngle = this._getRotation(); + let i; + for (i = 0; i < start; ++i) { + startAngle += this._circumference(i, reset); + } + for (i = start; i < start + count; ++i) { + const circumference = this._circumference(i, reset); + const arc = arcs[i]; + const properties = { + x: centerX + this.offsetX, + y: centerY + this.offsetY, + startAngle, + endAngle: startAngle + circumference, + circumference, + outerRadius, + innerRadius + }; + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode); + } + startAngle += circumference; + this.updateElement(arc, i, properties, mode); + } + this.updateSharedOptions(sharedOptions, mode, firstOpts); + } + calculateTotal() { + const meta = this._cachedMeta; + const metaData = meta.data; + let total = 0; + let i; + for (i = 0; i < metaData.length; i++) { + const value = meta._parsed[i]; + if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) { + total += Math.abs(value); + } + } + return total; + } + calculateCircumference(value) { + const total = this._cachedMeta.total; + if (total > 0 && !isNaN(value)) { + return TAU * (Math.abs(value) / total); + } + return 0; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const chart = this.chart; + const labels = chart.data.labels || []; + const value = formatNumber(meta._parsed[index], chart.options.locale); + return { + label: labels[index] || '', + value, + }; + } + getMaxBorderWidth(arcs) { + let max = 0; + const chart = this.chart; + let i, ilen, meta, controller, options; + if (!arcs) { + for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) { + if (chart.isDatasetVisible(i)) { + meta = chart.getDatasetMeta(i); + arcs = meta.data; + controller = meta.controller; + break; + } + } + } + if (!arcs) { + return 0; + } + for (i = 0, ilen = arcs.length; i < ilen; ++i) { + options = controller.resolveDataElementOptions(i); + if (options.borderAlign !== 'inner') { + max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0); + } + } + return max; + } + getMaxOffset(arcs) { + let max = 0; + for (let i = 0, ilen = arcs.length; i < ilen; ++i) { + const options = this.resolveDataElementOptions(i); + max = Math.max(max, options.offset || 0, options.hoverOffset || 0); + } + return max; + } + _getRingWeightOffset(datasetIndex) { + let ringWeightOffset = 0; + for (let i = 0; i < datasetIndex; ++i) { + if (this.chart.isDatasetVisible(i)) { + ringWeightOffset += this._getRingWeight(i); + } + } + return ringWeightOffset; + } + _getRingWeight(datasetIndex) { + return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0); + } + _getVisibleDatasetWeightTotal() { + return this._getRingWeightOffset(this.chart.data.datasets.length) || 1; + } +} +DoughnutController.id = 'doughnut'; +DoughnutController.defaults = { + datasetElementType: false, + dataElementType: 'arc', + animation: { + animateRotate: true, + animateScale: false + }, + animations: { + numbers: { + type: 'number', + properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing'] + }, + }, + cutout: '50%', + rotation: 0, + circumference: 360, + radius: '100%', + spacing: 0, + indexAxis: 'r', +}; +DoughnutController.descriptors = { + _scriptable: (name) => name !== 'spacing', + _indexable: (name) => name !== 'spacing', +}; +DoughnutController.overrides = { + aspectRatio: 1, + plugins: { + legend: { + labels: { + generateLabels(chart) { + const data = chart.data; + if (data.labels.length && data.datasets.length) { + const {labels: {pointStyle}} = chart.legend.options; + return data.labels.map((label, i) => { + const meta = chart.getDatasetMeta(0); + const style = meta.controller.getStyle(i); + return { + text: label, + fillStyle: style.backgroundColor, + strokeStyle: style.borderColor, + lineWidth: style.borderWidth, + pointStyle: pointStyle, + hidden: !chart.getDataVisibility(i), + index: i + }; + }); + } + return []; + } + }, + onClick(e, legendItem, legend) { + legend.chart.toggleDataVisibility(legendItem.index); + legend.chart.update(); + } + }, + tooltip: { + callbacks: { + title() { + return ''; + }, + label(tooltipItem) { + let dataLabel = tooltipItem.label; + const value = ': ' + tooltipItem.formattedValue; + if (isArray(dataLabel)) { + dataLabel = dataLabel.slice(); + dataLabel[0] += value; + } else { + dataLabel += value; + } + return dataLabel; + } + } + } + } +}; + +class LineController extends DatasetController { + initialize() { + this.enableOptionSharing = true; + super.initialize(); + } + update(mode) { + const meta = this._cachedMeta; + const {dataset: line, data: points = [], _dataset} = meta; + const animationsDisabled = this.chart._animationsDisabled; + let {start, count} = getStartAndCountOfVisiblePoints(meta, points, animationsDisabled); + this._drawStart = start; + this._drawCount = count; + if (scaleRangesChanged(meta)) { + start = 0; + count = points.length; + } + line._chart = this.chart; + line._datasetIndex = this.index; + line._decimated = !!_dataset._decimated; + line.points = points; + const options = this.resolveDatasetElementOptions(mode); + if (!this.options.showLine) { + options.borderWidth = 0; + } + options.segment = this.options.segment; + this.updateElement(line, undefined, { + animated: !animationsDisabled, + options + }, mode); + this.updateElements(points, start, count, mode); + } + updateElements(points, start, count, mode) { + const reset = mode === 'reset'; + const {iScale, vScale, _stacked, _dataset} = this._cachedMeta; + const firstOpts = this.resolveDataElementOptions(start, mode); + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions); + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const {spanGaps, segment} = this.options; + const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY; + const directUpdate = this.chart._animationsDisabled || reset || mode === 'none'; + let prevParsed = start > 0 && this.getParsed(start - 1); + for (let i = start; i < start + count; ++i) { + const point = points[i]; + const parsed = this.getParsed(i); + const properties = directUpdate ? point : {}; + const nullData = isNullOrUndef(parsed[vAxis]); + const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i); + const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i); + properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData; + properties.stop = i > 0 && (parsed[iAxis] - prevParsed[iAxis]) > maxGapLength; + if (segment) { + properties.parsed = parsed; + properties.raw = _dataset.data[i]; + } + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode); + } + if (!directUpdate) { + this.updateElement(point, i, properties, mode); + } + prevParsed = parsed; + } + this.updateSharedOptions(sharedOptions, mode, firstOpts); + } + getMaxOverflow() { + const meta = this._cachedMeta; + const dataset = meta.dataset; + const border = dataset.options && dataset.options.borderWidth || 0; + const data = meta.data || []; + if (!data.length) { + return border; + } + const firstPoint = data[0].size(this.resolveDataElementOptions(0)); + const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1)); + return Math.max(border, firstPoint, lastPoint) / 2; + } + draw() { + const meta = this._cachedMeta; + meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis); + super.draw(); + } +} +LineController.id = 'line'; +LineController.defaults = { + datasetElementType: 'line', + dataElementType: 'point', + showLine: true, + spanGaps: false, +}; +LineController.overrides = { + scales: { + _index_: { + type: 'category', + }, + _value_: { + type: 'linear', + }, + } +}; +function getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) { + const pointCount = points.length; + let start = 0; + let count = pointCount; + if (meta._sorted) { + const {iScale, _parsed} = meta; + const axis = iScale.axis; + const {min, max, minDefined, maxDefined} = iScale.getUserBounds(); + if (minDefined) { + start = _limitValue(Math.min( + _lookupByKey(_parsed, iScale.axis, min).lo, + animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo), + 0, pointCount - 1); + } + if (maxDefined) { + count = _limitValue(Math.max( + _lookupByKey(_parsed, iScale.axis, max).hi + 1, + animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max)).hi + 1), + start, pointCount) - start; + } else { + count = pointCount - start; + } + } + return {start, count}; +} +function scaleRangesChanged(meta) { + const {xScale, yScale, _scaleRanges} = meta; + const newRanges = { + xmin: xScale.min, + xmax: xScale.max, + ymin: yScale.min, + ymax: yScale.max + }; + if (!_scaleRanges) { + meta._scaleRanges = newRanges; + return true; + } + const changed = _scaleRanges.xmin !== xScale.min + || _scaleRanges.xmax !== xScale.max + || _scaleRanges.ymin !== yScale.min + || _scaleRanges.ymax !== yScale.max; + Object.assign(_scaleRanges, newRanges); + return changed; +} + +class PolarAreaController extends DatasetController { + constructor(chart, datasetIndex) { + super(chart, datasetIndex); + this.innerRadius = undefined; + this.outerRadius = undefined; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const chart = this.chart; + const labels = chart.data.labels || []; + const value = formatNumber(meta._parsed[index].r, chart.options.locale); + return { + label: labels[index] || '', + value, + }; + } + update(mode) { + const arcs = this._cachedMeta.data; + this._updateRadius(); + this.updateElements(arcs, 0, arcs.length, mode); + } + _updateRadius() { + const chart = this.chart; + const chartArea = chart.chartArea; + const opts = chart.options; + const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top); + const outerRadius = Math.max(minSize / 2, 0); + const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0); + const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount(); + this.outerRadius = outerRadius - (radiusLength * this.index); + this.innerRadius = this.outerRadius - radiusLength; + } + updateElements(arcs, start, count, mode) { + const reset = mode === 'reset'; + const chart = this.chart; + const dataset = this.getDataset(); + const opts = chart.options; + const animationOpts = opts.animation; + const scale = this._cachedMeta.rScale; + const centerX = scale.xCenter; + const centerY = scale.yCenter; + const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI; + let angle = datasetStartAngle; + let i; + const defaultAngle = 360 / this.countVisibleElements(); + for (i = 0; i < start; ++i) { + angle += this._computeAngle(i, mode, defaultAngle); + } + for (i = start; i < start + count; i++) { + const arc = arcs[i]; + let startAngle = angle; + let endAngle = angle + this._computeAngle(i, mode, defaultAngle); + let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(dataset.data[i]) : 0; + angle = endAngle; + if (reset) { + if (animationOpts.animateScale) { + outerRadius = 0; + } + if (animationOpts.animateRotate) { + startAngle = endAngle = datasetStartAngle; + } + } + const properties = { + x: centerX, + y: centerY, + innerRadius: 0, + outerRadius, + startAngle, + endAngle, + options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode) + }; + this.updateElement(arc, i, properties, mode); + } + } + countVisibleElements() { + const dataset = this.getDataset(); + const meta = this._cachedMeta; + let count = 0; + meta.data.forEach((element, index) => { + if (!isNaN(dataset.data[index]) && this.chart.getDataVisibility(index)) { + count++; + } + }); + return count; + } + _computeAngle(index, mode, defaultAngle) { + return this.chart.getDataVisibility(index) + ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle) + : 0; + } +} +PolarAreaController.id = 'polarArea'; +PolarAreaController.defaults = { + dataElementType: 'arc', + animation: { + animateRotate: true, + animateScale: true + }, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius'] + }, + }, + indexAxis: 'r', + startAngle: 0, +}; +PolarAreaController.overrides = { + aspectRatio: 1, + plugins: { + legend: { + labels: { + generateLabels(chart) { + const data = chart.data; + if (data.labels.length && data.datasets.length) { + const {labels: {pointStyle}} = chart.legend.options; + return data.labels.map((label, i) => { + const meta = chart.getDatasetMeta(0); + const style = meta.controller.getStyle(i); + return { + text: label, + fillStyle: style.backgroundColor, + strokeStyle: style.borderColor, + lineWidth: style.borderWidth, + pointStyle: pointStyle, + hidden: !chart.getDataVisibility(i), + index: i + }; + }); + } + return []; + } + }, + onClick(e, legendItem, legend) { + legend.chart.toggleDataVisibility(legendItem.index); + legend.chart.update(); + } + }, + tooltip: { + callbacks: { + title() { + return ''; + }, + label(context) { + return context.chart.data.labels[context.dataIndex] + ': ' + context.formattedValue; + } + } + } + }, + scales: { + r: { + type: 'radialLinear', + angleLines: { + display: false + }, + beginAtZero: true, + grid: { + circular: true + }, + pointLabels: { + display: false + }, + startAngle: 0 + } + } +}; + +class PieController extends DoughnutController { +} +PieController.id = 'pie'; +PieController.defaults = { + cutout: 0, + rotation: 0, + circumference: 360, + radius: '100%' +}; + +class RadarController extends DatasetController { + getLabelAndValue(index) { + const vScale = this._cachedMeta.vScale; + const parsed = this.getParsed(index); + return { + label: vScale.getLabels()[index], + value: '' + vScale.getLabelForValue(parsed[vScale.axis]) + }; + } + update(mode) { + const meta = this._cachedMeta; + const line = meta.dataset; + const points = meta.data || []; + const labels = meta.iScale.getLabels(); + line.points = points; + if (mode !== 'resize') { + const options = this.resolveDatasetElementOptions(mode); + if (!this.options.showLine) { + options.borderWidth = 0; + } + const properties = { + _loop: true, + _fullLoop: labels.length === points.length, + options + }; + this.updateElement(line, undefined, properties, mode); + } + this.updateElements(points, 0, points.length, mode); + } + updateElements(points, start, count, mode) { + const dataset = this.getDataset(); + const scale = this._cachedMeta.rScale; + const reset = mode === 'reset'; + for (let i = start; i < start + count; i++) { + const point = points[i]; + const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode); + const pointPosition = scale.getPointPositionForValue(i, dataset.data[i]); + const x = reset ? scale.xCenter : pointPosition.x; + const y = reset ? scale.yCenter : pointPosition.y; + const properties = { + x, + y, + angle: pointPosition.angle, + skip: isNaN(x) || isNaN(y), + options + }; + this.updateElement(point, i, properties, mode); + } + } +} +RadarController.id = 'radar'; +RadarController.defaults = { + datasetElementType: 'line', + dataElementType: 'point', + indexAxis: 'r', + showLine: true, + elements: { + line: { + fill: 'start' + } + }, +}; +RadarController.overrides = { + aspectRatio: 1, + scales: { + r: { + type: 'radialLinear', + } + } +}; + +class ScatterController extends LineController { +} +ScatterController.id = 'scatter'; +ScatterController.defaults = { + showLine: false, + fill: false +}; +ScatterController.overrides = { + interaction: { + mode: 'point' + }, + plugins: { + tooltip: { + callbacks: { + title() { + return ''; + }, + label(item) { + return '(' + item.label + ', ' + item.formattedValue + ')'; + } + } + } + }, + scales: { + x: { + type: 'linear' + }, + y: { + type: 'linear' + } + } +}; + +var controllers = /*#__PURE__*/Object.freeze({ +__proto__: null, +BarController: BarController, +BubbleController: BubbleController, +DoughnutController: DoughnutController, +LineController: LineController, +PolarAreaController: PolarAreaController, +PieController: PieController, +RadarController: RadarController, +ScatterController: ScatterController +}); + +function clipArc(ctx, element, endAngle) { + const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element; + let angleMargin = pixelMargin / outerRadius; + ctx.beginPath(); + ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin); + if (innerRadius > pixelMargin) { + angleMargin = pixelMargin / innerRadius; + ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true); + } else { + ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI); + } + ctx.closePath(); + ctx.clip(); +} +function toRadiusCorners(value) { + return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']); +} +function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) { + const o = toRadiusCorners(arc.options.borderRadius); + const halfThickness = (outerRadius - innerRadius) / 2; + const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2); + const computeOuterLimit = (val) => { + const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2; + return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit)); + }; + return { + outerStart: computeOuterLimit(o.outerStart), + outerEnd: computeOuterLimit(o.outerEnd), + innerStart: _limitValue(o.innerStart, 0, innerLimit), + innerEnd: _limitValue(o.innerEnd, 0, innerLimit), + }; +} +function rThetaToXY(r, theta, x, y) { + return { + x: x + r * Math.cos(theta), + y: y + r * Math.sin(theta), + }; +} +function pathArc(ctx, element, offset, spacing, end) { + const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element; + const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0); + const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0; + let spacingOffset = 0; + const alpha = end - start; + if (spacing) { + const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0; + const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0; + const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2; + const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha; + spacingOffset = (alpha - adjustedAngle) / 2; + } + const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius; + const angleOffset = (alpha - beta) / 2; + const startAngle = start + angleOffset + spacingOffset; + const endAngle = end - angleOffset - spacingOffset; + const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle); + const outerStartAdjustedRadius = outerRadius - outerStart; + const outerEndAdjustedRadius = outerRadius - outerEnd; + const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius; + const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius; + const innerStartAdjustedRadius = innerRadius + innerStart; + const innerEndAdjustedRadius = innerRadius + innerEnd; + const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius; + const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius; + ctx.beginPath(); + ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerEndAdjustedAngle); + if (outerEnd > 0) { + const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI); + } + const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y); + ctx.lineTo(p4.x, p4.y); + if (innerEnd > 0) { + const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI); + } + ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), startAngle + (innerStart / innerRadius), true); + if (innerStart > 0) { + const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI); + } + const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y); + ctx.lineTo(p8.x, p8.y); + if (outerStart > 0) { + const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle); + } + ctx.closePath(); +} +function drawArc(ctx, element, offset, spacing) { + const {fullCircles, startAngle, circumference} = element; + let endAngle = element.endAngle; + if (fullCircles) { + pathArc(ctx, element, offset, spacing, startAngle + TAU); + for (let i = 0; i < fullCircles; ++i) { + ctx.fill(); + } + if (!isNaN(circumference)) { + endAngle = startAngle + circumference % TAU; + if (circumference % TAU === 0) { + endAngle += TAU; + } + } + } + pathArc(ctx, element, offset, spacing, endAngle); + ctx.fill(); + return endAngle; +} +function drawFullCircleBorders(ctx, element, inner) { + const {x, y, startAngle, pixelMargin, fullCircles} = element; + const outerRadius = Math.max(element.outerRadius - pixelMargin, 0); + const innerRadius = element.innerRadius + pixelMargin; + let i; + if (inner) { + clipArc(ctx, element, startAngle + TAU); + } + ctx.beginPath(); + ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true); + for (i = 0; i < fullCircles; ++i) { + ctx.stroke(); + } + ctx.beginPath(); + ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU); + for (i = 0; i < fullCircles; ++i) { + ctx.stroke(); + } +} +function drawBorder(ctx, element, offset, spacing, endAngle) { + const {options} = element; + const {borderWidth, borderJoinStyle} = options; + const inner = options.borderAlign === 'inner'; + if (!borderWidth) { + return; + } + if (inner) { + ctx.lineWidth = borderWidth * 2; + ctx.lineJoin = borderJoinStyle || 'round'; + } else { + ctx.lineWidth = borderWidth; + ctx.lineJoin = borderJoinStyle || 'bevel'; + } + if (element.fullCircles) { + drawFullCircleBorders(ctx, element, inner); + } + if (inner) { + clipArc(ctx, element, endAngle); + } + pathArc(ctx, element, offset, spacing, endAngle); + ctx.stroke(); +} +class ArcElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.circumference = undefined; + this.startAngle = undefined; + this.endAngle = undefined; + this.innerRadius = undefined; + this.outerRadius = undefined; + this.pixelMargin = 0; + this.fullCircles = 0; + if (cfg) { + Object.assign(this, cfg); + } + } + inRange(chartX, chartY, useFinalPosition) { + const point = this.getProps(['x', 'y'], useFinalPosition); + const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY}); + const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([ + 'startAngle', + 'endAngle', + 'innerRadius', + 'outerRadius', + 'circumference' + ], useFinalPosition); + const rAdjust = this.options.spacing / 2; + const _circumference = valueOrDefault(circumference, endAngle - startAngle); + const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle); + const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust); + return (betweenAngles && withinRadius); + } + getCenterPoint(useFinalPosition) { + const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([ + 'x', + 'y', + 'startAngle', + 'endAngle', + 'innerRadius', + 'outerRadius', + 'circumference', + ], useFinalPosition); + const {offset, spacing} = this.options; + const halfAngle = (startAngle + endAngle) / 2; + const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2; + return { + x: x + Math.cos(halfAngle) * halfRadius, + y: y + Math.sin(halfAngle) * halfRadius + }; + } + tooltipPosition(useFinalPosition) { + return this.getCenterPoint(useFinalPosition); + } + draw(ctx) { + const {options, circumference} = this; + const offset = (options.offset || 0) / 2; + const spacing = (options.spacing || 0) / 2; + this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0; + this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0; + if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) { + return; + } + ctx.save(); + let radiusOffset = 0; + if (offset) { + radiusOffset = offset / 2; + const halfAngle = (this.startAngle + this.endAngle) / 2; + ctx.translate(Math.cos(halfAngle) * radiusOffset, Math.sin(halfAngle) * radiusOffset); + if (this.circumference >= PI) { + radiusOffset = offset; + } + } + ctx.fillStyle = options.backgroundColor; + ctx.strokeStyle = options.borderColor; + const endAngle = drawArc(ctx, this, radiusOffset, spacing); + drawBorder(ctx, this, radiusOffset, spacing, endAngle); + ctx.restore(); + } +} +ArcElement.id = 'arc'; +ArcElement.defaults = { + borderAlign: 'center', + borderColor: '#fff', + borderJoinStyle: undefined, + borderRadius: 0, + borderWidth: 2, + offset: 0, + spacing: 0, + angle: undefined, +}; +ArcElement.defaultRoutes = { + backgroundColor: 'backgroundColor' +}; + +function setStyle(ctx, options, style = options) { + ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle); + ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash)); + ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset); + ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle); + ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth); + ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor); +} +function lineTo(ctx, previous, target) { + ctx.lineTo(target.x, target.y); +} +function getLineMethod(options) { + if (options.stepped) { + return _steppedLineTo; + } + if (options.tension || options.cubicInterpolationMode === 'monotone') { + return _bezierCurveTo; + } + return lineTo; +} +function pathVars(points, segment, params = {}) { + const count = points.length; + const {start: paramsStart = 0, end: paramsEnd = count - 1} = params; + const {start: segmentStart, end: segmentEnd} = segment; + const start = Math.max(paramsStart, segmentStart); + const end = Math.min(paramsEnd, segmentEnd); + const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd; + return { + count, + start, + loop: segment.loop, + ilen: end < start && !outside ? count + end - start : end - start + }; +} +function pathSegment(ctx, line, segment, params) { + const {points, options} = line; + const {count, start, loop, ilen} = pathVars(points, segment, params); + const lineMethod = getLineMethod(options); + let {move = true, reverse} = params || {}; + let i, point, prev; + for (i = 0; i <= ilen; ++i) { + point = points[(start + (reverse ? ilen - i : i)) % count]; + if (point.skip) { + continue; + } else if (move) { + ctx.moveTo(point.x, point.y); + move = false; + } else { + lineMethod(ctx, prev, point, reverse, options.stepped); + } + prev = point; + } + if (loop) { + point = points[(start + (reverse ? ilen : 0)) % count]; + lineMethod(ctx, prev, point, reverse, options.stepped); + } + return !!loop; +} +function fastPathSegment(ctx, line, segment, params) { + const points = line.points; + const {count, start, ilen} = pathVars(points, segment, params); + const {move = true, reverse} = params || {}; + let avgX = 0; + let countX = 0; + let i, point, prevX, minY, maxY, lastY; + const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count; + const drawX = () => { + if (minY !== maxY) { + ctx.lineTo(avgX, maxY); + ctx.lineTo(avgX, minY); + ctx.lineTo(avgX, lastY); + } + }; + if (move) { + point = points[pointIndex(0)]; + ctx.moveTo(point.x, point.y); + } + for (i = 0; i <= ilen; ++i) { + point = points[pointIndex(i)]; + if (point.skip) { + continue; + } + const x = point.x; + const y = point.y; + const truncX = x | 0; + if (truncX === prevX) { + if (y < minY) { + minY = y; + } else if (y > maxY) { + maxY = y; + } + avgX = (countX * avgX + x) / ++countX; + } else { + drawX(); + ctx.lineTo(x, y); + prevX = truncX; + countX = 0; + minY = maxY = y; + } + lastY = y; + } + drawX(); +} +function _getSegmentMethod(line) { + const opts = line.options; + const borderDash = opts.borderDash && opts.borderDash.length; + const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash; + return useFastPath ? fastPathSegment : pathSegment; +} +function _getInterpolationMethod(options) { + if (options.stepped) { + return _steppedInterpolation; + } + if (options.tension || options.cubicInterpolationMode === 'monotone') { + return _bezierInterpolation; + } + return _pointInLine; +} +function strokePathWithCache(ctx, line, start, count) { + let path = line._path; + if (!path) { + path = line._path = new Path2D(); + if (line.path(path, start, count)) { + path.closePath(); + } + } + setStyle(ctx, line.options); + ctx.stroke(path); +} +function strokePathDirect(ctx, line, start, count) { + const {segments, options} = line; + const segmentMethod = _getSegmentMethod(line); + for (const segment of segments) { + setStyle(ctx, options, segment.style); + ctx.beginPath(); + if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) { + ctx.closePath(); + } + ctx.stroke(); + } +} +const usePath2D = typeof Path2D === 'function'; +function draw(ctx, line, start, count) { + if (usePath2D && !line.options.segment) { + strokePathWithCache(ctx, line, start, count); + } else { + strokePathDirect(ctx, line, start, count); + } +} +class LineElement extends Element { + constructor(cfg) { + super(); + this.animated = true; + this.options = undefined; + this._chart = undefined; + this._loop = undefined; + this._fullLoop = undefined; + this._path = undefined; + this._points = undefined; + this._segments = undefined; + this._decimated = false; + this._pointsUpdated = false; + this._datasetIndex = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + updateControlPoints(chartArea, indexAxis) { + const options = this.options; + if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) { + const loop = options.spanGaps ? this._loop : this._fullLoop; + _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis); + this._pointsUpdated = true; + } + } + set points(points) { + this._points = points; + delete this._segments; + delete this._path; + this._pointsUpdated = false; + } + get points() { + return this._points; + } + get segments() { + return this._segments || (this._segments = _computeSegments(this, this.options.segment)); + } + first() { + const segments = this.segments; + const points = this.points; + return segments.length && points[segments[0].start]; + } + last() { + const segments = this.segments; + const points = this.points; + const count = segments.length; + return count && points[segments[count - 1].end]; + } + interpolate(point, property) { + const options = this.options; + const value = point[property]; + const points = this.points; + const segments = _boundSegments(this, {property, start: value, end: value}); + if (!segments.length) { + return; + } + const result = []; + const _interpolate = _getInterpolationMethod(options); + let i, ilen; + for (i = 0, ilen = segments.length; i < ilen; ++i) { + const {start, end} = segments[i]; + const p1 = points[start]; + const p2 = points[end]; + if (p1 === p2) { + result.push(p1); + continue; + } + const t = Math.abs((value - p1[property]) / (p2[property] - p1[property])); + const interpolated = _interpolate(p1, p2, t, options.stepped); + interpolated[property] = point[property]; + result.push(interpolated); + } + return result.length === 1 ? result[0] : result; + } + pathSegment(ctx, segment, params) { + const segmentMethod = _getSegmentMethod(this); + return segmentMethod(ctx, this, segment, params); + } + path(ctx, start, count) { + const segments = this.segments; + const segmentMethod = _getSegmentMethod(this); + let loop = this._loop; + start = start || 0; + count = count || (this.points.length - start); + for (const segment of segments) { + loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1}); + } + return !!loop; + } + draw(ctx, chartArea, start, count) { + const options = this.options || {}; + const points = this.points || []; + if (points.length && options.borderWidth) { + ctx.save(); + draw(ctx, this, start, count); + ctx.restore(); + } + if (this.animated) { + this._pointsUpdated = false; + this._path = undefined; + } + } +} +LineElement.id = 'line'; +LineElement.defaults = { + borderCapStyle: 'butt', + borderDash: [], + borderDashOffset: 0, + borderJoinStyle: 'miter', + borderWidth: 3, + capBezierPoints: true, + cubicInterpolationMode: 'default', + fill: false, + spanGaps: false, + stepped: false, + tension: 0, +}; +LineElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; +LineElement.descriptors = { + _scriptable: true, + _indexable: (name) => name !== 'borderDash' && name !== 'fill', +}; + +function inRange$1(el, pos, axis, useFinalPosition) { + const options = el.options; + const {[axis]: value} = el.getProps([axis], useFinalPosition); + return (Math.abs(pos - value) < options.radius + options.hitRadius); +} +class PointElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.parsed = undefined; + this.skip = undefined; + this.stop = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + inRange(mouseX, mouseY, useFinalPosition) { + const options = this.options; + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2)); + } + inXRange(mouseX, useFinalPosition) { + return inRange$1(this, mouseX, 'x', useFinalPosition); + } + inYRange(mouseY, useFinalPosition) { + return inRange$1(this, mouseY, 'y', useFinalPosition); + } + getCenterPoint(useFinalPosition) { + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return {x, y}; + } + size(options) { + options = options || this.options || {}; + let radius = options.radius || 0; + radius = Math.max(radius, radius && options.hoverRadius || 0); + const borderWidth = radius && options.borderWidth || 0; + return (radius + borderWidth) * 2; + } + draw(ctx, area) { + const options = this.options; + if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) { + return; + } + ctx.strokeStyle = options.borderColor; + ctx.lineWidth = options.borderWidth; + ctx.fillStyle = options.backgroundColor; + drawPoint(ctx, options, this.x, this.y); + } + getRange() { + const options = this.options || {}; + return options.radius + options.hitRadius; + } +} +PointElement.id = 'point'; +PointElement.defaults = { + borderWidth: 1, + hitRadius: 1, + hoverBorderWidth: 1, + hoverRadius: 4, + pointStyle: 'circle', + radius: 3, + rotation: 0 +}; +PointElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; + +function getBarBounds(bar, useFinalPosition) { + const {x, y, base, width, height} = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition); + let left, right, top, bottom, half; + if (bar.horizontal) { + half = height / 2; + left = Math.min(x, base); + right = Math.max(x, base); + top = y - half; + bottom = y + half; + } else { + half = width / 2; + left = x - half; + right = x + half; + top = Math.min(y, base); + bottom = Math.max(y, base); + } + return {left, top, right, bottom}; +} +function skipOrLimit(skip, value, min, max) { + return skip ? 0 : _limitValue(value, min, max); +} +function parseBorderWidth(bar, maxW, maxH) { + const value = bar.options.borderWidth; + const skip = bar.borderSkipped; + const o = toTRBL(value); + return { + t: skipOrLimit(skip.top, o.top, 0, maxH), + r: skipOrLimit(skip.right, o.right, 0, maxW), + b: skipOrLimit(skip.bottom, o.bottom, 0, maxH), + l: skipOrLimit(skip.left, o.left, 0, maxW) + }; +} +function parseBorderRadius(bar, maxW, maxH) { + const {enableBorderRadius} = bar.getProps(['enableBorderRadius']); + const value = bar.options.borderRadius; + const o = toTRBLCorners(value); + const maxR = Math.min(maxW, maxH); + const skip = bar.borderSkipped; + const enableBorder = enableBorderRadius || isObject(value); + return { + topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR), + topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR), + bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR), + bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR) + }; +} +function boundingRects(bar) { + const bounds = getBarBounds(bar); + const width = bounds.right - bounds.left; + const height = bounds.bottom - bounds.top; + const border = parseBorderWidth(bar, width / 2, height / 2); + const radius = parseBorderRadius(bar, width / 2, height / 2); + return { + outer: { + x: bounds.left, + y: bounds.top, + w: width, + h: height, + radius + }, + inner: { + x: bounds.left + border.l, + y: bounds.top + border.t, + w: width - border.l - border.r, + h: height - border.t - border.b, + radius: { + topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)), + topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)), + bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)), + bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)), + } + } + }; +} +function inRange(bar, x, y, useFinalPosition) { + const skipX = x === null; + const skipY = y === null; + const skipBoth = skipX && skipY; + const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition); + return bounds + && (skipX || _isBetween(x, bounds.left, bounds.right)) + && (skipY || _isBetween(y, bounds.top, bounds.bottom)); +} +function hasRadius(radius) { + return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight; +} +function addNormalRectPath(ctx, rect) { + ctx.rect(rect.x, rect.y, rect.w, rect.h); +} +function inflateRect(rect, amount, refRect = {}) { + const x = rect.x !== refRect.x ? -amount : 0; + const y = rect.y !== refRect.y ? -amount : 0; + const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x; + const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y; + return { + x: rect.x + x, + y: rect.y + y, + w: rect.w + w, + h: rect.h + h, + radius: rect.radius + }; +} +class BarElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.horizontal = undefined; + this.base = undefined; + this.width = undefined; + this.height = undefined; + this.inflateAmount = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + draw(ctx) { + const {inflateAmount, options: {borderColor, backgroundColor}} = this; + const {inner, outer} = boundingRects(this); + const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath; + ctx.save(); + if (outer.w !== inner.w || outer.h !== inner.h) { + ctx.beginPath(); + addRectPath(ctx, inflateRect(outer, inflateAmount, inner)); + ctx.clip(); + addRectPath(ctx, inflateRect(inner, -inflateAmount, outer)); + ctx.fillStyle = borderColor; + ctx.fill('evenodd'); + } + ctx.beginPath(); + addRectPath(ctx, inflateRect(inner, inflateAmount)); + ctx.fillStyle = backgroundColor; + ctx.fill(); + ctx.restore(); + } + inRange(mouseX, mouseY, useFinalPosition) { + return inRange(this, mouseX, mouseY, useFinalPosition); + } + inXRange(mouseX, useFinalPosition) { + return inRange(this, mouseX, null, useFinalPosition); + } + inYRange(mouseY, useFinalPosition) { + return inRange(this, null, mouseY, useFinalPosition); + } + getCenterPoint(useFinalPosition) { + const {x, y, base, horizontal} = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition); + return { + x: horizontal ? (x + base) / 2 : x, + y: horizontal ? y : (y + base) / 2 + }; + } + getRange(axis) { + return axis === 'x' ? this.width / 2 : this.height / 2; + } +} +BarElement.id = 'bar'; +BarElement.defaults = { + borderSkipped: 'start', + borderWidth: 0, + borderRadius: 0, + inflateAmount: 'auto', + pointStyle: undefined +}; +BarElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; + +var elements = /*#__PURE__*/Object.freeze({ +__proto__: null, +ArcElement: ArcElement, +LineElement: LineElement, +PointElement: PointElement, +BarElement: BarElement +}); + +function lttbDecimation(data, start, count, availableWidth, options) { + const samples = options.samples || availableWidth; + if (samples >= count) { + return data.slice(start, start + count); + } + const decimated = []; + const bucketWidth = (count - 2) / (samples - 2); + let sampledIndex = 0; + const endIndex = start + count - 1; + let a = start; + let i, maxAreaPoint, maxArea, area, nextA; + decimated[sampledIndex++] = data[a]; + for (i = 0; i < samples - 2; i++) { + let avgX = 0; + let avgY = 0; + let j; + const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start; + const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start; + const avgRangeLength = avgRangeEnd - avgRangeStart; + for (j = avgRangeStart; j < avgRangeEnd; j++) { + avgX += data[j].x; + avgY += data[j].y; + } + avgX /= avgRangeLength; + avgY /= avgRangeLength; + const rangeOffs = Math.floor(i * bucketWidth) + 1 + start; + const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start; + const {x: pointAx, y: pointAy} = data[a]; + maxArea = area = -1; + for (j = rangeOffs; j < rangeTo; j++) { + area = 0.5 * Math.abs( + (pointAx - avgX) * (data[j].y - pointAy) - + (pointAx - data[j].x) * (avgY - pointAy) + ); + if (area > maxArea) { + maxArea = area; + maxAreaPoint = data[j]; + nextA = j; + } + } + decimated[sampledIndex++] = maxAreaPoint; + a = nextA; + } + decimated[sampledIndex++] = data[endIndex]; + return decimated; +} +function minMaxDecimation(data, start, count, availableWidth) { + let avgX = 0; + let countX = 0; + let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY; + const decimated = []; + const endIndex = start + count - 1; + const xMin = data[start].x; + const xMax = data[endIndex].x; + const dx = xMax - xMin; + for (i = start; i < start + count; ++i) { + point = data[i]; + x = (point.x - xMin) / dx * availableWidth; + y = point.y; + const truncX = x | 0; + if (truncX === prevX) { + if (y < minY) { + minY = y; + minIndex = i; + } else if (y > maxY) { + maxY = y; + maxIndex = i; + } + avgX = (countX * avgX + point.x) / ++countX; + } else { + const lastIndex = i - 1; + if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) { + const intermediateIndex1 = Math.min(minIndex, maxIndex); + const intermediateIndex2 = Math.max(minIndex, maxIndex); + if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) { + decimated.push({ + ...data[intermediateIndex1], + x: avgX, + }); + } + if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) { + decimated.push({ + ...data[intermediateIndex2], + x: avgX + }); + } + } + if (i > 0 && lastIndex !== startIndex) { + decimated.push(data[lastIndex]); + } + decimated.push(point); + prevX = truncX; + countX = 0; + minY = maxY = y; + minIndex = maxIndex = startIndex = i; + } + } + return decimated; +} +function cleanDecimatedDataset(dataset) { + if (dataset._decimated) { + const data = dataset._data; + delete dataset._decimated; + delete dataset._data; + Object.defineProperty(dataset, 'data', {value: data}); + } +} +function cleanDecimatedData(chart) { + chart.data.datasets.forEach((dataset) => { + cleanDecimatedDataset(dataset); + }); +} +function getStartAndCountOfVisiblePointsSimplified(meta, points) { + const pointCount = points.length; + let start = 0; + let count; + const {iScale} = meta; + const {min, max, minDefined, maxDefined} = iScale.getUserBounds(); + if (minDefined) { + start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1); + } + if (maxDefined) { + count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start; + } else { + count = pointCount - start; + } + return {start, count}; +} +var plugin_decimation = { + id: 'decimation', + defaults: { + algorithm: 'min-max', + enabled: false, + }, + beforeElementsUpdate: (chart, args, options) => { + if (!options.enabled) { + cleanDecimatedData(chart); + return; + } + const availableWidth = chart.width; + chart.data.datasets.forEach((dataset, datasetIndex) => { + const {_data, indexAxis} = dataset; + const meta = chart.getDatasetMeta(datasetIndex); + const data = _data || dataset.data; + if (resolve([indexAxis, chart.options.indexAxis]) === 'y') { + return; + } + if (meta.type !== 'line') { + return; + } + const xAxis = chart.scales[meta.xAxisID]; + if (xAxis.type !== 'linear' && xAxis.type !== 'time') { + return; + } + if (chart.options.parsing) { + return; + } + let {start, count} = getStartAndCountOfVisiblePointsSimplified(meta, data); + const threshold = options.threshold || 4 * availableWidth; + if (count <= threshold) { + cleanDecimatedDataset(dataset); + return; + } + if (isNullOrUndef(_data)) { + dataset._data = data; + delete dataset.data; + Object.defineProperty(dataset, 'data', { + configurable: true, + enumerable: true, + get: function() { + return this._decimated; + }, + set: function(d) { + this._data = d; + } + }); + } + let decimated; + switch (options.algorithm) { + case 'lttb': + decimated = lttbDecimation(data, start, count, availableWidth, options); + break; + case 'min-max': + decimated = minMaxDecimation(data, start, count, availableWidth); + break; + default: + throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`); + } + dataset._decimated = decimated; + }); + }, + destroy(chart) { + cleanDecimatedData(chart); + } +}; + +function getLineByIndex(chart, index) { + const meta = chart.getDatasetMeta(index); + const visible = meta && chart.isDatasetVisible(index); + return visible ? meta.dataset : null; +} +function parseFillOption(line) { + const options = line.options; + const fillOption = options.fill; + let fill = valueOrDefault(fillOption && fillOption.target, fillOption); + if (fill === undefined) { + fill = !!options.backgroundColor; + } + if (fill === false || fill === null) { + return false; + } + if (fill === true) { + return 'origin'; + } + return fill; +} +function decodeFill(line, index, count) { + const fill = parseFillOption(line); + if (isObject(fill)) { + return isNaN(fill.value) ? false : fill; + } + let target = parseFloat(fill); + if (isNumberFinite(target) && Math.floor(target) === target) { + if (fill[0] === '-' || fill[0] === '+') { + target = index + target; + } + if (target === index || target < 0 || target >= count) { + return false; + } + return target; + } + return ['origin', 'start', 'end', 'stack', 'shape'].indexOf(fill) >= 0 && fill; +} +function computeLinearBoundary(source) { + const {scale = {}, fill} = source; + let target = null; + let horizontal; + if (fill === 'start') { + target = scale.bottom; + } else if (fill === 'end') { + target = scale.top; + } else if (isObject(fill)) { + target = scale.getPixelForValue(fill.value); + } else if (scale.getBasePixel) { + target = scale.getBasePixel(); + } + if (isNumberFinite(target)) { + horizontal = scale.isHorizontal(); + return { + x: horizontal ? target : null, + y: horizontal ? null : target + }; + } + return null; +} +class simpleArc { + constructor(opts) { + this.x = opts.x; + this.y = opts.y; + this.radius = opts.radius; + } + pathSegment(ctx, bounds, opts) { + const {x, y, radius} = this; + bounds = bounds || {start: 0, end: TAU}; + ctx.arc(x, y, radius, bounds.end, bounds.start, true); + return !opts.bounds; + } + interpolate(point) { + const {x, y, radius} = this; + const angle = point.angle; + return { + x: x + Math.cos(angle) * radius, + y: y + Math.sin(angle) * radius, + angle + }; + } +} +function computeCircularBoundary(source) { + const {scale, fill} = source; + const options = scale.options; + const length = scale.getLabels().length; + const target = []; + const start = options.reverse ? scale.max : scale.min; + const end = options.reverse ? scale.min : scale.max; + let i, center, value; + if (fill === 'start') { + value = start; + } else if (fill === 'end') { + value = end; + } else if (isObject(fill)) { + value = fill.value; + } else { + value = scale.getBaseValue(); + } + if (options.grid.circular) { + center = scale.getPointPositionForValue(0, start); + return new simpleArc({ + x: center.x, + y: center.y, + radius: scale.getDistanceFromCenterForValue(value) + }); + } + for (i = 0; i < length; ++i) { + target.push(scale.getPointPositionForValue(i, value)); + } + return target; +} +function computeBoundary(source) { + const scale = source.scale || {}; + if (scale.getPointPositionForValue) { + return computeCircularBoundary(source); + } + return computeLinearBoundary(source); +} +function findSegmentEnd(start, end, points) { + for (;end > start; end--) { + const point = points[end]; + if (!isNaN(point.x) && !isNaN(point.y)) { + break; + } + } + return end; +} +function pointsFromSegments(boundary, line) { + const {x = null, y = null} = boundary || {}; + const linePoints = line.points; + const points = []; + line.segments.forEach(({start, end}) => { + end = findSegmentEnd(start, end, linePoints); + const first = linePoints[start]; + const last = linePoints[end]; + if (y !== null) { + points.push({x: first.x, y}); + points.push({x: last.x, y}); + } else if (x !== null) { + points.push({x, y: first.y}); + points.push({x, y: last.y}); + } + }); + return points; +} +function buildStackLine(source) { + const {scale, index, line} = source; + const points = []; + const segments = line.segments; + const sourcePoints = line.points; + const linesBelow = getLinesBelow(scale, index); + linesBelow.push(createBoundaryLine({x: null, y: scale.bottom}, line)); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + for (let j = segment.start; j <= segment.end; j++) { + addPointsBelow(points, sourcePoints[j], linesBelow); + } + } + return new LineElement({points, options: {}}); +} +function getLinesBelow(scale, index) { + const below = []; + const metas = scale.getMatchingVisibleMetas('line'); + for (let i = 0; i < metas.length; i++) { + const meta = metas[i]; + if (meta.index === index) { + break; + } + if (!meta.hidden) { + below.unshift(meta.dataset); + } + } + return below; +} +function addPointsBelow(points, sourcePoint, linesBelow) { + const postponed = []; + for (let j = 0; j < linesBelow.length; j++) { + const line = linesBelow[j]; + const {first, last, point} = findPoint(line, sourcePoint, 'x'); + if (!point || (first && last)) { + continue; + } + if (first) { + postponed.unshift(point); + } else { + points.push(point); + if (!last) { + break; + } + } + } + points.push(...postponed); +} +function findPoint(line, sourcePoint, property) { + const point = line.interpolate(sourcePoint, property); + if (!point) { + return {}; + } + const pointValue = point[property]; + const segments = line.segments; + const linePoints = line.points; + let first = false; + let last = false; + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + const firstValue = linePoints[segment.start][property]; + const lastValue = linePoints[segment.end][property]; + if (_isBetween(pointValue, firstValue, lastValue)) { + first = pointValue === firstValue; + last = pointValue === lastValue; + break; + } + } + return {first, last, point}; +} +function getTarget(source) { + const {chart, fill, line} = source; + if (isNumberFinite(fill)) { + return getLineByIndex(chart, fill); + } + if (fill === 'stack') { + return buildStackLine(source); + } + if (fill === 'shape') { + return true; + } + const boundary = computeBoundary(source); + if (boundary instanceof simpleArc) { + return boundary; + } + return createBoundaryLine(boundary, line); +} +function createBoundaryLine(boundary, line) { + let points = []; + let _loop = false; + if (isArray(boundary)) { + _loop = true; + points = boundary; + } else { + points = pointsFromSegments(boundary, line); + } + return points.length ? new LineElement({ + points, + options: {tension: 0}, + _loop, + _fullLoop: _loop + }) : null; +} +function resolveTarget(sources, index, propagate) { + const source = sources[index]; + let fill = source.fill; + const visited = [index]; + let target; + if (!propagate) { + return fill; + } + while (fill !== false && visited.indexOf(fill) === -1) { + if (!isNumberFinite(fill)) { + return fill; + } + target = sources[fill]; + if (!target) { + return false; + } + if (target.visible) { + return fill; + } + visited.push(fill); + fill = target.fill; + } + return false; +} +function _clip(ctx, target, clipY) { + const {segments, points} = target; + let first = true; + let lineLoop = false; + ctx.beginPath(); + for (const segment of segments) { + const {start, end} = segment; + const firstPoint = points[start]; + const lastPoint = points[findSegmentEnd(start, end, points)]; + if (first) { + ctx.moveTo(firstPoint.x, firstPoint.y); + first = false; + } else { + ctx.lineTo(firstPoint.x, clipY); + ctx.lineTo(firstPoint.x, firstPoint.y); + } + lineLoop = !!target.pathSegment(ctx, segment, {move: lineLoop}); + if (lineLoop) { + ctx.closePath(); + } else { + ctx.lineTo(lastPoint.x, clipY); + } + } + ctx.lineTo(target.first().x, clipY); + ctx.closePath(); + ctx.clip(); +} +function getBounds(property, first, last, loop) { + if (loop) { + return; + } + let start = first[property]; + let end = last[property]; + if (property === 'angle') { + start = _normalizeAngle(start); + end = _normalizeAngle(end); + } + return {property, start, end}; +} +function _getEdge(a, b, prop, fn) { + if (a && b) { + return fn(a[prop], b[prop]); + } + return a ? a[prop] : b ? b[prop] : 0; +} +function _segments(line, target, property) { + const segments = line.segments; + const points = line.points; + const tpoints = target.points; + const parts = []; + for (const segment of segments) { + let {start, end} = segment; + end = findSegmentEnd(start, end, points); + const bounds = getBounds(property, points[start], points[end], segment.loop); + if (!target.segments) { + parts.push({ + source: segment, + target: bounds, + start: points[start], + end: points[end] + }); + continue; + } + const targetSegments = _boundSegments(target, bounds); + for (const tgt of targetSegments) { + const subBounds = getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop); + const fillSources = _boundSegment(segment, points, subBounds); + for (const fillSource of fillSources) { + parts.push({ + source: fillSource, + target: tgt, + start: { + [property]: _getEdge(bounds, subBounds, 'start', Math.max) + }, + end: { + [property]: _getEdge(bounds, subBounds, 'end', Math.min) + } + }); + } + } + } + return parts; +} +function clipBounds(ctx, scale, bounds) { + const {top, bottom} = scale.chart.chartArea; + const {property, start, end} = bounds || {}; + if (property === 'x') { + ctx.beginPath(); + ctx.rect(start, top, end - start, bottom - top); + ctx.clip(); + } +} +function interpolatedLineTo(ctx, target, point, property) { + const interpolatedPoint = target.interpolate(point, property); + if (interpolatedPoint) { + ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y); + } +} +function _fill(ctx, cfg) { + const {line, target, property, color, scale} = cfg; + const segments = _segments(line, target, property); + for (const {source: src, target: tgt, start, end} of segments) { + const {style: {backgroundColor = color} = {}} = src; + const notShape = target !== true; + ctx.save(); + ctx.fillStyle = backgroundColor; + clipBounds(ctx, scale, notShape && getBounds(property, start, end)); + ctx.beginPath(); + const lineLoop = !!line.pathSegment(ctx, src); + let loop; + if (notShape) { + if (lineLoop) { + ctx.closePath(); + } else { + interpolatedLineTo(ctx, target, end, property); + } + const targetLoop = !!target.pathSegment(ctx, tgt, {move: lineLoop, reverse: true}); + loop = lineLoop && targetLoop; + if (!loop) { + interpolatedLineTo(ctx, target, start, property); + } + } + ctx.closePath(); + ctx.fill(loop ? 'evenodd' : 'nonzero'); + ctx.restore(); + } +} +function doFill(ctx, cfg) { + const {line, target, above, below, area, scale} = cfg; + const property = line._loop ? 'angle' : cfg.axis; + ctx.save(); + if (property === 'x' && below !== above) { + _clip(ctx, target, area.top); + _fill(ctx, {line, target, color: above, scale, property}); + ctx.restore(); + ctx.save(); + _clip(ctx, target, area.bottom); + } + _fill(ctx, {line, target, color: below, scale, property}); + ctx.restore(); +} +function drawfill(ctx, source, area) { + const target = getTarget(source); + const {line, scale, axis} = source; + const lineOpts = line.options; + const fillOption = lineOpts.fill; + const color = lineOpts.backgroundColor; + const {above = color, below = color} = fillOption || {}; + if (target && line.points.length) { + clipArea(ctx, area); + doFill(ctx, {line, target, above, below, area, scale, axis}); + unclipArea(ctx); + } +} +var plugin_filler = { + id: 'filler', + afterDatasetsUpdate(chart, _args, options) { + const count = (chart.data.datasets || []).length; + const sources = []; + let meta, i, line, source; + for (i = 0; i < count; ++i) { + meta = chart.getDatasetMeta(i); + line = meta.dataset; + source = null; + if (line && line.options && line instanceof LineElement) { + source = { + visible: chart.isDatasetVisible(i), + index: i, + fill: decodeFill(line, i, count), + chart, + axis: meta.controller.options.indexAxis, + scale: meta.vScale, + line, + }; + } + meta.$filler = source; + sources.push(source); + } + for (i = 0; i < count; ++i) { + source = sources[i]; + if (!source || source.fill === false) { + continue; + } + source.fill = resolveTarget(sources, i, options.propagate); + } + }, + beforeDraw(chart, _args, options) { + const draw = options.drawTime === 'beforeDraw'; + const metasets = chart.getSortedVisibleDatasetMetas(); + const area = chart.chartArea; + for (let i = metasets.length - 1; i >= 0; --i) { + const source = metasets[i].$filler; + if (!source) { + continue; + } + source.line.updateControlPoints(area, source.axis); + if (draw) { + drawfill(chart.ctx, source, area); + } + } + }, + beforeDatasetsDraw(chart, _args, options) { + if (options.drawTime !== 'beforeDatasetsDraw') { + return; + } + const metasets = chart.getSortedVisibleDatasetMetas(); + for (let i = metasets.length - 1; i >= 0; --i) { + const source = metasets[i].$filler; + if (source) { + drawfill(chart.ctx, source, chart.chartArea); + } + } + }, + beforeDatasetDraw(chart, args, options) { + const source = args.meta.$filler; + if (!source || source.fill === false || options.drawTime !== 'beforeDatasetDraw') { + return; + } + drawfill(chart.ctx, source, chart.chartArea); + }, + defaults: { + propagate: true, + drawTime: 'beforeDatasetDraw' + } +}; + +const getBoxSize = (labelOpts, fontSize) => { + let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts; + if (labelOpts.usePointStyle) { + boxHeight = Math.min(boxHeight, fontSize); + boxWidth = Math.min(boxWidth, fontSize); + } + return { + boxWidth, + boxHeight, + itemHeight: Math.max(fontSize, boxHeight) + }; +}; +const itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index; +class Legend extends Element { + constructor(config) { + super(); + this._added = false; + this.legendHitBoxes = []; + this._hoveredItem = null; + this.doughnutMode = false; + this.chart = config.chart; + this.options = config.options; + this.ctx = config.ctx; + this.legendItems = undefined; + this.columnSizes = undefined; + this.lineWidths = undefined; + this.maxHeight = undefined; + this.maxWidth = undefined; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.height = undefined; + this.width = undefined; + this._margins = undefined; + this.position = undefined; + this.weight = undefined; + this.fullSize = undefined; + } + update(maxWidth, maxHeight, margins) { + this.maxWidth = maxWidth; + this.maxHeight = maxHeight; + this._margins = margins; + this.setDimensions(); + this.buildLabels(); + this.fit(); + } + setDimensions() { + if (this.isHorizontal()) { + this.width = this.maxWidth; + this.left = this._margins.left; + this.right = this.width; + } else { + this.height = this.maxHeight; + this.top = this._margins.top; + this.bottom = this.height; + } + } + buildLabels() { + const labelOpts = this.options.labels || {}; + let legendItems = callback(labelOpts.generateLabels, [this.chart], this) || []; + if (labelOpts.filter) { + legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data)); + } + if (labelOpts.sort) { + legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data)); + } + if (this.options.reverse) { + legendItems.reverse(); + } + this.legendItems = legendItems; + } + fit() { + const {options, ctx} = this; + if (!options.display) { + this.width = this.height = 0; + return; + } + const labelOpts = options.labels; + const labelFont = toFont(labelOpts.font); + const fontSize = labelFont.size; + const titleHeight = this._computeTitleHeight(); + const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize); + let width, height; + ctx.font = labelFont.string; + if (this.isHorizontal()) { + width = this.maxWidth; + height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10; + } else { + height = this.maxHeight; + width = this._fitCols(titleHeight, fontSize, boxWidth, itemHeight) + 10; + } + this.width = Math.min(width, options.maxWidth || this.maxWidth); + this.height = Math.min(height, options.maxHeight || this.maxHeight); + } + _fitRows(titleHeight, fontSize, boxWidth, itemHeight) { + const {ctx, maxWidth, options: {labels: {padding}}} = this; + const hitboxes = this.legendHitBoxes = []; + const lineWidths = this.lineWidths = [0]; + const lineHeight = itemHeight + padding; + let totalHeight = titleHeight; + ctx.textAlign = 'left'; + ctx.textBaseline = 'middle'; + let row = -1; + let top = -lineHeight; + this.legendItems.forEach((legendItem, i) => { + const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; + if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) { + totalHeight += lineHeight; + lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0; + top += lineHeight; + row++; + } + hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight}; + lineWidths[lineWidths.length - 1] += itemWidth + padding; + }); + return totalHeight; + } + _fitCols(titleHeight, fontSize, boxWidth, itemHeight) { + const {ctx, maxHeight, options: {labels: {padding}}} = this; + const hitboxes = this.legendHitBoxes = []; + const columnSizes = this.columnSizes = []; + const heightLimit = maxHeight - titleHeight; + let totalWidth = padding; + let currentColWidth = 0; + let currentColHeight = 0; + let left = 0; + let col = 0; + this.legendItems.forEach((legendItem, i) => { + const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; + if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) { + totalWidth += currentColWidth + padding; + columnSizes.push({width: currentColWidth, height: currentColHeight}); + left += currentColWidth + padding; + col++; + currentColWidth = currentColHeight = 0; + } + hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight}; + currentColWidth = Math.max(currentColWidth, itemWidth); + currentColHeight += itemHeight + padding; + }); + totalWidth += currentColWidth; + columnSizes.push({width: currentColWidth, height: currentColHeight}); + return totalWidth; + } + adjustHitBoxes() { + if (!this.options.display) { + return; + } + const titleHeight = this._computeTitleHeight(); + const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this; + const rtlHelper = getRtlAdapter(rtl, this.left, this.width); + if (this.isHorizontal()) { + let row = 0; + let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]); + for (const hitbox of hitboxes) { + if (row !== hitbox.row) { + row = hitbox.row; + left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]); + } + hitbox.top += this.top + titleHeight + padding; + hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width); + left += hitbox.width + padding; + } + } else { + let col = 0; + let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height); + for (const hitbox of hitboxes) { + if (hitbox.col !== col) { + col = hitbox.col; + top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height); + } + hitbox.top = top; + hitbox.left += this.left + padding; + hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width); + top += hitbox.height + padding; + } + } + } + isHorizontal() { + return this.options.position === 'top' || this.options.position === 'bottom'; + } + draw() { + if (this.options.display) { + const ctx = this.ctx; + clipArea(ctx, this); + this._draw(); + unclipArea(ctx); + } + } + _draw() { + const {options: opts, columnSizes, lineWidths, ctx} = this; + const {align, labels: labelOpts} = opts; + const defaultColor = defaults.color; + const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width); + const labelFont = toFont(labelOpts.font); + const {color: fontColor, padding} = labelOpts; + const fontSize = labelFont.size; + const halfFontSize = fontSize / 2; + let cursor; + this.drawTitle(); + ctx.textAlign = rtlHelper.textAlign('left'); + ctx.textBaseline = 'middle'; + ctx.lineWidth = 0.5; + ctx.font = labelFont.string; + const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize); + const drawLegendBox = function(x, y, legendItem) { + if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) { + return; + } + ctx.save(); + const lineWidth = valueOrDefault(legendItem.lineWidth, 1); + ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor); + ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt'); + ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0); + ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter'); + ctx.lineWidth = lineWidth; + ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor); + ctx.setLineDash(valueOrDefault(legendItem.lineDash, [])); + if (labelOpts.usePointStyle) { + const drawOptions = { + radius: boxWidth * Math.SQRT2 / 2, + pointStyle: legendItem.pointStyle, + rotation: legendItem.rotation, + borderWidth: lineWidth + }; + const centerX = rtlHelper.xPlus(x, boxWidth / 2); + const centerY = y + halfFontSize; + drawPoint(ctx, drawOptions, centerX, centerY); + } else { + const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0); + const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth); + const borderRadius = toTRBLCorners(legendItem.borderRadius); + ctx.beginPath(); + if (Object.values(borderRadius).some(v => v !== 0)) { + addRoundedRectPath(ctx, { + x: xBoxLeft, + y: yBoxTop, + w: boxWidth, + h: boxHeight, + radius: borderRadius, + }); + } else { + ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight); + } + ctx.fill(); + if (lineWidth !== 0) { + ctx.stroke(); + } + } + ctx.restore(); + }; + const fillText = function(x, y, legendItem) { + renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, { + strikethrough: legendItem.hidden, + textAlign: rtlHelper.textAlign(legendItem.textAlign) + }); + }; + const isHorizontal = this.isHorizontal(); + const titleHeight = this._computeTitleHeight(); + if (isHorizontal) { + cursor = { + x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]), + y: this.top + padding + titleHeight, + line: 0 + }; + } else { + cursor = { + x: this.left + padding, + y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height), + line: 0 + }; + } + overrideTextDirection(this.ctx, opts.textDirection); + const lineHeight = itemHeight + padding; + this.legendItems.forEach((legendItem, i) => { + ctx.strokeStyle = legendItem.fontColor || fontColor; + ctx.fillStyle = legendItem.fontColor || fontColor; + const textWidth = ctx.measureText(legendItem.text).width; + const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign)); + const width = boxWidth + halfFontSize + textWidth; + let x = cursor.x; + let y = cursor.y; + rtlHelper.setWidth(this.width); + if (isHorizontal) { + if (i > 0 && x + width + padding > this.right) { + y = cursor.y += lineHeight; + cursor.line++; + x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]); + } + } else if (i > 0 && y + lineHeight > this.bottom) { + x = cursor.x = x + columnSizes[cursor.line].width + padding; + cursor.line++; + y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height); + } + const realX = rtlHelper.x(x); + drawLegendBox(realX, y, legendItem); + x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl); + fillText(rtlHelper.x(x), y, legendItem); + if (isHorizontal) { + cursor.x += width + padding; + } else { + cursor.y += lineHeight; + } + }); + restoreTextDirection(this.ctx, opts.textDirection); + } + drawTitle() { + const opts = this.options; + const titleOpts = opts.title; + const titleFont = toFont(titleOpts.font); + const titlePadding = toPadding(titleOpts.padding); + if (!titleOpts.display) { + return; + } + const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width); + const ctx = this.ctx; + const position = titleOpts.position; + const halfFontSize = titleFont.size / 2; + const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize; + let y; + let left = this.left; + let maxWidth = this.width; + if (this.isHorizontal()) { + maxWidth = Math.max(...this.lineWidths); + y = this.top + topPaddingPlusHalfFontSize; + left = _alignStartEnd(opts.align, left, this.right - maxWidth); + } else { + const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0); + y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight()); + } + const x = _alignStartEnd(position, left, left + maxWidth); + ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position)); + ctx.textBaseline = 'middle'; + ctx.strokeStyle = titleOpts.color; + ctx.fillStyle = titleOpts.color; + ctx.font = titleFont.string; + renderText(ctx, titleOpts.text, x, y, titleFont); + } + _computeTitleHeight() { + const titleOpts = this.options.title; + const titleFont = toFont(titleOpts.font); + const titlePadding = toPadding(titleOpts.padding); + return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0; + } + _getLegendItemAt(x, y) { + let i, hitBox, lh; + if (_isBetween(x, this.left, this.right) + && _isBetween(y, this.top, this.bottom)) { + lh = this.legendHitBoxes; + for (i = 0; i < lh.length; ++i) { + hitBox = lh[i]; + if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width) + && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) { + return this.legendItems[i]; + } + } + } + return null; + } + handleEvent(e) { + const opts = this.options; + if (!isListened(e.type, opts)) { + return; + } + const hoveredItem = this._getLegendItemAt(e.x, e.y); + if (e.type === 'mousemove') { + const previous = this._hoveredItem; + const sameItem = itemsEqual(previous, hoveredItem); + if (previous && !sameItem) { + callback(opts.onLeave, [e, previous, this], this); + } + this._hoveredItem = hoveredItem; + if (hoveredItem && !sameItem) { + callback(opts.onHover, [e, hoveredItem, this], this); + } + } else if (hoveredItem) { + callback(opts.onClick, [e, hoveredItem, this], this); + } + } +} +function isListened(type, opts) { + if (type === 'mousemove' && (opts.onHover || opts.onLeave)) { + return true; + } + if (opts.onClick && (type === 'click' || type === 'mouseup')) { + return true; + } + return false; +} +var plugin_legend = { + id: 'legend', + _element: Legend, + start(chart, _args, options) { + const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart}); + layouts.configure(chart, legend, options); + layouts.addBox(chart, legend); + }, + stop(chart) { + layouts.removeBox(chart, chart.legend); + delete chart.legend; + }, + beforeUpdate(chart, _args, options) { + const legend = chart.legend; + layouts.configure(chart, legend, options); + legend.options = options; + }, + afterUpdate(chart) { + const legend = chart.legend; + legend.buildLabels(); + legend.adjustHitBoxes(); + }, + afterEvent(chart, args) { + if (!args.replay) { + chart.legend.handleEvent(args.event); + } + }, + defaults: { + display: true, + position: 'top', + align: 'center', + fullSize: true, + reverse: false, + weight: 1000, + onClick(e, legendItem, legend) { + const index = legendItem.datasetIndex; + const ci = legend.chart; + if (ci.isDatasetVisible(index)) { + ci.hide(index); + legendItem.hidden = true; + } else { + ci.show(index); + legendItem.hidden = false; + } + }, + onHover: null, + onLeave: null, + labels: { + color: (ctx) => ctx.chart.options.color, + boxWidth: 40, + padding: 10, + generateLabels(chart) { + const datasets = chart.data.datasets; + const {labels: {usePointStyle, pointStyle, textAlign, color}} = chart.legend.options; + return chart._getSortedDatasetMetas().map((meta) => { + const style = meta.controller.getStyle(usePointStyle ? 0 : undefined); + const borderWidth = toPadding(style.borderWidth); + return { + text: datasets[meta.index].label, + fillStyle: style.backgroundColor, + fontColor: color, + hidden: !meta.visible, + lineCap: style.borderCapStyle, + lineDash: style.borderDash, + lineDashOffset: style.borderDashOffset, + lineJoin: style.borderJoinStyle, + lineWidth: (borderWidth.width + borderWidth.height) / 4, + strokeStyle: style.borderColor, + pointStyle: pointStyle || style.pointStyle, + rotation: style.rotation, + textAlign: textAlign || style.textAlign, + borderRadius: 0, + datasetIndex: meta.index + }; + }, this); + } + }, + title: { + color: (ctx) => ctx.chart.options.color, + display: false, + position: 'center', + text: '', + } + }, + descriptors: { + _scriptable: (name) => !name.startsWith('on'), + labels: { + _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name), + } + }, +}; + +class Title extends Element { + constructor(config) { + super(); + this.chart = config.chart; + this.options = config.options; + this.ctx = config.ctx; + this._padding = undefined; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.width = undefined; + this.height = undefined; + this.position = undefined; + this.weight = undefined; + this.fullSize = undefined; + } + update(maxWidth, maxHeight) { + const opts = this.options; + this.left = 0; + this.top = 0; + if (!opts.display) { + this.width = this.height = this.right = this.bottom = 0; + return; + } + this.width = this.right = maxWidth; + this.height = this.bottom = maxHeight; + const lineCount = isArray(opts.text) ? opts.text.length : 1; + this._padding = toPadding(opts.padding); + const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height; + if (this.isHorizontal()) { + this.height = textSize; + } else { + this.width = textSize; + } + } + isHorizontal() { + const pos = this.options.position; + return pos === 'top' || pos === 'bottom'; + } + _drawArgs(offset) { + const {top, left, bottom, right, options} = this; + const align = options.align; + let rotation = 0; + let maxWidth, titleX, titleY; + if (this.isHorizontal()) { + titleX = _alignStartEnd(align, left, right); + titleY = top + offset; + maxWidth = right - left; + } else { + if (options.position === 'left') { + titleX = left + offset; + titleY = _alignStartEnd(align, bottom, top); + rotation = PI * -0.5; + } else { + titleX = right - offset; + titleY = _alignStartEnd(align, top, bottom); + rotation = PI * 0.5; + } + maxWidth = bottom - top; + } + return {titleX, titleY, maxWidth, rotation}; + } + draw() { + const ctx = this.ctx; + const opts = this.options; + if (!opts.display) { + return; + } + const fontOpts = toFont(opts.font); + const lineHeight = fontOpts.lineHeight; + const offset = lineHeight / 2 + this._padding.top; + const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset); + renderText(ctx, opts.text, 0, 0, fontOpts, { + color: opts.color, + maxWidth, + rotation, + textAlign: _toLeftRightCenter(opts.align), + textBaseline: 'middle', + translation: [titleX, titleY], + }); + } +} +function createTitle(chart, titleOpts) { + const title = new Title({ + ctx: chart.ctx, + options: titleOpts, + chart + }); + layouts.configure(chart, title, titleOpts); + layouts.addBox(chart, title); + chart.titleBlock = title; +} +var plugin_title = { + id: 'title', + _element: Title, + start(chart, _args, options) { + createTitle(chart, options); + }, + stop(chart) { + const titleBlock = chart.titleBlock; + layouts.removeBox(chart, titleBlock); + delete chart.titleBlock; + }, + beforeUpdate(chart, _args, options) { + const title = chart.titleBlock; + layouts.configure(chart, title, options); + title.options = options; + }, + defaults: { + align: 'center', + display: false, + font: { + weight: 'bold', + }, + fullSize: true, + padding: 10, + position: 'top', + text: '', + weight: 2000 + }, + defaultRoutes: { + color: 'color' + }, + descriptors: { + _scriptable: true, + _indexable: false, + }, +}; + +const map = new WeakMap(); +var plugin_subtitle = { + id: 'subtitle', + start(chart, _args, options) { + const title = new Title({ + ctx: chart.ctx, + options, + chart + }); + layouts.configure(chart, title, options); + layouts.addBox(chart, title); + map.set(chart, title); + }, + stop(chart) { + layouts.removeBox(chart, map.get(chart)); + map.delete(chart); + }, + beforeUpdate(chart, _args, options) { + const title = map.get(chart); + layouts.configure(chart, title, options); + title.options = options; + }, + defaults: { + align: 'center', + display: false, + font: { + weight: 'normal', + }, + fullSize: true, + padding: 0, + position: 'top', + text: '', + weight: 1500 + }, + defaultRoutes: { + color: 'color' + }, + descriptors: { + _scriptable: true, + _indexable: false, + }, +}; + +const positioners = { + average(items) { + if (!items.length) { + return false; + } + let i, len; + let x = 0; + let y = 0; + let count = 0; + for (i = 0, len = items.length; i < len; ++i) { + const el = items[i].element; + if (el && el.hasValue()) { + const pos = el.tooltipPosition(); + x += pos.x; + y += pos.y; + ++count; + } + } + return { + x: x / count, + y: y / count + }; + }, + nearest(items, eventPosition) { + if (!items.length) { + return false; + } + let x = eventPosition.x; + let y = eventPosition.y; + let minDistance = Number.POSITIVE_INFINITY; + let i, len, nearestElement; + for (i = 0, len = items.length; i < len; ++i) { + const el = items[i].element; + if (el && el.hasValue()) { + const center = el.getCenterPoint(); + const d = distanceBetweenPoints(eventPosition, center); + if (d < minDistance) { + minDistance = d; + nearestElement = el; + } + } + } + if (nearestElement) { + const tp = nearestElement.tooltipPosition(); + x = tp.x; + y = tp.y; + } + return { + x, + y + }; + } +}; +function pushOrConcat(base, toPush) { + if (toPush) { + if (isArray(toPush)) { + Array.prototype.push.apply(base, toPush); + } else { + base.push(toPush); + } + } + return base; +} +function splitNewlines(str) { + if ((typeof str === 'string' || str instanceof String) && str.indexOf('\n') > -1) { + return str.split('\n'); + } + return str; +} +function createTooltipItem(chart, item) { + const {element, datasetIndex, index} = item; + const controller = chart.getDatasetMeta(datasetIndex).controller; + const {label, value} = controller.getLabelAndValue(index); + return { + chart, + label, + parsed: controller.getParsed(index), + raw: chart.data.datasets[datasetIndex].data[index], + formattedValue: value, + dataset: controller.getDataset(), + dataIndex: index, + datasetIndex, + element + }; +} +function getTooltipSize(tooltip, options) { + const ctx = tooltip.chart.ctx; + const {body, footer, title} = tooltip; + const {boxWidth, boxHeight} = options; + const bodyFont = toFont(options.bodyFont); + const titleFont = toFont(options.titleFont); + const footerFont = toFont(options.footerFont); + const titleLineCount = title.length; + const footerLineCount = footer.length; + const bodyLineItemCount = body.length; + const padding = toPadding(options.padding); + let height = padding.height; + let width = 0; + let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0); + combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length; + if (titleLineCount) { + height += titleLineCount * titleFont.lineHeight + + (titleLineCount - 1) * options.titleSpacing + + options.titleMarginBottom; + } + if (combinedBodyLength) { + const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight; + height += bodyLineItemCount * bodyLineHeight + + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + + (combinedBodyLength - 1) * options.bodySpacing; + } + if (footerLineCount) { + height += options.footerMarginTop + + footerLineCount * footerFont.lineHeight + + (footerLineCount - 1) * options.footerSpacing; + } + let widthPadding = 0; + const maxLineWidth = function(line) { + width = Math.max(width, ctx.measureText(line).width + widthPadding); + }; + ctx.save(); + ctx.font = titleFont.string; + each(tooltip.title, maxLineWidth); + ctx.font = bodyFont.string; + each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth); + widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0; + each(body, (bodyItem) => { + each(bodyItem.before, maxLineWidth); + each(bodyItem.lines, maxLineWidth); + each(bodyItem.after, maxLineWidth); + }); + widthPadding = 0; + ctx.font = footerFont.string; + each(tooltip.footer, maxLineWidth); + ctx.restore(); + width += padding.width; + return {width, height}; +} +function determineYAlign(chart, size) { + const {y, height} = size; + if (y < height / 2) { + return 'top'; + } else if (y > (chart.height - height / 2)) { + return 'bottom'; + } + return 'center'; +} +function doesNotFitWithAlign(xAlign, chart, options, size) { + const {x, width} = size; + const caret = options.caretSize + options.caretPadding; + if (xAlign === 'left' && x + width + caret > chart.width) { + return true; + } + if (xAlign === 'right' && x - width - caret < 0) { + return true; + } +} +function determineXAlign(chart, options, size, yAlign) { + const {x, width} = size; + const {width: chartWidth, chartArea: {left, right}} = chart; + let xAlign = 'center'; + if (yAlign === 'center') { + xAlign = x <= (left + right) / 2 ? 'left' : 'right'; + } else if (x <= width / 2) { + xAlign = 'left'; + } else if (x >= chartWidth - width / 2) { + xAlign = 'right'; + } + if (doesNotFitWithAlign(xAlign, chart, options, size)) { + xAlign = 'center'; + } + return xAlign; +} +function determineAlignment(chart, options, size) { + const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size); + return { + xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign), + yAlign + }; +} +function alignX(size, xAlign) { + let {x, width} = size; + if (xAlign === 'right') { + x -= width; + } else if (xAlign === 'center') { + x -= (width / 2); + } + return x; +} +function alignY(size, yAlign, paddingAndSize) { + let {y, height} = size; + if (yAlign === 'top') { + y += paddingAndSize; + } else if (yAlign === 'bottom') { + y -= height + paddingAndSize; + } else { + y -= (height / 2); + } + return y; +} +function getBackgroundPoint(options, size, alignment, chart) { + const {caretSize, caretPadding, cornerRadius} = options; + const {xAlign, yAlign} = alignment; + const paddingAndSize = caretSize + caretPadding; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius); + let x = alignX(size, xAlign); + const y = alignY(size, yAlign, paddingAndSize); + if (yAlign === 'center') { + if (xAlign === 'left') { + x += paddingAndSize; + } else if (xAlign === 'right') { + x -= paddingAndSize; + } + } else if (xAlign === 'left') { + x -= Math.max(topLeft, bottomLeft) + caretSize; + } else if (xAlign === 'right') { + x += Math.max(topRight, bottomRight) + caretSize; + } + return { + x: _limitValue(x, 0, chart.width - size.width), + y: _limitValue(y, 0, chart.height - size.height) + }; +} +function getAlignedX(tooltip, align, options) { + const padding = toPadding(options.padding); + return align === 'center' + ? tooltip.x + tooltip.width / 2 + : align === 'right' + ? tooltip.x + tooltip.width - padding.right + : tooltip.x + padding.left; +} +function getBeforeAfterBodyLines(callback) { + return pushOrConcat([], splitNewlines(callback)); +} +function createTooltipContext(parent, tooltip, tooltipItems) { + return createContext(parent, { + tooltip, + tooltipItems, + type: 'tooltip' + }); +} +function overrideCallbacks(callbacks, context) { + const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks; + return override ? callbacks.override(override) : callbacks; +} +class Tooltip extends Element { + constructor(config) { + super(); + this.opacity = 0; + this._active = []; + this._eventPosition = undefined; + this._size = undefined; + this._cachedAnimations = undefined; + this._tooltipItems = []; + this.$animations = undefined; + this.$context = undefined; + this.chart = config.chart || config._chart; + this._chart = this.chart; + this.options = config.options; + this.dataPoints = undefined; + this.title = undefined; + this.beforeBody = undefined; + this.body = undefined; + this.afterBody = undefined; + this.footer = undefined; + this.xAlign = undefined; + this.yAlign = undefined; + this.x = undefined; + this.y = undefined; + this.height = undefined; + this.width = undefined; + this.caretX = undefined; + this.caretY = undefined; + this.labelColors = undefined; + this.labelPointStyles = undefined; + this.labelTextColors = undefined; + } + initialize(options) { + this.options = options; + this._cachedAnimations = undefined; + this.$context = undefined; + } + _resolveAnimations() { + const cached = this._cachedAnimations; + if (cached) { + return cached; + } + const chart = this.chart; + const options = this.options.setContext(this.getContext()); + const opts = options.enabled && chart.options.animation && options.animations; + const animations = new Animations(this.chart, opts); + if (opts._cacheable) { + this._cachedAnimations = Object.freeze(animations); + } + return animations; + } + getContext() { + return this.$context || + (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems)); + } + getTitle(context, options) { + const {callbacks} = options; + const beforeTitle = callbacks.beforeTitle.apply(this, [context]); + const title = callbacks.title.apply(this, [context]); + const afterTitle = callbacks.afterTitle.apply(this, [context]); + let lines = []; + lines = pushOrConcat(lines, splitNewlines(beforeTitle)); + lines = pushOrConcat(lines, splitNewlines(title)); + lines = pushOrConcat(lines, splitNewlines(afterTitle)); + return lines; + } + getBeforeBody(tooltipItems, options) { + return getBeforeAfterBodyLines(options.callbacks.beforeBody.apply(this, [tooltipItems])); + } + getBody(tooltipItems, options) { + const {callbacks} = options; + const bodyItems = []; + each(tooltipItems, (context) => { + const bodyItem = { + before: [], + lines: [], + after: [] + }; + const scoped = overrideCallbacks(callbacks, context); + pushOrConcat(bodyItem.before, splitNewlines(scoped.beforeLabel.call(this, context))); + pushOrConcat(bodyItem.lines, scoped.label.call(this, context)); + pushOrConcat(bodyItem.after, splitNewlines(scoped.afterLabel.call(this, context))); + bodyItems.push(bodyItem); + }); + return bodyItems; + } + getAfterBody(tooltipItems, options) { + return getBeforeAfterBodyLines(options.callbacks.afterBody.apply(this, [tooltipItems])); + } + getFooter(tooltipItems, options) { + const {callbacks} = options; + const beforeFooter = callbacks.beforeFooter.apply(this, [tooltipItems]); + const footer = callbacks.footer.apply(this, [tooltipItems]); + const afterFooter = callbacks.afterFooter.apply(this, [tooltipItems]); + let lines = []; + lines = pushOrConcat(lines, splitNewlines(beforeFooter)); + lines = pushOrConcat(lines, splitNewlines(footer)); + lines = pushOrConcat(lines, splitNewlines(afterFooter)); + return lines; + } + _createItems(options) { + const active = this._active; + const data = this.chart.data; + const labelColors = []; + const labelPointStyles = []; + const labelTextColors = []; + let tooltipItems = []; + let i, len; + for (i = 0, len = active.length; i < len; ++i) { + tooltipItems.push(createTooltipItem(this.chart, active[i])); + } + if (options.filter) { + tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data)); + } + if (options.itemSort) { + tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data)); + } + each(tooltipItems, (context) => { + const scoped = overrideCallbacks(options.callbacks, context); + labelColors.push(scoped.labelColor.call(this, context)); + labelPointStyles.push(scoped.labelPointStyle.call(this, context)); + labelTextColors.push(scoped.labelTextColor.call(this, context)); + }); + this.labelColors = labelColors; + this.labelPointStyles = labelPointStyles; + this.labelTextColors = labelTextColors; + this.dataPoints = tooltipItems; + return tooltipItems; + } + update(changed, replay) { + const options = this.options.setContext(this.getContext()); + const active = this._active; + let properties; + let tooltipItems = []; + if (!active.length) { + if (this.opacity !== 0) { + properties = { + opacity: 0 + }; + } + } else { + const position = positioners[options.position].call(this, active, this._eventPosition); + tooltipItems = this._createItems(options); + this.title = this.getTitle(tooltipItems, options); + this.beforeBody = this.getBeforeBody(tooltipItems, options); + this.body = this.getBody(tooltipItems, options); + this.afterBody = this.getAfterBody(tooltipItems, options); + this.footer = this.getFooter(tooltipItems, options); + const size = this._size = getTooltipSize(this, options); + const positionAndSize = Object.assign({}, position, size); + const alignment = determineAlignment(this.chart, options, positionAndSize); + const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart); + this.xAlign = alignment.xAlign; + this.yAlign = alignment.yAlign; + properties = { + opacity: 1, + x: backgroundPoint.x, + y: backgroundPoint.y, + width: size.width, + height: size.height, + caretX: position.x, + caretY: position.y + }; + } + this._tooltipItems = tooltipItems; + this.$context = undefined; + if (properties) { + this._resolveAnimations().update(this, properties); + } + if (changed && options.external) { + options.external.call(this, {chart: this.chart, tooltip: this, replay}); + } + } + drawCaret(tooltipPoint, ctx, size, options) { + const caretPosition = this.getCaretPosition(tooltipPoint, size, options); + ctx.lineTo(caretPosition.x1, caretPosition.y1); + ctx.lineTo(caretPosition.x2, caretPosition.y2); + ctx.lineTo(caretPosition.x3, caretPosition.y3); + } + getCaretPosition(tooltipPoint, size, options) { + const {xAlign, yAlign} = this; + const {caretSize, cornerRadius} = options; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius); + const {x: ptX, y: ptY} = tooltipPoint; + const {width, height} = size; + let x1, x2, x3, y1, y2, y3; + if (yAlign === 'center') { + y2 = ptY + (height / 2); + if (xAlign === 'left') { + x1 = ptX; + x2 = x1 - caretSize; + y1 = y2 + caretSize; + y3 = y2 - caretSize; + } else { + x1 = ptX + width; + x2 = x1 + caretSize; + y1 = y2 - caretSize; + y3 = y2 + caretSize; + } + x3 = x1; + } else { + if (xAlign === 'left') { + x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize); + } else if (xAlign === 'right') { + x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize; + } else { + x2 = this.caretX; + } + if (yAlign === 'top') { + y1 = ptY; + y2 = y1 - caretSize; + x1 = x2 - caretSize; + x3 = x2 + caretSize; + } else { + y1 = ptY + height; + y2 = y1 + caretSize; + x1 = x2 + caretSize; + x3 = x2 - caretSize; + } + y3 = y1; + } + return {x1, x2, x3, y1, y2, y3}; + } + drawTitle(pt, ctx, options) { + const title = this.title; + const length = title.length; + let titleFont, titleSpacing, i; + if (length) { + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + pt.x = getAlignedX(this, options.titleAlign, options); + ctx.textAlign = rtlHelper.textAlign(options.titleAlign); + ctx.textBaseline = 'middle'; + titleFont = toFont(options.titleFont); + titleSpacing = options.titleSpacing; + ctx.fillStyle = options.titleColor; + ctx.font = titleFont.string; + for (i = 0; i < length; ++i) { + ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2); + pt.y += titleFont.lineHeight + titleSpacing; + if (i + 1 === length) { + pt.y += options.titleMarginBottom - titleSpacing; + } + } + } + } + _drawColorBox(ctx, pt, i, rtlHelper, options) { + const labelColors = this.labelColors[i]; + const labelPointStyle = this.labelPointStyles[i]; + const {boxHeight, boxWidth, boxPadding} = options; + const bodyFont = toFont(options.bodyFont); + const colorX = getAlignedX(this, 'left', options); + const rtlColorX = rtlHelper.x(colorX); + const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0; + const colorY = pt.y + yOffSet; + if (options.usePointStyle) { + const drawOptions = { + radius: Math.min(boxWidth, boxHeight) / 2, + pointStyle: labelPointStyle.pointStyle, + rotation: labelPointStyle.rotation, + borderWidth: 1 + }; + const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2; + const centerY = colorY + boxHeight / 2; + ctx.strokeStyle = options.multiKeyBackground; + ctx.fillStyle = options.multiKeyBackground; + drawPoint(ctx, drawOptions, centerX, centerY); + ctx.strokeStyle = labelColors.borderColor; + ctx.fillStyle = labelColors.backgroundColor; + drawPoint(ctx, drawOptions, centerX, centerY); + } else { + ctx.lineWidth = labelColors.borderWidth || 1; + ctx.strokeStyle = labelColors.borderColor; + ctx.setLineDash(labelColors.borderDash || []); + ctx.lineDashOffset = labelColors.borderDashOffset || 0; + const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth - boxPadding); + const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - boxPadding - 2); + const borderRadius = toTRBLCorners(labelColors.borderRadius); + if (Object.values(borderRadius).some(v => v !== 0)) { + ctx.beginPath(); + ctx.fillStyle = options.multiKeyBackground; + addRoundedRectPath(ctx, { + x: outerX, + y: colorY, + w: boxWidth, + h: boxHeight, + radius: borderRadius, + }); + ctx.fill(); + ctx.stroke(); + ctx.fillStyle = labelColors.backgroundColor; + ctx.beginPath(); + addRoundedRectPath(ctx, { + x: innerX, + y: colorY + 1, + w: boxWidth - 2, + h: boxHeight - 2, + radius: borderRadius, + }); + ctx.fill(); + } else { + ctx.fillStyle = options.multiKeyBackground; + ctx.fillRect(outerX, colorY, boxWidth, boxHeight); + ctx.strokeRect(outerX, colorY, boxWidth, boxHeight); + ctx.fillStyle = labelColors.backgroundColor; + ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2); + } + } + ctx.fillStyle = this.labelTextColors[i]; + } + drawBody(pt, ctx, options) { + const {body} = this; + const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options; + const bodyFont = toFont(options.bodyFont); + let bodyLineHeight = bodyFont.lineHeight; + let xLinePadding = 0; + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + const fillLineOfText = function(line) { + ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2); + pt.y += bodyLineHeight + bodySpacing; + }; + const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign); + let bodyItem, textColor, lines, i, j, ilen, jlen; + ctx.textAlign = bodyAlign; + ctx.textBaseline = 'middle'; + ctx.font = bodyFont.string; + pt.x = getAlignedX(this, bodyAlignForCalculation, options); + ctx.fillStyle = options.bodyColor; + each(this.beforeBody, fillLineOfText); + xLinePadding = displayColors && bodyAlignForCalculation !== 'right' + ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding) + : 0; + for (i = 0, ilen = body.length; i < ilen; ++i) { + bodyItem = body[i]; + textColor = this.labelTextColors[i]; + ctx.fillStyle = textColor; + each(bodyItem.before, fillLineOfText); + lines = bodyItem.lines; + if (displayColors && lines.length) { + this._drawColorBox(ctx, pt, i, rtlHelper, options); + bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight); + } + for (j = 0, jlen = lines.length; j < jlen; ++j) { + fillLineOfText(lines[j]); + bodyLineHeight = bodyFont.lineHeight; + } + each(bodyItem.after, fillLineOfText); + } + xLinePadding = 0; + bodyLineHeight = bodyFont.lineHeight; + each(this.afterBody, fillLineOfText); + pt.y -= bodySpacing; + } + drawFooter(pt, ctx, options) { + const footer = this.footer; + const length = footer.length; + let footerFont, i; + if (length) { + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + pt.x = getAlignedX(this, options.footerAlign, options); + pt.y += options.footerMarginTop; + ctx.textAlign = rtlHelper.textAlign(options.footerAlign); + ctx.textBaseline = 'middle'; + footerFont = toFont(options.footerFont); + ctx.fillStyle = options.footerColor; + ctx.font = footerFont.string; + for (i = 0; i < length; ++i) { + ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2); + pt.y += footerFont.lineHeight + options.footerSpacing; + } + } + } + drawBackground(pt, ctx, tooltipSize, options) { + const {xAlign, yAlign} = this; + const {x, y} = pt; + const {width, height} = tooltipSize; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius); + ctx.fillStyle = options.backgroundColor; + ctx.strokeStyle = options.borderColor; + ctx.lineWidth = options.borderWidth; + ctx.beginPath(); + ctx.moveTo(x + topLeft, y); + if (yAlign === 'top') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + width - topRight, y); + ctx.quadraticCurveTo(x + width, y, x + width, y + topRight); + if (yAlign === 'center' && xAlign === 'right') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + width, y + height - bottomRight); + ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height); + if (yAlign === 'bottom') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + bottomLeft, y + height); + ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft); + if (yAlign === 'center' && xAlign === 'left') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x, y + topLeft); + ctx.quadraticCurveTo(x, y, x + topLeft, y); + ctx.closePath(); + ctx.fill(); + if (options.borderWidth > 0) { + ctx.stroke(); + } + } + _updateAnimationTarget(options) { + const chart = this.chart; + const anims = this.$animations; + const animX = anims && anims.x; + const animY = anims && anims.y; + if (animX || animY) { + const position = positioners[options.position].call(this, this._active, this._eventPosition); + if (!position) { + return; + } + const size = this._size = getTooltipSize(this, options); + const positionAndSize = Object.assign({}, position, this._size); + const alignment = determineAlignment(chart, options, positionAndSize); + const point = getBackgroundPoint(options, positionAndSize, alignment, chart); + if (animX._to !== point.x || animY._to !== point.y) { + this.xAlign = alignment.xAlign; + this.yAlign = alignment.yAlign; + this.width = size.width; + this.height = size.height; + this.caretX = position.x; + this.caretY = position.y; + this._resolveAnimations().update(this, point); + } + } + } + draw(ctx) { + const options = this.options.setContext(this.getContext()); + let opacity = this.opacity; + if (!opacity) { + return; + } + this._updateAnimationTarget(options); + const tooltipSize = { + width: this.width, + height: this.height + }; + const pt = { + x: this.x, + y: this.y + }; + opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity; + const padding = toPadding(options.padding); + const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length; + if (options.enabled && hasTooltipContent) { + ctx.save(); + ctx.globalAlpha = opacity; + this.drawBackground(pt, ctx, tooltipSize, options); + overrideTextDirection(ctx, options.textDirection); + pt.y += padding.top; + this.drawTitle(pt, ctx, options); + this.drawBody(pt, ctx, options); + this.drawFooter(pt, ctx, options); + restoreTextDirection(ctx, options.textDirection); + ctx.restore(); + } + } + getActiveElements() { + return this._active || []; + } + setActiveElements(activeElements, eventPosition) { + const lastActive = this._active; + const active = activeElements.map(({datasetIndex, index}) => { + const meta = this.chart.getDatasetMeta(datasetIndex); + if (!meta) { + throw new Error('Cannot find a dataset at index ' + datasetIndex); + } + return { + datasetIndex, + element: meta.data[index], + index, + }; + }); + const changed = !_elementsEqual(lastActive, active); + const positionChanged = this._positionChanged(active, eventPosition); + if (changed || positionChanged) { + this._active = active; + this._eventPosition = eventPosition; + this._ignoreReplayEvents = true; + this.update(true); + } + } + handleEvent(e, replay, inChartArea = true) { + if (replay && this._ignoreReplayEvents) { + return false; + } + this._ignoreReplayEvents = false; + const options = this.options; + const lastActive = this._active || []; + const active = this._getActiveElements(e, lastActive, replay, inChartArea); + const positionChanged = this._positionChanged(active, e); + const changed = replay || !_elementsEqual(active, lastActive) || positionChanged; + if (changed) { + this._active = active; + if (options.enabled || options.external) { + this._eventPosition = { + x: e.x, + y: e.y + }; + this.update(true, replay); + } + } + return changed; + } + _getActiveElements(e, lastActive, replay, inChartArea) { + const options = this.options; + if (e.type === 'mouseout') { + return []; + } + if (!inChartArea) { + return lastActive; + } + const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay); + if (options.reverse) { + active.reverse(); + } + return active; + } + _positionChanged(active, e) { + const {caretX, caretY, options} = this; + const position = positioners[options.position].call(this, active, e); + return position !== false && (caretX !== position.x || caretY !== position.y); + } +} +Tooltip.positioners = positioners; +var plugin_tooltip = { + id: 'tooltip', + _element: Tooltip, + positioners, + afterInit(chart, _args, options) { + if (options) { + chart.tooltip = new Tooltip({chart, options}); + } + }, + beforeUpdate(chart, _args, options) { + if (chart.tooltip) { + chart.tooltip.initialize(options); + } + }, + reset(chart, _args, options) { + if (chart.tooltip) { + chart.tooltip.initialize(options); + } + }, + afterDraw(chart) { + const tooltip = chart.tooltip; + const args = { + tooltip + }; + if (chart.notifyPlugins('beforeTooltipDraw', args) === false) { + return; + } + if (tooltip) { + tooltip.draw(chart.ctx); + } + chart.notifyPlugins('afterTooltipDraw', args); + }, + afterEvent(chart, args) { + if (chart.tooltip) { + const useFinalPosition = args.replay; + if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) { + args.changed = true; + } + } + }, + defaults: { + enabled: true, + external: null, + position: 'average', + backgroundColor: 'rgba(0,0,0,0.8)', + titleColor: '#fff', + titleFont: { + weight: 'bold', + }, + titleSpacing: 2, + titleMarginBottom: 6, + titleAlign: 'left', + bodyColor: '#fff', + bodySpacing: 2, + bodyFont: { + }, + bodyAlign: 'left', + footerColor: '#fff', + footerSpacing: 2, + footerMarginTop: 6, + footerFont: { + weight: 'bold', + }, + footerAlign: 'left', + padding: 6, + caretPadding: 2, + caretSize: 5, + cornerRadius: 6, + boxHeight: (ctx, opts) => opts.bodyFont.size, + boxWidth: (ctx, opts) => opts.bodyFont.size, + multiKeyBackground: '#fff', + displayColors: true, + boxPadding: 0, + borderColor: 'rgba(0,0,0,0)', + borderWidth: 0, + animation: { + duration: 400, + easing: 'easeOutQuart', + }, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'], + }, + opacity: { + easing: 'linear', + duration: 200 + } + }, + callbacks: { + beforeTitle: noop, + title(tooltipItems) { + if (tooltipItems.length > 0) { + const item = tooltipItems[0]; + const labels = item.chart.data.labels; + const labelCount = labels ? labels.length : 0; + if (this && this.options && this.options.mode === 'dataset') { + return item.dataset.label || ''; + } else if (item.label) { + return item.label; + } else if (labelCount > 0 && item.dataIndex < labelCount) { + return labels[item.dataIndex]; + } + } + return ''; + }, + afterTitle: noop, + beforeBody: noop, + beforeLabel: noop, + label(tooltipItem) { + if (this && this.options && this.options.mode === 'dataset') { + return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue; + } + let label = tooltipItem.dataset.label || ''; + if (label) { + label += ': '; + } + const value = tooltipItem.formattedValue; + if (!isNullOrUndef(value)) { + label += value; + } + return label; + }, + labelColor(tooltipItem) { + const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); + const options = meta.controller.getStyle(tooltipItem.dataIndex); + return { + borderColor: options.borderColor, + backgroundColor: options.backgroundColor, + borderWidth: options.borderWidth, + borderDash: options.borderDash, + borderDashOffset: options.borderDashOffset, + borderRadius: 0, + }; + }, + labelTextColor() { + return this.options.bodyColor; + }, + labelPointStyle(tooltipItem) { + const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); + const options = meta.controller.getStyle(tooltipItem.dataIndex); + return { + pointStyle: options.pointStyle, + rotation: options.rotation, + }; + }, + afterLabel: noop, + afterBody: noop, + beforeFooter: noop, + footer: noop, + afterFooter: noop + } + }, + defaultRoutes: { + bodyFont: 'font', + footerFont: 'font', + titleFont: 'font' + }, + descriptors: { + _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external', + _indexable: false, + callbacks: { + _scriptable: false, + _indexable: false, + }, + animation: { + _fallback: false + }, + animations: { + _fallback: 'animation' + } + }, + additionalOptionScopes: ['interaction'] +}; + +var plugins = /*#__PURE__*/Object.freeze({ +__proto__: null, +Decimation: plugin_decimation, +Filler: plugin_filler, +Legend: plugin_legend, +SubTitle: plugin_subtitle, +Title: plugin_title, +Tooltip: plugin_tooltip +}); + +const addIfString = (labels, raw, index, addedLabels) => { + if (typeof raw === 'string') { + index = labels.push(raw) - 1; + addedLabels.unshift({index, label: raw}); + } else if (isNaN(raw)) { + index = null; + } + return index; +}; +function findOrAddLabel(labels, raw, index, addedLabels) { + const first = labels.indexOf(raw); + if (first === -1) { + return addIfString(labels, raw, index, addedLabels); + } + const last = labels.lastIndexOf(raw); + return first !== last ? index : first; +} +const validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max); +class CategoryScale extends Scale { + constructor(cfg) { + super(cfg); + this._startValue = undefined; + this._valueRange = 0; + this._addedLabels = []; + } + init(scaleOptions) { + const added = this._addedLabels; + if (added.length) { + const labels = this.getLabels(); + for (const {index, label} of added) { + if (labels[index] === label) { + labels.splice(index, 1); + } + } + this._addedLabels = []; + } + super.init(scaleOptions); + } + parse(raw, index) { + if (isNullOrUndef(raw)) { + return null; + } + const labels = this.getLabels(); + index = isFinite(index) && labels[index] === raw ? index + : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels); + return validIndex(index, labels.length - 1); + } + determineDataLimits() { + const {minDefined, maxDefined} = this.getUserBounds(); + let {min, max} = this.getMinMax(true); + if (this.options.bounds === 'ticks') { + if (!minDefined) { + min = 0; + } + if (!maxDefined) { + max = this.getLabels().length - 1; + } + } + this.min = min; + this.max = max; + } + buildTicks() { + const min = this.min; + const max = this.max; + const offset = this.options.offset; + const ticks = []; + let labels = this.getLabels(); + labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1); + this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1); + this._startValue = this.min - (offset ? 0.5 : 0); + for (let value = min; value <= max; value++) { + ticks.push({value}); + } + return ticks; + } + getLabelForValue(value) { + const labels = this.getLabels(); + if (value >= 0 && value < labels.length) { + return labels[value]; + } + return value; + } + configure() { + super.configure(); + if (!this.isHorizontal()) { + this._reversePixels = !this._reversePixels; + } + } + getPixelForValue(value) { + if (typeof value !== 'number') { + value = this.parse(value); + } + return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange); + } + getPixelForTick(index) { + const ticks = this.ticks; + if (index < 0 || index > ticks.length - 1) { + return null; + } + return this.getPixelForValue(ticks[index].value); + } + getValueForPixel(pixel) { + return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange); + } + getBasePixel() { + return this.bottom; + } +} +CategoryScale.id = 'category'; +CategoryScale.defaults = { + ticks: { + callback: CategoryScale.prototype.getLabelForValue + } +}; + +function generateTicks$1(generationOptions, dataRange) { + const ticks = []; + const MIN_SPACING = 1e-14; + const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions; + const unit = step || 1; + const maxSpaces = maxTicks - 1; + const {min: rmin, max: rmax} = dataRange; + const minDefined = !isNullOrUndef(min); + const maxDefined = !isNullOrUndef(max); + const countDefined = !isNullOrUndef(count); + const minSpacing = (rmax - rmin) / (maxDigits + 1); + let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit; + let factor, niceMin, niceMax, numSpaces; + if (spacing < MIN_SPACING && !minDefined && !maxDefined) { + return [{value: rmin}, {value: rmax}]; + } + numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing); + if (numSpaces > maxSpaces) { + spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit; + } + if (!isNullOrUndef(precision)) { + factor = Math.pow(10, precision); + spacing = Math.ceil(spacing * factor) / factor; + } + if (bounds === 'ticks') { + niceMin = Math.floor(rmin / spacing) * spacing; + niceMax = Math.ceil(rmax / spacing) * spacing; + } else { + niceMin = rmin; + niceMax = rmax; + } + if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) { + numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks)); + spacing = (max - min) / numSpaces; + niceMin = min; + niceMax = max; + } else if (countDefined) { + niceMin = minDefined ? min : niceMin; + niceMax = maxDefined ? max : niceMax; + numSpaces = count - 1; + spacing = (niceMax - niceMin) / numSpaces; + } else { + numSpaces = (niceMax - niceMin) / spacing; + if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) { + numSpaces = Math.round(numSpaces); + } else { + numSpaces = Math.ceil(numSpaces); + } + } + const decimalPlaces = Math.max( + _decimalPlaces(spacing), + _decimalPlaces(niceMin) + ); + factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision); + niceMin = Math.round(niceMin * factor) / factor; + niceMax = Math.round(niceMax * factor) / factor; + let j = 0; + if (minDefined) { + if (includeBounds && niceMin !== min) { + ticks.push({value: min}); + if (niceMin < min) { + j++; + } + if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) { + j++; + } + } else if (niceMin < min) { + j++; + } + } + for (; j < numSpaces; ++j) { + ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor}); + } + if (maxDefined && includeBounds && niceMax !== max) { + if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) { + ticks[ticks.length - 1].value = max; + } else { + ticks.push({value: max}); + } + } else if (!maxDefined || niceMax === max) { + ticks.push({value: niceMax}); + } + return ticks; +} +function relativeLabelSize(value, minSpacing, {horizontal, minRotation}) { + const rad = toRadians(minRotation); + const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001; + const length = 0.75 * minSpacing * ('' + value).length; + return Math.min(minSpacing / ratio, length); +} +class LinearScaleBase extends Scale { + constructor(cfg) { + super(cfg); + this.start = undefined; + this.end = undefined; + this._startValue = undefined; + this._endValue = undefined; + this._valueRange = 0; + } + parse(raw, index) { + if (isNullOrUndef(raw)) { + return null; + } + if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) { + return null; + } + return +raw; + } + handleTickRangeOptions() { + const {beginAtZero} = this.options; + const {minDefined, maxDefined} = this.getUserBounds(); + let {min, max} = this; + const setMin = v => (min = minDefined ? min : v); + const setMax = v => (max = maxDefined ? max : v); + if (beginAtZero) { + const minSign = sign(min); + const maxSign = sign(max); + if (minSign < 0 && maxSign < 0) { + setMax(0); + } else if (minSign > 0 && maxSign > 0) { + setMin(0); + } + } + if (min === max) { + let offset = 1; + if (max >= Number.MAX_SAFE_INTEGER || min <= Number.MIN_SAFE_INTEGER) { + offset = Math.abs(max * 0.05); + } + setMax(max + offset); + if (!beginAtZero) { + setMin(min - offset); + } + } + this.min = min; + this.max = max; + } + getTickLimit() { + const tickOpts = this.options.ticks; + let {maxTicksLimit, stepSize} = tickOpts; + let maxTicks; + if (stepSize) { + maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1; + if (maxTicks > 1000) { + console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`); + maxTicks = 1000; + } + } else { + maxTicks = this.computeTickLimit(); + maxTicksLimit = maxTicksLimit || 11; + } + if (maxTicksLimit) { + maxTicks = Math.min(maxTicksLimit, maxTicks); + } + return maxTicks; + } + computeTickLimit() { + return Number.POSITIVE_INFINITY; + } + buildTicks() { + const opts = this.options; + const tickOpts = opts.ticks; + let maxTicks = this.getTickLimit(); + maxTicks = Math.max(2, maxTicks); + const numericGeneratorOptions = { + maxTicks, + bounds: opts.bounds, + min: opts.min, + max: opts.max, + precision: tickOpts.precision, + step: tickOpts.stepSize, + count: tickOpts.count, + maxDigits: this._maxDigits(), + horizontal: this.isHorizontal(), + minRotation: tickOpts.minRotation || 0, + includeBounds: tickOpts.includeBounds !== false + }; + const dataRange = this._range || this; + const ticks = generateTicks$1(numericGeneratorOptions, dataRange); + if (opts.bounds === 'ticks') { + _setMinAndMaxByKey(ticks, this, 'value'); + } + if (opts.reverse) { + ticks.reverse(); + this.start = this.max; + this.end = this.min; + } else { + this.start = this.min; + this.end = this.max; + } + return ticks; + } + configure() { + const ticks = this.ticks; + let start = this.min; + let end = this.max; + super.configure(); + if (this.options.offset && ticks.length) { + const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2; + start -= offset; + end += offset; + } + this._startValue = start; + this._endValue = end; + this._valueRange = end - start; + } + getLabelForValue(value) { + return formatNumber(value, this.chart.options.locale, this.options.ticks.format); + } +} + +class LinearScale extends LinearScaleBase { + determineDataLimits() { + const {min, max} = this.getMinMax(true); + this.min = isNumberFinite(min) ? min : 0; + this.max = isNumberFinite(max) ? max : 1; + this.handleTickRangeOptions(); + } + computeTickLimit() { + const horizontal = this.isHorizontal(); + const length = horizontal ? this.width : this.height; + const minRotation = toRadians(this.options.ticks.minRotation); + const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001; + const tickFont = this._resolveTickFontOptions(0); + return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio)); + } + getPixelForValue(value) { + return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange); + } + getValueForPixel(pixel) { + return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange; + } +} +LinearScale.id = 'linear'; +LinearScale.defaults = { + ticks: { + callback: Ticks.formatters.numeric + } +}; + +function isMajor(tickVal) { + const remain = tickVal / (Math.pow(10, Math.floor(log10(tickVal)))); + return remain === 1; +} +function generateTicks(generationOptions, dataRange) { + const endExp = Math.floor(log10(dataRange.max)); + const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp)); + const ticks = []; + let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min)))); + let exp = Math.floor(log10(tickVal)); + let significand = Math.floor(tickVal / Math.pow(10, exp)); + let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1; + do { + ticks.push({value: tickVal, major: isMajor(tickVal)}); + ++significand; + if (significand === 10) { + significand = 1; + ++exp; + precision = exp >= 0 ? 1 : precision; + } + tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision; + } while (exp < endExp || (exp === endExp && significand < endSignificand)); + const lastTick = finiteOrDefault(generationOptions.max, tickVal); + ticks.push({value: lastTick, major: isMajor(tickVal)}); + return ticks; +} +class LogarithmicScale extends Scale { + constructor(cfg) { + super(cfg); + this.start = undefined; + this.end = undefined; + this._startValue = undefined; + this._valueRange = 0; + } + parse(raw, index) { + const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]); + if (value === 0) { + this._zero = true; + return undefined; + } + return isNumberFinite(value) && value > 0 ? value : null; + } + determineDataLimits() { + const {min, max} = this.getMinMax(true); + this.min = isNumberFinite(min) ? Math.max(0, min) : null; + this.max = isNumberFinite(max) ? Math.max(0, max) : null; + if (this.options.beginAtZero) { + this._zero = true; + } + this.handleTickRangeOptions(); + } + handleTickRangeOptions() { + const {minDefined, maxDefined} = this.getUserBounds(); + let min = this.min; + let max = this.max; + const setMin = v => (min = minDefined ? min : v); + const setMax = v => (max = maxDefined ? max : v); + const exp = (v, m) => Math.pow(10, Math.floor(log10(v)) + m); + if (min === max) { + if (min <= 0) { + setMin(1); + setMax(10); + } else { + setMin(exp(min, -1)); + setMax(exp(max, +1)); + } + } + if (min <= 0) { + setMin(exp(max, -1)); + } + if (max <= 0) { + setMax(exp(min, +1)); + } + if (this._zero && this.min !== this._suggestedMin && min === exp(this.min, 0)) { + setMin(exp(min, -1)); + } + this.min = min; + this.max = max; + } + buildTicks() { + const opts = this.options; + const generationOptions = { + min: this._userMin, + max: this._userMax + }; + const ticks = generateTicks(generationOptions, this); + if (opts.bounds === 'ticks') { + _setMinAndMaxByKey(ticks, this, 'value'); + } + if (opts.reverse) { + ticks.reverse(); + this.start = this.max; + this.end = this.min; + } else { + this.start = this.min; + this.end = this.max; + } + return ticks; + } + getLabelForValue(value) { + return value === undefined + ? '0' + : formatNumber(value, this.chart.options.locale, this.options.ticks.format); + } + configure() { + const start = this.min; + super.configure(); + this._startValue = log10(start); + this._valueRange = log10(this.max) - log10(start); + } + getPixelForValue(value) { + if (value === undefined || value === 0) { + value = this.min; + } + if (value === null || isNaN(value)) { + return NaN; + } + return this.getPixelForDecimal(value === this.min + ? 0 + : (log10(value) - this._startValue) / this._valueRange); + } + getValueForPixel(pixel) { + const decimal = this.getDecimalForPixel(pixel); + return Math.pow(10, this._startValue + decimal * this._valueRange); + } +} +LogarithmicScale.id = 'logarithmic'; +LogarithmicScale.defaults = { + ticks: { + callback: Ticks.formatters.logarithmic, + major: { + enabled: true + } + } +}; + +function getTickBackdropHeight(opts) { + const tickOpts = opts.ticks; + if (tickOpts.display && opts.display) { + const padding = toPadding(tickOpts.backdropPadding); + return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height; + } + return 0; +} +function measureLabelSize(ctx, font, label) { + label = isArray(label) ? label : [label]; + return { + w: _longestText(ctx, font.string, label), + h: label.length * font.lineHeight + }; +} +function determineLimits(angle, pos, size, min, max) { + if (angle === min || angle === max) { + return { + start: pos - (size / 2), + end: pos + (size / 2) + }; + } else if (angle < min || angle > max) { + return { + start: pos - size, + end: pos + }; + } + return { + start: pos, + end: pos + size + }; +} +function fitWithPointLabels(scale) { + const orig = { + l: scale.left + scale._padding.left, + r: scale.right - scale._padding.right, + t: scale.top + scale._padding.top, + b: scale.bottom - scale._padding.bottom + }; + const limits = Object.assign({}, orig); + const labelSizes = []; + const padding = []; + const valueCount = scale._pointLabels.length; + const pointLabelOpts = scale.options.pointLabels; + const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0; + for (let i = 0; i < valueCount; i++) { + const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i)); + padding[i] = opts.padding; + const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle); + const plFont = toFont(opts.font); + const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]); + labelSizes[i] = textSize; + const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle); + const angle = Math.round(toDegrees(angleRadians)); + const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180); + const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270); + updateLimits(limits, orig, angleRadians, hLimits, vLimits); + } + scale.setCenterPoint( + orig.l - limits.l, + limits.r - orig.r, + orig.t - limits.t, + limits.b - orig.b + ); + scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding); +} +function updateLimits(limits, orig, angle, hLimits, vLimits) { + const sin = Math.abs(Math.sin(angle)); + const cos = Math.abs(Math.cos(angle)); + let x = 0; + let y = 0; + if (hLimits.start < orig.l) { + x = (orig.l - hLimits.start) / sin; + limits.l = Math.min(limits.l, orig.l - x); + } else if (hLimits.end > orig.r) { + x = (hLimits.end - orig.r) / sin; + limits.r = Math.max(limits.r, orig.r + x); + } + if (vLimits.start < orig.t) { + y = (orig.t - vLimits.start) / cos; + limits.t = Math.min(limits.t, orig.t - y); + } else if (vLimits.end > orig.b) { + y = (vLimits.end - orig.b) / cos; + limits.b = Math.max(limits.b, orig.b + y); + } +} +function buildPointLabelItems(scale, labelSizes, padding) { + const items = []; + const valueCount = scale._pointLabels.length; + const opts = scale.options; + const extra = getTickBackdropHeight(opts) / 2; + const outerDistance = scale.drawingArea; + const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0; + for (let i = 0; i < valueCount; i++) { + const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle); + const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI))); + const size = labelSizes[i]; + const y = yForAngle(pointLabelPosition.y, size.h, angle); + const textAlign = getTextAlignForAngle(angle); + const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign); + items.push({ + x: pointLabelPosition.x, + y, + textAlign, + left, + top: y, + right: left + size.w, + bottom: y + size.h + }); + } + return items; +} +function getTextAlignForAngle(angle) { + if (angle === 0 || angle === 180) { + return 'center'; + } else if (angle < 180) { + return 'left'; + } + return 'right'; +} +function leftForTextAlign(x, w, align) { + if (align === 'right') { + x -= w; + } else if (align === 'center') { + x -= (w / 2); + } + return x; +} +function yForAngle(y, h, angle) { + if (angle === 90 || angle === 270) { + y -= (h / 2); + } else if (angle > 270 || angle < 90) { + y -= h; + } + return y; +} +function drawPointLabels(scale, labelCount) { + const {ctx, options: {pointLabels}} = scale; + for (let i = labelCount - 1; i >= 0; i--) { + const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i)); + const plFont = toFont(optsAtIndex.font); + const {x, y, textAlign, left, top, right, bottom} = scale._pointLabelItems[i]; + const {backdropColor} = optsAtIndex; + if (!isNullOrUndef(backdropColor)) { + const padding = toPadding(optsAtIndex.backdropPadding); + ctx.fillStyle = backdropColor; + ctx.fillRect(left - padding.left, top - padding.top, right - left + padding.width, bottom - top + padding.height); + } + renderText( + ctx, + scale._pointLabels[i], + x, + y + (plFont.lineHeight / 2), + plFont, + { + color: optsAtIndex.color, + textAlign: textAlign, + textBaseline: 'middle' + } + ); + } +} +function pathRadiusLine(scale, radius, circular, labelCount) { + const {ctx} = scale; + if (circular) { + ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU); + } else { + let pointPosition = scale.getPointPosition(0, radius); + ctx.moveTo(pointPosition.x, pointPosition.y); + for (let i = 1; i < labelCount; i++) { + pointPosition = scale.getPointPosition(i, radius); + ctx.lineTo(pointPosition.x, pointPosition.y); + } + } +} +function drawRadiusLine(scale, gridLineOpts, radius, labelCount) { + const ctx = scale.ctx; + const circular = gridLineOpts.circular; + const {color, lineWidth} = gridLineOpts; + if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) { + return; + } + ctx.save(); + ctx.strokeStyle = color; + ctx.lineWidth = lineWidth; + ctx.setLineDash(gridLineOpts.borderDash); + ctx.lineDashOffset = gridLineOpts.borderDashOffset; + ctx.beginPath(); + pathRadiusLine(scale, radius, circular, labelCount); + ctx.closePath(); + ctx.stroke(); + ctx.restore(); +} +function createPointLabelContext(parent, index, label) { + return createContext(parent, { + label, + index, + type: 'pointLabel' + }); +} +class RadialLinearScale extends LinearScaleBase { + constructor(cfg) { + super(cfg); + this.xCenter = undefined; + this.yCenter = undefined; + this.drawingArea = undefined; + this._pointLabels = []; + this._pointLabelItems = []; + } + setDimensions() { + const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2); + const w = this.width = this.maxWidth - padding.width; + const h = this.height = this.maxHeight - padding.height; + this.xCenter = Math.floor(this.left + w / 2 + padding.left); + this.yCenter = Math.floor(this.top + h / 2 + padding.top); + this.drawingArea = Math.floor(Math.min(w, h) / 2); + } + determineDataLimits() { + const {min, max} = this.getMinMax(false); + this.min = isNumberFinite(min) && !isNaN(min) ? min : 0; + this.max = isNumberFinite(max) && !isNaN(max) ? max : 0; + this.handleTickRangeOptions(); + } + computeTickLimit() { + return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options)); + } + generateTickLabels(ticks) { + LinearScaleBase.prototype.generateTickLabels.call(this, ticks); + this._pointLabels = this.getLabels() + .map((value, index) => { + const label = callback(this.options.pointLabels.callback, [value, index], this); + return label || label === 0 ? label : ''; + }) + .filter((v, i) => this.chart.getDataVisibility(i)); + } + fit() { + const opts = this.options; + if (opts.display && opts.pointLabels.display) { + fitWithPointLabels(this); + } else { + this.setCenterPoint(0, 0, 0, 0); + } + } + setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) { + this.xCenter += Math.floor((leftMovement - rightMovement) / 2); + this.yCenter += Math.floor((topMovement - bottomMovement) / 2); + this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement)); + } + getIndexAngle(index) { + const angleMultiplier = TAU / (this._pointLabels.length || 1); + const startAngle = this.options.startAngle || 0; + return _normalizeAngle(index * angleMultiplier + toRadians(startAngle)); + } + getDistanceFromCenterForValue(value) { + if (isNullOrUndef(value)) { + return NaN; + } + const scalingFactor = this.drawingArea / (this.max - this.min); + if (this.options.reverse) { + return (this.max - value) * scalingFactor; + } + return (value - this.min) * scalingFactor; + } + getValueForDistanceFromCenter(distance) { + if (isNullOrUndef(distance)) { + return NaN; + } + const scaledDistance = distance / (this.drawingArea / (this.max - this.min)); + return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance; + } + getPointLabelContext(index) { + const pointLabels = this._pointLabels || []; + if (index >= 0 && index < pointLabels.length) { + const pointLabel = pointLabels[index]; + return createPointLabelContext(this.getContext(), index, pointLabel); + } + } + getPointPosition(index, distanceFromCenter, additionalAngle = 0) { + const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle; + return { + x: Math.cos(angle) * distanceFromCenter + this.xCenter, + y: Math.sin(angle) * distanceFromCenter + this.yCenter, + angle + }; + } + getPointPositionForValue(index, value) { + return this.getPointPosition(index, this.getDistanceFromCenterForValue(value)); + } + getBasePosition(index) { + return this.getPointPositionForValue(index || 0, this.getBaseValue()); + } + getPointLabelPosition(index) { + const {left, top, right, bottom} = this._pointLabelItems[index]; + return { + left, + top, + right, + bottom, + }; + } + drawBackground() { + const {backgroundColor, grid: {circular}} = this.options; + if (backgroundColor) { + const ctx = this.ctx; + ctx.save(); + ctx.beginPath(); + pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length); + ctx.closePath(); + ctx.fillStyle = backgroundColor; + ctx.fill(); + ctx.restore(); + } + } + drawGrid() { + const ctx = this.ctx; + const opts = this.options; + const {angleLines, grid} = opts; + const labelCount = this._pointLabels.length; + let i, offset, position; + if (opts.pointLabels.display) { + drawPointLabels(this, labelCount); + } + if (grid.display) { + this.ticks.forEach((tick, index) => { + if (index !== 0) { + offset = this.getDistanceFromCenterForValue(tick.value); + const optsAtIndex = grid.setContext(this.getContext(index - 1)); + drawRadiusLine(this, optsAtIndex, offset, labelCount); + } + }); + } + if (angleLines.display) { + ctx.save(); + for (i = labelCount - 1; i >= 0; i--) { + const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i)); + const {color, lineWidth} = optsAtIndex; + if (!lineWidth || !color) { + continue; + } + ctx.lineWidth = lineWidth; + ctx.strokeStyle = color; + ctx.setLineDash(optsAtIndex.borderDash); + ctx.lineDashOffset = optsAtIndex.borderDashOffset; + offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max); + position = this.getPointPosition(i, offset); + ctx.beginPath(); + ctx.moveTo(this.xCenter, this.yCenter); + ctx.lineTo(position.x, position.y); + ctx.stroke(); + } + ctx.restore(); + } + } + drawBorder() {} + drawLabels() { + const ctx = this.ctx; + const opts = this.options; + const tickOpts = opts.ticks; + if (!tickOpts.display) { + return; + } + const startAngle = this.getIndexAngle(0); + let offset, width; + ctx.save(); + ctx.translate(this.xCenter, this.yCenter); + ctx.rotate(startAngle); + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + this.ticks.forEach((tick, index) => { + if (index === 0 && !opts.reverse) { + return; + } + const optsAtIndex = tickOpts.setContext(this.getContext(index)); + const tickFont = toFont(optsAtIndex.font); + offset = this.getDistanceFromCenterForValue(this.ticks[index].value); + if (optsAtIndex.showLabelBackdrop) { + ctx.font = tickFont.string; + width = ctx.measureText(tick.label).width; + ctx.fillStyle = optsAtIndex.backdropColor; + const padding = toPadding(optsAtIndex.backdropPadding); + ctx.fillRect( + -width / 2 - padding.left, + -offset - tickFont.size / 2 - padding.top, + width + padding.width, + tickFont.size + padding.height + ); + } + renderText(ctx, tick.label, 0, -offset, tickFont, { + color: optsAtIndex.color, + }); + }); + ctx.restore(); + } + drawTitle() {} +} +RadialLinearScale.id = 'radialLinear'; +RadialLinearScale.defaults = { + display: true, + animate: true, + position: 'chartArea', + angleLines: { + display: true, + lineWidth: 1, + borderDash: [], + borderDashOffset: 0.0 + }, + grid: { + circular: false + }, + startAngle: 0, + ticks: { + showLabelBackdrop: true, + callback: Ticks.formatters.numeric + }, + pointLabels: { + backdropColor: undefined, + backdropPadding: 2, + display: true, + font: { + size: 10 + }, + callback(label) { + return label; + }, + padding: 5, + centerPointLabels: false + } +}; +RadialLinearScale.defaultRoutes = { + 'angleLines.color': 'borderColor', + 'pointLabels.color': 'color', + 'ticks.color': 'color' +}; +RadialLinearScale.descriptors = { + angleLines: { + _fallback: 'grid' + } +}; + +const INTERVALS = { + millisecond: {common: true, size: 1, steps: 1000}, + second: {common: true, size: 1000, steps: 60}, + minute: {common: true, size: 60000, steps: 60}, + hour: {common: true, size: 3600000, steps: 24}, + day: {common: true, size: 86400000, steps: 30}, + week: {common: false, size: 604800000, steps: 4}, + month: {common: true, size: 2.628e9, steps: 12}, + quarter: {common: false, size: 7.884e9, steps: 4}, + year: {common: true, size: 3.154e10} +}; +const UNITS = (Object.keys(INTERVALS)); +function sorter(a, b) { + return a - b; +} +function parse(scale, input) { + if (isNullOrUndef(input)) { + return null; + } + const adapter = scale._adapter; + const {parser, round, isoWeekday} = scale._parseOpts; + let value = input; + if (typeof parser === 'function') { + value = parser(value); + } + if (!isNumberFinite(value)) { + value = typeof parser === 'string' + ? adapter.parse(value, parser) + : adapter.parse(value); + } + if (value === null) { + return null; + } + if (round) { + value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true) + ? adapter.startOf(value, 'isoWeek', isoWeekday) + : adapter.startOf(value, round); + } + return +value; +} +function determineUnitForAutoTicks(minUnit, min, max, capacity) { + const ilen = UNITS.length; + for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) { + const interval = INTERVALS[UNITS[i]]; + const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER; + if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) { + return UNITS[i]; + } + } + return UNITS[ilen - 1]; +} +function determineUnitForFormatting(scale, numTicks, minUnit, min, max) { + for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) { + const unit = UNITS[i]; + if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) { + return unit; + } + } + return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0]; +} +function determineMajorUnit(unit) { + for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) { + if (INTERVALS[UNITS[i]].common) { + return UNITS[i]; + } + } +} +function addTick(ticks, time, timestamps) { + if (!timestamps) { + ticks[time] = true; + } else if (timestamps.length) { + const {lo, hi} = _lookup(timestamps, time); + const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi]; + ticks[timestamp] = true; + } +} +function setMajorTicks(scale, ticks, map, majorUnit) { + const adapter = scale._adapter; + const first = +adapter.startOf(ticks[0].value, majorUnit); + const last = ticks[ticks.length - 1].value; + let major, index; + for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) { + index = map[major]; + if (index >= 0) { + ticks[index].major = true; + } + } + return ticks; +} +function ticksFromTimestamps(scale, values, majorUnit) { + const ticks = []; + const map = {}; + const ilen = values.length; + let i, value; + for (i = 0; i < ilen; ++i) { + value = values[i]; + map[value] = i; + ticks.push({ + value, + major: false + }); + } + return (ilen === 0 || !majorUnit) ? ticks : setMajorTicks(scale, ticks, map, majorUnit); +} +class TimeScale extends Scale { + constructor(props) { + super(props); + this._cache = { + data: [], + labels: [], + all: [] + }; + this._unit = 'day'; + this._majorUnit = undefined; + this._offsets = {}; + this._normalized = false; + this._parseOpts = undefined; + } + init(scaleOpts, opts) { + const time = scaleOpts.time || (scaleOpts.time = {}); + const adapter = this._adapter = new _adapters._date(scaleOpts.adapters.date); + mergeIf(time.displayFormats, adapter.formats()); + this._parseOpts = { + parser: time.parser, + round: time.round, + isoWeekday: time.isoWeekday + }; + super.init(scaleOpts); + this._normalized = opts.normalized; + } + parse(raw, index) { + if (raw === undefined) { + return null; + } + return parse(this, raw); + } + beforeLayout() { + super.beforeLayout(); + this._cache = { + data: [], + labels: [], + all: [] + }; + } + determineDataLimits() { + const options = this.options; + const adapter = this._adapter; + const unit = options.time.unit || 'day'; + let {min, max, minDefined, maxDefined} = this.getUserBounds(); + function _applyBounds(bounds) { + if (!minDefined && !isNaN(bounds.min)) { + min = Math.min(min, bounds.min); + } + if (!maxDefined && !isNaN(bounds.max)) { + max = Math.max(max, bounds.max); + } + } + if (!minDefined || !maxDefined) { + _applyBounds(this._getLabelBounds()); + if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') { + _applyBounds(this.getMinMax(false)); + } + } + min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit); + max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1; + this.min = Math.min(min, max - 1); + this.max = Math.max(min + 1, max); + } + _getLabelBounds() { + const arr = this.getLabelTimestamps(); + let min = Number.POSITIVE_INFINITY; + let max = Number.NEGATIVE_INFINITY; + if (arr.length) { + min = arr[0]; + max = arr[arr.length - 1]; + } + return {min, max}; + } + buildTicks() { + const options = this.options; + const timeOpts = options.time; + const tickOpts = options.ticks; + const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate(); + if (options.bounds === 'ticks' && timestamps.length) { + this.min = this._userMin || timestamps[0]; + this.max = this._userMax || timestamps[timestamps.length - 1]; + } + const min = this.min; + const max = this.max; + const ticks = _filterBetween(timestamps, min, max); + this._unit = timeOpts.unit || (tickOpts.autoSkip + ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) + : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max)); + this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined + : determineMajorUnit(this._unit); + this.initOffsets(timestamps); + if (options.reverse) { + ticks.reverse(); + } + return ticksFromTimestamps(this, ticks, this._majorUnit); + } + initOffsets(timestamps) { + let start = 0; + let end = 0; + let first, last; + if (this.options.offset && timestamps.length) { + first = this.getDecimalForValue(timestamps[0]); + if (timestamps.length === 1) { + start = 1 - first; + } else { + start = (this.getDecimalForValue(timestamps[1]) - first) / 2; + } + last = this.getDecimalForValue(timestamps[timestamps.length - 1]); + if (timestamps.length === 1) { + end = last; + } else { + end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2; + } + } + const limit = timestamps.length < 3 ? 0.5 : 0.25; + start = _limitValue(start, 0, limit); + end = _limitValue(end, 0, limit); + this._offsets = {start, end, factor: 1 / (start + 1 + end)}; + } + _generate() { + const adapter = this._adapter; + const min = this.min; + const max = this.max; + const options = this.options; + const timeOpts = options.time; + const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min)); + const stepSize = valueOrDefault(timeOpts.stepSize, 1); + const weekday = minor === 'week' ? timeOpts.isoWeekday : false; + const hasWeekday = isNumber(weekday) || weekday === true; + const ticks = {}; + let first = min; + let time, count; + if (hasWeekday) { + first = +adapter.startOf(first, 'isoWeek', weekday); + } + first = +adapter.startOf(first, hasWeekday ? 'day' : minor); + if (adapter.diff(max, min, minor) > 100000 * stepSize) { + throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor); + } + const timestamps = options.ticks.source === 'data' && this.getDataTimestamps(); + for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) { + addTick(ticks, time, timestamps); + } + if (time === max || options.bounds === 'ticks' || count === 1) { + addTick(ticks, time, timestamps); + } + return Object.keys(ticks).sort((a, b) => a - b).map(x => +x); + } + getLabelForValue(value) { + const adapter = this._adapter; + const timeOpts = this.options.time; + if (timeOpts.tooltipFormat) { + return adapter.format(value, timeOpts.tooltipFormat); + } + return adapter.format(value, timeOpts.displayFormats.datetime); + } + _tickFormatFunction(time, index, ticks, format) { + const options = this.options; + const formats = options.time.displayFormats; + const unit = this._unit; + const majorUnit = this._majorUnit; + const minorFormat = unit && formats[unit]; + const majorFormat = majorUnit && formats[majorUnit]; + const tick = ticks[index]; + const major = majorUnit && majorFormat && tick && tick.major; + const label = this._adapter.format(time, format || (major ? majorFormat : minorFormat)); + const formatter = options.ticks.callback; + return formatter ? callback(formatter, [label, index, ticks], this) : label; + } + generateTickLabels(ticks) { + let i, ilen, tick; + for (i = 0, ilen = ticks.length; i < ilen; ++i) { + tick = ticks[i]; + tick.label = this._tickFormatFunction(tick.value, i, ticks); + } + } + getDecimalForValue(value) { + return value === null ? NaN : (value - this.min) / (this.max - this.min); + } + getPixelForValue(value) { + const offsets = this._offsets; + const pos = this.getDecimalForValue(value); + return this.getPixelForDecimal((offsets.start + pos) * offsets.factor); + } + getValueForPixel(pixel) { + const offsets = this._offsets; + const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end; + return this.min + pos * (this.max - this.min); + } + _getLabelSize(label) { + const ticksOpts = this.options.ticks; + const tickLabelWidth = this.ctx.measureText(label).width; + const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation); + const cosRotation = Math.cos(angle); + const sinRotation = Math.sin(angle); + const tickFontSize = this._resolveTickFontOptions(0).size; + return { + w: (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation), + h: (tickLabelWidth * sinRotation) + (tickFontSize * cosRotation) + }; + } + _getLabelCapacity(exampleTime) { + const timeOpts = this.options.time; + const displayFormats = timeOpts.displayFormats; + const format = displayFormats[timeOpts.unit] || displayFormats.millisecond; + const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [exampleTime], this._majorUnit), format); + const size = this._getLabelSize(exampleLabel); + const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1; + return capacity > 0 ? capacity : 1; + } + getDataTimestamps() { + let timestamps = this._cache.data || []; + let i, ilen; + if (timestamps.length) { + return timestamps; + } + const metas = this.getMatchingVisibleMetas(); + if (this._normalized && metas.length) { + return (this._cache.data = metas[0].controller.getAllParsedValues(this)); + } + for (i = 0, ilen = metas.length; i < ilen; ++i) { + timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this)); + } + return (this._cache.data = this.normalize(timestamps)); + } + getLabelTimestamps() { + const timestamps = this._cache.labels || []; + let i, ilen; + if (timestamps.length) { + return timestamps; + } + const labels = this.getLabels(); + for (i = 0, ilen = labels.length; i < ilen; ++i) { + timestamps.push(parse(this, labels[i])); + } + return (this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps)); + } + normalize(values) { + return _arrayUnique(values.sort(sorter)); + } +} +TimeScale.id = 'time'; +TimeScale.defaults = { + bounds: 'data', + adapters: {}, + time: { + parser: false, + unit: false, + round: false, + isoWeekday: false, + minUnit: 'millisecond', + displayFormats: {} + }, + ticks: { + source: 'auto', + major: { + enabled: false + } + } +}; + +function interpolate(table, val, reverse) { + let lo = 0; + let hi = table.length - 1; + let prevSource, nextSource, prevTarget, nextTarget; + if (reverse) { + if (val >= table[lo].pos && val <= table[hi].pos) { + ({lo, hi} = _lookupByKey(table, 'pos', val)); + } + ({pos: prevSource, time: prevTarget} = table[lo]); + ({pos: nextSource, time: nextTarget} = table[hi]); + } else { + if (val >= table[lo].time && val <= table[hi].time) { + ({lo, hi} = _lookupByKey(table, 'time', val)); + } + ({time: prevSource, pos: prevTarget} = table[lo]); + ({time: nextSource, pos: nextTarget} = table[hi]); + } + const span = nextSource - prevSource; + return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget; +} +class TimeSeriesScale extends TimeScale { + constructor(props) { + super(props); + this._table = []; + this._minPos = undefined; + this._tableRange = undefined; + } + initOffsets() { + const timestamps = this._getTimestampsForTable(); + const table = this._table = this.buildLookupTable(timestamps); + this._minPos = interpolate(table, this.min); + this._tableRange = interpolate(table, this.max) - this._minPos; + super.initOffsets(timestamps); + } + buildLookupTable(timestamps) { + const {min, max} = this; + const items = []; + const table = []; + let i, ilen, prev, curr, next; + for (i = 0, ilen = timestamps.length; i < ilen; ++i) { + curr = timestamps[i]; + if (curr >= min && curr <= max) { + items.push(curr); + } + } + if (items.length < 2) { + return [ + {time: min, pos: 0}, + {time: max, pos: 1} + ]; + } + for (i = 0, ilen = items.length; i < ilen; ++i) { + next = items[i + 1]; + prev = items[i - 1]; + curr = items[i]; + if (Math.round((next + prev) / 2) !== curr) { + table.push({time: curr, pos: i / (ilen - 1)}); + } + } + return table; + } + _getTimestampsForTable() { + let timestamps = this._cache.all || []; + if (timestamps.length) { + return timestamps; + } + const data = this.getDataTimestamps(); + const label = this.getLabelTimestamps(); + if (data.length && label.length) { + timestamps = this.normalize(data.concat(label)); + } else { + timestamps = data.length ? data : label; + } + timestamps = this._cache.all = timestamps; + return timestamps; + } + getDecimalForValue(value) { + return (interpolate(this._table, value) - this._minPos) / this._tableRange; + } + getValueForPixel(pixel) { + const offsets = this._offsets; + const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end; + return interpolate(this._table, decimal * this._tableRange + this._minPos, true); + } +} +TimeSeriesScale.id = 'timeseries'; +TimeSeriesScale.defaults = TimeScale.defaults; + +var scales = /*#__PURE__*/Object.freeze({ +__proto__: null, +CategoryScale: CategoryScale, +LinearScale: LinearScale, +LogarithmicScale: LogarithmicScale, +RadialLinearScale: RadialLinearScale, +TimeScale: TimeScale, +TimeSeriesScale: TimeSeriesScale +}); + +Chart.register(controllers, scales, elements, plugins); +Chart.helpers = {...helpers}; +Chart._adapters = _adapters; +Chart.Animation = Animation; +Chart.Animations = Animations; +Chart.animator = animator; +Chart.controllers = registry.controllers.items; +Chart.DatasetController = DatasetController; +Chart.Element = Element; +Chart.elements = elements; +Chart.Interaction = Interaction; +Chart.layouts = layouts; +Chart.platforms = platforms; +Chart.Scale = Scale; +Chart.Ticks = Ticks; +Object.assign(Chart, controllers, scales, elements, plugins, platforms); +Chart.Chart = Chart; +if (typeof window !== 'undefined') { + window.Chart = Chart; +} + +return Chart; + +})); diff --git a/NEMO/apps/sensors/static/sensors/chartjs-adapter-moment.js b/NEMO/apps/sensors/static/sensors/chartjs-adapter-moment.js new file mode 100644 index 00000000..d9c08cc8 --- /dev/null +++ b/NEMO/apps/sensors/static/sensors/chartjs-adapter-moment.js @@ -0,0 +1,8 @@ +/*! + * chartjs-adapter-moment v1.0.0 + * https://www.chartjs.org + * (c) 2021 chartjs-adapter-moment Contributors + * Released under the MIT license + */ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(require("moment"),require("chart.js")):"function"==typeof define&&define.amd?define(["moment","chart.js"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).moment,e.Chart)}(this,(function(e,t){"use strict";function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var f=n(e);const a={datetime:"MMM D, YYYY, h:mm:ss a",millisecond:"h:mm:ss.SSS a",second:"h:mm:ss a",minute:"h:mm a",hour:"hA",day:"MMM D",week:"ll",month:"MMM YYYY",quarter:"[Q]Q - YYYY",year:"YYYY"};t._adapters._date.override("function"==typeof f.default?{_id:"moment",formats:function(){return a},parse:function(e,t){return"string"==typeof e&&"string"==typeof t?e=f.default(e,t):e instanceof f.default||(e=f.default(e)),e.isValid()?e.valueOf():null},format:function(e,t){return f.default(e).format(t)},add:function(e,t,n){return f.default(e).add(t,n).valueOf()},diff:function(e,t,n){return f.default(e).diff(f.default(t),n)},startOf:function(e,t,n){return e=f.default(e),"isoWeek"===t?(n=Math.trunc(Math.min(Math.max(0,n),6)),e.isoWeekday(n).startOf("day").valueOf()):e.startOf(t).valueOf()},endOf:function(e,t){return f.default(e).endOf(t).valueOf()}}:{})})); +//# sourceMappingURL=chartjs-adapter-moment.min.js.map diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html new file mode 100644 index 00000000..20226b87 --- /dev/null +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -0,0 +1,149 @@ +{% extends "base.html" %} +{% load static %} +{% block extrahead %} + {# Chart.js #} + + +{% endblock %} +{% block title %}Sensors{% endblock %} +{% block content %} +

{{ sensor.name }}

+
+
+ + + + +
+
+ + + + + + + + +
TimeValue
+
+
+ + + + +{% endblock %} \ No newline at end of file diff --git a/NEMO/apps/sensors/templates/sensors/sensors.html b/NEMO/apps/sensors/templates/sensors/sensors.html new file mode 100644 index 00000000..e34922ef --- /dev/null +++ b/NEMO/apps/sensors/templates/sensors/sensors.html @@ -0,0 +1,33 @@ +{% extends "base.html" %} +{% block title %}Sensors{% endblock %} +{% block content %} +

Sensors

+ {% if sensors %} + + + + + + + + {% regroup sensors by sensor_category as category_list %} + {% for category in category_list %} + {% if category.grouper %} + + + + {% endif %} + {% for sensor in category.list %} + + + + + + {% endfor %} + {% endfor %} + +
SensorValueLast read
{{ category.grouper }}
{{ sensor.name }}{{ sensor.last_data_point.display_value }}{{ sensor.last_data_point.created_date }}
+ {% else %} +

No sensors exist yet. You can create some in the Sensor section of 'Detailed Administration'.

+ {% endif %} +{% endblock %} \ No newline at end of file diff --git a/NEMO/apps/sensors/urls.py b/NEMO/apps/sensors/urls.py new file mode 100644 index 00000000..a4bd9e35 --- /dev/null +++ b/NEMO/apps/sensors/urls.py @@ -0,0 +1,10 @@ +from django.urls import path + +from NEMO.apps.sensors import views + +urlpatterns = [ + path("sensors/", views.sensors, name="sensors"), + path("sensor_details//", views.sensor_details, name="sensor_details"), + path("sensor_chart_data//", views.sensor_chart_data, name="sensor_chart_data"), + path("manage_sensor_data/", views.manage_sensor_data, name="manage_sensor_data"), +] diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py new file mode 100644 index 00000000..331b1b96 --- /dev/null +++ b/NEMO/apps/sensors/views.py @@ -0,0 +1,69 @@ +from datetime import timedelta +from math import floor + +from django.contrib.auth.decorators import login_required, permission_required +from django.db.models import QuerySet +from django.http import HttpResponse, JsonResponse +from django.shortcuts import get_object_or_404, render +from django.utils import timezone +from django.views.decorators.http import require_GET + +from NEMO.apps.sensors.models import Sensor, SensorData +from NEMO.decorators import postpone, staff_member_required +from NEMO.utilities import beginning_of_the_day, extract_times, format_datetime + + +@staff_member_required +@require_GET +def sensors(request): + sensor_list = Sensor.objects.filter(id__in=SensorData.objects.values_list("sensor", flat=True)) + sensor_list = sensor_list.order_by("sensor_category__name", "name") + return render(request, "sensors/sensors.html", {"sensors": sensor_list}) + + +@staff_member_required +@require_GET +def sensor_details(request, sensor_id): + sensor = get_object_or_404(Sensor, pk=sensor_id) + csv_export = bool(request.POST.get("csv", False)) + chart_step = int(request.GET.get("chart_step", 1)) + return render(request, "sensors/sensor_data.html", {"sensor": sensor, "chart_step": chart_step}) + + +@staff_member_required +@require_GET +def sensor_chart_data(request, sensor_id): + sensor = get_object_or_404(Sensor, pk=sensor_id) + labels = [] + data = [] + sensor_data = get_sensor_data(request, sensor).order_by("created_date") + for data_point in sensor_data: + labels.append(format_datetime(data_point.created_date, "m/d/Y H:i:s")) + data.append(data_point.value) + return JsonResponse(data={"labels": labels, "data": data}) + + +def get_sensor_data(request, sensor) -> QuerySet: + start, end = extract_times(request.POST, start_required=False, end_required=False) + sensor_data = SensorData.objects.filter(sensor=sensor) + if not start: + start = timezone.now() - timedelta(days=1) + if not end: + end = timezone.now() + return sensor_data.filter(created_date__gte=start, created_date__lte=end) + + +@login_required +@require_GET +@permission_required("NEMO.trigger_timed_services", raise_exception=True) +def manage_sensor_data(request): + return do_manage_sensor_data() + + +def do_manage_sensor_data(asynchronous=True): + minute_of_the_day = floor((timezone.now() - beginning_of_the_day(timezone.now())).total_seconds() / 60) + # Read data for each sensor at the minute interval set + for sensor in Sensor.objects.all(): + if minute_of_the_day % sensor.read_frequency == 0: + postpone(sensor.read_data)() if asynchronous else sensor.read_data() + return HttpResponse() diff --git a/NEMO/tests/test_sensors.py b/NEMO/tests/test_sensors.py new file mode 100644 index 00000000..9f1f1875 --- /dev/null +++ b/NEMO/tests/test_sensors.py @@ -0,0 +1,20 @@ +from unittest import TestCase + +from NEMO.apps.sensors.evaluators import evaluate_expression + + +class TestAstEval(TestCase): + def test(self): + variables = {"te": 5, "my_list": [1, 5, 10]} + res_1 = evaluate_expression("5*2", **variables) + print(res_1) + self.assertEqual(10, res_1) + res_2 = evaluate_expression("te*2", **variables) + print(res_2) + self.assertEqual(10, res_2) + res_3 = evaluate_expression("my_list[1]*2", **variables) + print(res_3) + self.assertEqual(10, res_3) + res_4 = evaluate_expression("my_list[0:2]", **variables) + print(res_4) + self.assertEqual([1, 5], res_4) From 4056ded81a371b58618074a3fc01584838d17ab0 Mon Sep 17 00:00:00 2001 From: mrampant Date: Fri, 22 Apr 2022 10:59:29 -0400 Subject: [PATCH 10/82] - added tabs in sensor data page - added button to export sensor data --- .../templates/sensors/sensor_data.html | 93 ++++++++++++++----- NEMO/apps/sensors/urls.py | 4 +- NEMO/apps/sensors/views.py | 46 +++++++-- 3 files changed, 109 insertions(+), 34 deletions(-) diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html index 20226b87..730786b6 100644 --- a/NEMO/apps/sensors/templates/sensors/sensor_data.html +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -8,41 +8,84 @@ {% block title %}Sensors{% endblock %} {% block content %}

{{ sensor.name }}

-
-
- - - - -
+
- - - - - - - - -
TimeValue
+
+ + +
+
+ +
+
+
+ + + +
+
+ +
+
+
+
+
+ +
+
+
+ + + + + + + +
TimeValue
+
+
+
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_calendar.html b/NEMO/templates/customizations/customizations_calendar.html new file mode 100644 index 00000000..085ddf6a --- /dev/null +++ b/NEMO/templates/customizations/customizations_calendar.html @@ -0,0 +1,107 @@ +
+

Calendar settings

+
+ {% csrf_token %} +
+ +
+
+ + + +
+
+
+
+ +
+
+ + +
+
+
+
+ +
+ +
+
+ The time the day starts in the calendar view (24h format). +
+
+
+ +
+
+ + days +
+
+
+ The maximum number of days a recurring scheduled outage can be set in advance. +
+
+
+
+ The following settings allow to customize the date format in the different calendar views. See FullCalendar documentation for more information on the syntax. +
+
+
+ +
+ +
+
+ The column date format for the day view. +
+
+
+ +
+ +
+
+ The column date format for the week view. +
+
+
+ +
+ +
+
+ The column date format for the month view. +
+
+
+ +
+
+
+
+
+
+
+ +
+
+
+
+
+
+
+ +
+
+ + + +
+
+
+
+ +
+
+
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_dashboard.html b/NEMO/templates/customizations/customizations_dashboard.html new file mode 100644 index 00000000..a3c6c613 --- /dev/null +++ b/NEMO/templates/customizations/customizations_dashboard.html @@ -0,0 +1,94 @@ +
+

Status dashboard settings

+
+ {% csrf_token %} +
+
+
Area occupancy
+
+
+
+ +
+
+
+
+
+
+
+
+
Staff status
+
+
+
+ +
+
+
+
+
+
+
+
+ +
+
+ + +
+
+
+
+ +
+ +
+
+ The date format to use in the status dashboard staff tab. See Django date formats for details. +
+
+
+ +
+
+ + + +
+
+
+
+ +
+
+ + + +
+
+
+
+ +
+
+ + + +
+
+
+
+ +
+
+ + + +
+
+
+
+ +
+
+
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_emails.html b/NEMO/templates/customizations/customizations_emails.html new file mode 100644 index 00000000..92714b49 --- /dev/null +++ b/NEMO/templates/customizations/customizations_emails.html @@ -0,0 +1,45 @@ +
+

Email addresses

+
+ {% csrf_token %} +
+ +
+ +
+
+ User feedback from the Feedback page is sent to this email address. +
+
+
+ +
+ +
+
+ Safety suggestions and observations are sent to this email address. +
+
+
+ +
+ +
+
+ Alerts about user activities that could constitute 'abuse' are sent to this email address. Examples include missed reservations and unauthorized tool access. +
+
+
+ +
+ +
+
+ The main point of contact for users to obtain {{ facility_name }} information. Automated emails sent from {{ site_title }} are typically 'from' this address. +
+
+
+ +
+
+
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_interlock.html b/NEMO/templates/customizations/customizations_interlock.html new file mode 100644 index 00000000..d94a8a91 --- /dev/null +++ b/NEMO/templates/customizations/customizations_interlock.html @@ -0,0 +1,44 @@ +
+

Interlock settings

+
+ {% csrf_token %} +
+ +
+ +
+
+ The message to display when a tool interlock command fails. +
+
+
+ +
+ +
+
+ The message to display when a door interlock command fails. +
+
+
+ +
+
+
+
+
+
+
+ +
+
+ +
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_rates.html b/NEMO/templates/customizations/customizations_rates.html new file mode 100644 index 00000000..8c671fa0 --- /dev/null +++ b/NEMO/templates/customizations/customizations_rates.html @@ -0,0 +1,15 @@ +
+

Tool Rates

+

+ You can upload a json file to display tool rates. An example of a valid rates file can be found on Github. +

It should be a JSON array of elements, and the following key/values are supported for each element: +

+
    +
  • item_id - the id of the tool or supply
    • +
  • table_id - the type of rate, one of "inventory_rate" (for supplies), "primetime_eq_hourly_rate" (for tool), "training_individual_hourly_rate" (for individual training rate), "training_group_hourly_rate" (for group training rate)
    • +
  • rate_class - the class, one of "full cost" or "cost shared"
    • +
  • rate - the rate amount
    • +
  • item - the name of the item (optional)
    • +
+ {% include 'customizations/customizations_upload.html' with element=rates name='rates' extension='json' tab_key='rates' %} +
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_requests.html b/NEMO/templates/customizations/customizations_requests.html new file mode 100644 index 00000000..7db6712f --- /dev/null +++ b/NEMO/templates/customizations/customizations_requests.html @@ -0,0 +1,112 @@ +
+

User requests settings

+
+ {% csrf_token %} +
+ +
+ +
+
+ The title for the buddy request tab of the user requests page. +
+
+
+ +
+ +
+
+ The description/instructions to display on the buddy board page. +
+
+
+ +
+ +
+
+ The title for the access request tab of the user requests page. +
+
+
+ +
+ +
+
+ The description/instructions to display on the access requests page. +
+
+
+ +
+
+ + users +
+
+
+ The minimum number of users (creator included) needed for an access request to be valid. +
+
+
+ +
+
+ + requests +
+
+
+ The maximum number of requests to display in each section (approved, denied, expired). Leave blank for all. +
+
+
+ +
+ +
+
+ The email(s) to notify for weekend access. A comma-separated list can be used. +
+
+
+ +
+ +
+
+ at +
+
+
+ + :00 hrs +
+
+
+ The cutoff day and hour after which an email is sent if there is no approved weekend access for the week (in 24hrs format). If left blank the "no weekend access" will NOT be sent. +
+
+
+ +
+
+ +
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_templates.html b/NEMO/templates/customizations/customizations_templates.html new file mode 100644 index 00000000..1296aba9 --- /dev/null +++ b/NEMO/templates/customizations/customizations_templates.html @@ -0,0 +1,356 @@ +
+

Login banner

+

The login banner is an informational message displayed underneath the username and password text boxes on the login page. You can customize this to convey rules for {{ site_title }} users at your organization.

+ {% include 'customizations/customizations_upload.html' with element=login_banner name='login banner' tab_key='templates' %} +
+
+
+

"{{ facility_name }} failed login" message

+

+ This message is displayed after authentication when either no matching username could be found in the database or if that user has been deactivated. +
The HTML you upload is rendered with the Django template engine. You can use JavaScript (including jQuery) within the message. +

+ {% include 'customizations/customizations_upload.html' with element=authorization_failed name='authorization failed' button_name='Upload failed login page' tab_key='templates' %} +
+
+
+

Introduction for "Safety suggestions and observations" page

+

What would you like everyone to know about safety policy and procedures? This introduction will be presented at the top of the safety page. You can use HTML to modify the look of the text.

+ {% include 'customizations/customizations_upload.html' with element=safety_introduction name='safety introduction' tab_key='templates' %} +
+
+
+

"{{ facility_name }} rules tutorial" page

+

+ The facility rules tutorial is an opportunity to provide new users with a tutorial to your lab operating procedures and rules. +
The HTML you upload is rendered with the Django template engine. You can use JavaScript (including jQuery) within the page. +
+

+
    +
  • The form should include {% templatetag openblock %} csrf_token {% templatetag closeblock %} inside the form tags.
    • +
  • Completion of the HTML form should be POSTed to "{% templatetag openblock %} url 'facility_rules' {% templatetag closeblock %}" (exactly as is).
    • +
+

+ Upon completion, the user's "training required" attribute is set to false, and they are able to make reservations and control tools. +

+ {% include 'customizations/customizations_upload.html' with element=facility_rules_tutorial name='facility rules tutorial' hide_content=True tab_key='templates' %} +
+
+
+

"Jumbotron" watermark

+

This image is displayed as background for the Jumbotron. It is set as a full background screen, so your image needs to take that into account. +
The image you upload should be a valid image file (recommended size is 1500x1000). +

+ {% include 'customizations/customizations_upload.html' with element=jumbotron_watermark name='jumbotron watermark' extension='png' tab_key='templates' %} +
+
+

Access request notification email

+

This email is sent to the person who created the request when an access request is created or updated. The other users present on the request as well as the facility managers are cc'ed.

+

The following context variables are provided when the email is rendered:

+
    +
  • template_color - the color: green if approved, red if denied, blue otherwise
    • +
  • access_request - the user's access request that was created or updated
    • +
  • status - the status of the request: received, updated, approved or denied
    • +
  • access_requests_url - the URL to the access requests page
    • +
+ {% include 'customizations/customizations_upload.html' with element=access_request_notification_email name='access request notification email' tab_key='templates' %} +
+
+ +
+

Cancellation email

+

This email is sent to a user when a staff member cancels the user's reservation. The following context variables are provided when the email is rendered:

+
    +
  • reservation - the user's reservation that was cancelled
    • +
  • staff_member - the user object of the staff member who cancelled the reservation
    • +
  • reason - the reason the staff member provided for cancelling the reservation
    • +
+ {% include 'customizations/customizations_upload.html' with element=cancellation_email name='cancellation email' tab_key='templates' %} +
+
+ +
+

Counter threshold reached email

+

+ This email is sent to the counter's warning email when the value of an counter reaches the warning threshold. + The following context variables are provided when the email is rendered: +

+
    +
  • counter - the counter which value reached the warning threshold
    • +
+ {% include 'customizations/customizations_upload.html' with element=counter_threshold_reached_email name='counter threshold reached email' tab_key='templates' %} +
+
+ +
+

Feedback email

+

+ This email is sent when a user submits feedback. The feedback email address (at the top of this page) must also be configured for users to be able to do this. + The following context variables are provided when the email is rendered: +

+
    +
  • contents - the user's feedback
    • +
  • user - the user object of the user who submitted the feedback
    • +
+ {% include 'customizations/customizations_upload.html' with element=feedback_email name='feedback email' tab_key='templates' %} +
+
+ +
+

Generic email

+

A generic email that can be sent to qualified tool users, members of an account, or members of a project. Send these using the email broadcast page. The following context variables are provided when the email is rendered:

+
    +
  • title - the user specified title of the email
    • +
  • greeting - a greeting to the recipients of the email
    • +
  • contents - the body of the email
    • +
  • template_color - the color to emphasize
    • +
+ {% include 'customizations/customizations_upload.html' with element=generic_email name='generic email' tab_key='templates' %} +
+
+ +
+

Missed reservation email

+

+ This email is sent when a user misses a reservation. If a tool is not used for an amount + of time after the user's reservation has begun, it is marked as missed and removed from the calendar. + The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the reservation that the user missed
    • +
+ {% include 'customizations/customizations_upload.html' with element=missed_reservation_email name='missed reservation email' tab_key='templates' %} +
+
+ +
+

Facility rules tutorial email

+

+ This email is sent when a user completes the facility rules tutorial. It can contain a free-response answer (quiz question). + If you do not upload a template then no notification email is sent to staff when a user completes the training tutorial. + The following context variables are provided when the email is rendered: +

+
    +
  • user - the user's model instance
    • +
  • making_reservations_rule_summary - a free-response answer provided by the user. Normally, this is provided by the user to summarize their understanding of the {{ facility_name }} rules and proceedures.
    • +
+ {% include 'customizations/customizations_upload.html' with element=facility_rules_tutorial_email name='facility rules tutorial email' tab_key='templates' %} +
+
+ +
+

New task email

+

+ This email is sent when a new maintenance task is created for a tool. + The following context variables are provided when the email is rendered: +

+
    +
  • user - the user who created the task
    • +
  • task - the task information
    • +
  • tool - the tool that the task is associated with
    • +
  • tool_control_absolute_url - the URL of the tool control page for the tool
    • +
  • template_color - an HTML color code indicating the severity of the problem. Orange for warning, red for shutdown.
    • +
+ {% include 'customizations/customizations_upload.html' with element=new_task_email name='new task email' tab_key='templates' %} +
+
+ +
+

Out of time reservation email

+

+ This email is sent when a user is still logged in an area but his reservation expired. A grace period can be set when configuring the area. + The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the reservation that the user is out of time on
    • +
+ {% include 'customizations/customizations_upload.html' with element=out_of_time_reservation_email name='out of time reservation email' tab_key='templates' %} +
+
+ +
+

Reorder supplies reminder email

+

+ This email is sent to the item's reminder email when the quantity of an item falls below the reminder threshold and should be reordered. + The following context variables are provided when the email is rendered: +

+
    +
  • item - the item which quantity fell below the reminder threshold
    • +
+ {% include 'customizations/customizations_upload.html' with element=reorder_supplies_reminder_email name='reorder supplies reminder email' tab_key='templates' %} +
+
+ +
+

Reservation ending reminder email

+

+ This email is sent to a user that is logged in an area 30 and 15 minutes before their area reservation ends. + The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the user's reservation ending
    • +
+ {% include 'customizations/customizations_upload.html' with element=reservation_ending_reminder_email name='reservation ending reminder email' tab_key='templates' %} +
+
+ +
+

Reservation reminder email

+

+ This email is sent to a user two hours before their tool/area reservation begins. + The reservation warning email must also exist for this email to be sent. + The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the user's upcoming reservation
    • +
+ {% include 'customizations/customizations_upload.html' with element=reservation_reminder_email name='reservation reminder email' tab_key='templates' %} +
+
+ +
+

Reservation warning email

+

+ This email is sent to a user two hours before their tool/area reservation begins and maintenance may interfere with the upcoming reservation. + The reservation reminder email must also exist for this email to be sent. + The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the user's upcoming reservation
    • +
  • fatal_error - boolean value that, when true, indicates that it will be impossible for the user to use the tool/access the area during their reservation (due to maintenance, outages or a missing required dependency)
    • +
  • template_color - an HTML color code indicating the severity of the problem. Orange for warning, red for shutdown.
    • +
+ {% include 'customizations/customizations_upload.html' with element=reservation_warning_email name='reservation warning email' tab_key='templates' %} +
+
+ +
+

Safety issue email

+

+ This email is sent when a new maintenance task is created for a tool. + The following context variables are provided when the email is rendered: +

+
    +
  • issue - the issue information
    • +
  • issue_absolute_url - the URL for the detailed view of the issue
    • +
+ {% include 'customizations/customizations_upload.html' with element=safety_issue_email name='safety issue email' tab_key='templates' %} +
+
+ +
+

Staff charge reminder email

+

+ This email is periodically sent to remind staff that they are charging a user for staff time. + The following context variables are provided when the email is rendered: +

+
    +
  • staff_charge - the staff charge that is in progress
    • +
+ {% include 'customizations/customizations_upload.html' with element=staff_charge_reminder_email name='staff charge reminder email' tab_key='templates' %} +
+
+ +
+

Task status notification email

+

+ This email is sent when a tool task has be updated and set to a particular state. + The following context variables are provided when the email is rendered: +

+
    +
  • template_color - the color to emphasize
    • +
  • title - a title indicating that the message is a task status notification
    • +
  • task - the task that was updated
    • +
  • status_message - the current status message for the task
    • +
  • notification_message - the notification message that is configured (via the admin site) for the status
    • +
  • tool_control_absolute_url - the URL of the tool control page for the task
    • +
+ {% include 'customizations/customizations_upload.html' with element=task_status_notification name='task status notification' tab_key='templates' %} +
+
+ +
+

Unauthorized tool access email

+

+ This email is sent when a user tries to access a tool: +

+
    +
  • without being logged in to the area in which the tool resides (type 'area').
    • +
  • without having a current area reservation (type 'reservation')
    • +
+

+ The following context variables are provided when the email is rendered: +

+
    +
  • operator - the person who attempted to use the tool
    • +
  • tool - the tool that the user was denied access to
    • +
  • type - the type of abuse ('area' or 'reservation')
    • +
+ {% include 'customizations/customizations_upload.html' with element=unauthorized_tool_access_email name='unauthorized tool access email' tab_key='templates' %} +
+
+ +
+

Usage reminder email

+

+ This email is periodically sent to remind a user that they have a tool enabled. + The following context variables are provided when the email is rendered: +

+
    +
  • user - the user who is using a tool or logged in to an area
    • +
+ {% include 'customizations/customizations_upload.html' with element=usage_reminder_email name='usage reminder email' tab_key='templates' %} +
+
+ +
+

User reservation created email

+

+ This email is sent to a user when the user creates a reservation and has opted to receive ics calendar notification in his preferences. +
This is optional, the email will still be sent with only the calendar attachment if this is left blank. +

The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the user's reservation that was created
    • +
+ {% include 'customizations/customizations_upload.html' with element=reservation_created_user_email name='reservation created user email' tab_key='templates' %} +
+
+ +
+

User reservation cancelled email

+

+ This email is sent to a user when the user cancels his own reservation and has opted to receive ics calendar notification in his preferences. +
This is optional, the email will still be sent with only the calendar attachment if this is left blank. +

The following context variables are provided when the email is rendered: +

+
    +
  • reservation - the user's reservation that was cancelled
    • +
+ {% include 'customizations/customizations_upload.html' with element=reservation_cancelled_user_email name='reservation cancelled user email' tab_key='templates' %} +
+
+ +
+

Weekend access notification email

+

+ This email is sent to the weekend access notification email(s) as well as the facility manager(s) when: +

+
    +
  • + there is at least one approved access request that includes weekend time during the current week. + (The email is sent when the first weekend access request is approved). +
    • +
  • + there are no approved access requests that include weekend time during the current week. + (the email is sent on the cutoff day at the cutoff hour provided in the user requests settings above). +
    • +
+

+ The following context variables are provided when the email is rendered: +

+
    +
  • weekend_access - true/false, whether there are approved weekend access requests for the current week.
    • +
+ {% include 'customizations/customizations_upload.html' with element=weekend_access_email name='weekend access email' tab_key='templates' %} +
\ No newline at end of file diff --git a/NEMO/templates/customizations/customizations_upload.html b/NEMO/templates/customizations/customizations_upload.html index 90e3c246..3db790a5 100644 --- a/NEMO/templates/customizations/customizations_upload.html +++ b/NEMO/templates/customizations/customizations_upload.html @@ -1,6 +1,6 @@ {% load static %} {% with element_name=name.split|join:"_"|lower extension=extension|default:"html" %} -
+ {% csrf_token %}
@@ -10,10 +10,10 @@
+ {% if element and not hide_content %} + Show current content + {% endif %}
- {% if element and not hide_content %} -
- Show current content - {% endif %} +{#
#} {% endwith %} \ No newline at end of file diff --git a/NEMO/urls.py b/NEMO/urls.py index 44302878..ebff3230 100644 --- a/NEMO/urls.py +++ b/NEMO/urls.py @@ -347,7 +347,9 @@ # Site customization: url(r'^customization/$', customization.customization, name='customization'), + url(r'^customization/(?P.+)/$', customization.customization, name='customization'), url(r'^customize/(?P.+)/$', customization.customize, name='customize'), + url(r'^customize/(?P.+)/(?P.+)$', customization.customize, name='customize'), # Project Usage: url(r'^project_usage/$', usage.project_usage, name='project_usage'), diff --git a/NEMO/views/customization.py b/NEMO/views/customization.py index ef3d8e39..8fed51ae 100644 --- a/NEMO/views/customization.py +++ b/NEMO/views/customization.py @@ -143,15 +143,16 @@ def set_customization(name, value): @administrator_required @require_GET -def customization(request): +def customization(request, tab: str = 'application'): dictionary = {name: get_media_file_contents(name + extension) for name, extension in customizable_content} dictionary.update({name: get_customization(name) for name in customizable_key_values.keys()}) + dictionary.update({"tab": tab, "customizations_config": customizations_configuration()}) return render(request, 'customizations/customizations.html', dictionary) @administrator_required @require_POST -def customize(request, element): +def customize(request, element, tab: str ='application'): item = None for name, extension in customizable_content: if name == element: @@ -213,4 +214,17 @@ def customize(request, element): set_customization('weekend_access_notification_cutoff_day', request.POST.get('weekend_access_notification_cutoff_day', '')) else: return HttpResponseBadRequest('Invalid customization') - return redirect('customization') + return redirect('customization', tab) + + +def customizations_configuration(): + return { + "application": "Application", + "emails": "Email addresses", + "calendar": "Calendar", + "dashboard": "Status dashboard", + "interlock": "Interlock", + "requests": "User requests", + "templates": "Email & file templates", + "rates": "Tool rates", + } \ No newline at end of file From 86347cb99230beaf0fd7b10d9f2d136a9920aa7e Mon Sep 17 00:00:00 2001 From: mrampant Date: Sun, 24 Apr 2022 18:14:56 -0400 Subject: [PATCH 14/82] - removed commented out code --- .../customizations/customizations.html | 890 ------------------ 1 file changed, 890 deletions(-) diff --git a/NEMO/templates/customizations/customizations.html b/NEMO/templates/customizations/customizations.html index 7cac28a7..28fbbe94 100644 --- a/NEMO/templates/customizations/customizations.html +++ b/NEMO/templates/customizations/customizations.html @@ -11,15 +11,6 @@

Customizations

{{ name }} {% endfor %} -{#
  • #} -{# Emails#} -{#
    • #} -{#
  • #} -{# Application#} -{#
    • #} -{#
  • #} -{# Calendar#} -{#
    • #}
    {% for key, name in customizations_config.items %} @@ -27,883 +18,7 @@

    Customizations

    {% include 'customizations/customizations_'|add:key|add:'.html' %}
    {% endfor %} -{#
    #} -{# {% include 'customizations/customizations_emails.html' %}#} -{#
    #} -{#
    #} -{# {% include 'customizations/customizations_application.html' %}#} -{#
    #} -{#
    #} -{# {% include 'customizations/customizations_calendar.html' %}#} -{#
    #}
    -{#
    #} -{#
    #} -{#

    Email addresses

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# User feedback from the Feedback page is sent to this email address.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# Safety suggestions and observations are sent to this email address.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# Alerts about user activities that could constitute 'abuse' are sent to this email address. Examples include missed reservations and unauthorized tool access.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The main point of contact for users to obtain {{ facility_name }} information. Automated emails sent from {{ site_title }} are typically 'from' this address.#} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Application settings

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The name of the facility to use in all templates.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The name of the site to use in all templates/headers.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The django template used for rendering project selection when enabling tools and making reservations. The context variable project is provided.#} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Calendar settings

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The time the day starts in the calendar view (24h format).#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# days#} -{#
    #} -{#
    #} -{#
    #} -{# The maximum number of days a recurring scheduled outage can be set in advance.#} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# The following settings allow to customize the date format in the different calendar views. See FullCalendar documentation for more information on the syntax.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The column date format for the day view.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The column date format for the week view.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The column date format for the month view.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Status dashboard settings

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{#
    #} -{#
    Area occupancy
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    Staff status
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The date format to use in the status dashboard staff tab. See Django date formats for details.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Interlock settings

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The message to display when a tool interlock command fails.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The message to display when a door interlock command fails.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    User requests settings

    #} -{#
    #} -{# {% csrf_token %}#} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The title for the buddy request tab of the user requests page.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The description/instructions to display on the buddy board page.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The title for the access request tab of the user requests page.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The description/instructions to display on the access requests page.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# users#} -{#
    #} -{#
    #} -{#
    #} -{# The minimum number of users (creator included) needed for an access request to be valid.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# #} -{# requests#} -{#
    #} -{#
    #} -{#
    #} -{# The maximum number of requests to display in each section (approved, denied, expired). Leave blank for all.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# The email(s) to notify for weekend access. A comma-separated list can be used.#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{# at#} -{#
    #} -{#
    #} -{#
    #} -{# #} -{# :00 hrs#} -{#
    #} -{#
    #} -{#
    #} -{# The cutoff day and hour after which an email is sent if there is no approved weekend access for the week (in 24hrs format). If left blank the "no weekend access" will NOT be sent.#} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{# #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Login banner

    #} -{#

    The login banner is an informational message displayed underneath the username and password text boxes on the login page. You can customize this to convey rules for {{ site_title }} users at your organization.

    #} -{# {% include 'customizations/customizations_upload.html' with element=login_banner name='login banner' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Introduction for "Safety suggestions and observations" page

    #} -{#

    What would you like everyone to know about safety policy and procedures? This introduction will be presented at the top of the safety page. You can use HTML to modify the look of the text.

    #} -{# {% include 'customizations/customizations_upload.html' with element=safety_introduction name='safety introduction' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    "{{ facility_name }} rules tutorial" page

    #} -{#

    #} -{# The facility rules tutorial is an opportunity to provide new users with a tutorial to your lab operating procedures and rules.#} -{#
    The HTML you upload is rendered with the Django template engine. You can use JavaScript (including jQuery) within the page.#} -{#
    #} -{#

    #} -{#
      #} -{#
    • The form should include {% templatetag openblock %} csrf_token {% templatetag closeblock %} inside the form tags.
      • #} -{#
    • Completion of the HTML form should be POSTed to "{% templatetag openblock %} url 'facility_rules' {% templatetag closeblock %}" (exactly as is).
      • #} -{#
    #} -{#

    #} -{# Upon completion, the user's "training required" attribute is set to false, and they are able to make reservations and control tools.#} -{#

    #} -{# {% include 'customizations/customizations_upload.html' with element=facility_rules_tutorial name='facility rules tutorial' hide_content=True %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    "{{ facility_name }} failed login" message

    #} -{#

    #} -{# This message is displayed after authentication when either no matching username could be found in the database or if that user has been deactivated.#} -{#
    The HTML you upload is rendered with the Django template engine. You can use JavaScript (including jQuery) within the message.#} -{#

    #} -{# {% include 'customizations/customizations_upload.html' with element=authorization_failed name='authorization failed' button_name='Upload failed login page' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    "Jumbotron" watermark

    #} -{#

    This image is displayed as background for the Jumbotron. It is set as a full background screen, so your image needs to take that into account.#} -{#
    The image you upload should be a valid image file (recommended size is 1500x1000).#} -{#

    #} -{# {% include 'customizations/customizations_upload.html' with element=jumbotron_watermark name='jumbotron watermark' extension='png' %}#} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Access request notification email

    #} -{#

    This email is sent to the person who created the request when an access request is created or updated. The other users present on the request as well as the facility managers are cc'ed.

    #} -{#

    The following context variables are provided when the email is rendered:

    #} -{#
      #} -{#
    • template_color - the color: green if approved, red if denied, blue otherwise
      • #} -{#
    • access_request - the user's access request that was created or updated
      • #} -{#
    • status - the status of the request: received, updated, approved or denied
      • #} -{#
    • access_requests_url - the URL to the access requests page
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=access_request_notification_email name='access request notification email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Cancellation email

    #} -{#

    This email is sent to a user when a staff member cancels the user's reservation. The following context variables are provided when the email is rendered:

    #} -{#
      #} -{#
    • reservation - the user's reservation that was cancelled
      • #} -{#
    • staff_member - the user object of the staff member who cancelled the reservation
      • #} -{#
    • reason - the reason the staff member provided for cancelling the reservation
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=cancellation_email name='cancellation email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Counter threshold reached email

    #} -{#

    #} -{# This email is sent to the counter's warning email when the value of an counter reaches the warning threshold.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • counter - the counter which value reached the warning threshold
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=counter_threshold_reached_email name='counter threshold reached email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Feedback email

    #} -{#

    #} -{# This email is sent when a user submits feedback. The feedback email address (at the top of this page) must also be configured for users to be able to do this.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • contents - the user's feedback
      • #} -{#
    • user - the user object of the user who submitted the feedback
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=feedback_email name='feedback email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Generic email

    #} -{#

    A generic email that can be sent to qualified tool users, members of an account, or members of a project. Send these using the email broadcast page. The following context variables are provided when the email is rendered:

    #} -{#
      #} -{#
    • title - the user specified title of the email
      • #} -{#
    • greeting - a greeting to the recipients of the email
      • #} -{#
    • contents - the body of the email
      • #} -{#
    • template_color - the color to emphasize
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=generic_email name='generic email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Missed reservation email

    #} -{#

    #} -{# This email is sent when a user misses a reservation. If a tool is not used for an amount#} -{# of time after the user's reservation has begun, it is marked as missed and removed from the calendar.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the reservation that the user missed
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=missed_reservation_email name='missed reservation email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Facility rules tutorial email

    #} -{#

    #} -{# This email is sent when a user completes the facility rules tutorial. It can contain a free-response answer (quiz question).#} -{# If you do not upload a template then no notification email is sent to staff when a user completes the training tutorial.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • user - the user's model instance
      • #} -{#
    • making_reservations_rule_summary - a free-response answer provided by the user. Normally, this is provided by the user to summarize their understanding of the {{ facility_name }} rules and proceedures.
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=facility_rules_tutorial_email name='facility rules tutorial email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    New task email

    #} -{#

    #} -{# This email is sent when a new maintenance task is created for a tool.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • user - the user who created the task
      • #} -{#
    • task - the task information
      • #} -{#
    • tool - the tool that the task is associated with
      • #} -{#
    • tool_control_absolute_url - the URL of the tool control page for the tool
      • #} -{#
    • template_color - an HTML color code indicating the severity of the problem. Orange for warning, red for shutdown.
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=new_task_email name='new task email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Out of time reservation email

    #} -{#

    #} -{# This email is sent when a user is still logged in an area but his reservation expired. A grace period can be set when configuring the area.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the reservation that the user is out of time on
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=out_of_time_reservation_email name='out of time reservation email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Reorder supplies reminder email

    #} -{#

    #} -{# This email is sent to the item's reminder email when the quantity of an item falls below the reminder threshold and should be reordered.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • item - the item which quantity fell below the reminder threshold
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reorder_supplies_reminder_email name='reorder supplies reminder email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Reservation ending reminder email

    #} -{#

    #} -{# This email is sent to a user that is logged in an area 30 and 15 minutes before their area reservation ends.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the user's reservation ending
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reservation_ending_reminder_email name='reservation ending reminder email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Reservation reminder email

    #} -{#

    #} -{# This email is sent to a user two hours before their tool/area reservation begins.#} -{# The reservation warning email must also exist for this email to be sent.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the user's upcoming reservation
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reservation_reminder_email name='reservation reminder email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Reservation warning email

    #} -{#

    #} -{# This email is sent to a user two hours before their tool/area reservation begins and maintenance may interfere with the upcoming reservation.#} -{# The reservation reminder email must also exist for this email to be sent.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the user's upcoming reservation
      • #} -{#
    • fatal_error - boolean value that, when true, indicates that it will be impossible for the user to use the tool/access the area during their reservation (due to maintenance, outages or a missing required dependency)
      • #} -{#
    • template_color - an HTML color code indicating the severity of the problem. Orange for warning, red for shutdown.
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reservation_warning_email name='reservation warning email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Safety issue email

    #} -{#

    #} -{# This email is sent when a new maintenance task is created for a tool.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • issue - the issue information
      • #} -{#
    • issue_absolute_url - the URL for the detailed view of the issue
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=safety_issue_email name='safety issue email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Staff charge reminder email

    #} -{#

    #} -{# This email is periodically sent to remind staff that they are charging a user for staff time.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • staff_charge - the staff charge that is in progress
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=staff_charge_reminder_email name='staff charge reminder email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Task status notification email

    #} -{#

    #} -{# This email is sent when a tool task has be updated and set to a particular state.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • template_color - the color to emphasize
      • #} -{#
    • title - a title indicating that the message is a task status notification
      • #} -{#
    • task - the task that was updated
      • #} -{#
    • status_message - the current status message for the task
      • #} -{#
    • notification_message - the notification message that is configured (via the admin site) for the status
      • #} -{#
    • tool_control_absolute_url - the URL of the tool control page for the task
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=task_status_notification name='task status notification' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Unauthorized tool access email

    #} -{#

    #} -{# This email is sent when a user tries to access a tool:#} -{#

    #} -{#
      #} -{#
    • without being logged in to the area in which the tool resides (type 'area').
      • #} -{#
    • without having a current area reservation (type 'reservation')
      • #} -{#
    #} -{#

    #} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • operator - the person who attempted to use the tool
      • #} -{#
    • tool - the tool that the user was denied access to
      • #} -{#
    • type - the type of abuse ('area' or 'reservation')
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=unauthorized_tool_access_email name='unauthorized tool access email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Usage reminder email

    #} -{#

    #} -{# This email is periodically sent to remind a user that they have a tool enabled.#} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • user - the user who is using a tool or logged in to an area
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=usage_reminder_email name='usage reminder email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    User reservation created email

    #} -{#

    #} -{# This email is sent to a user when the user creates a reservation and has opted to receive ics calendar notification in his preferences.#} -{#
    This is optional, the email will still be sent with only the calendar attachment if this is left blank.#} -{#

    The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the user's reservation that was created
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reservation_created_user_email name='reservation created user email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    User reservation cancelled email

    #} -{#

    #} -{# This email is sent to a user when the user cancels his own reservation and has opted to receive ics calendar notification in his preferences.#} -{#
    This is optional, the email will still be sent with only the calendar attachment if this is left blank.#} -{#

    The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • reservation - the user's reservation that was cancelled
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=reservation_cancelled_user_email name='reservation cancelled user email' %}#} -{#
    #} -{#
    #} -{##} -{#
    #} -{#
    #} -{#

    Weekend access notification email

    #} -{#

    #} -{# This email is sent to the weekend access notification email(s) as well as the facility manager(s) when:#} -{#

    #} -{#
      #} -{#
    • #} -{# there is at least one approved access request that includes weekend time during the current week.#} -{# (The email is sent when the first weekend access request is approved).#} -{#
      • #} -{#
    • #} -{# there are no approved access requests that include weekend time during the current week.#} -{# (the email is sent on the cutoff day at the cutoff hour provided in the user requests settings above).#} -{#
      • #} -{#
    #} -{#

    #} -{# The following context variables are provided when the email is rendered:#} -{#

    #} -{#
      #} -{#
    • weekend_access - true/false, whether there are approved weekend access requests for the current week.
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=weekend_access_email name='weekend access email' %}#} -{#
    #} -{#
    #} - -{#
    #} -{#
    #} -{#

    Tool Rates

    #} -{#

    #} -{# You can upload a json file to display tool rates. An example of a valid rates file can be found on Github.#} -{#

    It should be a JSON array of elements, and the following key/values are supported for each element:#} -{#

    #} -{#
      #} -{#
    • item_id - the id of the tool or supply
      • #} -{#
    • table_id - the type of rate, one of "inventory_rate" (for supplies), "primetime_eq_hourly_rate" (for tool), "training_individual_hourly_rate" (for individual training rate), "training_group_hourly_rate" (for group training rate)
      • #} -{#
    • rate_class - the class, one of "full cost" or "cost shared"
      • #} -{#
    • rate - the rate amount
      • #} -{#
    • item - the name of the item (optional)
      • #} -{#
    #} -{# {% include 'customizations/customizations_upload.html' with element=rates name='rates' extension="json" %}#} -{#
    #} -{#
    #}
    + {% endblock %} {% block title %}Sensors{% endblock %} {% block content %} -

    {{ sensor.name }}

    -
    -
    -
    - - -
    -
    - -
    -
    -
    -
    - - - -
    -
    -
    - +
    +
      +
    1. Dashboard
      2. + {% if sensor.sensor_category %} + {% for ancestor in sensor.sensor_category.ancestors %} +
    2. {{ ancestor.name }}
      3. + {% endfor %} +
    3. {{ sensor.sensor_category.name }}
      4. + {% endif %} +
    4. {{ sensor.name }}
      5. +
    +
    +
    +
    + +
    +
    -
    -
    -
    - + +
    +
    +
    +
    +
    + + + +
    +
    +
    + +
    -
    - - - - - - - -
    TimeValue
    +
    +
    +
    +
    + +
    +
    +
    + + + + + + + +
    Time{{ sensor.data_label|default_if_none:'Value' }}
    +
    +
    -
    - - {# Moment #} - + {% block head %} + {# Moment #} + - {# jQuery #} - + {# jQuery #} + - {# Bootstrap #} - - - + {# Bootstrap #} + + + - {# Typeahead #} - + {# Typeahead #} + + {% endblock %} {# NEMO #} diff --git a/NEMO/templates/calendar/calendar.html b/NEMO/templates/calendar/calendar.html index 87602428..88726e20 100644 --- a/NEMO/templates/calendar/calendar.html +++ b/NEMO/templates/calendar/calendar.html @@ -3,8 +3,8 @@ {% block title %}Calendar{% endblock %} {% block extrahead %} {% load static %} - - + + {% endblock %} {% block body %} From 16ace971c11695fded9e27bc69c31e49bce5e3a1 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 09:18:14 -0400 Subject: [PATCH 27/82] - added moment.min.js.map --- NEMO/static/moment.min.js.map | 1 + 1 file changed, 1 insertion(+) create mode 100644 NEMO/static/moment.min.js.map diff --git a/NEMO/static/moment.min.js.map b/NEMO/static/moment.min.js.map new file mode 100644 index 00000000..a8536566 --- /dev/null +++ b/NEMO/static/moment.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"moment.min.js","sources":["../moment.js"],"names":["global","factory","exports","module","define","amd","moment","this","hookCallback","hooks","apply","arguments","isArray","input","Array","Object","prototype","toString","call","isObject","hasOwnProp","a","b","hasOwnProperty","isObjectEmpty","obj","getOwnPropertyNames","length","k","isUndefined","isNumber","isDate","Date","map","arr","fn","res","arrLen","i","push","extend","valueOf","createUTC","format","locale","strict","createLocalOrUTC","utc","getParsingFlags","m","_pf","empty","unusedTokens","unusedInput","overflow","charsLeftOver","nullInput","invalidEra","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","era","meridiem","rfc2822","weekdayMismatch","isValid","_isValid","flags","parsedParts","some","isNowValid","isNaN","_d","getTime","invalidWeekday","_strict","undefined","bigHour","isFrozen","createInvalid","NaN","fun","t","len","momentProperties","updateInProgress","copyConfig","to","from","prop","val","momentPropertiesLen","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","Moment","config","updateOffset","isMoment","warn","msg","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","arg","key","args","argLen","slice","join","Error","stack","deprecations","deprecateSimple","name","isFunction","Function","mergeConfigs","parentConfig","childConfig","Locale","set","keys","zeroFill","number","targetLength","forceSign","absNumber","Math","abs","pow","max","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","token","padded","ordinal","callback","func","localeData","formatMoment","expandFormat","array","match","replace","mom","output","makeFormatFunction","invalidDate","replaceLongDateFormatTokens","longDateFormat","lastIndex","test","aliases","addUnitAlias","unit","shorthand","lowerCase","toLowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","priorities","addUnitPriority","priority","isLeapYear","year","absFloor","ceil","floor","toInt","argumentForCoercion","coercedNumber","value","isFinite","makeGetSet","keepTime","set$1","get","month","date","daysInMonth","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchWord","addRegexToken","regex","strictRegex","regexes","isStrict","getParseRegexForToken","RegExp","regexEscape","matched","p1","p2","p3","p4","s","tokens","addParseToken","tokenLen","addWeekParseToken","_w","indexOf","YEAR","MONTH","DATE","HOUR","MINUTE","SECOND","MILLISECOND","WEEK","WEEKDAY","modMonth","x","o","monthsShort","months","monthsShortRegex","monthsRegex","monthsParse","defaultLocaleMonths","split","defaultLocaleMonthsShort","MONTHS_IN_FORMAT","defaultMonthsShortRegex","defaultMonthsRegex","setMonth","dayOfMonth","min","getSetMonth","computeMonthsParse","cmpLenRev","shortPieces","longPieces","mixedPieces","sort","_monthsRegex","_monthsShortRegex","_monthsStrictRegex","_monthsShortStrictRegex","daysInYear","y","parseTwoDigitYear","parseInt","getSetYear","createDate","d","h","M","ms","getFullYear","setFullYear","createUTCDate","UTC","getUTCFullYear","setUTCFullYear","firstWeekOffset","dow","doy","fwd","getUTCDay","dayOfYearFromWeeks","week","weekday","resYear","dayOfYear","resDayOfYear","weekOfYear","resWeek","weekOffset","weeksInYear","weekOffsetNext","shiftWeekdays","ws","n","concat","weekdaysMin","weekdaysShort","weekdays","weekdaysMinRegex","weekdaysShortRegex","weekdaysRegex","weekdaysParse","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","defaultWeekdaysRegex","defaultWeekdaysShortRegex","defaultWeekdaysMinRegex","computeWeekdaysParse","minp","shortp","longp","minPieces","day","_weekdaysRegex","_weekdaysShortRegex","_weekdaysMinRegex","_weekdaysStrictRegex","_weekdaysShortStrictRegex","_weekdaysMinStrictRegex","hFormat","hours","lowercase","minutes","matchMeridiem","_meridiemParse","seconds","kInput","_isPm","isPM","_meridiem","pos","pos1","pos2","getSetHour","globalLocale","baseConfig","calendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","LTS","LT","L","LL","LLL","LLLL","dayOfMonthOrdinalParse","relativeTime","future","past","ss","mm","hh","dd","w","ww","MM","yy","meridiemParse","locales","localeFamilies","normalizeLocale","chooseLocale","names","j","next","loadLocale","arr1","arr2","minl","commonPrefix","oldLocale","_abbr","require","getSetGlobalLocale","e","values","data","getLocale","defineLocale","abbr","_config","parentLocale","forEach","checkOverflow","_a","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","obsOffsets","UT","GMT","EDT","EST","CDT","CST","MDT","MST","PDT","PST","configFromISO","l","allowTime","dateFormat","timeFormat","tzFormat","string","exec","isoDatesLen","isoTimesLen","configFromStringAndFormat","extractFromRFC2822Strings","yearStr","monthStr","dayStr","hourStr","minuteStr","secondStr","result","untruncateYear","configFromRFC2822","parsedArray","weekdayStr","parsedInput","getDay","obsOffset","militaryOffset","numOffset","hm","setUTCMinutes","getUTCMinutes","defaults","c","configFromArray","currentDate","weekYear","weekdayOverflow","curWeek","nowValue","now","_useUTC","getUTCMonth","getUTCDate","getMonth","getDate","GG","W","E","createLocal","_week","gg","temp","_dayOfYear","yearToUse","_nextDay","expectedWeekday","ISO_8601","RFC_2822","stringLength","totalParsedInputLength","skipped","hour","meridiemHour","isPm","meridiemFixWrap","erasConvertYear","prepareConfig","dayOrDate","preparse","tempConfig","bestMoment","scoreToBeat","currentScore","validFormatFound","bestFormatIsValid","configfLen","score","configFromStringAndArray","createFromInputFallback","minute","second","millisecond","isUTC","add","prototypeMin","other","prototypeMax","pickBy","moments","ordering","Duration","duration","years","quarters","quarter","weeks","isoWeek","days","milliseconds","unitHasDecimal","orderLen","parseFloat","isDurationValid","_milliseconds","_days","_months","_data","_bubble","isDuration","absRound","round","offset","separator","utcOffset","sign","offsetFromString","chunkOffset","matcher","matches","parts","cloneWithOffset","model","diff","clone","setTime","local","getDateOffset","getTimezoneOffset","isUtc","aspNetRegex","isoRegex","createDuration","parseIso","diffRes","base","isBefore","positiveMomentsDifference","momentsDifference","ret","inp","isAfter","createAdder","direction","period","tmp","addSubtract","isAdding","invalid","subtract","isString","String","isMomentInput","arrayTest","dataTypeTest","filter","item","isNumberOrStringArray","property","objectTest","propertyTest","properties","propertyLen","isMomentInputObject","monthDiff","wholeMonthDiff","anchor","adjust","newLocaleData","defaultFormat","defaultFormatUtc","lang","MS_PER_400_YEARS","mod$1","dividend","divisor","localStartOfDate","utcStartOfDate","matchEraAbbr","erasAbbrRegex","computeErasParse","abbrPieces","namePieces","narrowPieces","eras","narrow","_erasRegex","_erasNameRegex","_erasAbbrRegex","_erasNarrowRegex","addWeekYearFormatToken","getter","getSetWeekYearHelper","weeksTarget","dayOfYearData","erasNameRegex","erasNarrowRegex","erasParse","_eraYearOrdinalRegex","eraYearOrdinalParse","isoWeekYear","_dayOfMonthOrdinalParse","_ordinalParse","_dayOfMonthOrdinalParseLenient","getSetDayOfMonth","getSetMinute","getSetSecond","parseMs","getSetMillisecond","proto","preParsePostFormat","time","formats","isCalendarSpec","sod","startOf","calendarFormat","asFloat","that","zoneDelta","endOf","startOfDate","isoWeekday","inputString","postformat","withoutSuffix","humanize","fromNow","toNow","invalidAt","localInput","isBetween","inclusivity","localFrom","localTo","isSame","inputMs","isSameOrAfter","isSameOrBefore","parsingFlags","prioritized","unitsObj","u","getPrioritizedUnits","prioritizedLen","toArray","toObject","toDate","toISOString","keepOffset","inspect","zone","isLocal","prefix","Symbol","for","toJSON","unix","creationData","eraName","since","until","eraNarrow","eraAbbr","eraYear","dir","isoWeeks","weekInfo","weeksInWeekYear","isoWeeksInYear","isoWeeksInISOWeekYear","keepLocalTime","keepMinutes","localAdjust","_changeInProgress","parseZone","tZone","hasAlignedHourOffset","isDST","isUtcOffset","zoneAbbr","zoneName","dates","isDSTShifted","_isDSTShifted","array1","array2","dontConvert","lengthDiff","diffs","compareArrays","proto$1","get$1","index","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","shift","_calendar","_longDateFormat","formatUpper","toUpperCase","tok","_invalidDate","_ordinal","isFuture","_relativeTime","pastFuture","source","_eras","Infinity","isFormat","_monthsShort","monthName","_monthsParseExact","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","firstDayOfYear","firstDayOfWeek","_weekdays","_weekdaysMin","_weekdaysShort","weekdayName","_weekdaysParseExact","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","_fullWeekdaysParse","charAt","isLower","langData","mathAbs","addSubtract$1","absCeil","daysToMonths","monthsToDays","makeAs","alias","as","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asQuarters","asYears","makeGetter","thresholds","relativeTime$1","posNegDuration","abs$1","toISOString$1","ymSign","daysSign","hmsSign","total","toFixed","proto$2","monthsFromDays","argWithSuffix","argThresholds","withSuffix","th","assign","toIsoString","version","updateLocale","tmpLocale","relativeTimeRounding","roundingFunction","relativeTimeThreshold","threshold","limit","myMoment","HTML5_FMT","DATETIME_LOCAL","DATETIME_LOCAL_SECONDS","DATETIME_LOCAL_MS","TIME","TIME_SECONDS","TIME_MS"],"mappings":"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"} \ No newline at end of file From dcfaa3720fa0a7d3a54f1563e2ecc04c95860d7f Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 09:22:16 -0400 Subject: [PATCH 28/82] - added customization for sensor default refresh rate --- NEMO/apps/sensors/customizations.py | 2 +- .../customizations_sensors.html | 21 +++++++++++++---- NEMO/apps/sensors/views.py | 23 ++++++++++++++----- 3 files changed, 35 insertions(+), 11 deletions(-) diff --git a/NEMO/apps/sensors/customizations.py b/NEMO/apps/sensors/customizations.py index ebbf9484..996c7828 100644 --- a/NEMO/apps/sensors/customizations.py +++ b/NEMO/apps/sensors/customizations.py @@ -4,4 +4,4 @@ @customization(key="sensors", title="Sensor Data") class SensorCustomization(CustomizationBase): - variables = {"sensor_default_daterange": ""} + variables = {"sensor_default_daterange": "", "sensor_default_refresh_rate": "0"} diff --git a/NEMO/apps/sensors/templates/customizations/customizations_sensors.html b/NEMO/apps/sensors/templates/customizations/customizations_sensors.html index a1310c6d..d5305821 100644 --- a/NEMO/apps/sensors/templates/customizations/customizations_sensors.html +++ b/NEMO/apps/sensors/templates/customizations/customizations_sensors.html @@ -3,15 +3,28 @@

    Sensor data settings

    {% csrf_token %}
    - -
    + +
    - - + +
    +
    + +
    + +
    +
    diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py index dec34acc..8d80999a 100644 --- a/NEMO/apps/sensors/views.py +++ b/NEMO/apps/sensors/views.py @@ -1,6 +1,7 @@ from datetime import datetime, timedelta from math import floor +import pytz from django.contrib.auth.decorators import login_required, permission_required from django.db.models import QuerySet from django.http import HttpResponse, JsonResponse @@ -41,9 +42,18 @@ def sensors(request, category_id=None): def sensor_details(request, sensor_id, tab: str = None): sensor = get_object_or_404(Sensor, pk=sensor_id) chart_step = int(request.GET.get("chart_step", 1)) - return render( - request, "sensors/sensor_data.html", {"tab": tab or "chart", "sensor": sensor, "chart_step": chart_step} - ) + default_refresh_rate = int(SensorCustomization.get("sensor_default_refresh_rate")) + refresh_rate = int(request.GET.get("refresh_rate", default_refresh_rate)) + sensor_data, start, end = get_sensor_data(request, sensor) + dictionary = { + "tab": tab or "chart", + "sensor": sensor, + "start": start, + "end": end, + "refresh_rate": refresh_rate, + "chart_step": chart_step, + } + return render(request, "sensors/sensor_data.html", dictionary) @staff_member_required @@ -84,17 +94,18 @@ def sensor_chart_data(request, sensor_id): def get_sensor_data(request, sensor) -> (QuerySet, datetime, datetime): - start, end = extract_times(request.POST, start_required=False, end_required=False) + start, end = extract_times(request.GET, input_timezone=pytz.UTC, start_required=False, end_required=False) sensor_data = SensorData.objects.filter(sensor=sensor) + now = timezone.now().replace(second=0) sensor_default_daterange = SensorCustomization.get("sensor_default_daterange") - if not start and not end: - now = timezone.now() + if not start: if sensor_default_daterange == "last_week": start = now - timedelta(weeks=1) elif sensor_default_daterange == "last_72hrs": start = now - timedelta(days=3) else: start = now - timedelta(days=1) + if not end: end = now return sensor_data.filter(created_date__gte=start, created_date__lte=end), start, end From f7642fc2e3ed0385de9cad45e21ad3c6b4d201e3 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 11:25:36 -0400 Subject: [PATCH 29/82] - fixed bug preventing more data to be read when an error occurred --- NEMO/apps/sensors/sensors.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/NEMO/apps/sensors/sensors.py b/NEMO/apps/sensors/sensors.py index 4d76502d..b1c3b219 100644 --- a/NEMO/apps/sensors/sensors.py +++ b/NEMO/apps/sensors/sensors.py @@ -38,6 +38,8 @@ def read_values(self, sensor: Sensor_model, raise_exception=False): try: registers = self.do_read_values(sensor) data_value = self.evaluate_sensor(sensor, registers=registers) + if data_value: + return SensorData.objects.create(sensor=sensor, value=data_value) except Exception as error: sensors_logger.error(error) if raise_exception: @@ -45,9 +47,6 @@ def read_values(self, sensor: Sensor_model, raise_exception=False): else: return error - if data_value: - return SensorData.objects.create(sensor=sensor, value=data_value) - def evaluate_sensor(self, sensor, registers, raise_exception=True): try: if sensor.formula: From 96841b2d8ab88216080650a5e429e01f1237f71d Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 11:37:31 -0400 Subject: [PATCH 30/82] - when copying a sensor configuration, read frequency will be disabled and must be manually updated. --- NEMO/apps/sensors/admin.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/NEMO/apps/sensors/admin.py b/NEMO/apps/sensors/admin.py index 4fbda8d1..02558de5 100644 --- a/NEMO/apps/sensors/admin.py +++ b/NEMO/apps/sensors/admin.py @@ -25,8 +25,9 @@ def duplicate_sensor_configuration(model_admin, request, queryset): ) continue else: - new_sensor = deepcopy(sensor) + new_sensor: Sensor = deepcopy(sensor) new_sensor.name = new_name + new_sensor.read_frequency = 0 new_sensor.id = None new_sensor.pk = None new_sensor.save() From 102d53efa8db21f6c032647438d84d1a7ad2afc9 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 12:54:47 -0400 Subject: [PATCH 31/82] - fixed set_interval_when_visible js function which would get called multiple times when visibility changes --- NEMO/static/nemo.js | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/NEMO/static/nemo.js b/NEMO/static/nemo.js index 09aa2605..60a6b5af 100644 --- a/NEMO/static/nemo.js +++ b/NEMO/static/nemo.js @@ -4,17 +4,32 @@ String.prototype.capitalize = function() { // This function allows making regular interval calls to a function only when the tab/window is visible. // It also gets called when the tab/window becomes visible (changing tabs, minimizing window etc.) -// It returns the interval handle +// This function is safe in the sense that is can be called multiple times with the same function. +// It will clear any previously set events and replace them with the new ones. +let function_handlers = {}; function set_interval_when_visible(doc, function_to_repeat, time) { - doc.addEventListener("visibilitychange", function() - { - function_to_repeat(); - }); - return setInterval(function() + const function_name = function_to_repeat.name; + if (!function_name) { + console.error("You can only call 'set_interval_when_visible' with a named function"); + } + let call_function_when_visible = function () { if (!doc.hidden) function_to_repeat(); - }, time) + } + if (function_handlers[function_name]) + { + // Clear the previous event and interval handler + doc.removeEventListener("visibilitychange", function_handlers[function_name][0]); + clearInterval(function_handlers[function_name][1]); + } + doc.addEventListener("visibilitychange", call_function_when_visible); + let intervalHandle = setInterval(call_function_when_visible, time); + if (function_name) + { + // Save new event and handler + function_handlers[function_name] = [call_function_when_visible, intervalHandle]; + } } // This function allows any page to switch between content tabs in From 8539c01f545b58f62ae232e102d2851419efb69b Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 13:27:22 -0400 Subject: [PATCH 32/82] - when called with no time parameter, set_interval_when_visible will clear handlers --- NEMO/static/nemo.js | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/NEMO/static/nemo.js b/NEMO/static/nemo.js index 60a6b5af..1ea3a65f 100644 --- a/NEMO/static/nemo.js +++ b/NEMO/static/nemo.js @@ -23,12 +23,15 @@ function set_interval_when_visible(doc, function_to_repeat, time) doc.removeEventListener("visibilitychange", function_handlers[function_name][0]); clearInterval(function_handlers[function_name][1]); } - doc.addEventListener("visibilitychange", call_function_when_visible); - let intervalHandle = setInterval(call_function_when_visible, time); - if (function_name) + if (time) { - // Save new event and handler - function_handlers[function_name] = [call_function_when_visible, intervalHandle]; + doc.addEventListener("visibilitychange", call_function_when_visible); + let intervalHandle = setInterval(call_function_when_visible, time); + if (function_name) + { + // Save new event and handler + function_handlers[function_name] = [call_function_when_visible, intervalHandle]; + } } } From fbb09d0d0765f514b0ced4ef6f93d220621202d2 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 13:51:18 -0400 Subject: [PATCH 33/82] - added new variables to set js dateformat for date and datetime pickers - formats can be set in settings.py - still need to go over all the places using pickers and update the code --- NEMO/context_processors.py | 4 ++++ NEMO/templatetags/custom_tags_and_filters.py | 22 ++++++++++---------- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/NEMO/context_processors.py b/NEMO/context_processors.py index 32437ba2..33333ed1 100644 --- a/NEMO/context_processors.py +++ b/NEMO/context_processors.py @@ -1,3 +1,5 @@ +from django.conf import settings + from NEMO.models import Area, Notification, PhysicalAccessLevel, Tool, User from NEMO.views.customization import get_customization from NEMO.views.notifications import get_notification_counts @@ -73,5 +75,7 @@ def base_context(request): "buddy_notification_count": buddy_notification_count, "temporary_access_notification_count": temporary_access_notification_count, "facility_managers_exist": facility_managers_exist, + "date_picker_js_format": getattr(settings, "DATE_PICKER_JS_FORMAT", "MM/DD/YYYY"), + "datetime_picker_js_format": getattr(settings, "DATETIME_PICKER_JS_FORMAT", "MM/DD/YYYY h:mm A"), "no_header": request.session.get("no_header", False), } diff --git a/NEMO/templatetags/custom_tags_and_filters.py b/NEMO/templatetags/custom_tags_and_filters.py index a09e4e15..66bf1e0f 100644 --- a/NEMO/templatetags/custom_tags_and_filters.py +++ b/NEMO/templatetags/custom_tags_and_filters.py @@ -33,8 +33,8 @@ def to_int(value): @register.filter() def to_date(value, arg=None): - if value in (None, ''): - return '' + if value in (None, ""): + return "" if isinstance(value, datetime.date): return date(value, arg) if isinstance(value, datetime.time): @@ -43,7 +43,7 @@ def to_date(value, arg=None): @register.filter -def json_search_base(items_to_search, display = "__str__"): +def json_search_base(items_to_search, display="__str__"): result = "[" for item in items_to_search: attr = getattr(item, display, None) @@ -85,15 +85,15 @@ def navigation_url(url_name, description): def res_question_tbody(dictionary): input_dict = dictionary[list(dictionary.keys())[0]] headers = list(input_dict.keys()) - header_cells = ''.join([format_html('{}', h) for h in headers]) - head_html = format_html('#{}', mark_safe(header_cells)) + header_cells = "".join([format_html("{}", h) for h in headers]) + head_html = format_html("#{}", mark_safe(header_cells)) rows = [] for i, (index, d) in enumerate(dictionary.items()): - data_cells_html = ''.join([format_html("{}", d[h]) for h in headers]) - row_html = format_html('{}{}', i + 1, mark_safe(data_cells_html)) + data_cells_html = "".join([format_html("{}", d[h]) for h in headers]) + row_html = format_html("{}{}", i + 1, mark_safe(data_cells_html)) rows.append(row_html) - body_html = format_html('{}', mark_safe(''.join(rows))) + body_html = format_html("{}", mark_safe("".join(rows))) return head_html + body_html @@ -104,10 +104,10 @@ def get_item(dictionary, key): @register.simple_tag def project_selection_display(project): - project_selection_template = get_customization('project_selection_template') + project_selection_template = get_customization("project_selection_template") contents = "{{ project.name }}" try: - contents = Template(project_selection_template).render(Context({'project': project})) + contents = Template(project_selection_template).render(Context({"project": project})) except: pass return format_html(contents) @@ -116,7 +116,7 @@ def project_selection_display(project): dist_version: str = "0" -@register.simple_tag() +@register.simple_tag def app_version() -> str: global dist_version if dist_version != "0": From 98dda124de7e38fbbb265d0530646407889e74ac Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 13:52:24 -0400 Subject: [PATCH 34/82] - added daterange for sensor chart and data table --- NEMO/apps/sensors/static/sensors/chart.min.js | 13 + .../static/sensors/daterangepicker.css | 410 +++++ .../sensors/static/sensors/daterangepicker.js | 1578 +++++++++++++++++ .../templates/sensors/sensor_data.html | 156 +- NEMO/apps/sensors/views.py | 4 +- 5 files changed, 2118 insertions(+), 43 deletions(-) create mode 100644 NEMO/apps/sensors/static/sensors/chart.min.js create mode 100644 NEMO/apps/sensors/static/sensors/daterangepicker.css create mode 100644 NEMO/apps/sensors/static/sensors/daterangepicker.js diff --git a/NEMO/apps/sensors/static/sensors/chart.min.js b/NEMO/apps/sensors/static/sensors/chart.min.js new file mode 100644 index 00000000..2b3e9984 --- /dev/null +++ b/NEMO/apps/sensors/static/sensors/chart.min.js @@ -0,0 +1,13 @@ +/*! + * Chart.js v3.7.1 + * https://www.chartjs.org + * (c) 2022 Chart.js Contributors + * Released under the MIT License + */ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Chart=e()}(this,(function(){"use strict";const t="undefined"==typeof window?function(t){return t()}:window.requestAnimationFrame;function e(e,i,s){const n=s||(t=>Array.prototype.slice.call(t));let o=!1,a=[];return function(...s){a=n(s),o||(o=!0,t.call(window,(()=>{o=!1,e.apply(i,a)})))}}function i(t,e){let i;return function(...s){return e?(clearTimeout(i),i=setTimeout(t,e,s)):t.apply(this,s),e}}const s=t=>"start"===t?"left":"end"===t?"right":"center",n=(t,e,i)=>"start"===t?e:"end"===t?i:(e+i)/2,o=(t,e,i,s)=>t===(s?"left":"right")?i:"center"===t?(e+i)/2:e;var a=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(t,e,i,s){const n=e.listeners[s],o=e.duration;n.forEach((s=>s({chart:t,initial:e.initial,numSteps:o,currentStep:Math.min(i-e.start,o)})))}_refresh(){this._request||(this._running=!0,this._request=t.call(window,(()=>{this._update(),this._request=null,this._running&&this._refresh()})))}_update(t=Date.now()){let e=0;this._charts.forEach(((i,s)=>{if(!i.running||!i.items.length)return;const n=i.items;let o,a=n.length-1,r=!1;for(;a>=0;--a)o=n[a],o._active?(o._total>i.duration&&(i.duration=o._total),o.tick(t),r=!0):(n[a]=n[n.length-1],n.pop());r&&(s.draw(),this._notify(s,i,t,"progress")),n.length||(i.running=!1,this._notify(s,i,t,"complete"),i.initial=!1),e+=n.length})),this._lastDate=t,0===e&&(this._running=!1)}_getAnims(t){const e=this._charts;let i=e.get(t);return i||(i={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},e.set(t,i)),i}listen(t,e,i){this._getAnims(t).listeners[e].push(i)}add(t,e){e&&e.length&&this._getAnims(t).items.push(...e)}has(t){return this._getAnims(t).items.length>0}start(t){const e=this._charts.get(t);e&&(e.running=!0,e.start=Date.now(),e.duration=e.items.reduce(((t,e)=>Math.max(t,e._duration)),0),this._refresh())}running(t){if(!this._running)return!1;const e=this._charts.get(t);return!!(e&&e.running&&e.items.length)}stop(t){const e=this._charts.get(t);if(!e||!e.items.length)return;const i=e.items;let s=i.length-1;for(;s>=0;--s)i[s].cancel();e.items=[],this._notify(t,e,Date.now(),"complete")}remove(t){return this._charts.delete(t)}}; +/*! + * @kurkle/color v0.1.9 + * https://github.com/kurkle/color#readme + * (c) 2020 Jukka Kurkela + * Released under the MIT License + */const r={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},l="0123456789ABCDEF",h=t=>l[15&t],c=t=>l[(240&t)>>4]+l[15&t],d=t=>(240&t)>>4==(15&t);function u(t){var e=function(t){return d(t.r)&&d(t.g)&&d(t.b)&&d(t.a)}(t)?h:c;return t?"#"+e(t.r)+e(t.g)+e(t.b)+(t.a<255?e(t.a):""):t}function f(t){return t+.5|0}const g=(t,e,i)=>Math.max(Math.min(t,i),e);function p(t){return g(f(2.55*t),0,255)}function m(t){return g(f(255*t),0,255)}function x(t){return g(f(t/2.55)/100,0,1)}function b(t){return g(f(100*t),0,100)}const _=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;const y=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function v(t,e,i){const s=e*Math.min(i,1-i),n=(e,n=(e+t/30)%12)=>i-s*Math.max(Math.min(n-3,9-n,1),-1);return[n(0),n(8),n(4)]}function w(t,e,i){const s=(s,n=(s+t/60)%6)=>i-i*e*Math.max(Math.min(n,4-n,1),0);return[s(5),s(3),s(1)]}function M(t,e,i){const s=v(t,1,.5);let n;for(e+i>1&&(n=1/(e+i),e*=n,i*=n),n=0;n<3;n++)s[n]*=1-e-i,s[n]+=e;return s}function k(t){const e=t.r/255,i=t.g/255,s=t.b/255,n=Math.max(e,i,s),o=Math.min(e,i,s),a=(n+o)/2;let r,l,h;return n!==o&&(h=n-o,l=a>.5?h/(2-n-o):h/(n+o),r=n===e?(i-s)/h+(i>16&255,o>>8&255,255&o]}return t}(),T.transparent=[0,0,0,0]);const e=T[t.toLowerCase()];return e&&{r:e[0],g:e[1],b:e[2],a:4===e.length?e[3]:255}}function R(t,e,i){if(t){let s=k(t);s[e]=Math.max(0,Math.min(s[e]+s[e]*i,0===e?360:1)),s=P(s),t.r=s[0],t.g=s[1],t.b=s[2]}}function E(t,e){return t?Object.assign(e||{},t):t}function I(t){var e={r:0,g:0,b:0,a:255};return Array.isArray(t)?t.length>=3&&(e={r:t[0],g:t[1],b:t[2],a:255},t.length>3&&(e.a=m(t[3]))):(e=E(t,{r:0,g:0,b:0,a:1})).a=m(e.a),e}function z(t){return"r"===t.charAt(0)?function(t){const e=_.exec(t);let i,s,n,o=255;if(e){if(e[7]!==i){const t=+e[7];o=255&(e[8]?p(t):255*t)}return i=+e[1],s=+e[3],n=+e[5],i=255&(e[2]?p(i):i),s=255&(e[4]?p(s):s),n=255&(e[6]?p(n):n),{r:i,g:s,b:n,a:o}}}(t):C(t)}class F{constructor(t){if(t instanceof F)return t;const e=typeof t;let i;var s,n,o;"object"===e?i=I(t):"string"===e&&(o=(s=t).length,"#"===s[0]&&(4===o||5===o?n={r:255&17*r[s[1]],g:255&17*r[s[2]],b:255&17*r[s[3]],a:5===o?17*r[s[4]]:255}:7!==o&&9!==o||(n={r:r[s[1]]<<4|r[s[2]],g:r[s[3]]<<4|r[s[4]],b:r[s[5]]<<4|r[s[6]],a:9===o?r[s[7]]<<4|r[s[8]]:255})),i=n||L(t)||z(t)),this._rgb=i,this._valid=!!i}get valid(){return this._valid}get rgb(){var t=E(this._rgb);return t&&(t.a=x(t.a)),t}set rgb(t){this._rgb=I(t)}rgbString(){return this._valid?(t=this._rgb)&&(t.a<255?`rgba(${t.r}, ${t.g}, ${t.b}, ${x(t.a)})`:`rgb(${t.r}, ${t.g}, ${t.b})`):this._rgb;var t}hexString(){return this._valid?u(this._rgb):this._rgb}hslString(){return this._valid?function(t){if(!t)return;const e=k(t),i=e[0],s=b(e[1]),n=b(e[2]);return t.a<255?`hsla(${i}, ${s}%, ${n}%, ${x(t.a)})`:`hsl(${i}, ${s}%, ${n}%)`}(this._rgb):this._rgb}mix(t,e){const i=this;if(t){const s=i.rgb,n=t.rgb;let o;const a=e===o?.5:e,r=2*a-1,l=s.a-n.a,h=((r*l==-1?r:(r+l)/(1+r*l))+1)/2;o=1-h,s.r=255&h*s.r+o*n.r+.5,s.g=255&h*s.g+o*n.g+.5,s.b=255&h*s.b+o*n.b+.5,s.a=a*s.a+(1-a)*n.a,i.rgb=s}return i}clone(){return new F(this.rgb)}alpha(t){return this._rgb.a=m(t),this}clearer(t){return this._rgb.a*=1-t,this}greyscale(){const t=this._rgb,e=f(.3*t.r+.59*t.g+.11*t.b);return t.r=t.g=t.b=e,this}opaquer(t){return this._rgb.a*=1+t,this}negate(){const t=this._rgb;return t.r=255-t.r,t.g=255-t.g,t.b=255-t.b,this}lighten(t){return R(this._rgb,2,t),this}darken(t){return R(this._rgb,2,-t),this}saturate(t){return R(this._rgb,1,t),this}desaturate(t){return R(this._rgb,1,-t),this}rotate(t){return function(t,e){var i=k(t);i[0]=D(i[0]+e),i=P(i),t.r=i[0],t.g=i[1],t.b=i[2]}(this._rgb,t),this}}function B(t){return new F(t)}const V=t=>t instanceof CanvasGradient||t instanceof CanvasPattern;function W(t){return V(t)?t:B(t)}function N(t){return V(t)?t:B(t).saturate(.5).darken(.1).hexString()}function H(){}const j=function(){let t=0;return function(){return t++}}();function $(t){return null==t}function Y(t){if(Array.isArray&&Array.isArray(t))return!0;const e=Object.prototype.toString.call(t);return"[object"===e.substr(0,7)&&"Array]"===e.substr(-6)}function U(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)}const X=t=>("number"==typeof t||t instanceof Number)&&isFinite(+t);function q(t,e){return X(t)?t:e}function K(t,e){return void 0===t?e:t}const G=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100:t/e,Z=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100*e:+t;function J(t,e,i){if(t&&"function"==typeof t.call)return t.apply(i,e)}function Q(t,e,i,s){let n,o,a;if(Y(t))if(o=t.length,s)for(n=o-1;n>=0;n--)e.call(i,t[n],n);else for(n=0;ni;)t=t[e.substr(i,s-i)],i=s+1,s=rt(e,i);return t}function ht(t){return t.charAt(0).toUpperCase()+t.slice(1)}const ct=t=>void 0!==t,dt=t=>"function"==typeof t,ut=(t,e)=>{if(t.size!==e.size)return!1;for(const i of t)if(!e.has(i))return!1;return!0};function ft(t){return"mouseup"===t.type||"click"===t.type||"contextmenu"===t.type}const gt=Object.create(null),pt=Object.create(null);function mt(t,e){if(!e)return t;const i=e.split(".");for(let e=0,s=i.length;et.chart.platform.getDevicePixelRatio(),this.elements={},this.events=["mousemove","mouseout","click","touchstart","touchmove"],this.font={family:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",size:12,style:"normal",lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(t,e)=>N(e.backgroundColor),this.hoverBorderColor=(t,e)=>N(e.borderColor),this.hoverColor=(t,e)=>N(e.color),this.indexAxis="x",this.interaction={mode:"nearest",intersect:!0},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(t)}set(t,e){return xt(this,t,e)}get(t){return mt(this,t)}describe(t,e){return xt(pt,t,e)}override(t,e){return xt(gt,t,e)}route(t,e,i,s){const n=mt(this,t),o=mt(this,i),a="_"+e;Object.defineProperties(n,{[a]:{value:n[e],writable:!0},[e]:{enumerable:!0,get(){const t=this[a],e=o[s];return U(t)?Object.assign({},e,t):K(t,e)},set(t){this[a]=t}}})}}({_scriptable:t=>!t.startsWith("on"),_indexable:t=>"events"!==t,hover:{_fallback:"interaction"},interaction:{_scriptable:!1,_indexable:!1}});const _t=Math.PI,yt=2*_t,vt=yt+_t,wt=Number.POSITIVE_INFINITY,Mt=_t/180,kt=_t/2,St=_t/4,Pt=2*_t/3,Dt=Math.log10,Ct=Math.sign;function Ot(t){const e=Math.round(t);t=Lt(t,e,t/1e3)?e:t;const i=Math.pow(10,Math.floor(Dt(t))),s=t/i;return(s<=1?1:s<=2?2:s<=5?5:10)*i}function At(t){const e=[],i=Math.sqrt(t);let s;for(s=1;st-e)).pop(),e}function Tt(t){return!isNaN(parseFloat(t))&&isFinite(t)}function Lt(t,e,i){return Math.abs(t-e)=t}function Et(t,e,i){let s,n,o;for(s=0,n=t.length;sl&&h=Math.min(e,i)-s&&t<=Math.max(e,i)+s}function Ut(t){return!t||$(t.size)||$(t.family)?null:(t.style?t.style+" ":"")+(t.weight?t.weight+" ":"")+t.size+"px "+t.family}function Xt(t,e,i,s,n){let o=e[n];return o||(o=e[n]=t.measureText(n).width,i.push(n)),o>s&&(s=o),s}function qt(t,e,i,s){let n=(s=s||{}).data=s.data||{},o=s.garbageCollect=s.garbageCollect||[];s.font!==e&&(n=s.data={},o=s.garbageCollect=[],s.font=e),t.save(),t.font=e;let a=0;const r=i.length;let l,h,c,d,u;for(l=0;li.length){for(l=0;l0&&t.stroke()}}function Jt(t,e,i){return i=i||.5,!e||t&&t.x>e.left-i&&t.xe.top-i&&t.y0&&""!==o.strokeColor;let l,h;for(t.save(),t.font=n.string,function(t,e){e.translation&&t.translate(e.translation[0],e.translation[1]);$(e.rotation)||t.rotate(e.rotation);e.color&&(t.fillStyle=e.color);e.textAlign&&(t.textAlign=e.textAlign);e.textBaseline&&(t.textBaseline=e.textBaseline)}(t,o),l=0;lt[i]1;)s=o+n>>1,i(s)?o=s:n=s;return{lo:o,hi:n}}const re=(t,e,i)=>ae(t,i,(s=>t[s][e]ae(t,i,(s=>t[s][e]>=i));function he(t,e,i){let s=0,n=t.length;for(;ss&&t[n-1]>i;)n--;return s>0||n{const i="_onData"+ht(e),s=t[e];Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value(...e){const n=s.apply(this,e);return t._chartjs.listeners.forEach((t=>{"function"==typeof t[i]&&t[i](...e)})),n}})})))}function ue(t,e){const i=t._chartjs;if(!i)return;const s=i.listeners,n=s.indexOf(e);-1!==n&&s.splice(n,1),s.length>0||(ce.forEach((e=>{delete t[e]})),delete t._chartjs)}function fe(t){const e=new Set;let i,s;for(i=0,s=t.length;iwindow.getComputedStyle(t,null);function be(t,e){return xe(t).getPropertyValue(e)}const _e=["top","right","bottom","left"];function ye(t,e,i){const s={};i=i?"-"+i:"";for(let n=0;n<4;n++){const o=_e[n];s[o]=parseFloat(t[e+"-"+o+i])||0}return s.width=s.left+s.right,s.height=s.top+s.bottom,s}function ve(t,e){const{canvas:i,currentDevicePixelRatio:s}=e,n=xe(i),o="border-box"===n.boxSizing,a=ye(n,"padding"),r=ye(n,"border","width"),{x:l,y:h,box:c}=function(t,e){const i=t.native||t,s=i.touches,n=s&&s.length?s[0]:i,{offsetX:o,offsetY:a}=n;let r,l,h=!1;if(((t,e,i)=>(t>0||e>0)&&(!i||!i.shadowRoot))(o,a,i.target))r=o,l=a;else{const t=e.getBoundingClientRect();r=n.clientX-t.left,l=n.clientY-t.top,h=!0}return{x:r,y:l,box:h}}(t,i),d=a.left+(c&&r.left),u=a.top+(c&&r.top);let{width:f,height:g}=e;return o&&(f-=a.width+r.width,g-=a.height+r.height),{x:Math.round((l-d)/f*i.width/s),y:Math.round((h-u)/g*i.height/s)}}const we=t=>Math.round(10*t)/10;function Me(t,e,i,s){const n=xe(t),o=ye(n,"margin"),a=me(n.maxWidth,t,"clientWidth")||wt,r=me(n.maxHeight,t,"clientHeight")||wt,l=function(t,e,i){let s,n;if(void 0===e||void 0===i){const o=pe(t);if(o){const t=o.getBoundingClientRect(),a=xe(o),r=ye(a,"border","width"),l=ye(a,"padding");e=t.width-l.width-r.width,i=t.height-l.height-r.height,s=me(a.maxWidth,o,"clientWidth"),n=me(a.maxHeight,o,"clientHeight")}else e=t.clientWidth,i=t.clientHeight}return{width:e,height:i,maxWidth:s||wt,maxHeight:n||wt}}(t,e,i);let{width:h,height:c}=l;if("content-box"===n.boxSizing){const t=ye(n,"border","width"),e=ye(n,"padding");h-=e.width+t.width,c-=e.height+t.height}return h=Math.max(0,h-o.width),c=Math.max(0,s?Math.floor(h/s):c-o.height),h=we(Math.min(h,a,l.maxWidth)),c=we(Math.min(c,r,l.maxHeight)),h&&!c&&(c=we(h/2)),{width:h,height:c}}function ke(t,e,i){const s=e||1,n=Math.floor(t.height*s),o=Math.floor(t.width*s);t.height=n/s,t.width=o/s;const a=t.canvas;return a.style&&(i||!a.style.height&&!a.style.width)&&(a.style.height=`${t.height}px`,a.style.width=`${t.width}px`),(t.currentDevicePixelRatio!==s||a.height!==n||a.width!==o)&&(t.currentDevicePixelRatio=s,a.height=n,a.width=o,t.ctx.setTransform(s,0,0,s,0,0),!0)}const Se=function(){let t=!1;try{const e={get passive(){return t=!0,!1}};window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(t){}return t}();function Pe(t,e){const i=be(t,e),s=i&&i.match(/^(\d+)(\.\d+)?px$/);return s?+s[1]:void 0}function De(t,e){return"native"in t?{x:t.x,y:t.y}:ve(t,e)}function Ce(t,e,i,s){const{controller:n,data:o,_sorted:a}=t,r=n._cachedMeta.iScale;if(r&&e===r.axis&&"r"!==e&&a&&o.length){const t=r._reversePixels?le:re;if(!s)return t(o,e,i);if(n._sharedOptions){const s=o[0],n="function"==typeof s.getRange&&s.getRange(e);if(n){const s=t(o,e,i-n),a=t(o,e,i+n);return{lo:s.lo,hi:a.hi}}}}return{lo:0,hi:o.length-1}}function Oe(t,e,i,s,n){const o=t.getSortedVisibleDatasetMetas(),a=i[e];for(let t=0,i=o.length;t{t[r](n[a],s)&&o.push({element:t,datasetIndex:e,index:i}),t.inRange(n.x,n.y,s)&&(l=!0)})),i.intersect&&!l?[]:o}var Ee={modes:{index(t,e,i,s){const n=De(e,t),o=i.axis||"x",a=i.intersect?Ae(t,n,o,s):Le(t,n,o,!1,s),r=[];return a.length?(t.getSortedVisibleDatasetMetas().forEach((t=>{const e=a[0].index,i=t.data[e];i&&!i.skip&&r.push({element:i,datasetIndex:t.index,index:e})})),r):[]},dataset(t,e,i,s){const n=De(e,t),o=i.axis||"xy";let a=i.intersect?Ae(t,n,o,s):Le(t,n,o,!1,s);if(a.length>0){const e=a[0].datasetIndex,i=t.getDatasetMeta(e).data;a=[];for(let t=0;tAe(t,De(e,t),i.axis||"xy",s),nearest:(t,e,i,s)=>Le(t,De(e,t),i.axis||"xy",i.intersect,s),x:(t,e,i,s)=>Re(t,e,{axis:"x",intersect:i.intersect},s),y:(t,e,i,s)=>Re(t,e,{axis:"y",intersect:i.intersect},s)}};const Ie=new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/),ze=new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);function Fe(t,e){const i=(""+t).match(Ie);if(!i||"normal"===i[1])return 1.2*e;switch(t=+i[2],i[3]){case"px":return t;case"%":t/=100}return e*t}function Be(t,e){const i={},s=U(e),n=s?Object.keys(e):e,o=U(t)?s?i=>K(t[i],t[e[i]]):e=>t[e]:()=>t;for(const t of n)i[t]=+o(t)||0;return i}function Ve(t){return Be(t,{top:"y",right:"x",bottom:"y",left:"x"})}function We(t){return Be(t,["topLeft","topRight","bottomLeft","bottomRight"])}function Ne(t){const e=Ve(t);return e.width=e.left+e.right,e.height=e.top+e.bottom,e}function He(t,e){t=t||{},e=e||bt.font;let i=K(t.size,e.size);"string"==typeof i&&(i=parseInt(i,10));let s=K(t.style,e.style);s&&!(""+s).match(ze)&&(console.warn('Invalid font style specified: "'+s+'"'),s="");const n={family:K(t.family,e.family),lineHeight:Fe(K(t.lineHeight,e.lineHeight),i),size:i,style:s,weight:K(t.weight,e.weight),string:""};return n.string=Ut(n),n}function je(t,e,i,s){let n,o,a,r=!0;for(n=0,o=t.length;ni&&0===t?0:t+e;return{min:a(s,-Math.abs(o)),max:a(n,o)}}function Ye(t,e){return Object.assign(Object.create(t),e)}const Ue=["left","top","right","bottom"];function Xe(t,e){return t.filter((t=>t.pos===e))}function qe(t,e){return t.filter((t=>-1===Ue.indexOf(t.pos)&&t.box.axis===e))}function Ke(t,e){return t.sort(((t,i)=>{const s=e?i:t,n=e?t:i;return s.weight===n.weight?s.index-n.index:s.weight-n.weight}))}function Ge(t,e){const i=function(t){const e={};for(const i of t){const{stack:t,pos:s,stackWeight:n}=i;if(!t||!Ue.includes(s))continue;const o=e[t]||(e[t]={count:0,placed:0,weight:0,size:0});o.count++,o.weight+=n}return e}(t),{vBoxMaxWidth:s,hBoxMaxHeight:n}=e;let o,a,r;for(o=0,a=t.length;o{s[t]=Math.max(e[t],i[t])})),s}return s(t?["left","right"]:["top","bottom"])}function ei(t,e,i,s){const n=[];let o,a,r,l,h,c;for(o=0,a=t.length,h=0;ot.box.fullSize)),!0),s=Ke(Xe(e,"left"),!0),n=Ke(Xe(e,"right")),o=Ke(Xe(e,"top"),!0),a=Ke(Xe(e,"bottom")),r=qe(e,"x"),l=qe(e,"y");return{fullSize:i,leftAndTop:s.concat(o),rightAndBottom:n.concat(l).concat(a).concat(r),chartArea:Xe(e,"chartArea"),vertical:s.concat(n).concat(l),horizontal:o.concat(a).concat(r)}}(t.boxes),l=r.vertical,h=r.horizontal;Q(t.boxes,(t=>{"function"==typeof t.beforeLayout&&t.beforeLayout()}));const c=l.reduce(((t,e)=>e.box.options&&!1===e.box.options.display?t:t+1),0)||1,d=Object.freeze({outerWidth:e,outerHeight:i,padding:n,availableWidth:o,availableHeight:a,vBoxMaxWidth:o/2/c,hBoxMaxHeight:a/2}),u=Object.assign({},n);Je(u,Ne(s));const f=Object.assign({maxPadding:u,w:o,h:a,x:n.left,y:n.top},n),g=Ge(l.concat(h),d);ei(r.fullSize,f,d,g),ei(l,f,d,g),ei(h,f,d,g)&&ei(l,f,d,g),function(t){const e=t.maxPadding;function i(i){const s=Math.max(e[i]-t[i],0);return t[i]+=s,s}t.y+=i("top"),t.x+=i("left"),i("right"),i("bottom")}(f),si(r.leftAndTop,f,d,g),f.x+=f.w,f.y+=f.h,si(r.rightAndBottom,f,d,g),t.chartArea={left:f.left,top:f.top,right:f.left+f.w,bottom:f.top+f.h,height:f.h,width:f.w},Q(r.chartArea,(e=>{const i=e.box;Object.assign(i,t.chartArea),i.update(f.w,f.h,{left:0,top:0,right:0,bottom:0})}))}};function oi(t,e=[""],i=t,s,n=(()=>t[0])){ct(s)||(s=mi("_fallback",t));const o={[Symbol.toStringTag]:"Object",_cacheable:!0,_scopes:t,_rootScopes:i,_fallback:s,_getTarget:n,override:n=>oi([n,...t],e,i,s)};return new Proxy(o,{deleteProperty:(e,i)=>(delete e[i],delete e._keys,delete t[0][i],!0),get:(i,s)=>ci(i,s,(()=>function(t,e,i,s){let n;for(const o of e)if(n=mi(li(o,t),i),ct(n))return hi(t,n)?gi(i,s,t,n):n}(s,e,t,i))),getOwnPropertyDescriptor:(t,e)=>Reflect.getOwnPropertyDescriptor(t._scopes[0],e),getPrototypeOf:()=>Reflect.getPrototypeOf(t[0]),has:(t,e)=>xi(t).includes(e),ownKeys:t=>xi(t),set(t,e,i){const s=t._storage||(t._storage=n());return t[e]=s[e]=i,delete t._keys,!0}})}function ai(t,e,i,s){const n={_cacheable:!1,_proxy:t,_context:e,_subProxy:i,_stack:new Set,_descriptors:ri(t,s),setContext:e=>ai(t,e,i,s),override:n=>ai(t.override(n),e,i,s)};return new Proxy(n,{deleteProperty:(e,i)=>(delete e[i],delete t[i],!0),get:(t,e,i)=>ci(t,e,(()=>function(t,e,i){const{_proxy:s,_context:n,_subProxy:o,_descriptors:a}=t;let r=s[e];dt(r)&&a.isScriptable(e)&&(r=function(t,e,i,s){const{_proxy:n,_context:o,_subProxy:a,_stack:r}=i;if(r.has(t))throw new Error("Recursion detected: "+Array.from(r).join("->")+"->"+t);r.add(t),e=e(o,a||s),r.delete(t),hi(t,e)&&(e=gi(n._scopes,n,t,e));return e}(e,r,t,i));Y(r)&&r.length&&(r=function(t,e,i,s){const{_proxy:n,_context:o,_subProxy:a,_descriptors:r}=i;if(ct(o.index)&&s(t))e=e[o.index%e.length];else if(U(e[0])){const i=e,s=n._scopes.filter((t=>t!==i));e=[];for(const l of i){const i=gi(s,n,t,l);e.push(ai(i,o,a&&a[t],r))}}return e}(e,r,t,a.isIndexable));hi(e,r)&&(r=ai(r,n,o&&o[e],a));return r}(t,e,i))),getOwnPropertyDescriptor:(e,i)=>e._descriptors.allKeys?Reflect.has(t,i)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(t,i),getPrototypeOf:()=>Reflect.getPrototypeOf(t),has:(e,i)=>Reflect.has(t,i),ownKeys:()=>Reflect.ownKeys(t),set:(e,i,s)=>(t[i]=s,delete e[i],!0)})}function ri(t,e={scriptable:!0,indexable:!0}){const{_scriptable:i=e.scriptable,_indexable:s=e.indexable,_allKeys:n=e.allKeys}=t;return{allKeys:n,scriptable:i,indexable:s,isScriptable:dt(i)?i:()=>i,isIndexable:dt(s)?s:()=>s}}const li=(t,e)=>t?t+ht(e):e,hi=(t,e)=>U(e)&&"adapters"!==t&&(null===Object.getPrototypeOf(e)||e.constructor===Object);function ci(t,e,i){if(Object.prototype.hasOwnProperty.call(t,e))return t[e];const s=i();return t[e]=s,s}function di(t,e,i){return dt(t)?t(e,i):t}const ui=(t,e)=>!0===t?e:"string"==typeof t?lt(e,t):void 0;function fi(t,e,i,s,n){for(const o of e){const e=ui(i,o);if(e){t.add(e);const o=di(e._fallback,i,n);if(ct(o)&&o!==i&&o!==s)return o}else if(!1===e&&ct(s)&&i!==s)return null}return!1}function gi(t,e,i,s){const n=e._rootScopes,o=di(e._fallback,i,s),a=[...t,...n],r=new Set;r.add(s);let l=pi(r,a,i,o||i,s);return null!==l&&((!ct(o)||o===i||(l=pi(r,a,o,l,s),null!==l))&&oi(Array.from(r),[""],n,o,(()=>function(t,e,i){const s=t._getTarget();e in s||(s[e]={});const n=s[e];if(Y(n)&&U(i))return i;return n}(e,i,s))))}function pi(t,e,i,s,n){for(;i;)i=fi(t,e,i,s,n);return i}function mi(t,e){for(const i of e){if(!i)continue;const e=i[t];if(ct(e))return e}}function xi(t){let e=t._keys;return e||(e=t._keys=function(t){const e=new Set;for(const i of t)for(const t of Object.keys(i).filter((t=>!t.startsWith("_"))))e.add(t);return Array.from(e)}(t._scopes)),e}const bi=Number.EPSILON||1e-14,_i=(t,e)=>e"x"===t?"y":"x";function vi(t,e,i,s){const n=t.skip?e:t,o=e,a=i.skip?e:i,r=Vt(o,n),l=Vt(a,o);let h=r/(r+l),c=l/(r+l);h=isNaN(h)?0:h,c=isNaN(c)?0:c;const d=s*h,u=s*c;return{previous:{x:o.x-d*(a.x-n.x),y:o.y-d*(a.y-n.y)},next:{x:o.x+u*(a.x-n.x),y:o.y+u*(a.y-n.y)}}}function wi(t,e="x"){const i=yi(e),s=t.length,n=Array(s).fill(0),o=Array(s);let a,r,l,h=_i(t,0);for(a=0;a!t.skip))),"monotone"===e.cubicInterpolationMode)wi(t,n);else{let i=s?t[t.length-1]:t[0];for(o=0,a=t.length;o0===t||1===t,Pi=(t,e,i)=>-Math.pow(2,10*(t-=1))*Math.sin((t-e)*yt/i),Di=(t,e,i)=>Math.pow(2,-10*t)*Math.sin((t-e)*yt/i)+1,Ci={linear:t=>t,easeInQuad:t=>t*t,easeOutQuad:t=>-t*(t-2),easeInOutQuad:t=>(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1),easeInCubic:t=>t*t*t,easeOutCubic:t=>(t-=1)*t*t+1,easeInOutCubic:t=>(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2),easeInQuart:t=>t*t*t*t,easeOutQuart:t=>-((t-=1)*t*t*t-1),easeInOutQuart:t=>(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2),easeInQuint:t=>t*t*t*t*t,easeOutQuint:t=>(t-=1)*t*t*t*t+1,easeInOutQuint:t=>(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2),easeInSine:t=>1-Math.cos(t*kt),easeOutSine:t=>Math.sin(t*kt),easeInOutSine:t=>-.5*(Math.cos(_t*t)-1),easeInExpo:t=>0===t?0:Math.pow(2,10*(t-1)),easeOutExpo:t=>1===t?1:1-Math.pow(2,-10*t),easeInOutExpo:t=>Si(t)?t:t<.5?.5*Math.pow(2,10*(2*t-1)):.5*(2-Math.pow(2,-10*(2*t-1))),easeInCirc:t=>t>=1?t:-(Math.sqrt(1-t*t)-1),easeOutCirc:t=>Math.sqrt(1-(t-=1)*t),easeInOutCirc:t=>(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1),easeInElastic:t=>Si(t)?t:Pi(t,.075,.3),easeOutElastic:t=>Si(t)?t:Di(t,.075,.3),easeInOutElastic(t){const e=.1125;return Si(t)?t:t<.5?.5*Pi(2*t,e,.45):.5+.5*Di(2*t-1,e,.45)},easeInBack(t){const e=1.70158;return t*t*((e+1)*t-e)},easeOutBack(t){const e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack(t){let e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:t=>1-Ci.easeOutBounce(1-t),easeOutBounce(t){const e=7.5625,i=2.75;return t<1/i?e*t*t:t<2/i?e*(t-=1.5/i)*t+.75:t<2.5/i?e*(t-=2.25/i)*t+.9375:e*(t-=2.625/i)*t+.984375},easeInOutBounce:t=>t<.5?.5*Ci.easeInBounce(2*t):.5*Ci.easeOutBounce(2*t-1)+.5};function Oi(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:t.y+i*(e.y-t.y)}}function Ai(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:"middle"===s?i<.5?t.y:e.y:"after"===s?i<1?t.y:e.y:i>0?e.y:t.y}}function Ti(t,e,i,s){const n={x:t.cp2x,y:t.cp2y},o={x:e.cp1x,y:e.cp1y},a=Oi(t,n,i),r=Oi(n,o,i),l=Oi(o,e,i),h=Oi(a,r,i),c=Oi(r,l,i);return Oi(h,c,i)}const Li=new Map;function Ri(t,e,i){return function(t,e){e=e||{};const i=t+JSON.stringify(e);let s=Li.get(i);return s||(s=new Intl.NumberFormat(t,e),Li.set(i,s)),s}(e,i).format(t)}function Ei(t,e,i){return t?function(t,e){return{x:i=>t+t+e-i,setWidth(t){e=t},textAlign:t=>"center"===t?t:"right"===t?"left":"right",xPlus:(t,e)=>t-e,leftForLtr:(t,e)=>t-e}}(e,i):{x:t=>t,setWidth(t){},textAlign:t=>t,xPlus:(t,e)=>t+e,leftForLtr:(t,e)=>t}}function Ii(t,e){let i,s;"ltr"!==e&&"rtl"!==e||(i=t.canvas.style,s=[i.getPropertyValue("direction"),i.getPropertyPriority("direction")],i.setProperty("direction",e,"important"),t.prevTextDirection=s)}function zi(t,e){void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}function Fi(t){return"angle"===t?{between:Ht,compare:Wt,normalize:Nt}:{between:Yt,compare:(t,e)=>t-e,normalize:t=>t}}function Bi({start:t,end:e,count:i,loop:s,style:n}){return{start:t%i,end:e%i,loop:s&&(e-t+1)%i==0,style:n}}function Vi(t,e,i){if(!i)return[t];const{property:s,start:n,end:o}=i,a=e.length,{compare:r,between:l,normalize:h}=Fi(s),{start:c,end:d,loop:u,style:f}=function(t,e,i){const{property:s,start:n,end:o}=i,{between:a,normalize:r}=Fi(s),l=e.length;let h,c,{start:d,end:u,loop:f}=t;if(f){for(d+=l,u+=l,h=0,c=l;hb||l(n,x,p)&&0!==r(n,x),v=()=>!b||0===r(o,p)||l(o,x,p);for(let t=c,i=c;t<=d;++t)m=e[t%a],m.skip||(p=h(m[s]),p!==x&&(b=l(p,n,o),null===_&&y()&&(_=0===r(p,n)?t:i),null!==_&&v()&&(g.push(Bi({start:_,end:t,loop:u,count:a,style:f})),_=null),i=t,x=p));return null!==_&&g.push(Bi({start:_,end:d,loop:u,count:a,style:f})),g}function Wi(t,e){const i=[],s=t.segments;for(let n=0;nn&&t[o%e].skip;)o--;return o%=e,{start:n,end:o}}(i,n,o,s);if(!0===s)return Hi(t,[{start:a,end:r,loop:o}],i,e);return Hi(t,function(t,e,i,s){const n=t.length,o=[];let a,r=e,l=t[e];for(a=e+1;a<=i;++a){const i=t[a%n];i.skip||i.stop?l.skip||(s=!1,o.push({start:e%n,end:(a-1)%n,loop:s}),e=r=i.stop?a:null):(r=a,l.skip&&(e=a)),l=i}return null!==r&&o.push({start:e%n,end:r%n,loop:s}),o}(i,a,rnull===t||""===t;const Gi=!!Se&&{passive:!0};function Zi(t,e,i){t.canvas.removeEventListener(e,i,Gi)}function Ji(t,e){for(const i of t)if(i===e||i.contains(e))return!0}function Qi(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||Ji(i.addedNodes,s),e=e&&!Ji(i.removedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}function ts(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||Ji(i.removedNodes,s),e=e&&!Ji(i.addedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}const es=new Map;let is=0;function ss(){const t=window.devicePixelRatio;t!==is&&(is=t,es.forEach(((e,i)=>{i.currentDevicePixelRatio!==t&&e()})))}function ns(t,i,s){const n=t.canvas,o=n&&pe(n);if(!o)return;const a=e(((t,e)=>{const i=o.clientWidth;s(t,e),i{const e=t[0],i=e.contentRect.width,s=e.contentRect.height;0===i&&0===s||a(i,s)}));return r.observe(o),function(t,e){es.size||window.addEventListener("resize",ss),es.set(t,e)}(t,a),r}function os(t,e,i){i&&i.disconnect(),"resize"===e&&function(t){es.delete(t),es.size||window.removeEventListener("resize",ss)}(t)}function as(t,i,s){const n=t.canvas,o=e((e=>{null!==t.ctx&&s(function(t,e){const i=qi[t.type]||t.type,{x:s,y:n}=ve(t,e);return{type:i,chart:e,native:t,x:void 0!==s?s:null,y:void 0!==n?n:null}}(e,t))}),t,(t=>{const e=t[0];return[e,e.offsetX,e.offsetY]}));return function(t,e,i){t.addEventListener(e,i,Gi)}(n,i,o),o}class rs extends Ui{acquireContext(t,e){const i=t&&t.getContext&&t.getContext("2d");return i&&i.canvas===t?(function(t,e){const i=t.style,s=t.getAttribute("height"),n=t.getAttribute("width");if(t.$chartjs={initial:{height:s,width:n,style:{display:i.display,height:i.height,width:i.width}}},i.display=i.display||"block",i.boxSizing=i.boxSizing||"border-box",Ki(n)){const e=Pe(t,"width");void 0!==e&&(t.width=e)}if(Ki(s))if(""===t.style.height)t.height=t.width/(e||2);else{const e=Pe(t,"height");void 0!==e&&(t.height=e)}}(t,e),i):null}releaseContext(t){const e=t.canvas;if(!e.$chartjs)return!1;const i=e.$chartjs.initial;["height","width"].forEach((t=>{const s=i[t];$(s)?e.removeAttribute(t):e.setAttribute(t,s)}));const s=i.style||{};return Object.keys(s).forEach((t=>{e.style[t]=s[t]})),e.width=e.width,delete e.$chartjs,!0}addEventListener(t,e,i){this.removeEventListener(t,e);const s=t.$proxies||(t.$proxies={}),n={attach:Qi,detach:ts,resize:ns}[e]||as;s[e]=n(t,e,i)}removeEventListener(t,e){const i=t.$proxies||(t.$proxies={}),s=i[e];if(!s)return;({attach:os,detach:os,resize:os}[e]||Zi)(t,e,s),i[e]=void 0}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(t,e,i,s){return Me(t,e,i,s)}isAttached(t){const e=pe(t);return!(!e||!e.isConnected)}}function ls(t){return!ge()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas?Xi:rs}var hs=Object.freeze({__proto__:null,_detectPlatform:ls,BasePlatform:Ui,BasicPlatform:Xi,DomPlatform:rs});const cs="transparent",ds={boolean:(t,e,i)=>i>.5?e:t,color(t,e,i){const s=W(t||cs),n=s.valid&&W(e||cs);return n&&n.valid?n.mix(s,i).hexString():e},number:(t,e,i)=>t+(e-t)*i};class us{constructor(t,e,i,s){const n=e[i];s=je([t.to,s,n,t.from]);const o=je([t.from,n,s]);this._active=!0,this._fn=t.fn||ds[t.type||typeof o],this._easing=Ci[t.easing]||Ci.linear,this._start=Math.floor(Date.now()+(t.delay||0)),this._duration=this._total=Math.floor(t.duration),this._loop=!!t.loop,this._target=e,this._prop=i,this._from=o,this._to=s,this._promises=void 0}active(){return this._active}update(t,e,i){if(this._active){this._notify(!1);const s=this._target[this._prop],n=i-this._start,o=this._duration-n;this._start=i,this._duration=Math.floor(Math.max(o,t.duration)),this._total+=n,this._loop=!!t.loop,this._to=je([t.to,e,s,t.from]),this._from=je([t.from,s,e])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(t){const e=t-this._start,i=this._duration,s=this._prop,n=this._from,o=this._loop,a=this._to;let r;if(this._active=n!==a&&(o||e1?2-r:r,r=this._easing(Math.min(1,Math.max(0,r))),this._target[s]=this._fn(n,a,r))}wait(){const t=this._promises||(this._promises=[]);return new Promise(((e,i)=>{t.push({res:e,rej:i})}))}_notify(t){const e=t?"res":"rej",i=this._promises||[];for(let t=0;t"onProgress"!==t&&"onComplete"!==t&&"fn"!==t}),bt.set("animations",{colors:{type:"color",properties:["color","borderColor","backgroundColor"]},numbers:{type:"number",properties:["x","y","borderWidth","radius","tension"]}}),bt.describe("animations",{_fallback:"animation"}),bt.set("transitions",{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:"transparent"},visible:{type:"boolean",duration:0}}},hide:{animations:{colors:{to:"transparent"},visible:{type:"boolean",easing:"linear",fn:t=>0|t}}}});class gs{constructor(t,e){this._chart=t,this._properties=new Map,this.configure(e)}configure(t){if(!U(t))return;const e=this._properties;Object.getOwnPropertyNames(t).forEach((i=>{const s=t[i];if(!U(s))return;const n={};for(const t of fs)n[t]=s[t];(Y(s.properties)&&s.properties||[i]).forEach((t=>{t!==i&&e.has(t)||e.set(t,n)}))}))}_animateOptions(t,e){const i=e.options,s=function(t,e){if(!e)return;let i=t.options;if(!i)return void(t.options=e);i.$shared&&(t.options=i=Object.assign({},i,{$shared:!1,$animations:{}}));return i}(t,i);if(!s)return[];const n=this._createAnimations(s,i);return i.$shared&&function(t,e){const i=[],s=Object.keys(e);for(let e=0;e{t.options=i}),(()=>{})),n}_createAnimations(t,e){const i=this._properties,s=[],n=t.$animations||(t.$animations={}),o=Object.keys(e),a=Date.now();let r;for(r=o.length-1;r>=0;--r){const l=o[r];if("$"===l.charAt(0))continue;if("options"===l){s.push(...this._animateOptions(t,e));continue}const h=e[l];let c=n[l];const d=i.get(l);if(c){if(d&&c.active()){c.update(d,h,a);continue}c.cancel()}d&&d.duration?(n[l]=c=new us(d,t,l,h),s.push(c)):t[l]=h}return s}update(t,e){if(0===this._properties.size)return void Object.assign(t,e);const i=this._createAnimations(t,e);return i.length?(a.add(this._chart,i),!0):void 0}}function ps(t,e){const i=t&&t.options||{},s=i.reverse,n=void 0===i.min?e:0,o=void 0===i.max?e:0;return{start:s?o:n,end:s?n:o}}function ms(t,e){const i=[],s=t._getSortedDatasetMetas(e);let n,o;for(n=0,o=s.length;n0||!i&&e<0)return n.index}return null}function vs(t,e){const{chart:i,_cachedMeta:s}=t,n=i._stacks||(i._stacks={}),{iScale:o,vScale:a,index:r}=s,l=o.axis,h=a.axis,c=function(t,e,i){return`${t.id}.${e.id}.${i.stack||i.type}`}(o,a,s),d=e.length;let u;for(let t=0;ti[t].axis===e)).shift()}function Ms(t,e){const i=t.controller.index,s=t.vScale&&t.vScale.axis;if(s){e=e||t._parsed;for(const t of e){const e=t._stacks;if(!e||void 0===e[s]||void 0===e[s][i])return;delete e[s][i]}}}const ks=t=>"reset"===t||"none"===t,Ss=(t,e)=>e?t:Object.assign({},t);class Ps{constructor(t,e){this.chart=t,this._ctx=t.ctx,this.index=e,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.$context=void 0,this._syncList=[],this.initialize()}initialize(){const t=this._cachedMeta;this.configure(),this.linkScales(),t._stacked=bs(t.vScale,t),this.addElements()}updateIndex(t){this.index!==t&&Ms(this._cachedMeta),this.index=t}linkScales(){const t=this.chart,e=this._cachedMeta,i=this.getDataset(),s=(t,e,i,s)=>"x"===t?e:"r"===t?s:i,n=e.xAxisID=K(i.xAxisID,ws(t,"x")),o=e.yAxisID=K(i.yAxisID,ws(t,"y")),a=e.rAxisID=K(i.rAxisID,ws(t,"r")),r=e.indexAxis,l=e.iAxisID=s(r,n,o,a),h=e.vAxisID=s(r,o,n,a);e.xScale=this.getScaleForId(n),e.yScale=this.getScaleForId(o),e.rScale=this.getScaleForId(a),e.iScale=this.getScaleForId(l),e.vScale=this.getScaleForId(h)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(t){return this.chart.scales[t]}_getOtherScale(t){const e=this._cachedMeta;return t===e.iScale?e.vScale:e.iScale}reset(){this._update("reset")}_destroy(){const t=this._cachedMeta;this._data&&ue(this._data,this),t._stacked&&Ms(t)}_dataCheck(){const t=this.getDataset(),e=t.data||(t.data=[]),i=this._data;if(U(e))this._data=function(t){const e=Object.keys(t),i=new Array(e.length);let s,n,o;for(s=0,n=e.length;s0&&i._parsed[t-1];if(!1===this._parsing)i._parsed=s,i._sorted=!0,h=s;else{h=Y(s[t])?this.parseArrayData(i,s,t,e):U(s[t])?this.parseObjectData(i,s,t,e):this.parsePrimitiveData(i,s,t,e);const n=()=>null===l[a]||d&&l[a]t&&!e.hidden&&e._stacked&&{keys:ms(i,!0),values:null})(e,i,this.chart),l={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY},{min:h,max:c}=function(t){const{min:e,max:i,minDefined:s,maxDefined:n}=t.getUserBounds();return{min:s?e:Number.NEGATIVE_INFINITY,max:n?i:Number.POSITIVE_INFINITY}}(a);let d,u;function f(){u=s[d];const e=u[a.axis];return!X(u[t.axis])||h>e||c=0;--d)if(!f()){this.updateRangeFromParsed(l,t,u,r);break}return l}getAllParsedValues(t){const e=this._cachedMeta._parsed,i=[];let s,n,o;for(s=0,n=e.length;s=0&&tthis.getContext(i,s)),c);return f.$shared&&(f.$shared=r,n[o]=Object.freeze(Ss(f,r))),f}_resolveAnimations(t,e,i){const s=this.chart,n=this._cachedDataOpts,o=`animation-${e}`,a=n[o];if(a)return a;let r;if(!1!==s.options.animation){const s=this.chart.config,n=s.datasetAnimationScopeKeys(this._type,e),o=s.getOptionScopes(this.getDataset(),n);r=s.createResolver(o,this.getContext(t,i,e))}const l=new gs(s,r&&r.animations);return r&&r._cacheable&&(n[o]=Object.freeze(l)),l}getSharedOptions(t){if(t.$shared)return this._sharedOptions||(this._sharedOptions=Object.assign({},t))}includeOptions(t,e){return!e||ks(t)||this.chart._animationsDisabled}updateElement(t,e,i,s){ks(s)?Object.assign(t,i):this._resolveAnimations(e,s).update(t,i)}updateSharedOptions(t,e,i){t&&!ks(e)&&this._resolveAnimations(void 0,e).update(t,i)}_setStyle(t,e,i,s){t.active=s;const n=this.getStyle(e,s);this._resolveAnimations(e,i,s).update(t,{options:!s&&this.getSharedOptions(n)||n})}removeHoverStyle(t,e,i){this._setStyle(t,i,"active",!1)}setHoverStyle(t,e,i){this._setStyle(t,i,"active",!0)}_removeDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!1)}_setDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!0)}_resyncElements(t){const e=this._data,i=this._cachedMeta.data;for(const[t,e,i]of this._syncList)this[t](e,i);this._syncList=[];const s=i.length,n=e.length,o=Math.min(n,s);o&&this.parse(0,o),n>s?this._insertElements(s,n-s,t):n{for(t.length+=e,a=t.length-1;a>=o;a--)t[a]=t[a-e]};for(r(n),a=t;a{s[t]=i[t]&&i[t].active()?i[t]._to:this[t]})),s}}Ds.defaults={},Ds.defaultRoutes=void 0;const Cs={values:t=>Y(t)?t:""+t,numeric(t,e,i){if(0===t)return"0";const s=this.chart.options.locale;let n,o=t;if(i.length>1){const e=Math.max(Math.abs(i[0].value),Math.abs(i[i.length-1].value));(e<1e-4||e>1e15)&&(n="scientific"),o=function(t,e){let i=e.length>3?e[2].value-e[1].value:e[1].value-e[0].value;Math.abs(i)>=1&&t!==Math.floor(t)&&(i=t-Math.floor(t));return i}(t,i)}const a=Dt(Math.abs(o)),r=Math.max(Math.min(-1*Math.floor(a),20),0),l={notation:n,minimumFractionDigits:r,maximumFractionDigits:r};return Object.assign(l,this.options.ticks.format),Ri(t,s,l)},logarithmic(t,e,i){if(0===t)return"0";const s=t/Math.pow(10,Math.floor(Dt(t)));return 1===s||2===s||5===s?Cs.numeric.call(this,t,e,i):""}};var Os={formatters:Cs};function As(t,e){const i=t.options.ticks,s=i.maxTicksLimit||function(t){const e=t.options.offset,i=t._tickSize(),s=t._length/i+(e?0:1),n=t._maxLength/i;return Math.floor(Math.min(s,n))}(t),n=i.major.enabled?function(t){const e=[];let i,s;for(i=0,s=t.length;is)return function(t,e,i,s){let n,o=0,a=i[0];for(s=Math.ceil(s),n=0;nn)return e}return Math.max(n,1)}(n,e,s);if(o>0){let t,i;const s=o>1?Math.round((r-a)/(o-1)):null;for(Ts(e,l,h,$(s)?0:a-s,a),t=0,i=o-1;te.lineWidth,tickColor:(t,e)=>e.color,offset:!1,borderDash:[],borderDashOffset:0,borderWidth:1},title:{display:!1,text:"",padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:"",padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:Os.formatters.values,minor:{},major:{},align:"center",crossAlign:"near",showLabelBackdrop:!1,backdropColor:"rgba(255, 255, 255, 0.75)",backdropPadding:2}}),bt.route("scale.ticks","color","","color"),bt.route("scale.grid","color","","borderColor"),bt.route("scale.grid","borderColor","","borderColor"),bt.route("scale.title","color","","color"),bt.describe("scale",{_fallback:!1,_scriptable:t=>!t.startsWith("before")&&!t.startsWith("after")&&"callback"!==t&&"parser"!==t,_indexable:t=>"borderDash"!==t&&"tickBorderDash"!==t}),bt.describe("scales",{_fallback:"scale"}),bt.describe("scale.ticks",{_scriptable:t=>"backdropPadding"!==t&&"callback"!==t,_indexable:t=>"backdropPadding"!==t});const Ls=(t,e,i)=>"top"===e||"left"===e?t[e]+i:t[e]-i;function Rs(t,e){const i=[],s=t.length/e,n=t.length;let o=0;for(;oa+r)))return h}function Is(t){return t.drawTicks?t.tickLength:0}function zs(t,e){if(!t.display)return 0;const i=He(t.font,e),s=Ne(t.padding);return(Y(t.text)?t.text.length:1)*i.lineHeight+s.height}function Fs(t,e,i){let n=s(t);return(i&&"right"!==e||!i&&"right"===e)&&(n=(t=>"left"===t?"right":"right"===t?"left":t)(n)),n}class Bs extends Ds{constructor(t){super(),this.id=t.id,this.type=t.type,this.options=void 0,this.ctx=t.ctx,this.chart=t.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(t){this.options=t.setContext(this.getContext()),this.axis=t.axis,this._userMin=this.parse(t.min),this._userMax=this.parse(t.max),this._suggestedMin=this.parse(t.suggestedMin),this._suggestedMax=this.parse(t.suggestedMax)}parse(t,e){return t}getUserBounds(){let{_userMin:t,_userMax:e,_suggestedMin:i,_suggestedMax:s}=this;return t=q(t,Number.POSITIVE_INFINITY),e=q(e,Number.NEGATIVE_INFINITY),i=q(i,Number.POSITIVE_INFINITY),s=q(s,Number.NEGATIVE_INFINITY),{min:q(t,i),max:q(e,s),minDefined:X(t),maxDefined:X(e)}}getMinMax(t){let e,{min:i,max:s,minDefined:n,maxDefined:o}=this.getUserBounds();if(n&&o)return{min:i,max:s};const a=this.getMatchingVisibleMetas();for(let r=0,l=a.length;rs?s:i,s=n&&i>s?i:s,{min:q(i,q(s,i)),max:q(s,q(i,s))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){const t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels||[]}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){J(this.options.beforeUpdate,[this])}update(t,e,i){const{beginAtZero:s,grace:n,ticks:o}=this.options,a=o.sampleSize;this.beforeUpdate(),this.maxWidth=t,this.maxHeight=e,this._margins=i=Object.assign({left:0,right:0,top:0,bottom:0},i),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+i.left+i.right:this.height+i.top+i.bottom,this._dataLimitsCached||(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=$e(this,n,s),this._dataLimitsCached=!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();const r=a=n||i<=1||!this.isHorizontal())return void(this.labelRotation=s);const h=this._getLabelSizes(),c=h.widest.width,d=h.highest.height,u=jt(this.chart.width-c,0,this.maxWidth);o=t.offset?this.maxWidth/i:u/(i-1),c+6>o&&(o=u/(i-(t.offset?.5:1)),a=this.maxHeight-Is(t.grid)-e.padding-zs(t.title,this.chart.options.font),r=Math.sqrt(c*c+d*d),l=zt(Math.min(Math.asin(jt((h.highest.height+6)/o,-1,1)),Math.asin(jt(a/r,-1,1))-Math.asin(jt(d/r,-1,1)))),l=Math.max(s,Math.min(n,l))),this.labelRotation=l}afterCalculateLabelRotation(){J(this.options.afterCalculateLabelRotation,[this])}beforeFit(){J(this.options.beforeFit,[this])}fit(){const t={width:0,height:0},{chart:e,options:{ticks:i,title:s,grid:n}}=this,o=this._isVisible(),a=this.isHorizontal();if(o){const o=zs(s,e.options.font);if(a?(t.width=this.maxWidth,t.height=Is(n)+o):(t.height=this.maxHeight,t.width=Is(n)+o),i.display&&this.ticks.length){const{first:e,last:s,widest:n,highest:o}=this._getLabelSizes(),r=2*i.padding,l=It(this.labelRotation),h=Math.cos(l),c=Math.sin(l);if(a){const e=i.mirror?0:c*n.width+h*o.height;t.height=Math.min(this.maxHeight,t.height+e+r)}else{const e=i.mirror?0:h*n.width+c*o.height;t.width=Math.min(this.maxWidth,t.width+e+r)}this._calculatePadding(e,s,c,h)}}this._handleMargins(),a?(this.width=this._length=e.width-this._margins.left-this._margins.right,this.height=t.height):(this.width=t.width,this.height=this._length=e.height-this._margins.top-this._margins.bottom)}_calculatePadding(t,e,i,s){const{ticks:{align:n,padding:o},position:a}=this.options,r=0!==this.labelRotation,l="top"!==a&&"x"===this.axis;if(this.isHorizontal()){const a=this.getPixelForTick(0)-this.left,h=this.right-this.getPixelForTick(this.ticks.length-1);let c=0,d=0;r?l?(c=s*t.width,d=i*e.height):(c=i*t.height,d=s*e.width):"start"===n?d=e.width:"end"===n?c=t.width:(c=t.width/2,d=e.width/2),this.paddingLeft=Math.max((c-a+o)*this.width/(this.width-a),0),this.paddingRight=Math.max((d-h+o)*this.width/(this.width-h),0)}else{let i=e.height/2,s=t.height/2;"start"===n?(i=0,s=t.height):"end"===n&&(i=e.height,s=0),this.paddingTop=i+o,this.paddingBottom=s+o}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){J(this.options.afterFit,[this])}isHorizontal(){const{axis:t,position:e}=this.options;return"top"===e||"bottom"===e||"x"===t}isFullSize(){return this.options.fullSize}_convertTicksToLabels(t){let e,i;for(this.beforeTickToLabelConversion(),this.generateTickLabels(t),e=0,i=t.length;e{const i=t.gc,s=i.length/2;let n;if(s>e){for(n=0;n({width:n[t]||0,height:o[t]||0});return{first:v(0),last:v(e-1),widest:v(_),highest:v(y),widths:n,heights:o}}getLabelForValue(t){return t}getPixelForValue(t,e){return NaN}getValueForPixel(t){}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getPixelForDecimal(t){this._reversePixels&&(t=1-t);const e=this._startPixel+t*this._length;return $t(this._alignToPixels?Kt(this.chart,e,0):e)}getDecimalForPixel(t){const e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){const{min:t,max:e}=this;return t<0&&e<0?e:t>0&&e>0?t:0}getContext(t){const e=this.ticks||[];if(t>=0&&ta*s?a/i:r/s:r*s0}_computeGridLineItems(t){const e=this.axis,i=this.chart,s=this.options,{grid:n,position:o}=s,a=n.offset,r=this.isHorizontal(),l=this.ticks.length+(a?1:0),h=Is(n),c=[],d=n.setContext(this.getContext()),u=d.drawBorder?d.borderWidth:0,f=u/2,g=function(t){return Kt(i,t,u)};let p,m,x,b,_,y,v,w,M,k,S,P;if("top"===o)p=g(this.bottom),y=this.bottom-h,w=p-f,k=g(t.top)+f,P=t.bottom;else if("bottom"===o)p=g(this.top),k=t.top,P=g(t.bottom)-f,y=p+f,w=this.top+h;else if("left"===o)p=g(this.right),_=this.right-h,v=p-f,M=g(t.left)+f,S=t.right;else if("right"===o)p=g(this.left),M=t.left,S=g(t.right)-f,_=p+f,v=this.left+h;else if("x"===e){if("center"===o)p=g((t.top+t.bottom)/2+.5);else if(U(o)){const t=Object.keys(o)[0],e=o[t];p=g(this.chart.scales[t].getPixelForValue(e))}k=t.top,P=t.bottom,y=p+f,w=y+h}else if("y"===e){if("center"===o)p=g((t.left+t.right)/2);else if(U(o)){const t=Object.keys(o)[0],e=o[t];p=g(this.chart.scales[t].getPixelForValue(e))}_=p-f,v=_-h,M=t.left,S=t.right}const D=K(s.ticks.maxTicksLimit,l),C=Math.max(1,Math.ceil(l/D));for(m=0;me.value===t));if(i>=0){return e.setContext(this.getContext(i)).lineWidth}return 0}drawGrid(t){const e=this.options.grid,i=this.ctx,s=this._gridLineItems||(this._gridLineItems=this._computeGridLineItems(t));let n,o;const a=(t,e,s)=>{s.width&&s.color&&(i.save(),i.lineWidth=s.width,i.strokeStyle=s.color,i.setLineDash(s.borderDash||[]),i.lineDashOffset=s.borderDashOffset,i.beginPath(),i.moveTo(t.x,t.y),i.lineTo(e.x,e.y),i.stroke(),i.restore())};if(e.display)for(n=0,o=s.length;n{this.drawBackground(),this.drawGrid(t),this.drawTitle()}},{z:i+1,draw:()=>{this.drawBorder()}},{z:e,draw:t=>{this.drawLabels(t)}}]:[{z:e,draw:t=>{this.draw(t)}}]}getMatchingVisibleMetas(t){const e=this.chart.getSortedVisibleDatasetMetas(),i=this.axis+"AxisID",s=[];let n,o;for(n=0,o=e.length;n{const s=i.split("."),n=s.pop(),o=[t].concat(s).join("."),a=e[i].split("."),r=a.pop(),l=a.join(".");bt.route(o,n,l,r)}))}(e,t.defaultRoutes);t.descriptors&&bt.describe(e,t.descriptors)}(t,o,i),this.override&&bt.override(t.id,t.overrides)),o}get(t){return this.items[t]}unregister(t){const e=this.items,i=t.id,s=this.scope;i in e&&delete e[i],s&&i in bt[s]&&(delete bt[s][i],this.override&&delete gt[i])}}var Ws=new class{constructor(){this.controllers=new Vs(Ps,"datasets",!0),this.elements=new Vs(Ds,"elements"),this.plugins=new Vs(Object,"plugins"),this.scales=new Vs(Bs,"scales"),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...t){this._each("register",t)}remove(...t){this._each("unregister",t)}addControllers(...t){this._each("register",t,this.controllers)}addElements(...t){this._each("register",t,this.elements)}addPlugins(...t){this._each("register",t,this.plugins)}addScales(...t){this._each("register",t,this.scales)}getController(t){return this._get(t,this.controllers,"controller")}getElement(t){return this._get(t,this.elements,"element")}getPlugin(t){return this._get(t,this.plugins,"plugin")}getScale(t){return this._get(t,this.scales,"scale")}removeControllers(...t){this._each("unregister",t,this.controllers)}removeElements(...t){this._each("unregister",t,this.elements)}removePlugins(...t){this._each("unregister",t,this.plugins)}removeScales(...t){this._each("unregister",t,this.scales)}_each(t,e,i){[...e].forEach((e=>{const s=i||this._getRegistryForType(e);i||s.isForType(e)||s===this.plugins&&e.id?this._exec(t,s,e):Q(e,(e=>{const s=i||this._getRegistryForType(e);this._exec(t,s,e)}))}))}_exec(t,e,i){const s=ht(t);J(i["before"+s],[],i),e[t](i),J(i["after"+s],[],i)}_getRegistryForType(t){for(let e=0;et.filter((t=>!e.some((e=>t.plugin.id===e.plugin.id))));this._notify(s(e,i),t,"stop"),this._notify(s(i,e),t,"start")}}function Hs(t,e){return e||!1!==t?!0===t?{}:t:null}function js(t,e,i,s){const n=t.pluginScopeKeys(e),o=t.getOptionScopes(i,n);return t.createResolver(o,s,[""],{scriptable:!1,indexable:!1,allKeys:!0})}function $s(t,e){const i=bt.datasets[t]||{};return((e.datasets||{})[t]||{}).indexAxis||e.indexAxis||i.indexAxis||"x"}function Ys(t,e){return"x"===t||"y"===t?t:e.axis||("top"===(i=e.position)||"bottom"===i?"x":"left"===i||"right"===i?"y":void 0)||t.charAt(0).toLowerCase();var i}function Us(t){const e=t.options||(t.options={});e.plugins=K(e.plugins,{}),e.scales=function(t,e){const i=gt[t.type]||{scales:{}},s=e.scales||{},n=$s(t.type,e),o=Object.create(null),a=Object.create(null);return Object.keys(s).forEach((t=>{const e=s[t];if(!U(e))return console.error(`Invalid scale configuration for scale: ${t}`);if(e._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);const r=Ys(t,e),l=function(t,e){return t===e?"_index_":"_value_"}(r,n),h=i.scales||{};o[r]=o[r]||t,a[t]=ot(Object.create(null),[{axis:r},e,h[r],h[l]])})),t.data.datasets.forEach((i=>{const n=i.type||t.type,r=i.indexAxis||$s(n,e),l=(gt[n]||{}).scales||{};Object.keys(l).forEach((t=>{const e=function(t,e){let i=t;return"_index_"===t?i=e:"_value_"===t&&(i="x"===e?"y":"x"),i}(t,r),n=i[e+"AxisID"]||o[e]||e;a[n]=a[n]||Object.create(null),ot(a[n],[{axis:e},s[n],l[t]])}))})),Object.keys(a).forEach((t=>{const e=a[t];ot(e,[bt.scales[e.type],bt.scale])})),a}(t,e)}function Xs(t){return(t=t||{}).datasets=t.datasets||[],t.labels=t.labels||[],t}const qs=new Map,Ks=new Set;function Gs(t,e){let i=qs.get(t);return i||(i=e(),qs.set(t,i),Ks.add(i)),i}const Zs=(t,e,i)=>{const s=lt(e,i);void 0!==s&&t.add(s)};class Js{constructor(t){this._config=function(t){return(t=t||{}).data=Xs(t.data),Us(t),t}(t),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(t){this._config.type=t}get data(){return this._config.data}set data(t){this._config.data=Xs(t)}get options(){return this._config.options}set options(t){this._config.options=t}get plugins(){return this._config.plugins}update(){const t=this._config;this.clearCache(),Us(t)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(t){return Gs(t,(()=>[[`datasets.${t}`,""]]))}datasetAnimationScopeKeys(t,e){return Gs(`${t}.transition.${e}`,(()=>[[`datasets.${t}.transitions.${e}`,`transitions.${e}`],[`datasets.${t}`,""]]))}datasetElementScopeKeys(t,e){return Gs(`${t}-${e}`,(()=>[[`datasets.${t}.elements.${e}`,`datasets.${t}`,`elements.${e}`,""]]))}pluginScopeKeys(t){const e=t.id;return Gs(`${this.type}-plugin-${e}`,(()=>[[`plugins.${e}`,...t.additionalOptionScopes||[]]]))}_cachedScopes(t,e){const i=this._scopeCache;let s=i.get(t);return s&&!e||(s=new Map,i.set(t,s)),s}getOptionScopes(t,e,i){const{options:s,type:n}=this,o=this._cachedScopes(t,i),a=o.get(e);if(a)return a;const r=new Set;e.forEach((e=>{t&&(r.add(t),e.forEach((e=>Zs(r,t,e)))),e.forEach((t=>Zs(r,s,t))),e.forEach((t=>Zs(r,gt[n]||{},t))),e.forEach((t=>Zs(r,bt,t))),e.forEach((t=>Zs(r,pt,t)))}));const l=Array.from(r);return 0===l.length&&l.push(Object.create(null)),Ks.has(e)&&o.set(e,l),l}chartOptionScopes(){const{options:t,type:e}=this;return[t,gt[e]||{},bt.datasets[e]||{},{type:e},bt,pt]}resolveNamedOptions(t,e,i,s=[""]){const n={$shared:!0},{resolver:o,subPrefixes:a}=Qs(this._resolverCache,t,s);let r=o;if(function(t,e){const{isScriptable:i,isIndexable:s}=ri(t);for(const n of e){const e=i(n),o=s(n),a=(o||e)&&t[n];if(e&&(dt(a)||tn(a))||o&&Y(a))return!0}return!1}(o,e)){n.$shared=!1;r=ai(o,i=dt(i)?i():i,this.createResolver(t,i,a))}for(const t of e)n[t]=r[t];return n}createResolver(t,e,i=[""],s){const{resolver:n}=Qs(this._resolverCache,t,i);return U(e)?ai(n,e,void 0,s):n}}function Qs(t,e,i){let s=t.get(e);s||(s=new Map,t.set(e,s));const n=i.join();let o=s.get(n);if(!o){o={resolver:oi(e,i),subPrefixes:i.filter((t=>!t.toLowerCase().includes("hover")))},s.set(n,o)}return o}const tn=t=>U(t)&&Object.getOwnPropertyNames(t).reduce(((e,i)=>e||dt(t[i])),!1);const en=["top","bottom","left","right","chartArea"];function sn(t,e){return"top"===t||"bottom"===t||-1===en.indexOf(t)&&"x"===e}function nn(t,e){return function(i,s){return i[t]===s[t]?i[e]-s[e]:i[t]-s[t]}}function on(t){const e=t.chart,i=e.options.animation;e.notifyPlugins("afterRender"),J(i&&i.onComplete,[t],e)}function an(t){const e=t.chart,i=e.options.animation;J(i&&i.onProgress,[t],e)}function rn(t){return ge()&&"string"==typeof t?t=document.getElementById(t):t&&t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas),t}const ln={},hn=t=>{const e=rn(t);return Object.values(ln).filter((t=>t.canvas===e)).pop()};function cn(t,e,i){const s=Object.keys(t);for(const n of s){const s=+n;if(s>=e){const o=t[n];delete t[n],(i>0||s>e)&&(t[s+i]=o)}}}class dn{constructor(t,e){const s=this.config=new Js(e),n=rn(t),o=hn(n);if(o)throw new Error("Canvas is already in use. Chart with ID '"+o.id+"' must be destroyed before the canvas can be reused.");const r=s.createResolver(s.chartOptionScopes(),this.getContext());this.platform=new(s.platform||ls(n)),this.platform.updateConfig(s);const l=this.platform.acquireContext(n,r.aspectRatio),h=l&&l.canvas,c=h&&h.height,d=h&&h.width;this.id=j(),this.ctx=l,this.canvas=h,this.width=d,this.height=c,this._options=r,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new Ns,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=i((t=>this.update(t)),r.resizeDelay||0),this._dataChanges=[],ln[this.id]=this,l&&h?(a.listen(this,"complete",on),a.listen(this,"progress",an),this._initialize(),this.attached&&this.update()):console.error("Failed to create chart: can't acquire context from the given item")}get aspectRatio(){const{options:{aspectRatio:t,maintainAspectRatio:e},width:i,height:s,_aspectRatio:n}=this;return $(t)?e&&n?n:s?i/s:null:t}get data(){return this.config.data}set data(t){this.config.data=t}get options(){return this._options}set options(t){this.config.options=t}_initialize(){return this.notifyPlugins("beforeInit"),this.options.responsive?this.resize():ke(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins("afterInit"),this}clear(){return Gt(this.canvas,this.ctx),this}stop(){return a.stop(this),this}resize(t,e){a.running(this)?this._resizeBeforeDraw={width:t,height:e}:this._resize(t,e)}_resize(t,e){const i=this.options,s=this.canvas,n=i.maintainAspectRatio&&this.aspectRatio,o=this.platform.getMaximumSize(s,t,e,n),a=i.devicePixelRatio||this.platform.getDevicePixelRatio(),r=this.width?"resize":"attach";this.width=o.width,this.height=o.height,this._aspectRatio=this.aspectRatio,ke(this,a,!0)&&(this.notifyPlugins("resize",{size:o}),J(i.onResize,[this,o],this),this.attached&&this._doResize(r)&&this.render())}ensureScalesHaveIDs(){Q(this.options.scales||{},((t,e)=>{t.id=e}))}buildOrUpdateScales(){const t=this.options,e=t.scales,i=this.scales,s=Object.keys(i).reduce(((t,e)=>(t[e]=!1,t)),{});let n=[];e&&(n=n.concat(Object.keys(e).map((t=>{const i=e[t],s=Ys(t,i),n="r"===s,o="x"===s;return{options:i,dposition:n?"chartArea":o?"bottom":"left",dtype:n?"radialLinear":o?"category":"linear"}})))),Q(n,(e=>{const n=e.options,o=n.id,a=Ys(o,n),r=K(n.type,e.dtype);void 0!==n.position&&sn(n.position,a)===sn(e.dposition)||(n.position=e.dposition),s[o]=!0;let l=null;if(o in i&&i[o].type===r)l=i[o];else{l=new(Ws.getScale(r))({id:o,type:r,ctx:this.ctx,chart:this}),i[l.id]=l}l.init(n,t)})),Q(s,((t,e)=>{t||delete i[e]})),Q(i,(t=>{ni.configure(this,t,t.options),ni.addBox(this,t)}))}_updateMetasets(){const t=this._metasets,e=this.data.datasets.length,i=t.length;if(t.sort(((t,e)=>t.index-e.index)),i>e){for(let t=e;te.length&&delete this._stacks,t.forEach(((t,i)=>{0===e.filter((e=>e===t._dataset)).length&&this._destroyDatasetMeta(i)}))}buildOrUpdateControllers(){const t=[],e=this.data.datasets;let i,s;for(this._removeUnreferencedMetasets(),i=0,s=e.length;i{this.getDatasetMeta(e).controller.reset()}),this)}reset(){this._resetElements(),this.notifyPlugins("reset")}update(t){const e=this.config;e.update();const i=this._options=e.createResolver(e.chartOptionScopes(),this.getContext()),s=this._animationsDisabled=!i.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),!1===this.notifyPlugins("beforeUpdate",{mode:t,cancelable:!0}))return;const n=this.buildOrUpdateControllers();this.notifyPlugins("beforeElementsUpdate");let o=0;for(let t=0,e=this.data.datasets.length;t{t.reset()})),this._updateDatasets(t),this.notifyPlugins("afterUpdate",{mode:t}),this._layers.sort(nn("z","_idx"));const{_active:a,_lastEvent:r}=this;r?this._eventHandler(r,!0):a.length&&this._updateHoverStyles(a,a,!0),this.render()}_updateScales(){Q(this.scales,(t=>{ni.removeBox(this,t)})),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){const t=this.options,e=new Set(Object.keys(this._listeners)),i=new Set(t.events);ut(e,i)&&!!this._responsiveListeners===t.responsive||(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){const{_hiddenIndices:t}=this,e=this._getUniformDataChanges()||[];for(const{method:i,start:s,count:n}of e){cn(t,s,"_removeElements"===i?-n:n)}}_getUniformDataChanges(){const t=this._dataChanges;if(!t||!t.length)return;this._dataChanges=[];const e=this.data.datasets.length,i=e=>new Set(t.filter((t=>t[0]===e)).map(((t,e)=>e+","+t.splice(1).join(",")))),s=i(0);for(let t=1;tt.split(","))).map((t=>({method:t[1],start:+t[2],count:+t[3]})))}_updateLayout(t){if(!1===this.notifyPlugins("beforeLayout",{cancelable:!0}))return;ni.update(this,this.width,this.height,t);const e=this.chartArea,i=e.width<=0||e.height<=0;this._layers=[],Q(this.boxes,(t=>{i&&"chartArea"===t.position||(t.configure&&t.configure(),this._layers.push(...t._layers()))}),this),this._layers.forEach(((t,e)=>{t._idx=e})),this.notifyPlugins("afterLayout")}_updateDatasets(t){if(!1!==this.notifyPlugins("beforeDatasetsUpdate",{mode:t,cancelable:!0})){for(let t=0,e=this.data.datasets.length;t=0;--e)this._drawDataset(t[e]);this.notifyPlugins("afterDatasetsDraw")}_drawDataset(t){const e=this.ctx,i=t._clip,s=!i.disabled,n=this.chartArea,o={meta:t,index:t.index,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetDraw",o)&&(s&&Qt(e,{left:!1===i.left?0:n.left-i.left,right:!1===i.right?this.width:n.right+i.right,top:!1===i.top?0:n.top-i.top,bottom:!1===i.bottom?this.height:n.bottom+i.bottom}),t.controller.draw(),s&&te(e),o.cancelable=!1,this.notifyPlugins("afterDatasetDraw",o))}getElementsAtEventForMode(t,e,i,s){const n=Ee.modes[e];return"function"==typeof n?n(this,t,i,s):[]}getDatasetMeta(t){const e=this.data.datasets[t],i=this._metasets;let s=i.filter((t=>t&&t._dataset===e)).pop();return s||(s={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:e&&e.order||0,index:t,_dataset:e,_parsed:[],_sorted:!1},i.push(s)),s}getContext(){return this.$context||(this.$context=Ye(null,{chart:this,type:"chart"}))}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(t){const e=this.data.datasets[t];if(!e)return!1;const i=this.getDatasetMeta(t);return"boolean"==typeof i.hidden?!i.hidden:!e.hidden}setDatasetVisibility(t,e){this.getDatasetMeta(t).hidden=!e}toggleDataVisibility(t){this._hiddenIndices[t]=!this._hiddenIndices[t]}getDataVisibility(t){return!this._hiddenIndices[t]}_updateVisibility(t,e,i){const s=i?"show":"hide",n=this.getDatasetMeta(t),o=n.controller._resolveAnimations(void 0,s);ct(e)?(n.data[e].hidden=!i,this.update()):(this.setDatasetVisibility(t,i),o.update(n,{visible:i}),this.update((e=>e.datasetIndex===t?s:void 0)))}hide(t,e){this._updateVisibility(t,e,!1)}show(t,e){this._updateVisibility(t,e,!0)}_destroyDatasetMeta(t){const e=this._metasets[t];e&&e.controller&&e.controller._destroy(),delete this._metasets[t]}_stop(){let t,e;for(this.stop(),a.remove(this),t=0,e=this.data.datasets.length;t{e.addEventListener(this,i,s),t[i]=s},s=(t,e,i)=>{t.offsetX=e,t.offsetY=i,this._eventHandler(t)};Q(this.options.events,(t=>i(t,s)))}bindResponsiveEvents(){this._responsiveListeners||(this._responsiveListeners={});const t=this._responsiveListeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(i,s)=>{t[i]&&(e.removeEventListener(this,i,s),delete t[i])},n=(t,e)=>{this.canvas&&this.resize(t,e)};let o;const a=()=>{s("attach",a),this.attached=!0,this.resize(),i("resize",n),i("detach",o)};o=()=>{this.attached=!1,s("resize",n),this._stop(),this._resize(0,0),i("attach",a)},e.isAttached(this.canvas)?a():o()}unbindEvents(){Q(this._listeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._listeners={},Q(this._responsiveListeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._responsiveListeners=void 0}updateHoverStyle(t,e,i){const s=i?"set":"remove";let n,o,a,r;for("dataset"===e&&(n=this.getDatasetMeta(t[0].datasetIndex),n.controller["_"+s+"DatasetHoverStyle"]()),a=0,r=t.length;a{const i=this.getDatasetMeta(t);if(!i)throw new Error("No dataset found at index "+t);return{datasetIndex:t,element:i.data[e],index:e}}));!tt(i,e)&&(this._active=i,this._lastEvent=null,this._updateHoverStyles(i,e))}notifyPlugins(t,e,i){return this._plugins.notify(this,t,e,i)}_updateHoverStyles(t,e,i){const s=this.options.hover,n=(t,e)=>t.filter((t=>!e.some((e=>t.datasetIndex===e.datasetIndex&&t.index===e.index)))),o=n(e,t),a=i?t:n(t,e);o.length&&this.updateHoverStyle(o,s.mode,!1),a.length&&s.mode&&this.updateHoverStyle(a,s.mode,!0)}_eventHandler(t,e){const i={event:t,replay:e,cancelable:!0,inChartArea:Jt(t,this.chartArea,this._minPadding)},s=e=>(e.options.events||this.options.events).includes(t.native.type);if(!1===this.notifyPlugins("beforeEvent",i,s))return;const n=this._handleEvent(t,e,i.inChartArea);return i.cancelable=!1,this.notifyPlugins("afterEvent",i,s),(n||i.changed)&&this.render(),this}_handleEvent(t,e,i){const{_active:s=[],options:n}=this,o=e,a=this._getActiveElements(t,s,i,o),r=ft(t),l=function(t,e,i,s){return i&&"mouseout"!==t.type?s?e:t:null}(t,this._lastEvent,i,r);i&&(this._lastEvent=null,J(n.onHover,[t,a,this],this),r&&J(n.onClick,[t,a,this],this));const h=!tt(a,s);return(h||e)&&(this._active=a,this._updateHoverStyles(a,s,e)),this._lastEvent=l,h}_getActiveElements(t,e,i,s){if("mouseout"===t.type)return[];if(!i)return e;const n=this.options.hover;return this.getElementsAtEventForMode(t,n.mode,n,s)}}const un=()=>Q(dn.instances,(t=>t._plugins.invalidate())),fn=!0;function gn(){throw new Error("This method is not implemented: Check that a complete date adapter is provided.")}Object.defineProperties(dn,{defaults:{enumerable:fn,value:bt},instances:{enumerable:fn,value:ln},overrides:{enumerable:fn,value:gt},registry:{enumerable:fn,value:Ws},version:{enumerable:fn,value:"3.7.1"},getChart:{enumerable:fn,value:hn},register:{enumerable:fn,value:(...t)=>{Ws.add(...t),un()}},unregister:{enumerable:fn,value:(...t)=>{Ws.remove(...t),un()}}});class pn{constructor(t){this.options=t||{}}formats(){return gn()}parse(t,e){return gn()}format(t,e){return gn()}add(t,e,i){return gn()}diff(t,e,i){return gn()}startOf(t,e,i){return gn()}endOf(t,e){return gn()}}pn.override=function(t){Object.assign(pn.prototype,t)};var mn={_date:pn};function xn(t){const e=t.iScale,i=function(t,e){if(!t._cache.$bar){const i=t.getMatchingVisibleMetas(e);let s=[];for(let e=0,n=i.length;et-e)))}return t._cache.$bar}(e,t.type);let s,n,o,a,r=e._length;const l=()=>{32767!==o&&-32768!==o&&(ct(a)&&(r=Math.min(r,Math.abs(o-a)||r)),a=o)};for(s=0,n=i.length;sMath.abs(r)&&(l=r,h=a),e[i.axis]=h,e._custom={barStart:l,barEnd:h,start:n,end:o,min:a,max:r}}(t,e,i,s):e[i.axis]=i.parse(t,s),e}function _n(t,e,i,s){const n=t.iScale,o=t.vScale,a=n.getLabels(),r=n===o,l=[];let h,c,d,u;for(h=i,c=i+s;ht.x,i="left",s="right"):(e=t.base=i?1:-1)}(c,e,o)*n,d===o&&(p-=c/2),h=p+c),p===e.getPixelForValue(o)){const t=Ct(c)*e.getLineWidthForValue(o)/2;p+=t,c-=t}return{size:c,base:p,head:h,center:h+c/2}}_calculateBarIndexPixels(t,e){const i=e.scale,s=this.options,n=s.skipNull,o=K(s.maxBarThickness,1/0);let a,r;if(e.grouped){const i=n?this._getStackCount(t):e.stackCount,l="flex"===s.barThickness?function(t,e,i,s){const n=e.pixels,o=n[t];let a=t>0?n[t-1]:null,r=t=0;--i)e=Math.max(e,t[i].size(this.resolveDataElementOptions(i))/2);return e>0&&e}getLabelAndValue(t){const e=this._cachedMeta,{xScale:i,yScale:s}=e,n=this.getParsed(t),o=i.getLabelForValue(n.x),a=s.getLabelForValue(n.y),r=n._custom;return{label:e.label,value:"("+o+", "+a+(r?", "+r:"")+")"}}update(t){const e=this._cachedMeta.data;this.updateElements(e,0,e.length,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:o,vScale:a}=this._cachedMeta,r=this.resolveDataElementOptions(e,s),l=this.getSharedOptions(r),h=this.includeOptions(s,l),c=o.axis,d=a.axis;for(let r=e;r""}}}};class Dn extends Ps{constructor(t,e){super(t,e),this.enableOptionSharing=!0,this.innerRadius=void 0,this.outerRadius=void 0,this.offsetX=void 0,this.offsetY=void 0}linkScales(){}parse(t,e){const i=this.getDataset().data,s=this._cachedMeta;if(!1===this._parsing)s._parsed=i;else{let n,o,a=t=>+i[t];if(U(i[t])){const{key:t="value"}=this._parsing;a=e=>+lt(i[e],t)}for(n=t,o=t+e;nHt(t,r,l,!0)?1:Math.max(e,e*i,s,s*i),g=(t,e,s)=>Ht(t,r,l,!0)?-1:Math.min(e,e*i,s,s*i),p=f(0,h,d),m=f(kt,c,u),x=g(_t,h,d),b=g(_t+kt,c,u);s=(p-x)/2,n=(m-b)/2,o=-(p+x)/2,a=-(m+b)/2}return{ratioX:s,ratioY:n,offsetX:o,offsetY:a}}(c,h,r),p=(i.width-o)/d,m=(i.height-o)/u,x=Math.max(Math.min(p,m)/2,0),b=Z(this.options.radius,x),_=(b-Math.max(b*r,0))/this._getVisibleDatasetWeightTotal();this.offsetX=f*b,this.offsetY=g*b,s.total=this.calculateTotal(),this.outerRadius=b-_*this._getRingWeightOffset(this.index),this.innerRadius=Math.max(this.outerRadius-_*l,0),this.updateElements(n,0,n.length,t)}_circumference(t,e){const i=this.options,s=this._cachedMeta,n=this._getCircumference();return e&&i.animation.animateRotate||!this.chart.getDataVisibility(t)||null===s._parsed[t]||s.data[t].hidden?0:this.calculateCircumference(s._parsed[t]*n/yt)}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=o.chartArea,r=o.options.animation,l=(a.left+a.right)/2,h=(a.top+a.bottom)/2,c=n&&r.animateScale,d=c?0:this.innerRadius,u=c?0:this.outerRadius,f=this.resolveDataElementOptions(e,s),g=this.getSharedOptions(f),p=this.includeOptions(s,g);let m,x=this._getRotation();for(m=0;m0&&!isNaN(t)?yt*(Math.abs(t)/e):0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=Ri(e._parsed[t],i.options.locale);return{label:s[t]||"",value:n}}getMaxBorderWidth(t){let e=0;const i=this.chart;let s,n,o,a,r;if(!t)for(s=0,n=i.data.datasets.length;s"spacing"!==t,_indexable:t=>"spacing"!==t},Dn.overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i}}=t.legend.options;return e.labels.map(((e,s)=>{const n=t.getDatasetMeta(0).controller.getStyle(s);return{text:e,fillStyle:n.backgroundColor,strokeStyle:n.borderColor,lineWidth:n.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(s),index:s}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}},tooltip:{callbacks:{title:()=>"",label(t){let e=t.label;const i=": "+t.formattedValue;return Y(e)?(e=e.slice(),e[0]+=i):e+=i,e}}}}};class Cn extends Ps{initialize(){this.enableOptionSharing=!0,super.initialize()}update(t){const e=this._cachedMeta,{dataset:i,data:s=[],_dataset:n}=e,o=this.chart._animationsDisabled;let{start:a,count:r}=function(t,e,i){const s=e.length;let n=0,o=s;if(t._sorted){const{iScale:a,_parsed:r}=t,l=a.axis,{min:h,max:c,minDefined:d,maxDefined:u}=a.getUserBounds();d&&(n=jt(Math.min(re(r,a.axis,h).lo,i?s:re(e,l,a.getPixelForValue(h)).lo),0,s-1)),o=u?jt(Math.max(re(r,a.axis,c).hi+1,i?0:re(e,l,a.getPixelForValue(c)).hi+1),n,s)-n:s-n}return{start:n,count:o}}(e,s,o);this._drawStart=a,this._drawCount=r,function(t){const{xScale:e,yScale:i,_scaleRanges:s}=t,n={xmin:e.min,xmax:e.max,ymin:i.min,ymax:i.max};if(!s)return t._scaleRanges=n,!0;const o=s.xmin!==e.min||s.xmax!==e.max||s.ymin!==i.min||s.ymax!==i.max;return Object.assign(s,n),o}(e)&&(a=0,r=s.length),i._chart=this.chart,i._datasetIndex=this.index,i._decimated=!!n._decimated,i.points=s;const l=this.resolveDatasetElementOptions(t);this.options.showLine||(l.borderWidth=0),l.segment=this.options.segment,this.updateElement(i,void 0,{animated:!o,options:l},t),this.updateElements(s,a,r,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:o,vScale:a,_stacked:r,_dataset:l}=this._cachedMeta,h=this.resolveDataElementOptions(e,s),c=this.getSharedOptions(h),d=this.includeOptions(s,c),u=o.axis,f=a.axis,{spanGaps:g,segment:p}=this.options,m=Tt(g)?g:Number.POSITIVE_INFINITY,x=this.chart._animationsDisabled||n||"none"===s;let b=e>0&&this.getParsed(e-1);for(let h=e;h0&&i[u]-b[u]>m,p&&(g.parsed=i,g.raw=l.data[h]),d&&(g.options=c||this.resolveDataElementOptions(h,e.active?"active":s)),x||this.updateElement(e,h,g,s),b=i}this.updateSharedOptions(c,s,h)}getMaxOverflow(){const t=this._cachedMeta,e=t.dataset,i=e.options&&e.options.borderWidth||0,s=t.data||[];if(!s.length)return i;const n=s[0].size(this.resolveDataElementOptions(0)),o=s[s.length-1].size(this.resolveDataElementOptions(s.length-1));return Math.max(i,n,o)/2}draw(){const t=this._cachedMeta;t.dataset.updateControlPoints(this.chart.chartArea,t.iScale.axis),super.draw()}}Cn.id="line",Cn.defaults={datasetElementType:"line",dataElementType:"point",showLine:!0,spanGaps:!1},Cn.overrides={scales:{_index_:{type:"category"},_value_:{type:"linear"}}};class On extends Ps{constructor(t,e){super(t,e),this.innerRadius=void 0,this.outerRadius=void 0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=Ri(e._parsed[t].r,i.options.locale);return{label:s[t]||"",value:n}}update(t){const e=this._cachedMeta.data;this._updateRadius(),this.updateElements(e,0,e.length,t)}_updateRadius(){const t=this.chart,e=t.chartArea,i=t.options,s=Math.min(e.right-e.left,e.bottom-e.top),n=Math.max(s/2,0),o=(n-Math.max(i.cutoutPercentage?n/100*i.cutoutPercentage:1,0))/t.getVisibleDatasetCount();this.outerRadius=n-o*this.index,this.innerRadius=this.outerRadius-o}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=this.getDataset(),r=o.options.animation,l=this._cachedMeta.rScale,h=l.xCenter,c=l.yCenter,d=l.getIndexAngle(0)-.5*_t;let u,f=d;const g=360/this.countVisibleElements();for(u=0;u{!isNaN(t.data[s])&&this.chart.getDataVisibility(s)&&i++})),i}_computeAngle(t,e,i){return this.chart.getDataVisibility(t)?It(this.resolveDataElementOptions(t,e).angle||i):0}}On.id="polarArea",On.defaults={dataElementType:"arc",animation:{animateRotate:!0,animateScale:!0},animations:{numbers:{type:"number",properties:["x","y","startAngle","endAngle","innerRadius","outerRadius"]}},indexAxis:"r",startAngle:0},On.overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i}}=t.legend.options;return e.labels.map(((e,s)=>{const n=t.getDatasetMeta(0).controller.getStyle(s);return{text:e,fillStyle:n.backgroundColor,strokeStyle:n.borderColor,lineWidth:n.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(s),index:s}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}},tooltip:{callbacks:{title:()=>"",label:t=>t.chart.data.labels[t.dataIndex]+": "+t.formattedValue}}},scales:{r:{type:"radialLinear",angleLines:{display:!1},beginAtZero:!0,grid:{circular:!0},pointLabels:{display:!1},startAngle:0}}};class An extends Dn{}An.id="pie",An.defaults={cutout:0,rotation:0,circumference:360,radius:"100%"};class Tn extends Ps{getLabelAndValue(t){const e=this._cachedMeta.vScale,i=this.getParsed(t);return{label:e.getLabels()[t],value:""+e.getLabelForValue(i[e.axis])}}update(t){const e=this._cachedMeta,i=e.dataset,s=e.data||[],n=e.iScale.getLabels();if(i.points=s,"resize"!==t){const e=this.resolveDatasetElementOptions(t);this.options.showLine||(e.borderWidth=0);const o={_loop:!0,_fullLoop:n.length===s.length,options:e};this.updateElement(i,void 0,o,t)}this.updateElements(s,0,s.length,t)}updateElements(t,e,i,s){const n=this.getDataset(),o=this._cachedMeta.rScale,a="reset"===s;for(let r=e;r"",label:t=>"("+t.label+", "+t.formattedValue+")"}}},scales:{x:{type:"linear"},y:{type:"linear"}}};var Rn=Object.freeze({__proto__:null,BarController:Sn,BubbleController:Pn,DoughnutController:Dn,LineController:Cn,PolarAreaController:On,PieController:An,RadarController:Tn,ScatterController:Ln});function En(t,e,i){const{startAngle:s,pixelMargin:n,x:o,y:a,outerRadius:r,innerRadius:l}=e;let h=n/r;t.beginPath(),t.arc(o,a,r,s-h,i+h),l>n?(h=n/l,t.arc(o,a,l,i+h,s-h,!0)):t.arc(o,a,n,i+kt,s-kt),t.closePath(),t.clip()}function In(t,e,i,s){const n=Be(t.options.borderRadius,["outerStart","outerEnd","innerStart","innerEnd"]);const o=(i-e)/2,a=Math.min(o,s*e/2),r=t=>{const e=(i-Math.min(o,t))*s/2;return jt(t,0,Math.min(o,e))};return{outerStart:r(n.outerStart),outerEnd:r(n.outerEnd),innerStart:jt(n.innerStart,0,a),innerEnd:jt(n.innerEnd,0,a)}}function zn(t,e,i,s){return{x:i+t*Math.cos(e),y:s+t*Math.sin(e)}}function Fn(t,e,i,s,n){const{x:o,y:a,startAngle:r,pixelMargin:l,innerRadius:h}=e,c=Math.max(e.outerRadius+s+i-l,0),d=h>0?h+s+i+l:0;let u=0;const f=n-r;if(s){const t=((h>0?h-s:0)+(c>0?c-s:0))/2;u=(f-(0!==t?f*t/(t+s):f))/2}const g=(f-Math.max(.001,f*c-i/_t)/c)/2,p=r+g+u,m=n-g-u,{outerStart:x,outerEnd:b,innerStart:_,innerEnd:y}=In(e,d,c,m-p),v=c-x,w=c-b,M=p+x/v,k=m-b/w,S=d+_,P=d+y,D=p+_/S,C=m-y/P;if(t.beginPath(),t.arc(o,a,c,M,k),b>0){const e=zn(w,k,o,a);t.arc(e.x,e.y,b,k,m+kt)}const O=zn(P,m,o,a);if(t.lineTo(O.x,O.y),y>0){const e=zn(P,C,o,a);t.arc(e.x,e.y,y,m+kt,C+Math.PI)}if(t.arc(o,a,d,m-y/d,p+_/d,!0),_>0){const e=zn(S,D,o,a);t.arc(e.x,e.y,_,D+Math.PI,p-kt)}const A=zn(v,p,o,a);if(t.lineTo(A.x,A.y),x>0){const e=zn(v,M,o,a);t.arc(e.x,e.y,x,p-kt,M)}t.closePath()}function Bn(t,e,i,s,n){const{options:o}=e,{borderWidth:a,borderJoinStyle:r}=o,l="inner"===o.borderAlign;a&&(l?(t.lineWidth=2*a,t.lineJoin=r||"round"):(t.lineWidth=a,t.lineJoin=r||"bevel"),e.fullCircles&&function(t,e,i){const{x:s,y:n,startAngle:o,pixelMargin:a,fullCircles:r}=e,l=Math.max(e.outerRadius-a,0),h=e.innerRadius+a;let c;for(i&&En(t,e,o+yt),t.beginPath(),t.arc(s,n,h,o+yt,o,!0),c=0;c=yt||Ht(n,a,r),f=Yt(o,l+d,h+d);return u&&f}getCenterPoint(t){const{x:e,y:i,startAngle:s,endAngle:n,innerRadius:o,outerRadius:a}=this.getProps(["x","y","startAngle","endAngle","innerRadius","outerRadius","circumference"],t),{offset:r,spacing:l}=this.options,h=(s+n)/2,c=(o+a+l+r)/2;return{x:e+Math.cos(h)*c,y:i+Math.sin(h)*c}}tooltipPosition(t){return this.getCenterPoint(t)}draw(t){const{options:e,circumference:i}=this,s=(e.offset||0)/2,n=(e.spacing||0)/2;if(this.pixelMargin="inner"===e.borderAlign?.33:0,this.fullCircles=i>yt?Math.floor(i/yt):0,0===i||this.innerRadius<0||this.outerRadius<0)return;t.save();let o=0;if(s){o=s/2;const e=(this.startAngle+this.endAngle)/2;t.translate(Math.cos(e)*o,Math.sin(e)*o),this.circumference>=_t&&(o=s)}t.fillStyle=e.backgroundColor,t.strokeStyle=e.borderColor;const a=function(t,e,i,s){const{fullCircles:n,startAngle:o,circumference:a}=e;let r=e.endAngle;if(n){Fn(t,e,i,s,o+yt);for(let e=0;er&&o>r;return{count:s,start:l,loop:e.loop,ilen:h(a+(h?r-t:t))%o,_=()=>{f!==g&&(t.lineTo(m,g),t.lineTo(m,f),t.lineTo(m,p))};for(l&&(d=n[b(0)],t.moveTo(d.x,d.y)),c=0;c<=r;++c){if(d=n[b(c)],d.skip)continue;const e=d.x,i=d.y,s=0|e;s===u?(ig&&(g=i),m=(x*m+e)/++x):(_(),t.lineTo(e,i),u=s,x=0,f=g=i),p=i}_()}function Yn(t){const e=t.options,i=e.borderDash&&e.borderDash.length;return!(t._decimated||t._loop||e.tension||"monotone"===e.cubicInterpolationMode||e.stepped||i)?$n:jn}Vn.id="arc",Vn.defaults={borderAlign:"center",borderColor:"#fff",borderJoinStyle:void 0,borderRadius:0,borderWidth:2,offset:0,spacing:0,angle:void 0},Vn.defaultRoutes={backgroundColor:"backgroundColor"};const Un="function"==typeof Path2D;function Xn(t,e,i,s){Un&&!e.options.segment?function(t,e,i,s){let n=e._path;n||(n=e._path=new Path2D,e.path(n,i,s)&&n.closePath()),Wn(t,e.options),t.stroke(n)}(t,e,i,s):function(t,e,i,s){const{segments:n,options:o}=e,a=Yn(e);for(const r of n)Wn(t,o,r.style),t.beginPath(),a(t,e,r,{start:i,end:i+s-1})&&t.closePath(),t.stroke()}(t,e,i,s)}class qn extends Ds{constructor(t){super(),this.animated=!0,this.options=void 0,this._chart=void 0,this._loop=void 0,this._fullLoop=void 0,this._path=void 0,this._points=void 0,this._segments=void 0,this._decimated=!1,this._pointsUpdated=!1,this._datasetIndex=void 0,t&&Object.assign(this,t)}updateControlPoints(t,e){const i=this.options;if((i.tension||"monotone"===i.cubicInterpolationMode)&&!i.stepped&&!this._pointsUpdated){const s=i.spanGaps?this._loop:this._fullLoop;ki(this._points,i,t,s,e),this._pointsUpdated=!0}}set points(t){this._points=t,delete this._segments,delete this._path,this._pointsUpdated=!1}get points(){return this._points}get segments(){return this._segments||(this._segments=Ni(this,this.options.segment))}first(){const t=this.segments,e=this.points;return t.length&&e[t[0].start]}last(){const t=this.segments,e=this.points,i=t.length;return i&&e[t[i-1].end]}interpolate(t,e){const i=this.options,s=t[e],n=this.points,o=Wi(this,{property:e,start:s,end:s});if(!o.length)return;const a=[],r=function(t){return t.stepped?Ai:t.tension||"monotone"===t.cubicInterpolationMode?Ti:Oi}(i);let l,h;for(l=0,h=o.length;l"borderDash"!==t&&"fill"!==t};class Gn extends Ds{constructor(t){super(),this.options=void 0,this.parsed=void 0,this.skip=void 0,this.stop=void 0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.options,{x:n,y:o}=this.getProps(["x","y"],i);return Math.pow(t-n,2)+Math.pow(e-o,2){oo(t)}))}var ro={id:"decimation",defaults:{algorithm:"min-max",enabled:!1},beforeElementsUpdate:(t,e,i)=>{if(!i.enabled)return void ao(t);const s=t.width;t.data.datasets.forEach(((e,n)=>{const{_data:o,indexAxis:a}=e,r=t.getDatasetMeta(n),l=o||e.data;if("y"===je([a,t.options.indexAxis]))return;if("line"!==r.type)return;const h=t.scales[r.xAxisID];if("linear"!==h.type&&"time"!==h.type)return;if(t.options.parsing)return;let{start:c,count:d}=function(t,e){const i=e.length;let s,n=0;const{iScale:o}=t,{min:a,max:r,minDefined:l,maxDefined:h}=o.getUserBounds();return l&&(n=jt(re(e,o.axis,a).lo,0,i-1)),s=h?jt(re(e,o.axis,r).hi+1,n,i)-n:i-n,{start:n,count:s}}(r,l);if(d<=(i.threshold||4*s))return void oo(e);let u;switch($(o)&&(e._data=l,delete e.data,Object.defineProperty(e,"data",{configurable:!0,enumerable:!0,get:function(){return this._decimated},set:function(t){this._data=t}})),i.algorithm){case"lttb":u=function(t,e,i,s,n){const o=n.samples||s;if(o>=i)return t.slice(e,e+i);const a=[],r=(i-2)/(o-2);let l=0;const h=e+i-1;let c,d,u,f,g,p=e;for(a[l++]=t[p],c=0;cu&&(u=f,d=t[s],g=s);a[l++]=d,p=g}return a[l++]=t[h],a}(l,c,d,s,i);break;case"min-max":u=function(t,e,i,s){let n,o,a,r,l,h,c,d,u,f,g=0,p=0;const m=[],x=e+i-1,b=t[e].x,_=t[x].x-b;for(n=e;nf&&(f=r,c=n),g=(p*g+o.x)/++p;else{const i=n-1;if(!$(h)&&!$(c)){const e=Math.min(h,c),s=Math.max(h,c);e!==d&&e!==i&&m.push({...t[e],x:g}),s!==d&&s!==i&&m.push({...t[s],x:g})}n>0&&i!==d&&m.push(t[i]),m.push(o),l=e,p=0,u=f=r,h=c=d=n}}return m}(l,c,d,s);break;default:throw new Error(`Unsupported decimation algorithm '${i.algorithm}'`)}e._decimated=u}))},destroy(t){ao(t)}};function lo(t,e,i){const s=function(t){const e=t.options,i=e.fill;let s=K(i&&i.target,i);return void 0===s&&(s=!!e.backgroundColor),!1!==s&&null!==s&&(!0===s?"origin":s)}(t);if(U(s))return!isNaN(s.value)&&s;let n=parseFloat(s);return X(n)&&Math.floor(n)===n?("-"!==s[0]&&"+"!==s[0]||(n=e+n),!(n===e||n<0||n>=i)&&n):["origin","start","end","stack","shape"].indexOf(s)>=0&&s}class ho{constructor(t){this.x=t.x,this.y=t.y,this.radius=t.radius}pathSegment(t,e,i){const{x:s,y:n,radius:o}=this;return e=e||{start:0,end:yt},t.arc(s,n,o,e.end,e.start,!0),!i.bounds}interpolate(t){const{x:e,y:i,radius:s}=this,n=t.angle;return{x:e+Math.cos(n)*s,y:i+Math.sin(n)*s,angle:n}}}function co(t){return(t.scale||{}).getPointPositionForValue?function(t){const{scale:e,fill:i}=t,s=e.options,n=e.getLabels().length,o=[],a=s.reverse?e.max:e.min,r=s.reverse?e.min:e.max;let l,h,c;if(c="start"===i?a:"end"===i?r:U(i)?i.value:e.getBaseValue(),s.grid.circular)return h=e.getPointPositionForValue(0,a),new ho({x:h.x,y:h.y,radius:e.getDistanceFromCenterForValue(c)});for(l=0;lt;e--){const t=i[e];if(!isNaN(t.x)&&!isNaN(t.y))break}return e}function fo(t,e,i){const s=[];for(let n=0;n{e=uo(t,e,n);const a=n[t],r=n[e];null!==s?(o.push({x:a.x,y:s}),o.push({x:r.x,y:s})):null!==i&&(o.push({x:i,y:a.y}),o.push({x:i,y:r.y}))})),o}(t,e),i.length?new qn({points:i,options:{tension:0},_loop:s,_fullLoop:s}):null}function xo(t,e,i){let s=t[e].fill;const n=[e];let o;if(!i)return s;for(;!1!==s&&-1===n.indexOf(s);){if(!X(s))return s;if(o=t[s],!o)return!1;if(o.visible)return s;n.push(s),s=o.fill}return!1}function bo(t,e,i){const{segments:s,points:n}=e;let o=!0,a=!1;t.beginPath();for(const r of s){const{start:s,end:l}=r,h=n[s],c=n[uo(s,l,n)];o?(t.moveTo(h.x,h.y),o=!1):(t.lineTo(h.x,i),t.lineTo(h.x,h.y)),a=!!e.pathSegment(t,r,{move:a}),a?t.closePath():t.lineTo(c.x,i)}t.lineTo(e.first().x,i),t.closePath(),t.clip()}function _o(t,e,i,s){if(s)return;let n=e[t],o=i[t];return"angle"===t&&(n=Nt(n),o=Nt(o)),{property:t,start:n,end:o}}function yo(t,e,i,s){return t&&e?s(t[i],e[i]):t?t[i]:e?e[i]:0}function vo(t,e,i){const{top:s,bottom:n}=e.chart.chartArea,{property:o,start:a,end:r}=i||{};"x"===o&&(t.beginPath(),t.rect(a,s,r-a,n-s),t.clip())}function wo(t,e,i,s){const n=e.interpolate(i,s);n&&t.lineTo(n.x,n.y)}function Mo(t,e){const{line:i,target:s,property:n,color:o,scale:a}=e,r=function(t,e,i){const s=t.segments,n=t.points,o=e.points,a=[];for(const t of s){let{start:s,end:r}=t;r=uo(s,r,n);const l=_o(i,n[s],n[r],t.loop);if(!e.segments){a.push({source:t,target:l,start:n[s],end:n[r]});continue}const h=Wi(e,l);for(const e of h){const s=_o(i,o[e.start],o[e.end],e.loop),r=Vi(t,n,s);for(const t of r)a.push({source:t,target:e,start:{[i]:yo(l,s,"start",Math.max)},end:{[i]:yo(l,s,"end",Math.min)}})}}return a}(i,s,n);for(const{source:e,target:l,start:h,end:c}of r){const{style:{backgroundColor:r=o}={}}=e,d=!0!==s;t.save(),t.fillStyle=r,vo(t,a,d&&_o(n,h,c)),t.beginPath();const u=!!i.pathSegment(t,e);let f;if(d){u?t.closePath():wo(t,s,c,n);const e=!!s.pathSegment(t,l,{move:u,reverse:!0});f=u&&e,f||wo(t,s,h,n)}t.closePath(),t.fill(f?"evenodd":"nonzero"),t.restore()}}function ko(t,e,i){const s=po(e),{line:n,scale:o,axis:a}=e,r=n.options,l=r.fill,h=r.backgroundColor,{above:c=h,below:d=h}=l||{};s&&n.points.length&&(Qt(t,i),function(t,e){const{line:i,target:s,above:n,below:o,area:a,scale:r}=e,l=i._loop?"angle":e.axis;t.save(),"x"===l&&o!==n&&(bo(t,s,a.top),Mo(t,{line:i,target:s,color:n,scale:r,property:l}),t.restore(),t.save(),bo(t,s,a.bottom)),Mo(t,{line:i,target:s,color:o,scale:r,property:l}),t.restore()}(t,{line:n,target:s,above:c,below:d,area:i,scale:o,axis:a}),te(t))}var So={id:"filler",afterDatasetsUpdate(t,e,i){const s=(t.data.datasets||[]).length,n=[];let o,a,r,l;for(a=0;a=0;--e){const i=n[e].$filler;i&&(i.line.updateControlPoints(o,i.axis),s&&ko(t.ctx,i,o))}},beforeDatasetsDraw(t,e,i){if("beforeDatasetsDraw"!==i.drawTime)return;const s=t.getSortedVisibleDatasetMetas();for(let e=s.length-1;e>=0;--e){const i=s[e].$filler;i&&ko(t.ctx,i,t.chartArea)}},beforeDatasetDraw(t,e,i){const s=e.meta.$filler;s&&!1!==s.fill&&"beforeDatasetDraw"===i.drawTime&&ko(t.ctx,s,t.chartArea)},defaults:{propagate:!0,drawTime:"beforeDatasetDraw"}};const Po=(t,e)=>{let{boxHeight:i=e,boxWidth:s=e}=t;return t.usePointStyle&&(i=Math.min(i,e),s=Math.min(s,e)),{boxWidth:s,boxHeight:i,itemHeight:Math.max(e,i)}};class Do extends Ds{constructor(t){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e,i){this.maxWidth=t,this.maxHeight=e,this._margins=i,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){const t=this.options.labels||{};let e=J(t.generateLabels,[this.chart],this)||[];t.filter&&(e=e.filter((e=>t.filter(e,this.chart.data)))),t.sort&&(e=e.sort(((e,i)=>t.sort(e,i,this.chart.data)))),this.options.reverse&&e.reverse(),this.legendItems=e}fit(){const{options:t,ctx:e}=this;if(!t.display)return void(this.width=this.height=0);const i=t.labels,s=He(i.font),n=s.size,o=this._computeTitleHeight(),{boxWidth:a,itemHeight:r}=Po(i,n);let l,h;e.font=s.string,this.isHorizontal()?(l=this.maxWidth,h=this._fitRows(o,n,a,r)+10):(h=this.maxHeight,l=this._fitCols(o,n,a,r)+10),this.width=Math.min(l,t.maxWidth||this.maxWidth),this.height=Math.min(h,t.maxHeight||this.maxHeight)}_fitRows(t,e,i,s){const{ctx:n,maxWidth:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.lineWidths=[0],h=s+a;let c=t;n.textAlign="left",n.textBaseline="middle";let d=-1,u=-h;return this.legendItems.forEach(((t,f)=>{const g=i+e/2+n.measureText(t.text).width;(0===f||l[l.length-1]+g+2*a>o)&&(c+=h,l[l.length-(f>0?0:1)]=0,u+=h,d++),r[f]={left:0,top:u,row:d,width:g,height:s},l[l.length-1]+=g+a})),c}_fitCols(t,e,i,s){const{ctx:n,maxHeight:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.columnSizes=[],h=o-t;let c=a,d=0,u=0,f=0,g=0;return this.legendItems.forEach(((t,o)=>{const p=i+e/2+n.measureText(t.text).width;o>0&&u+s+2*a>h&&(c+=d+a,l.push({width:d,height:u}),f+=d+a,g++,d=u=0),r[o]={left:f,top:u,col:g,width:p,height:s},d=Math.max(d,p),u+=s+a})),c+=d,l.push({width:d,height:u}),c}adjustHitBoxes(){if(!this.options.display)return;const t=this._computeTitleHeight(),{legendHitBoxes:e,options:{align:i,labels:{padding:s},rtl:o}}=this,a=Ei(o,this.left,this.width);if(this.isHorizontal()){let o=0,r=n(i,this.left+s,this.right-this.lineWidths[o]);for(const l of e)o!==l.row&&(o=l.row,r=n(i,this.left+s,this.right-this.lineWidths[o])),l.top+=this.top+t+s,l.left=a.leftForLtr(a.x(r),l.width),r+=l.width+s}else{let o=0,r=n(i,this.top+t+s,this.bottom-this.columnSizes[o].height);for(const l of e)l.col!==o&&(o=l.col,r=n(i,this.top+t+s,this.bottom-this.columnSizes[o].height)),l.top=r,l.left+=this.left+s,l.left=a.leftForLtr(a.x(l.left),l.width),r+=l.height+s}}isHorizontal(){return"top"===this.options.position||"bottom"===this.options.position}draw(){if(this.options.display){const t=this.ctx;Qt(t,this),this._draw(),te(t)}}_draw(){const{options:t,columnSizes:e,lineWidths:i,ctx:s}=this,{align:a,labels:r}=t,l=bt.color,h=Ei(t.rtl,this.left,this.width),c=He(r.font),{color:d,padding:u}=r,f=c.size,g=f/2;let p;this.drawTitle(),s.textAlign=h.textAlign("left"),s.textBaseline="middle",s.lineWidth=.5,s.font=c.string;const{boxWidth:m,boxHeight:x,itemHeight:b}=Po(r,f),_=this.isHorizontal(),y=this._computeTitleHeight();p=_?{x:n(a,this.left+u,this.right-i[0]),y:this.top+u+y,line:0}:{x:this.left+u,y:n(a,this.top+y+u,this.bottom-e[0].height),line:0},Ii(this.ctx,t.textDirection);const v=b+u;this.legendItems.forEach(((w,M)=>{s.strokeStyle=w.fontColor||d,s.fillStyle=w.fontColor||d;const k=s.measureText(w.text).width,S=h.textAlign(w.textAlign||(w.textAlign=r.textAlign)),P=m+g+k;let D=p.x,C=p.y;h.setWidth(this.width),_?M>0&&D+P+u>this.right&&(C=p.y+=v,p.line++,D=p.x=n(a,this.left+u,this.right-i[p.line])):M>0&&C+v>this.bottom&&(D=p.x=D+e[p.line].width+u,p.line++,C=p.y=n(a,this.top+y+u,this.bottom-e[p.line].height));!function(t,e,i){if(isNaN(m)||m<=0||isNaN(x)||x<0)return;s.save();const n=K(i.lineWidth,1);if(s.fillStyle=K(i.fillStyle,l),s.lineCap=K(i.lineCap,"butt"),s.lineDashOffset=K(i.lineDashOffset,0),s.lineJoin=K(i.lineJoin,"miter"),s.lineWidth=n,s.strokeStyle=K(i.strokeStyle,l),s.setLineDash(K(i.lineDash,[])),r.usePointStyle){const o={radius:m*Math.SQRT2/2,pointStyle:i.pointStyle,rotation:i.rotation,borderWidth:n},a=h.xPlus(t,m/2);Zt(s,o,a,e+g)}else{const o=e+Math.max((f-x)/2,0),a=h.leftForLtr(t,m),r=We(i.borderRadius);s.beginPath(),Object.values(r).some((t=>0!==t))?oe(s,{x:a,y:o,w:m,h:x,radius:r}):s.rect(a,o,m,x),s.fill(),0!==n&&s.stroke()}s.restore()}(h.x(D),C,w),D=o(S,D+m+g,_?D+P:this.right,t.rtl),function(t,e,i){se(s,i.text,t,e+b/2,c,{strikethrough:i.hidden,textAlign:h.textAlign(i.textAlign)})}(h.x(D),C,w),_?p.x+=P+u:p.y+=v})),zi(this.ctx,t.textDirection)}drawTitle(){const t=this.options,e=t.title,i=He(e.font),o=Ne(e.padding);if(!e.display)return;const a=Ei(t.rtl,this.left,this.width),r=this.ctx,l=e.position,h=i.size/2,c=o.top+h;let d,u=this.left,f=this.width;if(this.isHorizontal())f=Math.max(...this.lineWidths),d=this.top+c,u=n(t.align,u,this.right-f);else{const e=this.columnSizes.reduce(((t,e)=>Math.max(t,e.height)),0);d=c+n(t.align,this.top,this.bottom-e-t.labels.padding-this._computeTitleHeight())}const g=n(l,u,u+f);r.textAlign=a.textAlign(s(l)),r.textBaseline="middle",r.strokeStyle=e.color,r.fillStyle=e.color,r.font=i.string,se(r,e.text,g,d,i)}_computeTitleHeight(){const t=this.options.title,e=He(t.font),i=Ne(t.padding);return t.display?e.lineHeight+i.height:0}_getLegendItemAt(t,e){let i,s,n;if(Yt(t,this.left,this.right)&&Yt(e,this.top,this.bottom))for(n=this.legendHitBoxes,i=0;it.chart.options.color,boxWidth:40,padding:10,generateLabels(t){const e=t.data.datasets,{labels:{usePointStyle:i,pointStyle:s,textAlign:n,color:o}}=t.legend.options;return t._getSortedDatasetMetas().map((t=>{const a=t.controller.getStyle(i?0:void 0),r=Ne(a.borderWidth);return{text:e[t.index].label,fillStyle:a.backgroundColor,fontColor:o,hidden:!t.visible,lineCap:a.borderCapStyle,lineDash:a.borderDash,lineDashOffset:a.borderDashOffset,lineJoin:a.borderJoinStyle,lineWidth:(r.width+r.height)/4,strokeStyle:a.borderColor,pointStyle:s||a.pointStyle,rotation:a.rotation,textAlign:n||a.textAlign,borderRadius:0,datasetIndex:t.index}}),this)}},title:{color:t=>t.chart.options.color,display:!1,position:"center",text:""}},descriptors:{_scriptable:t=>!t.startsWith("on"),labels:{_scriptable:t=>!["generateLabels","filter","sort"].includes(t)}}};class Oo extends Ds{constructor(t){super(),this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this._padding=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e){const i=this.options;if(this.left=0,this.top=0,!i.display)return void(this.width=this.height=this.right=this.bottom=0);this.width=this.right=t,this.height=this.bottom=e;const s=Y(i.text)?i.text.length:1;this._padding=Ne(i.padding);const n=s*He(i.font).lineHeight+this._padding.height;this.isHorizontal()?this.height=n:this.width=n}isHorizontal(){const t=this.options.position;return"top"===t||"bottom"===t}_drawArgs(t){const{top:e,left:i,bottom:s,right:o,options:a}=this,r=a.align;let l,h,c,d=0;return this.isHorizontal()?(h=n(r,i,o),c=e+t,l=o-i):("left"===a.position?(h=i+t,c=n(r,s,e),d=-.5*_t):(h=o-t,c=n(r,e,s),d=.5*_t),l=s-e),{titleX:h,titleY:c,maxWidth:l,rotation:d}}draw(){const t=this.ctx,e=this.options;if(!e.display)return;const i=He(e.font),n=i.lineHeight/2+this._padding.top,{titleX:o,titleY:a,maxWidth:r,rotation:l}=this._drawArgs(n);se(t,e.text,0,0,i,{color:e.color,maxWidth:r,rotation:l,textAlign:s(e.align),textBaseline:"middle",translation:[o,a]})}}var Ao={id:"title",_element:Oo,start(t,e,i){!function(t,e){const i=new Oo({ctx:t.ctx,options:e,chart:t});ni.configure(t,i,e),ni.addBox(t,i),t.titleBlock=i}(t,i)},stop(t){const e=t.titleBlock;ni.removeBox(t,e),delete t.titleBlock},beforeUpdate(t,e,i){const s=t.titleBlock;ni.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"bold"},fullSize:!0,padding:10,position:"top",text:"",weight:2e3},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const To=new WeakMap;var Lo={id:"subtitle",start(t,e,i){const s=new Oo({ctx:t.ctx,options:i,chart:t});ni.configure(t,s,i),ni.addBox(t,s),To.set(t,s)},stop(t){ni.removeBox(t,To.get(t)),To.delete(t)},beforeUpdate(t,e,i){const s=To.get(t);ni.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"normal"},fullSize:!0,padding:0,position:"top",text:"",weight:1500},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const Ro={average(t){if(!t.length)return!1;let e,i,s=0,n=0,o=0;for(e=0,i=t.length;e-1?t.split("\n"):t}function zo(t,e){const{element:i,datasetIndex:s,index:n}=e,o=t.getDatasetMeta(s).controller,{label:a,value:r}=o.getLabelAndValue(n);return{chart:t,label:a,parsed:o.getParsed(n),raw:t.data.datasets[s].data[n],formattedValue:r,dataset:o.getDataset(),dataIndex:n,datasetIndex:s,element:i}}function Fo(t,e){const i=t.chart.ctx,{body:s,footer:n,title:o}=t,{boxWidth:a,boxHeight:r}=e,l=He(e.bodyFont),h=He(e.titleFont),c=He(e.footerFont),d=o.length,u=n.length,f=s.length,g=Ne(e.padding);let p=g.height,m=0,x=s.reduce(((t,e)=>t+e.before.length+e.lines.length+e.after.length),0);if(x+=t.beforeBody.length+t.afterBody.length,d&&(p+=d*h.lineHeight+(d-1)*e.titleSpacing+e.titleMarginBottom),x){p+=f*(e.displayColors?Math.max(r,l.lineHeight):l.lineHeight)+(x-f)*l.lineHeight+(x-1)*e.bodySpacing}u&&(p+=e.footerMarginTop+u*c.lineHeight+(u-1)*e.footerSpacing);let b=0;const _=function(t){m=Math.max(m,i.measureText(t).width+b)};return i.save(),i.font=h.string,Q(t.title,_),i.font=l.string,Q(t.beforeBody.concat(t.afterBody),_),b=e.displayColors?a+2+e.boxPadding:0,Q(s,(t=>{Q(t.before,_),Q(t.lines,_),Q(t.after,_)})),b=0,i.font=c.string,Q(t.footer,_),i.restore(),m+=g.width,{width:m,height:p}}function Bo(t,e,i,s){const{x:n,width:o}=i,{width:a,chartArea:{left:r,right:l}}=t;let h="center";return"center"===s?h=n<=(r+l)/2?"left":"right":n<=o/2?h="left":n>=a-o/2&&(h="right"),function(t,e,i,s){const{x:n,width:o}=s,a=i.caretSize+i.caretPadding;return"left"===t&&n+o+a>e.width||"right"===t&&n-o-a<0||void 0}(h,t,e,i)&&(h="center"),h}function Vo(t,e,i){const s=i.yAlign||e.yAlign||function(t,e){const{y:i,height:s}=e;return it.height-s/2?"bottom":"center"}(t,i);return{xAlign:i.xAlign||e.xAlign||Bo(t,e,i,s),yAlign:s}}function Wo(t,e,i,s){const{caretSize:n,caretPadding:o,cornerRadius:a}=t,{xAlign:r,yAlign:l}=i,h=n+o,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:f}=We(a);let g=function(t,e){let{x:i,width:s}=t;return"right"===e?i-=s:"center"===e&&(i-=s/2),i}(e,r);const p=function(t,e,i){let{y:s,height:n}=t;return"top"===e?s+=i:s-="bottom"===e?n+i:n/2,s}(e,l,h);return"center"===l?"left"===r?g+=h:"right"===r&&(g-=h):"left"===r?g-=Math.max(c,u)+n:"right"===r&&(g+=Math.max(d,f)+n),{x:jt(g,0,s.width-e.width),y:jt(p,0,s.height-e.height)}}function No(t,e,i){const s=Ne(i.padding);return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-s.right:t.x+s.left}function Ho(t){return Eo([],Io(t))}function jo(t,e){const i=e&&e.dataset&&e.dataset.tooltip&&e.dataset.tooltip.callbacks;return i?t.override(i):t}class $o extends Ds{constructor(t){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=t.chart||t._chart,this._chart=this.chart,this.options=t.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(t){this.options=t,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){const t=this._cachedAnimations;if(t)return t;const e=this.chart,i=this.options.setContext(this.getContext()),s=i.enabled&&e.options.animation&&i.animations,n=new gs(this.chart,s);return s._cacheable&&(this._cachedAnimations=Object.freeze(n)),n}getContext(){return this.$context||(this.$context=(t=this.chart.getContext(),e=this,i=this._tooltipItems,Ye(t,{tooltip:e,tooltipItems:i,type:"tooltip"})));var t,e,i}getTitle(t,e){const{callbacks:i}=e,s=i.beforeTitle.apply(this,[t]),n=i.title.apply(this,[t]),o=i.afterTitle.apply(this,[t]);let a=[];return a=Eo(a,Io(s)),a=Eo(a,Io(n)),a=Eo(a,Io(o)),a}getBeforeBody(t,e){return Ho(e.callbacks.beforeBody.apply(this,[t]))}getBody(t,e){const{callbacks:i}=e,s=[];return Q(t,(t=>{const e={before:[],lines:[],after:[]},n=jo(i,t);Eo(e.before,Io(n.beforeLabel.call(this,t))),Eo(e.lines,n.label.call(this,t)),Eo(e.after,Io(n.afterLabel.call(this,t))),s.push(e)})),s}getAfterBody(t,e){return Ho(e.callbacks.afterBody.apply(this,[t]))}getFooter(t,e){const{callbacks:i}=e,s=i.beforeFooter.apply(this,[t]),n=i.footer.apply(this,[t]),o=i.afterFooter.apply(this,[t]);let a=[];return a=Eo(a,Io(s)),a=Eo(a,Io(n)),a=Eo(a,Io(o)),a}_createItems(t){const e=this._active,i=this.chart.data,s=[],n=[],o=[];let a,r,l=[];for(a=0,r=e.length;at.filter(e,s,n,i)))),t.itemSort&&(l=l.sort(((e,s)=>t.itemSort(e,s,i)))),Q(l,(e=>{const i=jo(t.callbacks,e);s.push(i.labelColor.call(this,e)),n.push(i.labelPointStyle.call(this,e)),o.push(i.labelTextColor.call(this,e))})),this.labelColors=s,this.labelPointStyles=n,this.labelTextColors=o,this.dataPoints=l,l}update(t,e){const i=this.options.setContext(this.getContext()),s=this._active;let n,o=[];if(s.length){const t=Ro[i.position].call(this,s,this._eventPosition);o=this._createItems(i),this.title=this.getTitle(o,i),this.beforeBody=this.getBeforeBody(o,i),this.body=this.getBody(o,i),this.afterBody=this.getAfterBody(o,i),this.footer=this.getFooter(o,i);const e=this._size=Fo(this,i),a=Object.assign({},t,e),r=Vo(this.chart,i,a),l=Wo(i,a,r,this.chart);this.xAlign=r.xAlign,this.yAlign=r.yAlign,n={opacity:1,x:l.x,y:l.y,width:e.width,height:e.height,caretX:t.x,caretY:t.y}}else 0!==this.opacity&&(n={opacity:0});this._tooltipItems=o,this.$context=void 0,n&&this._resolveAnimations().update(this,n),t&&i.external&&i.external.call(this,{chart:this.chart,tooltip:this,replay:e})}drawCaret(t,e,i,s){const n=this.getCaretPosition(t,i,s);e.lineTo(n.x1,n.y1),e.lineTo(n.x2,n.y2),e.lineTo(n.x3,n.y3)}getCaretPosition(t,e,i){const{xAlign:s,yAlign:n}=this,{caretSize:o,cornerRadius:a}=i,{topLeft:r,topRight:l,bottomLeft:h,bottomRight:c}=We(a),{x:d,y:u}=t,{width:f,height:g}=e;let p,m,x,b,_,y;return"center"===n?(_=u+g/2,"left"===s?(p=d,m=p-o,b=_+o,y=_-o):(p=d+f,m=p+o,b=_-o,y=_+o),x=p):(m="left"===s?d+Math.max(r,h)+o:"right"===s?d+f-Math.max(l,c)-o:this.caretX,"top"===n?(b=u,_=b-o,p=m-o,x=m+o):(b=u+g,_=b+o,p=m+o,x=m-o),y=b),{x1:p,x2:m,x3:x,y1:b,y2:_,y3:y}}drawTitle(t,e,i){const s=this.title,n=s.length;let o,a,r;if(n){const l=Ei(i.rtl,this.x,this.width);for(t.x=No(this,i.titleAlign,i),e.textAlign=l.textAlign(i.titleAlign),e.textBaseline="middle",o=He(i.titleFont),a=i.titleSpacing,e.fillStyle=i.titleColor,e.font=o.string,r=0;r0!==t))?(t.beginPath(),t.fillStyle=n.multiKeyBackground,oe(t,{x:e,y:g,w:l,h:r,radius:a}),t.fill(),t.stroke(),t.fillStyle=o.backgroundColor,t.beginPath(),oe(t,{x:i,y:g+1,w:l-2,h:r-2,radius:a}),t.fill()):(t.fillStyle=n.multiKeyBackground,t.fillRect(e,g,l,r),t.strokeRect(e,g,l,r),t.fillStyle=o.backgroundColor,t.fillRect(i,g+1,l-2,r-2))}t.fillStyle=this.labelTextColors[i]}drawBody(t,e,i){const{body:s}=this,{bodySpacing:n,bodyAlign:o,displayColors:a,boxHeight:r,boxWidth:l,boxPadding:h}=i,c=He(i.bodyFont);let d=c.lineHeight,u=0;const f=Ei(i.rtl,this.x,this.width),g=function(i){e.fillText(i,f.x(t.x+u),t.y+d/2),t.y+=d+n},p=f.textAlign(o);let m,x,b,_,y,v,w;for(e.textAlign=o,e.textBaseline="middle",e.font=c.string,t.x=No(this,p,i),e.fillStyle=i.bodyColor,Q(this.beforeBody,g),u=a&&"right"!==p?"center"===o?l/2+h:l+2+h:0,_=0,v=s.length;_0&&e.stroke()}_updateAnimationTarget(t){const e=this.chart,i=this.$animations,s=i&&i.x,n=i&&i.y;if(s||n){const i=Ro[t.position].call(this,this._active,this._eventPosition);if(!i)return;const o=this._size=Fo(this,t),a=Object.assign({},i,this._size),r=Vo(e,t,a),l=Wo(t,a,r,e);s._to===l.x&&n._to===l.y||(this.xAlign=r.xAlign,this.yAlign=r.yAlign,this.width=o.width,this.height=o.height,this.caretX=i.x,this.caretY=i.y,this._resolveAnimations().update(this,l))}}draw(t){const e=this.options.setContext(this.getContext());let i=this.opacity;if(!i)return;this._updateAnimationTarget(e);const s={width:this.width,height:this.height},n={x:this.x,y:this.y};i=Math.abs(i)<.001?0:i;const o=Ne(e.padding),a=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;e.enabled&&a&&(t.save(),t.globalAlpha=i,this.drawBackground(n,t,s,e),Ii(t,e.textDirection),n.y+=o.top,this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),zi(t,e.textDirection),t.restore())}getActiveElements(){return this._active||[]}setActiveElements(t,e){const i=this._active,s=t.map((({datasetIndex:t,index:e})=>{const i=this.chart.getDatasetMeta(t);if(!i)throw new Error("Cannot find a dataset at index "+t);return{datasetIndex:t,element:i.data[e],index:e}})),n=!tt(i,s),o=this._positionChanged(s,e);(n||o)&&(this._active=s,this._eventPosition=e,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(t,e,i=!0){if(e&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;const s=this.options,n=this._active||[],o=this._getActiveElements(t,n,e,i),a=this._positionChanged(o,t),r=e||!tt(o,n)||a;return r&&(this._active=o,(s.enabled||s.external)&&(this._eventPosition={x:t.x,y:t.y},this.update(!0,e))),r}_getActiveElements(t,e,i,s){const n=this.options;if("mouseout"===t.type)return[];if(!s)return e;const o=this.chart.getElementsAtEventForMode(t,n.mode,n,i);return n.reverse&&o.reverse(),o}_positionChanged(t,e){const{caretX:i,caretY:s,options:n}=this,o=Ro[n.position].call(this,t,e);return!1!==o&&(i!==o.x||s!==o.y)}}$o.positioners=Ro;var Yo={id:"tooltip",_element:$o,positioners:Ro,afterInit(t,e,i){i&&(t.tooltip=new $o({chart:t,options:i}))},beforeUpdate(t,e,i){t.tooltip&&t.tooltip.initialize(i)},reset(t,e,i){t.tooltip&&t.tooltip.initialize(i)},afterDraw(t){const e=t.tooltip,i={tooltip:e};!1!==t.notifyPlugins("beforeTooltipDraw",i)&&(e&&e.draw(t.ctx),t.notifyPlugins("afterTooltipDraw",i))},afterEvent(t,e){if(t.tooltip){const i=e.replay;t.tooltip.handleEvent(e.event,i,e.inChartArea)&&(e.changed=!0)}},defaults:{enabled:!0,external:null,position:"average",backgroundColor:"rgba(0,0,0,0.8)",titleColor:"#fff",titleFont:{weight:"bold"},titleSpacing:2,titleMarginBottom:6,titleAlign:"left",bodyColor:"#fff",bodySpacing:2,bodyFont:{},bodyAlign:"left",footerColor:"#fff",footerSpacing:2,footerMarginTop:6,footerFont:{weight:"bold"},footerAlign:"left",padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(t,e)=>e.bodyFont.size,boxWidth:(t,e)=>e.bodyFont.size,multiKeyBackground:"#fff",displayColors:!0,boxPadding:0,borderColor:"rgba(0,0,0,0)",borderWidth:0,animation:{duration:400,easing:"easeOutQuart"},animations:{numbers:{type:"number",properties:["x","y","width","height","caretX","caretY"]},opacity:{easing:"linear",duration:200}},callbacks:{beforeTitle:H,title(t){if(t.length>0){const e=t[0],i=e.chart.data.labels,s=i?i.length:0;if(this&&this.options&&"dataset"===this.options.mode)return e.dataset.label||"";if(e.label)return e.label;if(s>0&&e.dataIndex"filter"!==t&&"itemSort"!==t&&"external"!==t,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:"animation"}},additionalOptionScopes:["interaction"]},Uo=Object.freeze({__proto__:null,Decimation:ro,Filler:So,Legend:Co,SubTitle:Lo,Title:Ao,Tooltip:Yo});function Xo(t,e,i,s){const n=t.indexOf(e);if(-1===n)return((t,e,i,s)=>("string"==typeof e?(i=t.push(e)-1,s.unshift({index:i,label:e})):isNaN(e)&&(i=null),i))(t,e,i,s);return n!==t.lastIndexOf(e)?i:n}class qo extends Bs{constructor(t){super(t),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(t){const e=this._addedLabels;if(e.length){const t=this.getLabels();for(const{index:i,label:s}of e)t[i]===s&&t.splice(i,1);this._addedLabels=[]}super.init(t)}parse(t,e){if($(t))return null;const i=this.getLabels();return((t,e)=>null===t?null:jt(Math.round(t),0,e))(e=isFinite(e)&&i[e]===t?e:Xo(i,t,K(e,t),this._addedLabels),i.length-1)}determineDataLimits(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let{min:i,max:s}=this.getMinMax(!0);"ticks"===this.options.bounds&&(t||(i=0),e||(s=this.getLabels().length-1)),this.min=i,this.max=s}buildTicks(){const t=this.min,e=this.max,i=this.options.offset,s=[];let n=this.getLabels();n=0===t&&e===n.length-1?n:n.slice(t,e+1),this._valueRange=Math.max(n.length-(i?0:1),1),this._startValue=this.min-(i?.5:0);for(let i=t;i<=e;i++)s.push({value:i});return s}getLabelForValue(t){const e=this.getLabels();return t>=0&&te.length-1?null:this.getPixelForValue(e[t].value)}getValueForPixel(t){return Math.round(this._startValue+this.getDecimalForPixel(t)*this._valueRange)}getBasePixel(){return this.bottom}}function Ko(t,e,{horizontal:i,minRotation:s}){const n=It(s),o=(i?Math.sin(n):Math.cos(n))||.001,a=.75*e*(""+t).length;return Math.min(e/o,a)}qo.id="category",qo.defaults={ticks:{callback:qo.prototype.getLabelForValue}};class Go extends Bs{constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(t,e){return $(t)||("number"==typeof t||t instanceof Number)&&!isFinite(+t)?null:+t}handleTickRangeOptions(){const{beginAtZero:t}=this.options,{minDefined:e,maxDefined:i}=this.getUserBounds();let{min:s,max:n}=this;const o=t=>s=e?s:t,a=t=>n=i?n:t;if(t){const t=Ct(s),e=Ct(n);t<0&&e<0?a(0):t>0&&e>0&&o(0)}if(s===n){let e=1;(n>=Number.MAX_SAFE_INTEGER||s<=Number.MIN_SAFE_INTEGER)&&(e=Math.abs(.05*n)),a(n+e),t||o(s-e)}this.min=s,this.max=n}getTickLimit(){const t=this.options.ticks;let e,{maxTicksLimit:i,stepSize:s}=t;return s?(e=Math.ceil(this.max/s)-Math.floor(this.min/s)+1,e>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${s} would result generating up to ${e} ticks. Limiting to 1000.`),e=1e3)):(e=this.computeTickLimit(),i=i||11),i&&(e=Math.min(i,e)),e}computeTickLimit(){return Number.POSITIVE_INFINITY}buildTicks(){const t=this.options,e=t.ticks;let i=this.getTickLimit();i=Math.max(2,i);const s=function(t,e){const i=[],{bounds:s,step:n,min:o,max:a,precision:r,count:l,maxTicks:h,maxDigits:c,includeBounds:d}=t,u=n||1,f=h-1,{min:g,max:p}=e,m=!$(o),x=!$(a),b=!$(l),_=(p-g)/(c+1);let y,v,w,M,k=Ot((p-g)/f/u)*u;if(k<1e-14&&!m&&!x)return[{value:g},{value:p}];M=Math.ceil(p/k)-Math.floor(g/k),M>f&&(k=Ot(M*k/f/u)*u),$(r)||(y=Math.pow(10,r),k=Math.ceil(k*y)/y),"ticks"===s?(v=Math.floor(g/k)*k,w=Math.ceil(p/k)*k):(v=g,w=p),m&&x&&n&&Rt((a-o)/n,k/1e3)?(M=Math.round(Math.min((a-o)/k,h)),k=(a-o)/M,v=o,w=a):b?(v=m?o:v,w=x?a:w,M=l-1,k=(w-v)/M):(M=(w-v)/k,M=Lt(M,Math.round(M),k/1e3)?Math.round(M):Math.ceil(M));const S=Math.max(Ft(k),Ft(v));y=Math.pow(10,$(r)?S:r),v=Math.round(v*y)/y,w=Math.round(w*y)/y;let P=0;for(m&&(d&&v!==o?(i.push({value:o}),v0?i:null;this._zero=!0}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=X(t)?Math.max(0,t):null,this.max=X(e)?Math.max(0,e):null,this.options.beginAtZero&&(this._zero=!0),this.handleTickRangeOptions()}handleTickRangeOptions(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let i=this.min,s=this.max;const n=e=>i=t?i:e,o=t=>s=e?s:t,a=(t,e)=>Math.pow(10,Math.floor(Dt(t))+e);i===s&&(i<=0?(n(1),o(10)):(n(a(i,-1)),o(a(s,1)))),i<=0&&n(a(s,-1)),s<=0&&o(a(i,1)),this._zero&&this.min!==this._suggestedMin&&i===a(this.min,0)&&n(a(i,-1)),this.min=i,this.max=s}buildTicks(){const t=this.options,e=function(t,e){const i=Math.floor(Dt(e.max)),s=Math.ceil(e.max/Math.pow(10,i)),n=[];let o=q(t.min,Math.pow(10,Math.floor(Dt(e.min)))),a=Math.floor(Dt(o)),r=Math.floor(o/Math.pow(10,a)),l=a<0?Math.pow(10,Math.abs(a)):1;do{n.push({value:o,major:Jo(o)}),++r,10===r&&(r=1,++a,l=a>=0?1:l),o=Math.round(r*Math.pow(10,a)*l)/l}while(an?{start:e-i,end:e}:{start:e,end:e+i}}function ia(t){const e={l:t.left+t._padding.left,r:t.right-t._padding.right,t:t.top+t._padding.top,b:t.bottom-t._padding.bottom},i=Object.assign({},e),s=[],n=[],o=t._pointLabels.length,a=t.options.pointLabels,r=a.centerPointLabels?_t/o:0;for(let d=0;de.r&&(r=(s.end-e.r)/o,t.r=Math.max(t.r,e.r+r)),n.starte.b&&(l=(n.end-e.b)/a,t.b=Math.max(t.b,e.b+l))}function na(t){return 0===t||180===t?"center":t<180?"left":"right"}function oa(t,e,i){return"right"===i?t-=e:"center"===i&&(t-=e/2),t}function aa(t,e,i){return 90===i||270===i?t-=e/2:(i>270||i<90)&&(t-=e),t}function ra(t,e,i,s){const{ctx:n}=t;if(i)n.arc(t.xCenter,t.yCenter,e,0,yt);else{let i=t.getPointPosition(0,e);n.moveTo(i.x,i.y);for(let o=1;o{const i=J(this.options.pointLabels.callback,[t,e],this);return i||0===i?i:""})).filter(((t,e)=>this.chart.getDataVisibility(e)))}fit(){const t=this.options;t.display&&t.pointLabels.display?ia(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(t,e,i,s){this.xCenter+=Math.floor((t-e)/2),this.yCenter+=Math.floor((i-s)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(t,e,i,s))}getIndexAngle(t){return Nt(t*(yt/(this._pointLabels.length||1))+It(this.options.startAngle||0))}getDistanceFromCenterForValue(t){if($(t))return NaN;const e=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-t)*e:(t-this.min)*e}getValueForDistanceFromCenter(t){if($(t))return NaN;const e=t/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-e:this.min+e}getPointLabelContext(t){const e=this._pointLabels||[];if(t>=0&&t=0;n--){const e=s.setContext(t.getPointLabelContext(n)),o=He(e.font),{x:a,y:r,textAlign:l,left:h,top:c,right:d,bottom:u}=t._pointLabelItems[n],{backdropColor:f}=e;if(!$(f)){const t=Ne(e.backdropPadding);i.fillStyle=f,i.fillRect(h-t.left,c-t.top,d-h+t.width,u-c+t.height)}se(i,t._pointLabels[n],a,r+o.lineHeight/2,o,{color:e.color,textAlign:l,textBaseline:"middle"})}}(this,n),s.display&&this.ticks.forEach(((t,e)=>{if(0!==e){a=this.getDistanceFromCenterForValue(t.value);!function(t,e,i,s){const n=t.ctx,o=e.circular,{color:a,lineWidth:r}=e;!o&&!s||!a||!r||i<0||(n.save(),n.strokeStyle=a,n.lineWidth=r,n.setLineDash(e.borderDash),n.lineDashOffset=e.borderDashOffset,n.beginPath(),ra(t,i,o,s),n.closePath(),n.stroke(),n.restore())}(this,s.setContext(this.getContext(e-1)),a,n)}})),i.display){for(t.save(),o=n-1;o>=0;o--){const s=i.setContext(this.getPointLabelContext(o)),{color:n,lineWidth:l}=s;l&&n&&(t.lineWidth=l,t.strokeStyle=n,t.setLineDash(s.borderDash),t.lineDashOffset=s.borderDashOffset,a=this.getDistanceFromCenterForValue(e.ticks.reverse?this.min:this.max),r=this.getPointPosition(o,a),t.beginPath(),t.moveTo(this.xCenter,this.yCenter),t.lineTo(r.x,r.y),t.stroke())}t.restore()}}drawBorder(){}drawLabels(){const t=this.ctx,e=this.options,i=e.ticks;if(!i.display)return;const s=this.getIndexAngle(0);let n,o;t.save(),t.translate(this.xCenter,this.yCenter),t.rotate(s),t.textAlign="center",t.textBaseline="middle",this.ticks.forEach(((s,a)=>{if(0===a&&!e.reverse)return;const r=i.setContext(this.getContext(a)),l=He(r.font);if(n=this.getDistanceFromCenterForValue(this.ticks[a].value),r.showLabelBackdrop){t.font=l.string,o=t.measureText(s.label).width,t.fillStyle=r.backdropColor;const e=Ne(r.backdropPadding);t.fillRect(-o/2-e.left,-n-l.size/2-e.top,o+e.width,l.size+e.height)}se(t,s.label,0,-n,l,{color:r.color})})),t.restore()}drawTitle(){}}la.id="radialLinear",la.defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:Os.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback:t=>t,padding:5,centerPointLabels:!1}},la.defaultRoutes={"angleLines.color":"borderColor","pointLabels.color":"color","ticks.color":"color"},la.descriptors={angleLines:{_fallback:"grid"}};const ha={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},ca=Object.keys(ha);function da(t,e){return t-e}function ua(t,e){if($(e))return null;const i=t._adapter,{parser:s,round:n,isoWeekday:o}=t._parseOpts;let a=e;return"function"==typeof s&&(a=s(a)),X(a)||(a="string"==typeof s?i.parse(a,s):i.parse(a)),null===a?null:(n&&(a="week"!==n||!Tt(o)&&!0!==o?i.startOf(a,n):i.startOf(a,"isoWeek",o)),+a)}function fa(t,e,i,s){const n=ca.length;for(let o=ca.indexOf(t);o=e?i[s]:i[n]]=!0}}else t[e]=!0}function pa(t,e,i){const s=[],n={},o=e.length;let a,r;for(a=0;a=0&&(e[l].major=!0);return e}(t,s,n,i):s}class ma extends Bs{constructor(t){super(t),this._cache={data:[],labels:[],all:[]},this._unit="day",this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(t,e){const i=t.time||(t.time={}),s=this._adapter=new mn._date(t.adapters.date);ot(i.displayFormats,s.formats()),this._parseOpts={parser:i.parser,round:i.round,isoWeekday:i.isoWeekday},super.init(t),this._normalized=e.normalized}parse(t,e){return void 0===t?null:ua(this,t)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){const t=this.options,e=this._adapter,i=t.time.unit||"day";let{min:s,max:n,minDefined:o,maxDefined:a}=this.getUserBounds();function r(t){o||isNaN(t.min)||(s=Math.min(s,t.min)),a||isNaN(t.max)||(n=Math.max(n,t.max))}o&&a||(r(this._getLabelBounds()),"ticks"===t.bounds&&"labels"===t.ticks.source||r(this.getMinMax(!1))),s=X(s)&&!isNaN(s)?s:+e.startOf(Date.now(),i),n=X(n)&&!isNaN(n)?n:+e.endOf(Date.now(),i)+1,this.min=Math.min(s,n-1),this.max=Math.max(s+1,n)}_getLabelBounds(){const t=this.getLabelTimestamps();let e=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;return t.length&&(e=t[0],i=t[t.length-1]),{min:e,max:i}}buildTicks(){const t=this.options,e=t.time,i=t.ticks,s="labels"===i.source?this.getLabelTimestamps():this._generate();"ticks"===t.bounds&&s.length&&(this.min=this._userMin||s[0],this.max=this._userMax||s[s.length-1]);const n=this.min,o=he(s,n,this.max);return this._unit=e.unit||(i.autoSkip?fa(e.minUnit,this.min,this.max,this._getLabelCapacity(n)):function(t,e,i,s,n){for(let o=ca.length-1;o>=ca.indexOf(i);o--){const i=ca[o];if(ha[i].common&&t._adapter.diff(n,s,i)>=e-1)return i}return ca[i?ca.indexOf(i):0]}(this,o.length,e.minUnit,this.min,this.max)),this._majorUnit=i.major.enabled&&"year"!==this._unit?function(t){for(let e=ca.indexOf(t)+1,i=ca.length;e1e5*a)throw new Error(e+" and "+i+" are too far apart with stepSize of "+a+" "+o);const f="data"===s.ticks.source&&this.getDataTimestamps();for(c=u,d=0;ct-e)).map((t=>+t))}getLabelForValue(t){const e=this._adapter,i=this.options.time;return i.tooltipFormat?e.format(t,i.tooltipFormat):e.format(t,i.displayFormats.datetime)}_tickFormatFunction(t,e,i,s){const n=this.options,o=n.time.displayFormats,a=this._unit,r=this._majorUnit,l=a&&o[a],h=r&&o[r],c=i[e],d=r&&h&&c&&c.major,u=this._adapter.format(t,s||(d?h:l)),f=n.ticks.callback;return f?J(f,[u,e,i],this):u}generateTickLabels(t){let e,i,s;for(e=0,i=t.length;e0?a:1}getDataTimestamps(){let t,e,i=this._cache.data||[];if(i.length)return i;const s=this.getMatchingVisibleMetas();if(this._normalized&&s.length)return this._cache.data=s[0].controller.getAllParsedValues(this);for(t=0,e=s.length;t=t[r].pos&&e<=t[l].pos&&({lo:r,hi:l}=re(t,"pos",e)),({pos:s,time:o}=t[r]),({pos:n,time:a}=t[l])):(e>=t[r].time&&e<=t[l].time&&({lo:r,hi:l}=re(t,"time",e)),({time:s,pos:o}=t[r]),({time:n,pos:a}=t[l]));const h=n-s;return h?o+(a-o)*(e-s)/h:o}ma.id="time",ma.defaults={bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{source:"auto",major:{enabled:!1}}};class ba extends ma{constructor(t){super(t),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){const t=this._getTimestampsForTable(),e=this._table=this.buildLookupTable(t);this._minPos=xa(e,this.min),this._tableRange=xa(e,this.max)-this._minPos,super.initOffsets(t)}buildLookupTable(t){const{min:e,max:i}=this,s=[],n=[];let o,a,r,l,h;for(o=0,a=t.length;o=e&&l<=i&&s.push(l);if(s.length<2)return[{time:e,pos:0},{time:i,pos:1}];for(o=0,a=s.length;o' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '
    ' + + '' + + '' + + ' ' + + '
    ' + + '
    '; + + this.parentEl = (options.parentEl && $(options.parentEl).length) ? $(options.parentEl) : $(this.parentEl); + this.container = $(options.template).appendTo(this.parentEl); + + // + // handle all the possible options overriding defaults + // + + if (typeof options.locale === 'object') { + + if (typeof options.locale.direction === 'string') + this.locale.direction = options.locale.direction; + + if (typeof options.locale.format === 'string') + this.locale.format = options.locale.format; + + if (typeof options.locale.separator === 'string') + this.locale.separator = options.locale.separator; + + if (typeof options.locale.daysOfWeek === 'object') + this.locale.daysOfWeek = options.locale.daysOfWeek.slice(); + + if (typeof options.locale.monthNames === 'object') + this.locale.monthNames = options.locale.monthNames.slice(); + + if (typeof options.locale.firstDay === 'number') + this.locale.firstDay = options.locale.firstDay; + + if (typeof options.locale.applyLabel === 'string') + this.locale.applyLabel = options.locale.applyLabel; + + if (typeof options.locale.cancelLabel === 'string') + this.locale.cancelLabel = options.locale.cancelLabel; + + if (typeof options.locale.weekLabel === 'string') + this.locale.weekLabel = options.locale.weekLabel; + + if (typeof options.locale.customRangeLabel === 'string'){ + //Support unicode chars in the custom range name. + var elem = document.createElement('textarea'); + elem.innerHTML = options.locale.customRangeLabel; + var rangeHtml = elem.value; + this.locale.customRangeLabel = rangeHtml; + } + } + this.container.addClass(this.locale.direction); + + if (typeof options.startDate === 'string') + this.startDate = moment(options.startDate, this.locale.format); + + if (typeof options.endDate === 'string') + this.endDate = moment(options.endDate, this.locale.format); + + if (typeof options.minDate === 'string') + this.minDate = moment(options.minDate, this.locale.format); + + if (typeof options.maxDate === 'string') + this.maxDate = moment(options.maxDate, this.locale.format); + + if (typeof options.startDate === 'object') + this.startDate = moment(options.startDate); + + if (typeof options.endDate === 'object') + this.endDate = moment(options.endDate); + + if (typeof options.minDate === 'object') + this.minDate = moment(options.minDate); + + if (typeof options.maxDate === 'object') + this.maxDate = moment(options.maxDate); + + // sanity check for bad options + if (this.minDate && this.startDate.isBefore(this.minDate)) + this.startDate = this.minDate.clone(); + + // sanity check for bad options + if (this.maxDate && this.endDate.isAfter(this.maxDate)) + this.endDate = this.maxDate.clone(); + + if (typeof options.applyButtonClasses === 'string') + this.applyButtonClasses = options.applyButtonClasses; + + if (typeof options.applyClass === 'string') //backwards compat + this.applyButtonClasses = options.applyClass; + + if (typeof options.cancelButtonClasses === 'string') + this.cancelButtonClasses = options.cancelButtonClasses; + + if (typeof options.cancelClass === 'string') //backwards compat + this.cancelButtonClasses = options.cancelClass; + + if (typeof options.maxSpan === 'object') + this.maxSpan = options.maxSpan; + + if (typeof options.dateLimit === 'object') //backwards compat + this.maxSpan = options.dateLimit; + + if (typeof options.opens === 'string') + this.opens = options.opens; + + if (typeof options.drops === 'string') + this.drops = options.drops; + + if (typeof options.showWeekNumbers === 'boolean') + this.showWeekNumbers = options.showWeekNumbers; + + if (typeof options.showISOWeekNumbers === 'boolean') + this.showISOWeekNumbers = options.showISOWeekNumbers; + + if (typeof options.buttonClasses === 'string') + this.buttonClasses = options.buttonClasses; + + if (typeof options.buttonClasses === 'object') + this.buttonClasses = options.buttonClasses.join(' '); + + if (typeof options.showDropdowns === 'boolean') + this.showDropdowns = options.showDropdowns; + + if (typeof options.minYear === 'number') + this.minYear = options.minYear; + + if (typeof options.maxYear === 'number') + this.maxYear = options.maxYear; + + if (typeof options.showCustomRangeLabel === 'boolean') + this.showCustomRangeLabel = options.showCustomRangeLabel; + + if (typeof options.singleDatePicker === 'boolean') { + this.singleDatePicker = options.singleDatePicker; + if (this.singleDatePicker) + this.endDate = this.startDate.clone(); + } + + if (typeof options.timePicker === 'boolean') + this.timePicker = options.timePicker; + + if (typeof options.timePickerSeconds === 'boolean') + this.timePickerSeconds = options.timePickerSeconds; + + if (typeof options.timePickerIncrement === 'number') + this.timePickerIncrement = options.timePickerIncrement; + + if (typeof options.timePicker24Hour === 'boolean') + this.timePicker24Hour = options.timePicker24Hour; + + if (typeof options.autoApply === 'boolean') + this.autoApply = options.autoApply; + + if (typeof options.autoUpdateInput === 'boolean') + this.autoUpdateInput = options.autoUpdateInput; + + if (typeof options.linkedCalendars === 'boolean') + this.linkedCalendars = options.linkedCalendars; + + if (typeof options.isInvalidDate === 'function') + this.isInvalidDate = options.isInvalidDate; + + if (typeof options.isCustomDate === 'function') + this.isCustomDate = options.isCustomDate; + + if (typeof options.alwaysShowCalendars === 'boolean') + this.alwaysShowCalendars = options.alwaysShowCalendars; + + // update day names order to firstDay + if (this.locale.firstDay != 0) { + var iterator = this.locale.firstDay; + while (iterator > 0) { + this.locale.daysOfWeek.push(this.locale.daysOfWeek.shift()); + iterator--; + } + } + + var start, end, range; + + //if no start/end dates set, check if an input element contains initial values + if (typeof options.startDate === 'undefined' && typeof options.endDate === 'undefined') { + if ($(this.element).is(':text')) { + var val = $(this.element).val(), + split = val.split(this.locale.separator); + + start = end = null; + + if (split.length == 2) { + start = moment(split[0], this.locale.format); + end = moment(split[1], this.locale.format); + } else if (this.singleDatePicker && val !== "") { + start = moment(val, this.locale.format); + end = moment(val, this.locale.format); + } + if (start !== null && end !== null) { + this.setStartDate(start); + this.setEndDate(end); + } + } + } + + if (typeof options.ranges === 'object') { + for (range in options.ranges) { + + if (typeof options.ranges[range][0] === 'string') + start = moment(options.ranges[range][0], this.locale.format); + else + start = moment(options.ranges[range][0]); + + if (typeof options.ranges[range][1] === 'string') + end = moment(options.ranges[range][1], this.locale.format); + else + end = moment(options.ranges[range][1]); + + // If the start or end date exceed those allowed by the minDate or maxSpan + // options, shorten the range to the allowable period. + if (this.minDate && start.isBefore(this.minDate)) + start = this.minDate.clone(); + + var maxDate = this.maxDate; + if (this.maxSpan && maxDate && start.clone().add(this.maxSpan).isAfter(maxDate)) + maxDate = start.clone().add(this.maxSpan); + if (maxDate && end.isAfter(maxDate)) + end = maxDate.clone(); + + // If the end of the range is before the minimum or the start of the range is + // after the maximum, don't display this range option at all. + if ((this.minDate && end.isBefore(this.minDate, this.timepicker ? 'minute' : 'day')) + || (maxDate && start.isAfter(maxDate, this.timepicker ? 'minute' : 'day'))) + continue; + + //Support unicode chars in the range names. + var elem = document.createElement('textarea'); + elem.innerHTML = range; + var rangeHtml = elem.value; + + this.ranges[rangeHtml] = [start, end]; + } + + var list = '
      '; + for (range in this.ranges) { + list += '
    • ' + range + '
      • '; + } + if (this.showCustomRangeLabel) { + list += '
    • ' + this.locale.customRangeLabel + '
      • '; + } + list += '
    '; + this.container.find('.ranges').prepend(list); + } + + if (typeof cb === 'function') { + this.callback = cb; + } + + if (!this.timePicker) { + this.startDate = this.startDate.startOf('day'); + this.endDate = this.endDate.endOf('day'); + this.container.find('.calendar-time').hide(); + } + + //can't be used together for now + if (this.timePicker && this.autoApply) + this.autoApply = false; + + if (this.autoApply) { + this.container.addClass('auto-apply'); + } + + if (typeof options.ranges === 'object') + this.container.addClass('show-ranges'); + + if (this.singleDatePicker) { + this.container.addClass('single'); + this.container.find('.drp-calendar.left').addClass('single'); + this.container.find('.drp-calendar.left').show(); + this.container.find('.drp-calendar.right').hide(); + if (!this.timePicker && this.autoApply) { + this.container.addClass('auto-apply'); + } + } + + if ((typeof options.ranges === 'undefined' && !this.singleDatePicker) || this.alwaysShowCalendars) { + this.container.addClass('show-calendar'); + } + + this.container.addClass('opens' + this.opens); + + //apply CSS classes and labels to buttons + this.container.find('.applyBtn, .cancelBtn').addClass(this.buttonClasses); + if (this.applyButtonClasses.length) + this.container.find('.applyBtn').addClass(this.applyButtonClasses); + if (this.cancelButtonClasses.length) + this.container.find('.cancelBtn').addClass(this.cancelButtonClasses); + this.container.find('.applyBtn').html(this.locale.applyLabel); + this.container.find('.cancelBtn').html(this.locale.cancelLabel); + + // + // event listeners + // + + this.container.find('.drp-calendar') + .on('click.daterangepicker', '.prev', $.proxy(this.clickPrev, this)) + .on('click.daterangepicker', '.next', $.proxy(this.clickNext, this)) + .on('mousedown.daterangepicker', 'td.available', $.proxy(this.clickDate, this)) + .on('mouseenter.daterangepicker', 'td.available', $.proxy(this.hoverDate, this)) + .on('change.daterangepicker', 'select.yearselect', $.proxy(this.monthOrYearChanged, this)) + .on('change.daterangepicker', 'select.monthselect', $.proxy(this.monthOrYearChanged, this)) + .on('change.daterangepicker', 'select.hourselect,select.minuteselect,select.secondselect,select.ampmselect', $.proxy(this.timeChanged, this)); + + this.container.find('.ranges') + .on('click.daterangepicker', 'li', $.proxy(this.clickRange, this)); + + this.container.find('.drp-buttons') + .on('click.daterangepicker', 'button.applyBtn', $.proxy(this.clickApply, this)) + .on('click.daterangepicker', 'button.cancelBtn', $.proxy(this.clickCancel, this)); + + if (this.element.is('input') || this.element.is('button')) { + this.element.on({ + 'click.daterangepicker': $.proxy(this.show, this), + 'focus.daterangepicker': $.proxy(this.show, this), + 'keyup.daterangepicker': $.proxy(this.elementChanged, this), + 'keydown.daterangepicker': $.proxy(this.keydown, this) //IE 11 compatibility + }); + } else { + this.element.on('click.daterangepicker', $.proxy(this.toggle, this)); + this.element.on('keydown.daterangepicker', $.proxy(this.toggle, this)); + } + + // + // if attached to a text input, set the initial value + // + + this.updateElement(); + + }; + + DateRangePicker.prototype = { + + constructor: DateRangePicker, + + setStartDate: function(startDate) { + if (typeof startDate === 'string') + this.startDate = moment(startDate, this.locale.format); + + if (typeof startDate === 'object') + this.startDate = moment(startDate); + + if (!this.timePicker) + this.startDate = this.startDate.startOf('day'); + + if (this.timePicker && this.timePickerIncrement) + this.startDate.minute(Math.round(this.startDate.minute() / this.timePickerIncrement) * this.timePickerIncrement); + + if (this.minDate && this.startDate.isBefore(this.minDate)) { + this.startDate = this.minDate.clone(); + if (this.timePicker && this.timePickerIncrement) + this.startDate.minute(Math.round(this.startDate.minute() / this.timePickerIncrement) * this.timePickerIncrement); + } + + if (this.maxDate && this.startDate.isAfter(this.maxDate)) { + this.startDate = this.maxDate.clone(); + if (this.timePicker && this.timePickerIncrement) + this.startDate.minute(Math.floor(this.startDate.minute() / this.timePickerIncrement) * this.timePickerIncrement); + } + + if (!this.isShowing) + this.updateElement(); + + this.updateMonthsInView(); + }, + + setEndDate: function(endDate) { + if (typeof endDate === 'string') + this.endDate = moment(endDate, this.locale.format); + + if (typeof endDate === 'object') + this.endDate = moment(endDate); + + if (!this.timePicker) + this.endDate = this.endDate.endOf('day'); + + if (this.timePicker && this.timePickerIncrement) + this.endDate.minute(Math.round(this.endDate.minute() / this.timePickerIncrement) * this.timePickerIncrement); + + if (this.endDate.isBefore(this.startDate)) + this.endDate = this.startDate.clone(); + + if (this.maxDate && this.endDate.isAfter(this.maxDate)) + this.endDate = this.maxDate.clone(); + + if (this.maxSpan && this.startDate.clone().add(this.maxSpan).isBefore(this.endDate)) + this.endDate = this.startDate.clone().add(this.maxSpan); + + this.previousRightTime = this.endDate.clone(); + + this.container.find('.drp-selected').html(this.startDate.format(this.locale.format) + this.locale.separator + this.endDate.format(this.locale.format)); + + if (!this.isShowing) + this.updateElement(); + + this.updateMonthsInView(); + }, + + isInvalidDate: function() { + return false; + }, + + isCustomDate: function() { + return false; + }, + + updateView: function() { + if (this.timePicker) { + this.renderTimePicker('left'); + this.renderTimePicker('right'); + if (!this.endDate) { + this.container.find('.right .calendar-time select').prop('disabled', true).addClass('disabled'); + } else { + this.container.find('.right .calendar-time select').prop('disabled', false).removeClass('disabled'); + } + } + if (this.endDate) + this.container.find('.drp-selected').html(this.startDate.format(this.locale.format) + this.locale.separator + this.endDate.format(this.locale.format)); + this.updateMonthsInView(); + this.updateCalendars(); + this.updateFormInputs(); + }, + + updateMonthsInView: function() { + if (this.endDate) { + + //if both dates are visible already, do nothing + if (!this.singleDatePicker && this.leftCalendar.month && this.rightCalendar.month && + (this.startDate.format('YYYY-MM') == this.leftCalendar.month.format('YYYY-MM') || this.startDate.format('YYYY-MM') == this.rightCalendar.month.format('YYYY-MM')) + && + (this.endDate.format('YYYY-MM') == this.leftCalendar.month.format('YYYY-MM') || this.endDate.format('YYYY-MM') == this.rightCalendar.month.format('YYYY-MM')) + ) { + return; + } + + this.leftCalendar.month = this.startDate.clone().date(2); + if (!this.linkedCalendars && (this.endDate.month() != this.startDate.month() || this.endDate.year() != this.startDate.year())) { + this.rightCalendar.month = this.endDate.clone().date(2); + } else { + this.rightCalendar.month = this.startDate.clone().date(2).add(1, 'month'); + } + + } else { + if (this.leftCalendar.month.format('YYYY-MM') != this.startDate.format('YYYY-MM') && this.rightCalendar.month.format('YYYY-MM') != this.startDate.format('YYYY-MM')) { + this.leftCalendar.month = this.startDate.clone().date(2); + this.rightCalendar.month = this.startDate.clone().date(2).add(1, 'month'); + } + } + if (this.maxDate && this.linkedCalendars && !this.singleDatePicker && this.rightCalendar.month > this.maxDate) { + this.rightCalendar.month = this.maxDate.clone().date(2); + this.leftCalendar.month = this.maxDate.clone().date(2).subtract(1, 'month'); + } + }, + + updateCalendars: function() { + + if (this.timePicker) { + var hour, minute, second; + if (this.endDate) { + hour = parseInt(this.container.find('.left .hourselect').val(), 10); + minute = parseInt(this.container.find('.left .minuteselect').val(), 10); + if (isNaN(minute)) { + minute = parseInt(this.container.find('.left .minuteselect option:last').val(), 10); + } + second = this.timePickerSeconds ? parseInt(this.container.find('.left .secondselect').val(), 10) : 0; + if (!this.timePicker24Hour) { + var ampm = this.container.find('.left .ampmselect').val(); + if (ampm === 'PM' && hour < 12) + hour += 12; + if (ampm === 'AM' && hour === 12) + hour = 0; + } + } else { + hour = parseInt(this.container.find('.right .hourselect').val(), 10); + minute = parseInt(this.container.find('.right .minuteselect').val(), 10); + if (isNaN(minute)) { + minute = parseInt(this.container.find('.right .minuteselect option:last').val(), 10); + } + second = this.timePickerSeconds ? parseInt(this.container.find('.right .secondselect').val(), 10) : 0; + if (!this.timePicker24Hour) { + var ampm = this.container.find('.right .ampmselect').val(); + if (ampm === 'PM' && hour < 12) + hour += 12; + if (ampm === 'AM' && hour === 12) + hour = 0; + } + } + this.leftCalendar.month.hour(hour).minute(minute).second(second); + this.rightCalendar.month.hour(hour).minute(minute).second(second); + } + + this.renderCalendar('left'); + this.renderCalendar('right'); + + //highlight any predefined range matching the current start and end dates + this.container.find('.ranges li').removeClass('active'); + if (this.endDate == null) return; + + this.calculateChosenLabel(); + }, + + renderCalendar: function(side) { + + // + // Build the matrix of dates that will populate the calendar + // + + var calendar = side == 'left' ? this.leftCalendar : this.rightCalendar; + var month = calendar.month.month(); + var year = calendar.month.year(); + var hour = calendar.month.hour(); + var minute = calendar.month.minute(); + var second = calendar.month.second(); + var daysInMonth = moment([year, month]).daysInMonth(); + var firstDay = moment([year, month, 1]); + var lastDay = moment([year, month, daysInMonth]); + var lastMonth = moment(firstDay).subtract(1, 'month').month(); + var lastYear = moment(firstDay).subtract(1, 'month').year(); + var daysInLastMonth = moment([lastYear, lastMonth]).daysInMonth(); + var dayOfWeek = firstDay.day(); + + //initialize a 6 rows x 7 columns array for the calendar + var calendar = []; + calendar.firstDay = firstDay; + calendar.lastDay = lastDay; + + for (var i = 0; i < 6; i++) { + calendar[i] = []; + } + + //populate the calendar with date objects + var startDay = daysInLastMonth - dayOfWeek + this.locale.firstDay + 1; + if (startDay > daysInLastMonth) + startDay -= 7; + + if (dayOfWeek == this.locale.firstDay) + startDay = daysInLastMonth - 6; + + var curDate = moment([lastYear, lastMonth, startDay, 12, minute, second]); + + var col, row; + for (var i = 0, col = 0, row = 0; i < 42; i++, col++, curDate = moment(curDate).add(24, 'hour')) { + if (i > 0 && col % 7 === 0) { + col = 0; + row++; + } + calendar[row][col] = curDate.clone().hour(hour).minute(minute).second(second); + curDate.hour(12); + + if (this.minDate && calendar[row][col].format('YYYY-MM-DD') == this.minDate.format('YYYY-MM-DD') && calendar[row][col].isBefore(this.minDate) && side == 'left') { + calendar[row][col] = this.minDate.clone(); + } + + if (this.maxDate && calendar[row][col].format('YYYY-MM-DD') == this.maxDate.format('YYYY-MM-DD') && calendar[row][col].isAfter(this.maxDate) && side == 'right') { + calendar[row][col] = this.maxDate.clone(); + } + + } + + //make the calendar object available to hoverDate/clickDate + if (side == 'left') { + this.leftCalendar.calendar = calendar; + } else { + this.rightCalendar.calendar = calendar; + } + + // + // Display the calendar + // + + var minDate = side == 'left' ? this.minDate : this.startDate; + var maxDate = this.maxDate; + var selected = side == 'left' ? this.startDate : this.endDate; + var arrow = this.locale.direction == 'ltr' ? {left: 'chevron-left', right: 'chevron-right'} : {left: 'chevron-right', right: 'chevron-left'}; + + var html = ''; + html += ''; + html += ''; + + // add empty cell for week number + if (this.showWeekNumbers || this.showISOWeekNumbers) + html += ''; + + if ((!minDate || minDate.isBefore(calendar.firstDay)) && (!this.linkedCalendars || side == 'left')) { + html += ''; + } else { + html += ''; + } + + var dateHtml = this.locale.monthNames[calendar[1][1].month()] + calendar[1][1].format(" YYYY"); + + if (this.showDropdowns) { + var currentMonth = calendar[1][1].month(); + var currentYear = calendar[1][1].year(); + var maxYear = (maxDate && maxDate.year()) || (this.maxYear); + var minYear = (minDate && minDate.year()) || (this.minYear); + var inMinYear = currentYear == minYear; + var inMaxYear = currentYear == maxYear; + + var monthHtml = '"; + + var yearHtml = ''; + + dateHtml = monthHtml + yearHtml; + } + + html += ''; + if ((!maxDate || maxDate.isAfter(calendar.lastDay)) && (!this.linkedCalendars || side == 'right' || this.singleDatePicker)) { + html += ''; + } else { + html += ''; + } + + html += ''; + html += ''; + + // add week number label + if (this.showWeekNumbers || this.showISOWeekNumbers) + html += ''; + + $.each(this.locale.daysOfWeek, function(index, dayOfWeek) { + html += ''; + }); + + html += ''; + html += ''; + html += ''; + + //adjust maxDate to reflect the maxSpan setting in order to + //grey out end dates beyond the maxSpan + if (this.endDate == null && this.maxSpan) { + var maxLimit = this.startDate.clone().add(this.maxSpan).endOf('day'); + if (!maxDate || maxLimit.isBefore(maxDate)) { + maxDate = maxLimit; + } + } + + for (var row = 0; row < 6; row++) { + html += ''; + + // add week number + if (this.showWeekNumbers) + html += ''; + else if (this.showISOWeekNumbers) + html += ''; + + for (var col = 0; col < 7; col++) { + + var classes = []; + + //highlight today's date + if (calendar[row][col].isSame(new Date(), "day")) + classes.push('today'); + + //highlight weekends + if (calendar[row][col].isoWeekday() > 5) + classes.push('weekend'); + + //grey out the dates in other months displayed at beginning and end of this calendar + if (calendar[row][col].month() != calendar[1][1].month()) + classes.push('off', 'ends'); + + //don't allow selection of dates before the minimum date + if (this.minDate && calendar[row][col].isBefore(this.minDate, 'day')) + classes.push('off', 'disabled'); + + //don't allow selection of dates after the maximum date + if (maxDate && calendar[row][col].isAfter(maxDate, 'day')) + classes.push('off', 'disabled'); + + //don't allow selection of date if a custom function decides it's invalid + if (this.isInvalidDate(calendar[row][col])) + classes.push('off', 'disabled'); + + //highlight the currently selected start date + if (calendar[row][col].format('YYYY-MM-DD') == this.startDate.format('YYYY-MM-DD')) + classes.push('active', 'start-date'); + + //highlight the currently selected end date + if (this.endDate != null && calendar[row][col].format('YYYY-MM-DD') == this.endDate.format('YYYY-MM-DD')) + classes.push('active', 'end-date'); + + //highlight dates in-between the selected dates + if (this.endDate != null && calendar[row][col] > this.startDate && calendar[row][col] < this.endDate) + classes.push('in-range'); + + //apply custom classes for this date + var isCustom = this.isCustomDate(calendar[row][col]); + if (isCustom !== false) { + if (typeof isCustom === 'string') + classes.push(isCustom); + else + Array.prototype.push.apply(classes, isCustom); + } + + var cname = '', disabled = false; + for (var i = 0; i < classes.length; i++) { + cname += classes[i] + ' '; + if (classes[i] == 'disabled') + disabled = true; + } + if (!disabled) + cname += 'available'; + + html += ''; + + } + html += ''; + } + + html += ''; + html += '
    ' + dateHtml + '
    ' + this.locale.weekLabel + '' + dayOfWeek + '
    ' + calendar[row][0].week() + '' + calendar[row][0].isoWeek() + '' + calendar[row][col].date() + '
    '; + + this.container.find('.drp-calendar.' + side + ' .calendar-table').html(html); + + }, + + renderTimePicker: function(side) { + + // Don't bother updating the time picker if it's currently disabled + // because an end date hasn't been clicked yet + if (side == 'right' && !this.endDate) return; + + var html, selected, minDate, maxDate = this.maxDate; + + if (this.maxSpan && (!this.maxDate || this.startDate.clone().add(this.maxSpan).isBefore(this.maxDate))) + maxDate = this.startDate.clone().add(this.maxSpan); + + if (side == 'left') { + selected = this.startDate.clone(); + minDate = this.minDate; + } else if (side == 'right') { + selected = this.endDate.clone(); + minDate = this.startDate; + + //Preserve the time already selected + var timeSelector = this.container.find('.drp-calendar.right .calendar-time'); + if (timeSelector.html() != '') { + + selected.hour(!isNaN(selected.hour()) ? selected.hour() : timeSelector.find('.hourselect option:selected').val()); + selected.minute(!isNaN(selected.minute()) ? selected.minute() : timeSelector.find('.minuteselect option:selected').val()); + selected.second(!isNaN(selected.second()) ? selected.second() : timeSelector.find('.secondselect option:selected').val()); + + if (!this.timePicker24Hour) { + var ampm = timeSelector.find('.ampmselect option:selected').val(); + if (ampm === 'PM' && selected.hour() < 12) + selected.hour(selected.hour() + 12); + if (ampm === 'AM' && selected.hour() === 12) + selected.hour(0); + } + + } + + if (selected.isBefore(this.startDate)) + selected = this.startDate.clone(); + + if (maxDate && selected.isAfter(maxDate)) + selected = maxDate.clone(); + + } + + // + // hours + // + + html = ' '; + + // + // minutes + // + + html += ': '; + + // + // seconds + // + + if (this.timePickerSeconds) { + html += ': '; + } + + // + // AM/PM + // + + if (!this.timePicker24Hour) { + html += ''; + } + + this.container.find('.drp-calendar.' + side + ' .calendar-time').html(html); + + }, + + updateFormInputs: function() { + + if (this.singleDatePicker || (this.endDate && (this.startDate.isBefore(this.endDate) || this.startDate.isSame(this.endDate)))) { + this.container.find('button.applyBtn').prop('disabled', false); + } else { + this.container.find('button.applyBtn').prop('disabled', true); + } + + }, + + move: function() { + var parentOffset = { top: 0, left: 0 }, + containerTop, + drops = this.drops; + + var parentRightEdge = $(window).width(); + if (!this.parentEl.is('body')) { + parentOffset = { + top: this.parentEl.offset().top - this.parentEl.scrollTop(), + left: this.parentEl.offset().left - this.parentEl.scrollLeft() + }; + parentRightEdge = this.parentEl[0].clientWidth + this.parentEl.offset().left; + } + + switch (drops) { + case 'auto': + containerTop = this.element.offset().top + this.element.outerHeight() - parentOffset.top; + if (containerTop + this.container.outerHeight() >= this.parentEl[0].scrollHeight) { + containerTop = this.element.offset().top - this.container.outerHeight() - parentOffset.top; + drops = 'up'; + } + break; + case 'up': + containerTop = this.element.offset().top - this.container.outerHeight() - parentOffset.top; + break; + default: + containerTop = this.element.offset().top + this.element.outerHeight() - parentOffset.top; + break; + } + + // Force the container to it's actual width + this.container.css({ + top: 0, + left: 0, + right: 'auto' + }); + var containerWidth = this.container.outerWidth(); + + this.container.toggleClass('drop-up', drops == 'up'); + + if (this.opens == 'left') { + var containerRight = parentRightEdge - this.element.offset().left - this.element.outerWidth(); + if (containerWidth + containerRight > $(window).width()) { + this.container.css({ + top: containerTop, + right: 'auto', + left: 9 + }); + } else { + this.container.css({ + top: containerTop, + right: containerRight, + left: 'auto' + }); + } + } else if (this.opens == 'center') { + var containerLeft = this.element.offset().left - parentOffset.left + this.element.outerWidth() / 2 + - containerWidth / 2; + if (containerLeft < 0) { + this.container.css({ + top: containerTop, + right: 'auto', + left: 9 + }); + } else if (containerLeft + containerWidth > $(window).width()) { + this.container.css({ + top: containerTop, + left: 'auto', + right: 0 + }); + } else { + this.container.css({ + top: containerTop, + left: containerLeft, + right: 'auto' + }); + } + } else { + var containerLeft = this.element.offset().left - parentOffset.left; + if (containerLeft + containerWidth > $(window).width()) { + this.container.css({ + top: containerTop, + left: 'auto', + right: 0 + }); + } else { + this.container.css({ + top: containerTop, + left: containerLeft, + right: 'auto' + }); + } + } + }, + + show: function(e) { + if (this.isShowing) return; + + // Create a click proxy that is private to this instance of datepicker, for unbinding + this._outsideClickProxy = $.proxy(function(e) { this.outsideClick(e); }, this); + + // Bind global datepicker mousedown for hiding and + $(document) + .on('mousedown.daterangepicker', this._outsideClickProxy) + // also support mobile devices + .on('touchend.daterangepicker', this._outsideClickProxy) + // also explicitly play nice with Bootstrap dropdowns, which stopPropagation when clicking them + .on('click.daterangepicker', '[data-toggle=dropdown]', this._outsideClickProxy) + // and also close when focus changes to outside the picker (eg. tabbing between controls) + .on('focusin.daterangepicker', this._outsideClickProxy); + + // Reposition the picker if the window is resized while it's open + $(window).on('resize.daterangepicker', $.proxy(function(e) { this.move(e); }, this)); + + this.oldStartDate = this.startDate.clone(); + this.oldEndDate = this.endDate.clone(); + this.previousRightTime = this.endDate.clone(); + + this.updateView(); + this.container.show(); + this.move(); + this.element.trigger('show.daterangepicker', this); + this.isShowing = true; + }, + + hide: function(e) { + if (!this.isShowing) return; + + //incomplete date selection, revert to last values + if (!this.endDate) { + this.startDate = this.oldStartDate.clone(); + this.endDate = this.oldEndDate.clone(); + } + + //if a new date range was selected, invoke the user callback function + if (!this.startDate.isSame(this.oldStartDate) || !this.endDate.isSame(this.oldEndDate)) + this.callback(this.startDate.clone(), this.endDate.clone(), this.chosenLabel); + + //if picker is attached to a text input, update it + this.updateElement(); + + $(document).off('.daterangepicker'); + $(window).off('.daterangepicker'); + this.container.hide(); + this.element.trigger('hide.daterangepicker', this); + this.isShowing = false; + }, + + toggle: function(e) { + if (this.isShowing) { + this.hide(); + } else { + this.show(); + } + }, + + outsideClick: function(e) { + var target = $(e.target); + // if the page is clicked anywhere except within the daterangerpicker/button + // itself then call this.hide() + if ( + // ie modal dialog fix + e.type == "focusin" || + target.closest(this.element).length || + target.closest(this.container).length || + target.closest('.calendar-table').length + ) return; + this.hide(); + this.element.trigger('outsideClick.daterangepicker', this); + }, + + showCalendars: function() { + this.container.addClass('show-calendar'); + this.move(); + this.element.trigger('showCalendar.daterangepicker', this); + }, + + hideCalendars: function() { + this.container.removeClass('show-calendar'); + this.element.trigger('hideCalendar.daterangepicker', this); + }, + + clickRange: function(e) { + var label = e.target.getAttribute('data-range-key'); + this.chosenLabel = label; + if (label == this.locale.customRangeLabel) { + this.showCalendars(); + } else { + var dates = this.ranges[label]; + this.startDate = dates[0]; + this.endDate = dates[1]; + + if (!this.timePicker) { + this.startDate.startOf('day'); + this.endDate.endOf('day'); + } + + if (!this.alwaysShowCalendars) + this.hideCalendars(); + this.clickApply(); + } + }, + + clickPrev: function(e) { + var cal = $(e.target).parents('.drp-calendar'); + if (cal.hasClass('left')) { + this.leftCalendar.month.subtract(1, 'month'); + if (this.linkedCalendars) + this.rightCalendar.month.subtract(1, 'month'); + } else { + this.rightCalendar.month.subtract(1, 'month'); + } + this.updateCalendars(); + }, + + clickNext: function(e) { + var cal = $(e.target).parents('.drp-calendar'); + if (cal.hasClass('left')) { + this.leftCalendar.month.add(1, 'month'); + } else { + this.rightCalendar.month.add(1, 'month'); + if (this.linkedCalendars) + this.leftCalendar.month.add(1, 'month'); + } + this.updateCalendars(); + }, + + hoverDate: function(e) { + + //ignore dates that can't be selected + if (!$(e.target).hasClass('available')) return; + + var title = $(e.target).attr('data-title'); + var row = title.substr(1, 1); + var col = title.substr(3, 1); + var cal = $(e.target).parents('.drp-calendar'); + var date = cal.hasClass('left') ? this.leftCalendar.calendar[row][col] : this.rightCalendar.calendar[row][col]; + + //highlight the dates between the start date and the date being hovered as a potential end date + var leftCalendar = this.leftCalendar; + var rightCalendar = this.rightCalendar; + var startDate = this.startDate; + if (!this.endDate) { + this.container.find('.drp-calendar tbody td').each(function(index, el) { + + //skip week numbers, only look at dates + if ($(el).hasClass('week')) return; + + var title = $(el).attr('data-title'); + var row = title.substr(1, 1); + var col = title.substr(3, 1); + var cal = $(el).parents('.drp-calendar'); + var dt = cal.hasClass('left') ? leftCalendar.calendar[row][col] : rightCalendar.calendar[row][col]; + + if ((dt.isAfter(startDate) && dt.isBefore(date)) || dt.isSame(date, 'day')) { + $(el).addClass('in-range'); + } else { + $(el).removeClass('in-range'); + } + + }); + } + + }, + + clickDate: function(e) { + + if (!$(e.target).hasClass('available')) return; + + var title = $(e.target).attr('data-title'); + var row = title.substr(1, 1); + var col = title.substr(3, 1); + var cal = $(e.target).parents('.drp-calendar'); + var date = cal.hasClass('left') ? this.leftCalendar.calendar[row][col] : this.rightCalendar.calendar[row][col]; + + // + // this function needs to do a few things: + // * alternate between selecting a start and end date for the range, + // * if the time picker is enabled, apply the hour/minute/second from the select boxes to the clicked date + // * if autoapply is enabled, and an end date was chosen, apply the selection + // * if single date picker mode, and time picker isn't enabled, apply the selection immediately + // * if one of the inputs above the calendars was focused, cancel that manual input + // + + if (this.endDate || date.isBefore(this.startDate, 'day')) { //picking start + if (this.timePicker) { + var hour = parseInt(this.container.find('.left .hourselect').val(), 10); + if (!this.timePicker24Hour) { + var ampm = this.container.find('.left .ampmselect').val(); + if (ampm === 'PM' && hour < 12) + hour += 12; + if (ampm === 'AM' && hour === 12) + hour = 0; + } + var minute = parseInt(this.container.find('.left .minuteselect').val(), 10); + if (isNaN(minute)) { + minute = parseInt(this.container.find('.left .minuteselect option:last').val(), 10); + } + var second = this.timePickerSeconds ? parseInt(this.container.find('.left .secondselect').val(), 10) : 0; + date = date.clone().hour(hour).minute(minute).second(second); + } + this.endDate = null; + this.setStartDate(date.clone()); + } else if (!this.endDate && date.isBefore(this.startDate)) { + //special case: clicking the same date for start/end, + //but the time of the end date is before the start date + this.setEndDate(this.startDate.clone()); + } else { // picking end + if (this.timePicker) { + var hour = parseInt(this.container.find('.right .hourselect').val(), 10); + if (!this.timePicker24Hour) { + var ampm = this.container.find('.right .ampmselect').val(); + if (ampm === 'PM' && hour < 12) + hour += 12; + if (ampm === 'AM' && hour === 12) + hour = 0; + } + var minute = parseInt(this.container.find('.right .minuteselect').val(), 10); + if (isNaN(minute)) { + minute = parseInt(this.container.find('.right .minuteselect option:last').val(), 10); + } + var second = this.timePickerSeconds ? parseInt(this.container.find('.right .secondselect').val(), 10) : 0; + date = date.clone().hour(hour).minute(minute).second(second); + } + this.setEndDate(date.clone()); + if (this.autoApply) { + this.calculateChosenLabel(); + this.clickApply(); + } + } + + if (this.singleDatePicker) { + this.setEndDate(this.startDate); + if (!this.timePicker && this.autoApply) + this.clickApply(); + } + + this.updateView(); + + //This is to cancel the blur event handler if the mouse was in one of the inputs + e.stopPropagation(); + + }, + + calculateChosenLabel: function () { + var customRange = true; + var i = 0; + for (var range in this.ranges) { + if (this.timePicker) { + var format = this.timePickerSeconds ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD HH:mm"; + //ignore times when comparing dates if time picker seconds is not enabled + if (this.startDate.format(format) == this.ranges[range][0].format(format) && this.endDate.format(format) == this.ranges[range][1].format(format)) { + customRange = false; + this.chosenLabel = this.container.find('.ranges li:eq(' + i + ')').addClass('active').attr('data-range-key'); + break; + } + } else { + //ignore times when comparing dates if time picker is not enabled + if (this.startDate.format('YYYY-MM-DD') == this.ranges[range][0].format('YYYY-MM-DD') && this.endDate.format('YYYY-MM-DD') == this.ranges[range][1].format('YYYY-MM-DD')) { + customRange = false; + this.chosenLabel = this.container.find('.ranges li:eq(' + i + ')').addClass('active').attr('data-range-key'); + break; + } + } + i++; + } + if (customRange) { + if (this.showCustomRangeLabel) { + this.chosenLabel = this.container.find('.ranges li:last').addClass('active').attr('data-range-key'); + } else { + this.chosenLabel = null; + } + this.showCalendars(); + } + }, + + clickApply: function(e) { + this.hide(); + this.element.trigger('apply.daterangepicker', this); + }, + + clickCancel: function(e) { + this.startDate = this.oldStartDate; + this.endDate = this.oldEndDate; + this.hide(); + this.element.trigger('cancel.daterangepicker', this); + }, + + monthOrYearChanged: function(e) { + var isLeft = $(e.target).closest('.drp-calendar').hasClass('left'), + leftOrRight = isLeft ? 'left' : 'right', + cal = this.container.find('.drp-calendar.'+leftOrRight); + + // Month must be Number for new moment versions + var month = parseInt(cal.find('.monthselect').val(), 10); + var year = cal.find('.yearselect').val(); + + if (!isLeft) { + if (year < this.startDate.year() || (year == this.startDate.year() && month < this.startDate.month())) { + month = this.startDate.month(); + year = this.startDate.year(); + } + } + + if (this.minDate) { + if (year < this.minDate.year() || (year == this.minDate.year() && month < this.minDate.month())) { + month = this.minDate.month(); + year = this.minDate.year(); + } + } + + if (this.maxDate) { + if (year > this.maxDate.year() || (year == this.maxDate.year() && month > this.maxDate.month())) { + month = this.maxDate.month(); + year = this.maxDate.year(); + } + } + + if (isLeft) { + this.leftCalendar.month.month(month).year(year); + if (this.linkedCalendars) + this.rightCalendar.month = this.leftCalendar.month.clone().add(1, 'month'); + } else { + this.rightCalendar.month.month(month).year(year); + if (this.linkedCalendars) + this.leftCalendar.month = this.rightCalendar.month.clone().subtract(1, 'month'); + } + this.updateCalendars(); + }, + + timeChanged: function(e) { + + var cal = $(e.target).closest('.drp-calendar'), + isLeft = cal.hasClass('left'); + + var hour = parseInt(cal.find('.hourselect').val(), 10); + var minute = parseInt(cal.find('.minuteselect').val(), 10); + if (isNaN(minute)) { + minute = parseInt(cal.find('.minuteselect option:last').val(), 10); + } + var second = this.timePickerSeconds ? parseInt(cal.find('.secondselect').val(), 10) : 0; + + if (!this.timePicker24Hour) { + var ampm = cal.find('.ampmselect').val(); + if (ampm === 'PM' && hour < 12) + hour += 12; + if (ampm === 'AM' && hour === 12) + hour = 0; + } + + if (isLeft) { + var start = this.startDate.clone(); + start.hour(hour); + start.minute(minute); + start.second(second); + this.setStartDate(start); + if (this.singleDatePicker) { + this.endDate = this.startDate.clone(); + } else if (this.endDate && this.endDate.format('YYYY-MM-DD') == start.format('YYYY-MM-DD') && this.endDate.isBefore(start)) { + this.setEndDate(start.clone()); + } + } else if (this.endDate) { + var end = this.endDate.clone(); + end.hour(hour); + end.minute(minute); + end.second(second); + this.setEndDate(end); + } + + //update the calendars so all clickable dates reflect the new time component + this.updateCalendars(); + + //update the form inputs above the calendars with the new time + this.updateFormInputs(); + + //re-render the time pickers because changing one selection can affect what's enabled in another + this.renderTimePicker('left'); + this.renderTimePicker('right'); + + }, + + elementChanged: function() { + if (!this.element.is('input')) return; + if (!this.element.val().length) return; + + var dateString = this.element.val().split(this.locale.separator), + start = null, + end = null; + + if (dateString.length === 2) { + start = moment(dateString[0], this.locale.format); + end = moment(dateString[1], this.locale.format); + } + + if (this.singleDatePicker || start === null || end === null) { + start = moment(this.element.val(), this.locale.format); + end = start; + } + + if (!start.isValid() || !end.isValid()) return; + + this.setStartDate(start); + this.setEndDate(end); + this.updateView(); + }, + + keydown: function(e) { + //hide on tab or enter + if ((e.keyCode === 9) || (e.keyCode === 13)) { + this.hide(); + } + + //hide on esc and prevent propagation + if (e.keyCode === 27) { + e.preventDefault(); + e.stopPropagation(); + + this.hide(); + } + }, + + updateElement: function() { + if (this.element.is('input') && this.autoUpdateInput) { + var newValue = this.startDate.format(this.locale.format); + if (!this.singleDatePicker) { + newValue += this.locale.separator + this.endDate.format(this.locale.format); + } + if (newValue !== this.element.val()) { + this.element.val(newValue).trigger('change'); + } + } + }, + + remove: function() { + this.container.remove(); + this.element.off('.daterangepicker'); + this.element.removeData(); + } + + }; + + $.fn.daterangepicker = function(options, callback) { + var implementOptions = $.extend(true, {}, $.fn.daterangepicker.defaultOptions, options); + this.each(function() { + var el = $(this); + if (el.data('daterangepicker')) + el.data('daterangepicker').remove(); + el.data('daterangepicker', new DateRangePicker(el, implementOptions, callback)); + }); + return this; + }; + + return DateRangePicker; + +})); diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html index fb7cd049..a8bef996 100644 --- a/NEMO/apps/sensors/templates/sensors/sensor_data.html +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -2,11 +2,15 @@ {% load static %} {% block extrahead %} {# Chart.js #} - + + {# Daterange picker #} + + + {# Sensors #} {% endblock %} -{% block title %}Sensors{% endblock %} +{% block title %}{{ sensor.name }} data{% endblock %} {% block content %}
      @@ -19,20 +23,35 @@ {% endif %}
    1. {{ sensor.name }}
    -
    -
    +
    +
    + +
    + + + + + +
    + +
    + + + + +
    +
    - + + + + + +
    -
    -
    + +
    - +
    - +
    @@ -61,11 +83,11 @@
    - +
    - +
    @@ -78,31 +100,70 @@ - {% endblock %} \ No newline at end of file diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py index 8d80999a..f89a039c 100644 --- a/NEMO/apps/sensors/views.py +++ b/NEMO/apps/sensors/views.py @@ -105,9 +105,7 @@ def get_sensor_data(request, sensor) -> (QuerySet, datetime, datetime): start = now - timedelta(days=3) else: start = now - timedelta(days=1) - if not end: - end = now - return sensor_data.filter(created_date__gte=start, created_date__lte=end), start, end + return sensor_data.filter(created_date__gte=start, created_date__lte=(end or now)), start, end @login_required From 0425a4ce283d56d7073fb954465108a677f22906 Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 19:04:20 -0400 Subject: [PATCH 35/82] - added disable session expiry refresh on sensor data pull --- NEMO/apps/sensors/views.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py index f89a039c..8b81184b 100644 --- a/NEMO/apps/sensors/views.py +++ b/NEMO/apps/sensors/views.py @@ -12,7 +12,7 @@ from NEMO.apps.sensors.customizations import SensorCustomization from NEMO.apps.sensors.models import Sensor, SensorCategory, SensorData -from NEMO.decorators import postpone, staff_member_required +from NEMO.decorators import disable_session_expiry_refresh, postpone, staff_member_required from NEMO.utilities import ( BasicDisplayTable, beginning_of_the_day, @@ -82,6 +82,7 @@ def export_sensor_data(request, sensor_id): @staff_member_required @require_GET +@disable_session_expiry_refresh def sensor_chart_data(request, sensor_id): sensor = get_object_or_404(Sensor, pk=sensor_id) labels = [] From c835e19efa0f5b03c6e4bc3741385e393fcdffce Mon Sep 17 00:00:00 2001 From: mrampant Date: Thu, 5 May 2022 19:05:24 -0400 Subject: [PATCH 36/82] - removed hardcoded date formats for calendar feed and mobile calendar from utilities.py --- NEMO/utilities.py | 38 ++------------------------------------ NEMO/views/calendar.py | 34 ++++++++++++++++++++++++++++++++-- NEMO/views/mobile.py | 5 +++-- 3 files changed, 37 insertions(+), 40 deletions(-) diff --git a/NEMO/utilities.py b/NEMO/utilities.py index 91789490..ac268b0a 100644 --- a/NEMO/utilities.py +++ b/NEMO/utilities.py @@ -194,40 +194,6 @@ def extract_times(parameters, input_timezone=None, start_required=True, end_requ return new_start, new_end -def extract_date(date): - return localize(datetime.strptime(date, "%Y-%m-%d")) - - -def extract_dates(parameters): - """ - Extract the "start" and "end" parameters from an HTTP request while performing a few logic validation checks. - """ - try: - start = parameters["start"] - except: - raise Exception("The request parameters did not contain a start time.") - - try: - end = parameters["end"] - except: - raise Exception("The request parameters did not contain an end time.") - - try: - start = extract_date(start) - except: - raise Exception("The request parameters did not have a valid start time.") - - try: - end = extract_date(end) - except: - raise Exception("The request parameters did not have a valid end time.") - - if end < start: - raise Exception("The request parameters have an end time that precedes the start time.") - - return start, end - - def format_daterange(start_time, end_time, dt_format="DATETIME_FORMAT", d_format="DATE_FORMAT", t_format="TIME_FORMAT", date_separator=" from ", time_separator=" to ") -> str: # This method returns a formatted date range, using the date only once if it is on the same day if isinstance(start_time, time): @@ -283,8 +249,8 @@ def naive_local_current_datetime(): def beginning_of_the_day(t: datetime, in_local_timezone=True) -> datetime: """ Returns the BEGINNING of today's day (12:00:00.000000 AM of the current day) in LOCAL time. """ - midnight = t.replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=None) - return localize(midnight) if in_local_timezone else midnight + zero = t.replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=None) + return localize(zero) if in_local_timezone else zero def end_of_the_day(t: datetime, in_local_timezone=True) -> datetime: diff --git a/NEMO/views/calendar.py b/NEMO/views/calendar.py index 26f1f82b..eacd49de 100644 --- a/NEMO/views/calendar.py +++ b/NEMO/views/calendar.py @@ -43,7 +43,6 @@ as_timezone, bootstrap_primary_color, create_email_attachment, - extract_dates, extract_times, format_datetime, localize, @@ -150,7 +149,7 @@ def calendar(request, item_type=None, item_id=None): def event_feed(request): """ Get all reservations for a specific time-window. Optionally: filter by tool, area or user name. """ try: - start, end = extract_dates(request.GET) + start, end = extract_calendar_dates(request.GET) except Exception as e: return HttpResponseBadRequest('Invalid start or end time. ' + str(e)) @@ -175,6 +174,37 @@ def event_feed(request): return HttpResponseBadRequest('Invalid event type or operation not authorized.') +def extract_calendar_dates(parameters): + """ + Extract the "start" and "end" parameters for FullCalendar's specific date format while performing a few logic validation checks. + """ + full_calendar_date_format = "%Y-%m-%d" + try: + start = parameters["start"] + except: + raise Exception("The request parameters did not contain a start time.") + + try: + end = parameters["end"] + except: + raise Exception("The request parameters did not contain an end time.") + + try: + start = localize(datetime.strptime(start, full_calendar_date_format)) + except: + raise Exception("The request parameters did not have a valid start time.") + + try: + end = localize(datetime.strptime(end, full_calendar_date_format)) + except: + raise Exception("The request parameters did not have a valid end time.") + + if end < start: + raise Exception("The request parameters have an end time that precedes the start time.") + + return start, end + + def reservation_event_feed(request, start, end): events = Reservation.objects.filter(cancelled=False, missed=False, shortened=False) outages = ScheduledOutage.objects.none() diff --git a/NEMO/views/mobile.py b/NEMO/views/mobile.py index 44066b0a..bb17fa37 100644 --- a/NEMO/views/mobile.py +++ b/NEMO/views/mobile.py @@ -11,7 +11,7 @@ from NEMO.exceptions import ProjectChargeException, RequiredUnansweredQuestionsException from NEMO.models import Area, Project, Reservation, ReservationItemType, ScheduledOutage, Tool, User -from NEMO.utilities import beginning_of_the_day, end_of_the_day, extract_date, localize +from NEMO.utilities import beginning_of_the_day, end_of_the_day, localize from NEMO.views.calendar import ( extract_configuration, extract_reservation_questions, @@ -148,7 +148,8 @@ def view_calendar(request, item_type, item_id, date=None): item = get_object_or_404(item_type.get_object_class(), id=item_id) if date: try: - date = extract_date(date) + # Try to extract date using the hardcoded format + date = localize(datetime.strptime(date, "%Y-%m-%d")) except: render(request, 'mobile/error.html', {'message': 'Invalid date requested for tool calendar'}) return HttpResponseBadRequest() From 284af14bff7f3dae72d887352710e78464fa7ea4 Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 9 May 2022 10:28:32 -0400 Subject: [PATCH 37/82] - now using date/time input formats already set in settings.py in sensor and abuse pages date pickers. - added function to convert python date format to javascript date format --- .../templates/sensors/sensor_data.html | 8 +-- NEMO/context_processors.py | 12 +++- NEMO/templates/abuse/abuse.html | 6 +- NEMO/templatetags/custom_tags_and_filters.py | 11 ++- NEMO/utilities.py | 69 +++++++++++++++++-- 5 files changed, 87 insertions(+), 19 deletions(-) diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html index a8bef996..ec186e1b 100644 --- a/NEMO/apps/sensors/templates/sensors/sensor_data.html +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -113,10 +113,10 @@ {# Update dates in input fields and refresh the page. If there is no end we will use 'now' #} function set_dates(start, end) { - $('#start').val(start.format('{{ datetime_picker_js_format }}')); + $('#start').val(start.format('{{ datetime_input_js_format }}')); if (!end.isSame(now_moment_date)) { - $('#end').val(end.format('{{ datetime_picker_js_format }}')); + $('#end').val(end.format('{{ datetime_input_js_format }}')); } else { @@ -151,9 +151,9 @@ function get_start_end_dates() { - const start = moment($("#start").val(), '{{ datetime_picker_js_format }}').unix(); + const start = moment($("#start").val(), '{{ datetime_input_js_format }}').unix(); const end_input = $("#end").val(); - const end = end_input && end_input !== 'now' ? moment(end_input, '{{ datetime_picker_js_format }}').unix() : ''; + const end = end_input && end_input !== 'now' ? moment(end_input, '{{ datetime_input_js_format }}').unix() : ''; return [start, end]; } diff --git a/NEMO/context_processors.py b/NEMO/context_processors.py index 33333ed1..5910cdc9 100644 --- a/NEMO/context_processors.py +++ b/NEMO/context_processors.py @@ -1,9 +1,14 @@ -from django.conf import settings +from django.utils.formats import get_format from NEMO.models import Area, Notification, PhysicalAccessLevel, Tool, User +from NEMO.utilities import convert_py_format_to_js from NEMO.views.customization import get_customization from NEMO.views.notifications import get_notification_counts +time_input_js_format = convert_py_format_to_js(get_format('TIME_INPUT_FORMATS')[0]) +date_input_js_format = convert_py_format_to_js(get_format('DATE_INPUT_FORMATS')[0]) +datetime_input_js_format = convert_py_format_to_js(get_format('DATETIME_INPUT_FORMATS')[0]) + def show_logout_button(request): return {"logout_allowed": True} @@ -75,7 +80,8 @@ def base_context(request): "buddy_notification_count": buddy_notification_count, "temporary_access_notification_count": temporary_access_notification_count, "facility_managers_exist": facility_managers_exist, - "date_picker_js_format": getattr(settings, "DATE_PICKER_JS_FORMAT", "MM/DD/YYYY"), - "datetime_picker_js_format": getattr(settings, "DATETIME_PICKER_JS_FORMAT", "MM/DD/YYYY h:mm A"), + "time_input_js_format": time_input_js_format, + "date_input_js_format": date_input_js_format, + "datetime_input_js_format": datetime_input_js_format, "no_header": request.session.get("no_header", False), } diff --git a/NEMO/templates/abuse/abuse.html b/NEMO/templates/abuse/abuse.html index 19d19aa0..16262de3 100644 --- a/NEMO/templates/abuse/abuse.html +++ b/NEMO/templates/abuse/abuse.html @@ -56,11 +56,11 @@

    Reservation abuse

    - +
    - +
    @@ -88,7 +88,7 @@

    Reservation abuse

    {% endif %} diff --git a/NEMO/templatetags/custom_tags_and_filters.py b/NEMO/templatetags/custom_tags_and_filters.py index 66bf1e0f..a86043cf 100644 --- a/NEMO/templatetags/custom_tags_and_filters.py +++ b/NEMO/templatetags/custom_tags_and_filters.py @@ -6,6 +6,7 @@ from django.template.defaultfilters import date, time from django.urls import NoReverseMatch, reverse from django.utils import timezone +from django.utils.formats import localize_input from django.utils.html import escape, format_html from django.utils.safestring import mark_safe from pkg_resources import DistributionNotFound, get_distribution @@ -26,12 +27,12 @@ def is_soon(time): return time <= timezone.now() + timedelta(minutes=10) -@register.filter() +@register.filter def to_int(value): return int(value) -@register.filter() +@register.filter def to_date(value, arg=None): if value in (None, ""): return "" @@ -42,6 +43,12 @@ def to_date(value, arg=None): return value +# Function to format input date using python strftime and the date/time input formats from settings +@register.filter +def input_date_format(value, arg=None): + return localize_input(value, arg) + + @register.filter def json_search_base(items_to_search, display="__str__"): result = "[" diff --git a/NEMO/utilities.py b/NEMO/utilities.py index ac268b0a..44a8ae9f 100644 --- a/NEMO/utilities.py +++ b/NEMO/utilities.py @@ -21,6 +21,41 @@ from django.utils.formats import date_format, time_format from django.utils.timezone import is_naive, localtime +# List of python to js formats +py_to_js_date_formats = { + "%A": "dddd", + "%a": "ddd", + "%B": "MMMM", + "%b": "MMM", + "%c": "ddd MMM DD HH:mm:ss YYYY", + "%d": "DD", + "%f": "SSS", + "%H": "HH", + "%I": "hh", + "%j": "DDDD", + "%M": "mm", + "%m": "MM", + "%p": "A", + "%S": "ss", + "%U": "ww", + "%W": "ww", + "%w": "d", + "%X": "HH:mm:ss", + "%x": "MM/DD/YYYY", + "%Y": "YYYY", + "%y": "YY", + "%Z": "z", + "%z": "ZZ", + "%%": "%", +} + + +# Convert a python format string to javascript format string +def convert_py_format_to_js(string_format: str) -> str: + for py, js in py_to_js_date_formats.items(): + string_format = js.join(string_format.split(py)) + return string_format + class BasicDisplayTable(object): """ Utility table to make adding headers and rows easier, and export to csv """ @@ -220,13 +255,19 @@ def format_datetime(universal_time=None, df=None, as_current_timezone=True, use_ def export_format_datetime(date_time=None, d_format=True, t_format=True, underscore=True, as_current_timezone=True) -> str: """ This function returns a formatted date/time for export files. Default returns date + time format, with underscores """ this_time = date_time if date_time else timezone.now() if as_current_timezone else datetime.now() - export_date_format = getattr(settings, 'EXPORT_DATE_FORMAT', 'm_d_Y').replace("-", "_") - export_time_format = getattr(settings, 'EXPORT_TIME_FORMAT', 'h_i_s').replace("-", "_") + export_date_format = getattr(settings, "EXPORT_DATE_FORMAT", "m_d_Y").replace("-", "_") + export_time_format = getattr(settings, "EXPORT_TIME_FORMAT", "h_i_s").replace("-", "_") if not underscore: export_date_format = export_date_format.replace("_", "-") export_time_format = export_time_format.replace("_", "-") separator = "-" if underscore else "_" - datetime_format = export_date_format if d_format and not t_format else export_time_format if not d_format and t_format else export_date_format + separator + export_time_format + datetime_format = ( + export_date_format + if d_format and not t_format + else export_time_format + if not d_format and t_format + else export_date_format + separator + export_time_format + ) return format_datetime(this_time, datetime_format, as_current_timezone) @@ -263,7 +304,7 @@ def remove_duplicates(iterable: Union[List, Set, Tuple]) -> Optional[List]: if not iterable: return None if isinstance(iterable, str): - raise TypeError('argument must be a list, set or tuple') + raise TypeError("argument must be a list, set or tuple") return list(set(iterable)) @@ -273,8 +314,16 @@ def send_mail(subject, content, from_email, to=None, bcc=None, cc=None, attachme clean_bcc = remove_duplicates(bcc) clean_cc = remove_duplicates(cc) except TypeError: - raise TypeError('to, cc and bcc arguments must be a list, set or tuple') - mail = EmailMessage(subject=subject, body=content, from_email=from_email, to=clean_to, bcc=clean_bcc, cc=clean_cc, attachments=attachments) + raise TypeError("to, cc and bcc arguments must be a list, set or tuple") + mail = EmailMessage( + subject=subject, + body=content, + from_email=from_email, + to=clean_to, + bcc=clean_bcc, + cc=clean_cc, + attachments=attachments, + ) mail.content_subtype = "html" msg_sent = 0 if mail.recipients(): @@ -293,7 +342,13 @@ def send_mail(subject, content, from_email, to=None, bcc=None, cc=None, attachme def create_email_log(email: EmailMessage, email_category: EmailCategory): from NEMO.models import EmailLog - email_record: EmailLog = EmailLog.objects.create(category=email_category, sender=email.from_email, to=", ".join(email.recipients()), subject=email.subject, content=email.body) + email_record: EmailLog = EmailLog.objects.create( + category=email_category, + sender=email.from_email, + to=", ".join(email.recipients()), + subject=email.subject, + content=email.body, + ) if email.attachments: email_attachments = [] for attachment in email.attachments: From b3606030325234f4f4669a9ce1e142117f93fe63 Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 9 May 2022 11:09:05 -0400 Subject: [PATCH 38/82] - updated create account and create project pages to use date input format from settings --- NEMO/templates/accounts_and_projects/create_account.html | 4 ++-- NEMO/templates/accounts_and_projects/create_project.html | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/NEMO/templates/accounts_and_projects/create_account.html b/NEMO/templates/accounts_and_projects/create_account.html index 05fae4fb..e7224731 100644 --- a/NEMO/templates/accounts_and_projects/create_account.html +++ b/NEMO/templates/accounts_and_projects/create_account.html @@ -40,7 +40,7 @@

    New account

    - +
    {{ form.start_date.errors|striptags }} @@ -69,7 +69,7 @@

    New account

    {% endblock %} \ No newline at end of file diff --git a/NEMO/templates/accounts_and_projects/create_project.html b/NEMO/templates/accounts_and_projects/create_project.html index 062c5b4d..4b6f0231 100644 --- a/NEMO/templates/accounts_and_projects/create_project.html +++ b/NEMO/templates/accounts_and_projects/create_project.html @@ -47,7 +47,7 @@

    New project

    - +
    {{ form.start_date.errors|striptags }} @@ -86,7 +86,7 @@

    New project

    } window.addEventListener("load", function () { - $('#start_date').datetimepicker({format: 'MM/DD/YYYY'}); + $('#start_date').datetimepicker({format: '{{ date_input_js_format }}'}); $('#account_search').autocomplete('account', select_account, {{ account_list|json_search_base }}); }); From 4dc3a47747cc868b353bf6d5cf3989501454f47b Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 9 May 2022 11:32:58 -0400 Subject: [PATCH 39/82] - updated new user page to use date input format from settings --- NEMO/templates/users/create_or_modify_user.html | 6 +++--- NEMO/views/users.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/NEMO/templates/users/create_or_modify_user.html b/NEMO/templates/users/create_or_modify_user.html index d1764f78..edd7a008 100644 --- a/NEMO/templates/users/create_or_modify_user.html +++ b/NEMO/templates/users/create_or_modify_user.html @@ -104,10 +104,10 @@

    {% if form.instance.id %}Modify user{% else %}New user{% endif %}

    - +
    - One year from now + One year from now
    {% if form.access_expiration.errors %}
    @@ -335,7 +335,7 @@

    {% if form.instance.id %}Modify user{% else %}New user{% endif %}

    function on_load() { $('[data-toggle="tooltip"]').tooltip(); - $("#access_expiration").datetimepicker({format: 'MM/DD/YYYY'}); + $("#access_expiration").datetimepicker({format: '{{ date_input_js_format }}'}); $('#add_a_project').autocomplete('projects', on_search_selection, {% json_search_base_with_extra_fields projects 'application_identifier' %}); $('#add_a_tool_qualification').autocomplete('tools', on_search_selection, {{ tools|json_search_base }}); {% if form.instance.id %} {# Only look for projects and qualifications if this is an existing user (and not a new user). #} diff --git a/NEMO/views/users.py b/NEMO/views/users.py index af406486..59b2d0af 100644 --- a/NEMO/views/users.py +++ b/NEMO/views/users.py @@ -62,7 +62,7 @@ def create_or_modify_user(request, user_id): 'tools': Tool.objects.filter(visible=True), 'area_access_dict': dict_area, 'area_access_levels': area_access_levels, - 'one_year_from_now': timezone.now() + timedelta(days=365), + 'one_year_from_now': timezone.localdate() + timedelta(days=365), 'identity_service_available': identity_service.get('available', False), 'identity_service_domains': identity_service.get('domains', []), } From 5775ee9a396285fe9322258a4611df9a00f25470 Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 9 May 2022 11:48:15 -0400 Subject: [PATCH 40/82] - updated staff absence form to use date input format from settings --- NEMO/templates/status_dashboard/staff_absence.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/NEMO/templates/status_dashboard/staff_absence.html b/NEMO/templates/status_dashboard/staff_absence.html index 9f9cef96..1d7651b8 100644 --- a/NEMO/templates/status_dashboard/staff_absence.html +++ b/NEMO/templates/status_dashboard/staff_absence.html @@ -38,11 +38,11 @@
    - +
    - +
    {% if form.start_date.errors or form.end_date.errors %}
    {% if form.start_date.errors %}{{ form.start_date.errors|striptags }}{% endif %}
    @@ -125,7 +125,7 @@ let timepicker_properties = { - format: 'MM/DD/YYYY', + format: '{{ date_input_js_format }}', useCurrent: false, {# Setting view date according to the current week view. Javascript Date takes ms so we need to multiply by 1000 #} viewDate: new Date({% widthratio page_timestamp 1 1000 %}) From 50e81e18ec459f76ce2949cb94a7eb4912de4fe4 Mon Sep 17 00:00:00 2001 From: mrampant Date: Mon, 9 May 2022 12:46:57 -0400 Subject: [PATCH 41/82] - updated buddy request form to use date input format from settings --- NEMO/templates/requests/buddy_requests/buddy_request.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/NEMO/templates/requests/buddy_requests/buddy_request.html b/NEMO/templates/requests/buddy_requests/buddy_request.html index d65dac7d..7e7565e9 100644 --- a/NEMO/templates/requests/buddy_requests/buddy_request.html +++ b/NEMO/templates/requests/buddy_requests/buddy_request.html @@ -19,11 +19,11 @@

    {% if form.instance.id %}Modify buddy request{% else %}Ne
    {% if form.start.errors %} - {{ form.start.errors|striptags }}{% endif %} - +
    {% if form.end.errors %} - {{ form.end.errors|striptags }}{% endif %} - +

    @@ -43,7 +43,7 @@

    {% if form.instance.id %}Modify buddy request{% else %}Ne From 5289579b9195e34f1ea707c31bd6f9bb1fecb43a Mon Sep 17 00:00:00 2001 From: mrampant Date: Tue, 10 May 2022 10:18:12 -0400 Subject: [PATCH 45/82] - added option to extract times with beginning and end of the day --- NEMO/utilities.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/NEMO/utilities.py b/NEMO/utilities.py index 44a8ae9f..8301d59c 100644 --- a/NEMO/utilities.py +++ b/NEMO/utilities.py @@ -189,7 +189,7 @@ def get_month_timeframe(date=None): return first_of_the_month, last_of_the_month -def extract_times(parameters, input_timezone=None, start_required=True, end_required=True) -> Tuple[datetime, datetime]: +def extract_times(parameters, input_timezone=None, start_required=True, end_required=True, beginning_and_end=False) -> Tuple[datetime, datetime]: """ Extract the "start" and "end" parameters from an HTTP request while performing a few logic validation checks. The function assumes the UNIX timestamp is in the local timezone. Use input_timezone to specify the timezone. @@ -211,6 +211,8 @@ def extract_times(parameters, input_timezone=None, start_required=True, end_requ new_start = float(start) new_start = datetime.utcfromtimestamp(new_start) new_start = localize(new_start, input_timezone) + if beginning_and_end: + new_start = beginning_of_the_day(new_start) except: if start or start_required: raise Exception("The request parameters did not have a valid start time.") @@ -219,6 +221,8 @@ def extract_times(parameters, input_timezone=None, start_required=True, end_requ new_end = float(end) new_end = datetime.utcfromtimestamp(new_end) new_end = localize(new_end, input_timezone) + if beginning_and_end: + new_end = end_of_the_day(new_end) except: if end or end_required: raise Exception("The request parameters did not have a valid end time.") From 22bd797eced281dba05a5c2b5cfa155ba7b07045 Mon Sep 17 00:00:00 2001 From: mrampant Date: Tue, 10 May 2022 10:18:57 -0400 Subject: [PATCH 46/82] - using UTC moment dates in sensor for consistency --- NEMO/apps/sensors/templates/sensors/sensor_data.html | 8 ++++---- NEMO/apps/sensors/views.py | 3 +-- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html index a7be79fd..6a35b9a8 100644 --- a/NEMO/apps/sensors/templates/sensors/sensor_data.html +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -151,9 +151,9 @@ function get_start_end_dates() { - const start = moment($("#start").val(), '{{ datetime_input_js_format }}').unix(); + const start = moment.utc($("#start").val(), '{{ datetime_input_js_format }}').unix(); const end_input = $("#end").val(); - const end = end_input && end_input !== 'now' ? moment(end_input, '{{ datetime_input_js_format }}').unix() : ''; + const end = end_input && end_input !== 'now' ? moment.utc(end_input, '{{ datetime_input_js_format }}').unix() : ''; return [start, end]; } @@ -278,8 +278,8 @@ function open_daterange_picker() { const dates = get_start_end_dates(); - daterange_picker.data('daterangepicker').setStartDate(moment.unix(dates[0])); - daterange_picker.data('daterangepicker').setEndDate(dates[1] ? moment.unix(dates[1]) : now_moment_date); + daterange_picker.data('daterangepicker').setStartDate(moment.unix(dates[0]).utc()); + daterange_picker.data('daterangepicker').setEndDate(dates[1] ? moment.unix(dates[1]).utc() : now_moment_date); daterange_picker.data('daterangepicker').show(); } diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py index 8b81184b..bcc71de0 100644 --- a/NEMO/apps/sensors/views.py +++ b/NEMO/apps/sensors/views.py @@ -1,7 +1,6 @@ from datetime import datetime, timedelta from math import floor -import pytz from django.contrib.auth.decorators import login_required, permission_required from django.db.models import QuerySet from django.http import HttpResponse, JsonResponse @@ -95,7 +94,7 @@ def sensor_chart_data(request, sensor_id): def get_sensor_data(request, sensor) -> (QuerySet, datetime, datetime): - start, end = extract_times(request.GET, input_timezone=pytz.UTC, start_required=False, end_required=False) + start, end = extract_times(request.GET, start_required=False, end_required=False) sensor_data = SensorData.objects.filter(sensor=sensor) now = timezone.now().replace(second=0) sensor_default_daterange = SensorCustomization.get("sensor_default_daterange") From d5aeb4391af204a8d4ec7c027191950fb1657f9f Mon Sep 17 00:00:00 2001 From: mrampant Date: Tue, 10 May 2022 10:20:34 -0400 Subject: [PATCH 47/82] - updated comments and usage data forms to use date input format from settings --- NEMO/templates/tool_control/tool_control.html | 13 ++++++------- NEMO/templates/tool_control/tool_status.html | 4 ++-- NEMO/templates/tool_control/usage_data.html | 8 ++++---- NEMO/views/tool_control.py | 14 ++++++-------- 4 files changed, 18 insertions(+), 21 deletions(-) diff --git a/NEMO/templates/tool_control/tool_control.html b/NEMO/templates/tool_control/tool_control.html index ba607307..6aaf0312 100644 --- a/NEMO/templates/tool_control/tool_control.html +++ b/NEMO/templates/tool_control/tool_control.html @@ -246,9 +246,8 @@ function load_tasks_and_comments(ten_most_recent) { let data = serialize("#history_form"); - if (data.start) data.start = moment(data.start, "MM/DD/YYYY").unix(); - if (data.end) data.end = moment(data.end, "MM/DD/YYYY").add(1, 'day').unix(); - {# Add one day because by default the time is midnight the day of. We want to include the full duration of the last day. #} + if (data.start) data.start = moment.utc(data.start, "{{ date_input_js_format }}").unix(); + if (data.end) data.end = moment.utc(data.end, "{{ date_input_js_format }}").unix(); let tasks_and_comments_url = "{% url 'past_comments_and_tasks' %}?" + $.param(data); if (ten_most_recent) { @@ -283,8 +282,8 @@ function load_tasks_and_comments_for_last_three_months() { - let start = moment().subtract(3, 'months').format("MM/DD/YYYY"); - let end = moment().format("MM/DD/YYYY"); + let start = moment().subtract(3, 'months').format("{{ date_input_js_format }}"); + let end = moment().format("{{ date_input_js_format }}"); $("#task_and_comment_start").val(start); $("#task_and_comment_end").val(end); load_tasks_and_comments(); @@ -300,8 +299,8 @@ let failure_dialog = ajax_complete_callback("Unable to find usage data", "There was a problem looking up usage data."); let data = serialize("#usage_data_form"); data.csrfmiddlewaretoken= "{{ csrf_token }}"; - if (data.data_history_start_date) data.start = moment(data.data_history_start_date, "MM/DD/YYYY").unix(); - if (data.data_history_end_date) data.end = moment(data.data_history_end_date, "MM/DD/YYYY").unix(); + if (data.data_history_start_date) data.start = moment.utc(data.data_history_start_date, "{{ date_input_js_format }}").unix(); + if (data.data_history_end_date) data.end = moment.utc(data.data_history_end_date, "{{ date_input_js_format }}").unix(); $("#usage_data").load("{% url 'usage_data_history' 999 %}".replace('999', tool_id), data, failure_dialog); if (csv_export) { diff --git a/NEMO/templates/tool_control/tool_status.html b/NEMO/templates/tool_control/tool_status.html index 1cd3ef2f..968ef25b 100644 --- a/NEMO/templates/tool_control/tool_status.html +++ b/NEMO/templates/tool_control/tool_status.html @@ -647,8 +647,8 @@

    Task & comment history for this tool

    $(this).tooltip({trigger: 'manual', html: 'true', title: $(this).data('title')}).tooltip('toggle'); }); $("#tabs").find("a").click(switch_tab); - $('#task_and_comment_start').datetimepicker({format: 'MM/DD/YYYY', 'widgetParent': '#task_and_comment_start_form_group'}); - $('#task_and_comment_end').datetimepicker({format: 'MM/DD/YYYY', 'widgetParent': '#task_and_comment_end_form_group'}); + $('#task_and_comment_start').datetimepicker({format: '{{ date_input_js_format }}', 'widgetParent': '#task_and_comment_start_form_group'}); + $('#task_and_comment_end').datetimepicker({format: '{{ date_input_js_format }}', 'widgetParent': '#task_and_comment_end_form_group'}); $('#delayed_logoff_help').popover(); function update_stop_button() diff --git a/NEMO/templates/tool_control/usage_data.html b/NEMO/templates/tool_control/usage_data.html index 2314ba30..fec1ade6 100644 --- a/NEMO/templates/tool_control/usage_data.html +++ b/NEMO/templates/tool_control/usage_data.html @@ -13,13 +13,13 @@

    - +
    - +
    @@ -103,6 +103,6 @@ $('#data_history_user_id').val(search_selection.id); } $('#user_search').autocomplete('users', select_user, {{ users|json_search_base }}); - $('#data_history_start_date').datetimepicker({format: 'MM/DD/YYYY'}).on('dp.change', function (e) { $('#data_history_last').val('') }); - $('#data_history_end_date').datetimepicker({format: 'MM/DD/YYYY'}).on('dp.change', function (e) { $('#data_history_last').val('') }); + $('#data_history_start_date').datetimepicker({format: '{{ date_input_js_format }}'}).on('dp.change', function (e) { $('#data_history_last').val('') }); + $('#data_history_end_date').datetimepicker({format: '{{ date_input_js_format }}'}).on('dp.change', function (e) { $('#data_history_last').val('') }); \ No newline at end of file diff --git a/NEMO/views/tool_control.py b/NEMO/views/tool_control.py index 3d95deb0..e4f25d8b 100644 --- a/NEMO/views/tool_control.py +++ b/NEMO/views/tool_control.py @@ -38,8 +38,6 @@ from NEMO.utilities import ( BasicDisplayTable, EmailCategory, - beginning_of_the_day, - end_of_the_day, export_format_datetime, extract_times, format_datetime, @@ -147,7 +145,7 @@ def get_tool_full_config_history(tool: Tool): def usage_data_history(request, tool_id): """ This method return a dictionary of headers and rows containing run_data information for Usage Events """ csv_export = bool(request.POST.get("csv", False)) - start, end = extract_times(request.POST, start_required=False, end_required=False) + start, end = extract_times(request.POST, beginning_and_end=True, start_required=False, end_required=False) last = request.POST.get("data_history_last") user_id = request.POST.get("data_history_user_id") show_project_info = request.POST.get("show_project_info") @@ -156,9 +154,9 @@ def usage_data_history(request, tool_id): last = 25 usage_events = UsageEvent.objects.filter(tool_id=tool_id, end__isnull=False).order_by("-end") if start: - usage_events = usage_events.filter(end__gte=beginning_of_the_day(start)) + usage_events = usage_events.filter(end__gte=start) if end: - usage_events = usage_events.filter(end__lte=end_of_the_day(end)) + usage_events = usage_events.filter(end__lte=end) if user_id: try: usage_events = usage_events.filter(user_id=int(user_id)) @@ -222,8 +220,8 @@ def usage_data_history(request, tool_id): else: dictionary = { "tool_id": tool_id, - "data_history_start": start, - "data_history_end": end, + "data_history_start": start.date() if start else None, + "data_history_end": end.date() if end else None, "data_history_last": str(last), "usage_data_table": table_result, "data_history_user": User.objects.get(id=user_id) if user_id else None, @@ -429,7 +427,7 @@ def disable_tool(request, tool_id): @login_required @require_GET def past_comments_and_tasks(request): - start, end = extract_times(request.GET, start_required=False, end_required=False) + start, end = extract_times(request.GET, beginning_and_end=True, start_required=False, end_required=False) search = request.GET.get("search") if not start and not end and not search: return HttpResponseBadRequest("Please enter a search keyword, start date or end date.") From caf09f5424a0a22a1ef33a08987f89c8784ab811 Mon Sep 17 00:00:00 2001 From: mrampant Date: Tue, 10 May 2022 21:54:10 -0400 Subject: [PATCH 48/82] - fixed cancel outage button not displayed --- NEMO/templates/event_details/outage_details.html | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/NEMO/templates/event_details/outage_details.html b/NEMO/templates/event_details/outage_details.html index bd4fa001..c01f1814 100644 --- a/NEMO/templates/event_details/outage_details.html +++ b/NEMO/templates/event_details/outage_details.html @@ -17,11 +17,11 @@

    Scheduled outage details

    Details:
    {{ outage.details|linebreaksbr }} {% endif %} -{% endblock %} -{# Allow the user to cancel the outage if they have that priviledge. only in popup view #} -{% if user.is_staff and popup_view %} -
    - -
    -{% endif %} \ No newline at end of file + {# Allow the user to cancel the outage if they have that priviledge. only in popup view #} + {% if user.is_staff and popup_view %} +
    + +
    + {% endif %} +{% endblock %} \ No newline at end of file From a170f7a1df8cd2c59f828d3cbf77a7e01f3ed3ff Mon Sep 17 00:00:00 2001 From: mrampant Date: Wed, 11 May 2022 07:54:07 -0400 Subject: [PATCH 49/82] - made all date/time parsing consistent with input formats from settings.py - removed datepicker dependency in favor of datetimepicker - updated usage, remote work and area access to use date input format from settings --- .../templates/sensors/sensor_data.html | 3 +- NEMO/apps/sensors/views.py | 2 +- NEMO/context_processors.py | 8 +- .../datetimepicker/bootstrap-datepicker.js | 2039 ----------------- .../datetimepicker/bootstrap-datepicker3.css | 683 ------ NEMO/static/numpad/custom_numpad.jquery.js | 2 +- NEMO/templates/area_access/area_access.html | 9 +- .../scheduled_outage_information.html | 9 +- NEMO/templates/remote_work.html | 36 +- NEMO/templates/usage/usage_base.html | 20 +- NEMO/utilities.py | 46 +- NEMO/views/area_access.py | 14 +- NEMO/views/calendar.py | 3 +- NEMO/views/remote_work.py | 18 +- NEMO/views/tool_control.py | 6 +- NEMO/views/usage.py | 6 +- 16 files changed, 112 insertions(+), 2792 deletions(-) delete mode 100644 NEMO/static/datetimepicker/bootstrap-datepicker.js delete mode 100644 NEMO/static/datetimepicker/bootstrap-datepicker3.css diff --git a/NEMO/apps/sensors/templates/sensors/sensor_data.html b/NEMO/apps/sensors/templates/sensors/sensor_data.html index 6a35b9a8..72322a01 100644 --- a/NEMO/apps/sensors/templates/sensors/sensor_data.html +++ b/NEMO/apps/sensors/templates/sensors/sensor_data.html @@ -1,5 +1,6 @@ {% extends "base.html" %} {% load static %} +{% load custom_tags_and_filters %} {% block extrahead %} {# Chart.js #} @@ -288,7 +289,7 @@ set_interval_when_visible(document, refresh_page, $('#refresh-rate').val()); } - set_dates(moment.unix({{ start|date:"U" }}), {% if end %}moment.unix({{ end|date:"U" }}){% else %}now_moment_date{% endif %}); + set_dates(moment('{{ start|input_date_format }}', '{{ datetime_input_js_format }}'), {% if end %}moment('{{ end|input_date_format }}', '{{ datetime_input_js_format }}'){% else %}now_moment_date{% endif %}); update_refresh_rate(); diff --git a/NEMO/apps/sensors/views.py b/NEMO/apps/sensors/views.py index bcc71de0..1f962f5c 100644 --- a/NEMO/apps/sensors/views.py +++ b/NEMO/apps/sensors/views.py @@ -96,7 +96,7 @@ def sensor_chart_data(request, sensor_id): def get_sensor_data(request, sensor) -> (QuerySet, datetime, datetime): start, end = extract_times(request.GET, start_required=False, end_required=False) sensor_data = SensorData.objects.filter(sensor=sensor) - now = timezone.now().replace(second=0) + now = timezone.now().replace(second=0, microsecond=0).astimezone() sensor_default_daterange = SensorCustomization.get("sensor_default_daterange") if not start: if sensor_default_daterange == "last_week": diff --git a/NEMO/context_processors.py b/NEMO/context_processors.py index 5910cdc9..45c38e30 100644 --- a/NEMO/context_processors.py +++ b/NEMO/context_processors.py @@ -1,14 +1,8 @@ -from django.utils.formats import get_format - from NEMO.models import Area, Notification, PhysicalAccessLevel, Tool, User -from NEMO.utilities import convert_py_format_to_js +from NEMO.utilities import date_input_js_format, datetime_input_js_format, time_input_js_format from NEMO.views.customization import get_customization from NEMO.views.notifications import get_notification_counts -time_input_js_format = convert_py_format_to_js(get_format('TIME_INPUT_FORMATS')[0]) -date_input_js_format = convert_py_format_to_js(get_format('DATE_INPUT_FORMATS')[0]) -datetime_input_js_format = convert_py_format_to_js(get_format('DATETIME_INPUT_FORMATS')[0]) - def show_logout_button(request): return {"logout_allowed": True} diff --git a/NEMO/static/datetimepicker/bootstrap-datepicker.js b/NEMO/static/datetimepicker/bootstrap-datepicker.js deleted file mode 100644 index a94f79fc..00000000 --- a/NEMO/static/datetimepicker/bootstrap-datepicker.js +++ /dev/null @@ -1,2039 +0,0 @@ -/*! - * Datepicker for Bootstrap v1.9.0 (https://github.com/uxsolutions/bootstrap-datepicker) - * - * Licensed under the Apache License v2.0 (http://www.apache.org/licenses/LICENSE-2.0) - */ - -(function(factory){ - if (typeof define === 'function' && define.amd) { - define(['jquery'], factory); - } else if (typeof exports === 'object') { - factory(require('jquery')); - } else { - factory(jQuery); - } -}(function($, undefined){ - function UTCDate(){ - return new Date(Date.UTC.apply(Date, arguments)); - } - function UTCToday(){ - var today = new Date(); - return UTCDate(today.getFullYear(), today.getMonth(), today.getDate()); - } - function isUTCEquals(date1, date2) { - return ( - date1.getUTCFullYear() === date2.getUTCFullYear() && - date1.getUTCMonth() === date2.getUTCMonth() && - date1.getUTCDate() === date2.getUTCDate() - ); - } - function alias(method, deprecationMsg){ - return function(){ - if (deprecationMsg !== undefined) { - $.fn.datepicker.deprecated(deprecationMsg); - } - - return this[method].apply(this, arguments); - }; - } - function isValidDate(d) { - return d && !isNaN(d.getTime()); - } - - var DateArray = (function(){ - var extras = { - get: function(i){ - return this.slice(i)[0]; - }, - contains: function(d){ - // Array.indexOf is not cross-browser; - // $.inArray doesn't work with Dates - var val = d && d.valueOf(); - for (var i=0, l=this.length; i < l; i++) - // Use date arithmetic to allow dates with different times to match - if (0 <= this[i].valueOf() - val && this[i].valueOf() - val < 1000*60*60*24) - return i; - return -1; - }, - remove: function(i){ - this.splice(i,1); - }, - replace: function(new_array){ - if (!new_array) - return; - if (!$.isArray(new_array)) - new_array = [new_array]; - this.clear(); - this.push.apply(this, new_array); - }, - clear: function(){ - this.length = 0; - }, - copy: function(){ - var a = new DateArray(); - a.replace(this); - return a; - } - }; - - return function(){ - var a = []; - a.push.apply(a, arguments); - $.extend(a, extras); - return a; - }; - })(); - - - // Picker object - - var Datepicker = function(element, options){ - $.data(element, 'datepicker', this); - - this._events = []; - this._secondaryEvents = []; - - this._process_options(options); - - this.dates = new DateArray(); - this.viewDate = this.o.defaultViewDate; - this.focusDate = null; - - this.element = $(element); - this.isInput = this.element.is('input'); - this.inputField = this.isInput ? this.element : this.element.find('input'); - this.component = this.element.hasClass('date') ? this.element.find('.add-on, .input-group-addon, .input-group-append, .input-group-prepend, .btn') : false; - if (this.component && this.component.length === 0) - this.component = false; - this.isInline = !this.component && this.element.is('div'); - - this.picker = $(DPGlobal.template); - - // Checking templates and inserting - if (this._check_template(this.o.templates.leftArrow)) { - this.picker.find('.prev').html(this.o.templates.leftArrow); - } - - if (this._check_template(this.o.templates.rightArrow)) { - this.picker.find('.next').html(this.o.templates.rightArrow); - } - - this._buildEvents(); - this._attachEvents(); - - if (this.isInline){ - this.picker.addClass('datepicker-inline').appendTo(this.element); - } - else { - this.picker.addClass('datepicker-dropdown dropdown-menu'); - } - - if (this.o.rtl){ - this.picker.addClass('datepicker-rtl'); - } - - if (this.o.calendarWeeks) { - this.picker.find('.datepicker-days .datepicker-switch, thead .datepicker-title, tfoot .today, tfoot .clear') - .attr('colspan', function(i, val){ - return Number(val) + 1; - }); - } - - this._process_options({ - startDate: this._o.startDate, - endDate: this._o.endDate, - daysOfWeekDisabled: this.o.daysOfWeekDisabled, - daysOfWeekHighlighted: this.o.daysOfWeekHighlighted, - datesDisabled: this.o.datesDisabled - }); - - this._allow_update = false; - this.setViewMode(this.o.startView); - this._allow_update = true; - - this.fillDow(); - this.fillMonths(); - - this.update(); - - if (this.isInline){ - this.show(); - } - }; - - Datepicker.prototype = { - constructor: Datepicker, - - _resolveViewName: function(view){ - $.each(DPGlobal.viewModes, function(i, viewMode){ - if (view === i || $.inArray(view, viewMode.names) !== -1){ - view = i; - return false; - } - }); - - return view; - }, - - _resolveDaysOfWeek: function(daysOfWeek){ - if (!$.isArray(daysOfWeek)) - daysOfWeek = daysOfWeek.split(/[,\s]*/); - return $.map(daysOfWeek, Number); - }, - - _check_template: function(tmp){ - try { - // If empty - if (tmp === undefined || tmp === "") { - return false; - } - // If no html, everything ok - if ((tmp.match(/[<>]/g) || []).length <= 0) { - return true; - } - // Checking if html is fine - var jDom = $(tmp); - return jDom.length > 0; - } - catch (ex) { - return false; - } - }, - - _process_options: function(opts){ - // Store raw options for reference - this._o = $.extend({}, this._o, opts); - // Processed options - var o = this.o = $.extend({}, this._o); - - // Check if "de-DE" style date is available, if not language should - // fallback to 2 letter code eg "de" - var lang = o.language; - if (!dates[lang]){ - lang = lang.split('-')[0]; - if (!dates[lang]) - lang = defaults.language; - } - o.language = lang; - - // Retrieve view index from any aliases - o.startView = this._resolveViewName(o.startView); - o.minViewMode = this._resolveViewName(o.minViewMode); - o.maxViewMode = this._resolveViewName(o.maxViewMode); - - // Check view is between min and max - o.startView = Math.max(this.o.minViewMode, Math.min(this.o.maxViewMode, o.startView)); - - // true, false, or Number > 0 - if (o.multidate !== true){ - o.multidate = Number(o.multidate) || false; - if (o.multidate !== false) - o.multidate = Math.max(0, o.multidate); - } - o.multidateSeparator = String(o.multidateSeparator); - - o.weekStart %= 7; - o.weekEnd = (o.weekStart + 6) % 7; - - var format = DPGlobal.parseFormat(o.format); - if (o.startDate !== -Infinity){ - if (!!o.startDate){ - if (o.startDate instanceof Date) - o.startDate = this._local_to_utc(this._zero_time(o.startDate)); - else - o.startDate = DPGlobal.parseDate(o.startDate, format, o.language, o.assumeNearbyYear); - } - else { - o.startDate = -Infinity; - } - } - if (o.endDate !== Infinity){ - if (!!o.endDate){ - if (o.endDate instanceof Date) - o.endDate = this._local_to_utc(this._zero_time(o.endDate)); - else - o.endDate = DPGlobal.parseDate(o.endDate, format, o.language, o.assumeNearbyYear); - } - else { - o.endDate = Infinity; - } - } - - o.daysOfWeekDisabled = this._resolveDaysOfWeek(o.daysOfWeekDisabled||[]); - o.daysOfWeekHighlighted = this._resolveDaysOfWeek(o.daysOfWeekHighlighted||[]); - - o.datesDisabled = o.datesDisabled||[]; - if (!$.isArray(o.datesDisabled)) { - o.datesDisabled = o.datesDisabled.split(','); - } - o.datesDisabled = $.map(o.datesDisabled, function(d){ - return DPGlobal.parseDate(d, format, o.language, o.assumeNearbyYear); - }); - - var plc = String(o.orientation).toLowerCase().split(/\s+/g), - _plc = o.orientation.toLowerCase(); - plc = $.grep(plc, function(word){ - return /^auto|left|right|top|bottom$/.test(word); - }); - o.orientation = {x: 'auto', y: 'auto'}; - if (!_plc || _plc === 'auto') - ; // no action - else if (plc.length === 1){ - switch (plc[0]){ - case 'top': - case 'bottom': - o.orientation.y = plc[0]; - break; - case 'left': - case 'right': - o.orientation.x = plc[0]; - break; - } - } - else { - _plc = $.grep(plc, function(word){ - return /^left|right$/.test(word); - }); - o.orientation.x = _plc[0] || 'auto'; - - _plc = $.grep(plc, function(word){ - return /^top|bottom$/.test(word); - }); - o.orientation.y = _plc[0] || 'auto'; - } - if (o.defaultViewDate instanceof Date || typeof o.defaultViewDate === 'string') { - o.defaultViewDate = DPGlobal.parseDate(o.defaultViewDate, format, o.language, o.assumeNearbyYear); - } else if (o.defaultViewDate) { - var year = o.defaultViewDate.year || new Date().getFullYear(); - var month = o.defaultViewDate.month || 0; - var day = o.defaultViewDate.day || 1; - o.defaultViewDate = UTCDate(year, month, day); - } else { - o.defaultViewDate = UTCToday(); - } - }, - _applyEvents: function(evs){ - for (var i=0, el, ch, ev; i < evs.length; i++){ - el = evs[i][0]; - if (evs[i].length === 2){ - ch = undefined; - ev = evs[i][1]; - } else if (evs[i].length === 3){ - ch = evs[i][1]; - ev = evs[i][2]; - } - el.on(ev, ch); - } - }, - _unapplyEvents: function(evs){ - for (var i=0, el, ev, ch; i < evs.length; i++){ - el = evs[i][0]; - if (evs[i].length === 2){ - ch = undefined; - ev = evs[i][1]; - } else if (evs[i].length === 3){ - ch = evs[i][1]; - ev = evs[i][2]; - } - el.off(ev, ch); - } - }, - _buildEvents: function(){ - var events = { - keyup: $.proxy(function(e){ - if ($.inArray(e.keyCode, [27, 37, 39, 38, 40, 32, 13, 9]) === -1) - this.update(); - }, this), - keydown: $.proxy(this.keydown, this), - paste: $.proxy(this.paste, this) - }; - - if (this.o.showOnFocus === true) { - events.focus = $.proxy(this.show, this); - } - - if (this.isInput) { // single input - this._events = [ - [this.element, events] - ]; - } - // component: input + button - else if (this.component && this.inputField.length) { - this._events = [ - // For components that are not readonly, allow keyboard nav - [this.inputField, events], - [this.component, { - click: $.proxy(this.show, this) - }] - ]; - } - else { - this._events = [ - [this.element, { - click: $.proxy(this.show, this), - keydown: $.proxy(this.keydown, this) - }] - ]; - } - this._events.push( - // Component: listen for blur on element descendants - [this.element, '*', { - blur: $.proxy(function(e){ - this._focused_from = e.target; - }, this) - }], - // Input: listen for blur on element - [this.element, { - blur: $.proxy(function(e){ - this._focused_from = e.target; - }, this) - }] - ); - - if (this.o.immediateUpdates) { - // Trigger input updates immediately on changed year/month - this._events.push([this.element, { - 'changeYear changeMonth': $.proxy(function(e){ - this.update(e.date); - }, this) - }]); - } - - this._secondaryEvents = [ - [this.picker, { - click: $.proxy(this.click, this) - }], - [this.picker, '.prev, .next', { - click: $.proxy(this.navArrowsClick, this) - }], - [this.picker, '.day:not(.disabled)', { - click: $.proxy(this.dayCellClick, this) - }], - [$(window), { - resize: $.proxy(this.place, this) - }], - [$(document), { - 'mousedown touchstart': $.proxy(function(e){ - // Clicked outside the datepicker, hide it - if (!( - this.element.is(e.target) || - this.element.find(e.target).length || - this.picker.is(e.target) || - this.picker.find(e.target).length || - this.isInline - )){ - this.hide(); - } - }, this) - }] - ]; - }, - _attachEvents: function(){ - this._detachEvents(); - this._applyEvents(this._events); - }, - _detachEvents: function(){ - this._unapplyEvents(this._events); - }, - _attachSecondaryEvents: function(){ - this._detachSecondaryEvents(); - this._applyEvents(this._secondaryEvents); - }, - _detachSecondaryEvents: function(){ - this._unapplyEvents(this._secondaryEvents); - }, - _trigger: function(event, altdate){ - var date = altdate || this.dates.get(-1), - local_date = this._utc_to_local(date); - - this.element.trigger({ - type: event, - date: local_date, - viewMode: this.viewMode, - dates: $.map(this.dates, this._utc_to_local), - format: $.proxy(function(ix, format){ - if (arguments.length === 0){ - ix = this.dates.length - 1; - format = this.o.format; - } else if (typeof ix === 'string'){ - format = ix; - ix = this.dates.length - 1; - } - format = format || this.o.format; - var date = this.dates.get(ix); - return DPGlobal.formatDate(date, format, this.o.language); - }, this) - }); - }, - - show: function(){ - if (this.inputField.is(':disabled') || (this.inputField.prop('readonly') && this.o.enableOnReadonly === false)) - return; - if (!this.isInline) - this.picker.appendTo(this.o.container); - this.place(); - this.picker.show(); - this._attachSecondaryEvents(); - this._trigger('show'); - if ((window.navigator.msMaxTouchPoints || 'ontouchstart' in document) && this.o.disableTouchKeyboard) { - $(this.element).blur(); - } - return this; - }, - - hide: function(){ - if (this.isInline || !this.picker.is(':visible')) - return this; - this.focusDate = null; - this.picker.hide().detach(); - this._detachSecondaryEvents(); - this.setViewMode(this.o.startView); - - if (this.o.forceParse && this.inputField.val()) - this.setValue(); - this._trigger('hide'); - return this; - }, - - destroy: function(){ - this.hide(); - this._detachEvents(); - this._detachSecondaryEvents(); - this.picker.remove(); - delete this.element.data().datepicker; - if (!this.isInput){ - delete this.element.data().date; - } - return this; - }, - - paste: function(e){ - var dateString; - if (e.originalEvent.clipboardData && e.originalEvent.clipboardData.types - && $.inArray('text/plain', e.originalEvent.clipboardData.types) !== -1) { - dateString = e.originalEvent.clipboardData.getData('text/plain'); - } else if (window.clipboardData) { - dateString = window.clipboardData.getData('Text'); - } else { - return; - } - this.setDate(dateString); - this.update(); - e.preventDefault(); - }, - - _utc_to_local: function(utc){ - if (!utc) { - return utc; - } - - var local = new Date(utc.getTime() + (utc.getTimezoneOffset() * 60000)); - - if (local.getTimezoneOffset() !== utc.getTimezoneOffset()) { - local = new Date(utc.getTime() + (local.getTimezoneOffset() * 60000)); - } - - return local; - }, - _local_to_utc: function(local){ - return local && new Date(local.getTime() - (local.getTimezoneOffset()*60000)); - }, - _zero_time: function(local){ - return local && new Date(local.getFullYear(), local.getMonth(), local.getDate()); - }, - _zero_utc_time: function(utc){ - return utc && UTCDate(utc.getUTCFullYear(), utc.getUTCMonth(), utc.getUTCDate()); - }, - - getDates: function(){ - return $.map(this.dates, this._utc_to_local); - }, - - getUTCDates: function(){ - return $.map(this.dates, function(d){ - return new Date(d); - }); - }, - - getDate: function(){ - return this._utc_to_local(this.getUTCDate()); - }, - - getUTCDate: function(){ - var selected_date = this.dates.get(-1); - if (selected_date !== undefined) { - return new Date(selected_date); - } else { - return null; - } - }, - - clearDates: function(){ - this.inputField.val(''); - this.update(); - this._trigger('changeDate'); - - if (this.o.autoclose) { - this.hide(); - } - }, - - setDates: function(){ - var args = $.isArray(arguments[0]) ? arguments[0] : arguments; - this.update.apply(this, args); - this._trigger('changeDate'); - this.setValue(); - return this; - }, - - setUTCDates: function(){ - var args = $.isArray(arguments[0]) ? arguments[0] : arguments; - this.setDates.apply(this, $.map(args, this._utc_to_local)); - return this; - }, - - setDate: alias('setDates'), - setUTCDate: alias('setUTCDates'), - remove: alias('destroy', 'Method `remove` is deprecated and will be removed in version 2.0. Use `destroy` instead'), - - setValue: function(){ - var formatted = this.getFormattedDate(); - this.inputField.val(formatted); - return this; - }, - - getFormattedDate: function(format){ - if (format === undefined) - format = this.o.format; - - var lang = this.o.language; - return $.map(this.dates, function(d){ - return DPGlobal.formatDate(d, format, lang); - }).join(this.o.multidateSeparator); - }, - - getStartDate: function(){ - return this.o.startDate; - }, - - setStartDate: function(startDate){ - this._process_options({startDate: startDate}); - this.update(); - this.updateNavArrows(); - return this; - }, - - getEndDate: function(){ - return this.o.endDate; - }, - - setEndDate: function(endDate){ - this._process_options({endDate: endDate}); - this.update(); - this.updateNavArrows(); - return this; - }, - - setDaysOfWeekDisabled: function(daysOfWeekDisabled){ - this._process_options({daysOfWeekDisabled: daysOfWeekDisabled}); - this.update(); - return this; - }, - - setDaysOfWeekHighlighted: function(daysOfWeekHighlighted){ - this._process_options({daysOfWeekHighlighted: daysOfWeekHighlighted}); - this.update(); - return this; - }, - - setDatesDisabled: function(datesDisabled){ - this._process_options({datesDisabled: datesDisabled}); - this.update(); - return this; - }, - - place: function(){ - if (this.isInline) - return this; - var calendarWidth = this.picker.outerWidth(), - calendarHeight = this.picker.outerHeight(), - visualPadding = 10, - container = $(this.o.container), - windowWidth = container.width(), - scrollTop = this.o.container === 'body' ? $(document).scrollTop() : container.scrollTop(), - appendOffset = container.offset(); - - var parentsZindex = [0]; - this.element.parents().each(function(){ - var itemZIndex = $(this).css('z-index'); - if (itemZIndex !== 'auto' && Number(itemZIndex) !== 0) parentsZindex.push(Number(itemZIndex)); - }); - var zIndex = Math.max.apply(Math, parentsZindex) + this.o.zIndexOffset; - var offset = this.component ? this.component.parent().offset() : this.element.offset(); - var height = this.component ? this.component.outerHeight(true) : this.element.outerHeight(false); - var width = this.component ? this.component.outerWidth(true) : this.element.outerWidth(false); - var left = offset.left - appendOffset.left; - var top = offset.top - appendOffset.top; - - if (this.o.container !== 'body') { - top += scrollTop; - } - - this.picker.removeClass( - 'datepicker-orient-top datepicker-orient-bottom '+ - 'datepicker-orient-right datepicker-orient-left' - ); - - if (this.o.orientation.x !== 'auto'){ - this.picker.addClass('datepicker-orient-' + this.o.orientation.x); - if (this.o.orientation.x === 'right') - left -= calendarWidth - width; - } - // auto x orientation is best-placement: if it crosses a window - // edge, fudge it sideways - else { - if (offset.left < 0) { - // component is outside the window on the left side. Move it into visible range - this.picker.addClass('datepicker-orient-left'); - left -= offset.left - visualPadding; - } else if (left + calendarWidth > windowWidth) { - // the calendar passes the widow right edge. Align it to component right side - this.picker.addClass('datepicker-orient-right'); - left += width - calendarWidth; - } else { - if (this.o.rtl) { - // Default to right - this.picker.addClass('datepicker-orient-right'); - } else { - // Default to left - this.picker.addClass('datepicker-orient-left'); - } - } - } - - // auto y orientation is best-situation: top or bottom, no fudging, - // decision based on which shows more of the calendar - var yorient = this.o.orientation.y, - top_overflow; - if (yorient === 'auto'){ - top_overflow = -scrollTop + top - calendarHeight; - yorient = top_overflow < 0 ? 'bottom' : 'top'; - } - - this.picker.addClass('datepicker-orient-' + yorient); - if (yorient === 'top') - top -= calendarHeight + parseInt(this.picker.css('padding-top')); - else - top += height; - - if (this.o.rtl) { - var right = windowWidth - (left + width); - this.picker.css({ - top: top, - right: right, - zIndex: zIndex - }); - } else { - this.picker.css({ - top: top, - left: left, - zIndex: zIndex - }); - } - return this; - }, - - _allow_update: true, - update: function(){ - if (!this._allow_update) - return this; - - var oldDates = this.dates.copy(), - dates = [], - fromArgs = false; - if (arguments.length){ - $.each(arguments, $.proxy(function(i, date){ - if (date instanceof Date) - date = this._local_to_utc(date); - dates.push(date); - }, this)); - fromArgs = true; - } else { - dates = this.isInput - ? this.element.val() - : this.element.data('date') || this.inputField.val(); - if (dates && this.o.multidate) - dates = dates.split(this.o.multidateSeparator); - else - dates = [dates]; - delete this.element.data().date; - } - - dates = $.map(dates, $.proxy(function(date){ - return DPGlobal.parseDate(date, this.o.format, this.o.language, this.o.assumeNearbyYear); - }, this)); - dates = $.grep(dates, $.proxy(function(date){ - return ( - !this.dateWithinRange(date) || - !date - ); - }, this), true); - this.dates.replace(dates); - - if (this.o.updateViewDate) { - if (this.dates.length) - this.viewDate = new Date(this.dates.get(-1)); - else if (this.viewDate < this.o.startDate) - this.viewDate = new Date(this.o.startDate); - else if (this.viewDate > this.o.endDate) - this.viewDate = new Date(this.o.endDate); - else - this.viewDate = this.o.defaultViewDate; - } - - if (fromArgs){ - // setting date by clicking - this.setValue(); - this.element.change(); - } - else if (this.dates.length){ - // setting date by typing - if (String(oldDates) !== String(this.dates) && fromArgs) { - this._trigger('changeDate'); - this.element.change(); - } - } - if (!this.dates.length && oldDates.length) { - this._trigger('clearDate'); - this.element.change(); - } - - this.fill(); - return this; - }, - - fillDow: function(){ - if (this.o.showWeekDays) { - var dowCnt = this.o.weekStart, - html = '
    '; - if (this.o.calendarWeeks){ - html += ''; - } - while (dowCnt < this.o.weekStart + 7){ - html += ''; - } - html += ''; - this.picker.find('.datepicker-days thead').append(html); - } - }, - - fillMonths: function(){ - var localDate = this._utc_to_local(this.viewDate); - var html = ''; - var focused; - for (var i = 0; i < 12; i++){ - focused = localDate && localDate.getMonth() === i ? ' focused' : ''; - html += '' + dates[this.o.language].monthsShort[i] + ''; - } - this.picker.find('.datepicker-months td').html(html); - }, - - setRange: function(range){ - if (!range || !range.length) - delete this.range; - else - this.range = $.map(range, function(d){ - return d.valueOf(); - }); - this.fill(); - }, - - getClassNames: function(date){ - var cls = [], - year = this.viewDate.getUTCFullYear(), - month = this.viewDate.getUTCMonth(), - today = UTCToday(); - if (date.getUTCFullYear() < year || (date.getUTCFullYear() === year && date.getUTCMonth() < month)){ - cls.push('old'); - } else if (date.getUTCFullYear() > year || (date.getUTCFullYear() === year && date.getUTCMonth() > month)){ - cls.push('new'); - } - if (this.focusDate && date.valueOf() === this.focusDate.valueOf()) - cls.push('focused'); - // Compare internal UTC date with UTC today, not local today - if (this.o.todayHighlight && isUTCEquals(date, today)) { - cls.push('today'); - } - if (this.dates.contains(date) !== -1) - cls.push('active'); - if (!this.dateWithinRange(date)){ - cls.push('disabled'); - } - if (this.dateIsDisabled(date)){ - cls.push('disabled', 'disabled-date'); - } - if ($.inArray(date.getUTCDay(), this.o.daysOfWeekHighlighted) !== -1){ - cls.push('highlighted'); - } - - if (this.range){ - if (date > this.range[0] && date < this.range[this.range.length-1]){ - cls.push('range'); - } - if ($.inArray(date.valueOf(), this.range) !== -1){ - cls.push('selected'); - } - if (date.valueOf() === this.range[0]){ - cls.push('range-start'); - } - if (date.valueOf() === this.range[this.range.length-1]){ - cls.push('range-end'); - } - } - return cls; - }, - - _fill_yearsView: function(selector, cssClass, factor, year, startYear, endYear, beforeFn){ - var html = ''; - var step = factor / 10; - var view = this.picker.find(selector); - var startVal = Math.floor(year / factor) * factor; - var endVal = startVal + step * 9; - var focusedVal = Math.floor(this.viewDate.getFullYear() / step) * step; - var selected = $.map(this.dates, function(d){ - return Math.floor(d.getUTCFullYear() / step) * step; - }); - - var classes, tooltip, before; - for (var currVal = startVal - step; currVal <= endVal + step; currVal += step) { - classes = [cssClass]; - tooltip = null; - - if (currVal === startVal - step) { - classes.push('old'); - } else if (currVal === endVal + step) { - classes.push('new'); - } - if ($.inArray(currVal, selected) !== -1) { - classes.push('active'); - } - if (currVal < startYear || currVal > endYear) { - classes.push('disabled'); - } - if (currVal === focusedVal) { - classes.push('focused'); - } - - if (beforeFn !== $.noop) { - before = beforeFn(new Date(currVal, 0, 1)); - if (before === undefined) { - before = {}; - } else if (typeof before === 'boolean') { - before = {enabled: before}; - } else if (typeof before === 'string') { - before = {classes: before}; - } - if (before.enabled === false) { - classes.push('disabled'); - } - if (before.classes) { - classes = classes.concat(before.classes.split(/\s+/)); - } - if (before.tooltip) { - tooltip = before.tooltip; - } - } - - html += '' + currVal + ''; - } - - view.find('.datepicker-switch').text(startVal + '-' + endVal); - view.find('td').html(html); - }, - - fill: function(){ - var d = new Date(this.viewDate), - year = d.getUTCFullYear(), - month = d.getUTCMonth(), - startYear = this.o.startDate !== -Infinity ? this.o.startDate.getUTCFullYear() : -Infinity, - startMonth = this.o.startDate !== -Infinity ? this.o.startDate.getUTCMonth() : -Infinity, - endYear = this.o.endDate !== Infinity ? this.o.endDate.getUTCFullYear() : Infinity, - endMonth = this.o.endDate !== Infinity ? this.o.endDate.getUTCMonth() : Infinity, - todaytxt = dates[this.o.language].today || dates['en'].today || '', - cleartxt = dates[this.o.language].clear || dates['en'].clear || '', - titleFormat = dates[this.o.language].titleFormat || dates['en'].titleFormat, - todayDate = UTCToday(), - titleBtnVisible = (this.o.todayBtn === true || this.o.todayBtn === 'linked') && todayDate >= this.o.startDate && todayDate <= this.o.endDate && !this.weekOfDateIsDisabled(todayDate), - tooltip, - before; - if (isNaN(year) || isNaN(month)) - return; - this.picker.find('.datepicker-days .datepicker-switch') - .text(DPGlobal.formatDate(d, titleFormat, this.o.language)); - this.picker.find('tfoot .today') - .text(todaytxt) - .css('display', titleBtnVisible ? 'table-cell' : 'none'); - this.picker.find('tfoot .clear') - .text(cleartxt) - .css('display', this.o.clearBtn === true ? 'table-cell' : 'none'); - this.picker.find('thead .datepicker-title') - .text(this.o.title) - .css('display', typeof this.o.title === 'string' && this.o.title !== '' ? 'table-cell' : 'none'); - this.updateNavArrows(); - this.fillMonths(); - var prevMonth = UTCDate(year, month, 0), - day = prevMonth.getUTCDate(); - prevMonth.setUTCDate(day - (prevMonth.getUTCDay() - this.o.weekStart + 7)%7); - var nextMonth = new Date(prevMonth); - if (prevMonth.getUTCFullYear() < 100){ - nextMonth.setUTCFullYear(prevMonth.getUTCFullYear()); - } - nextMonth.setUTCDate(nextMonth.getUTCDate() + 42); - nextMonth = nextMonth.valueOf(); - var html = []; - var weekDay, clsName; - while (prevMonth.valueOf() < nextMonth){ - weekDay = prevMonth.getUTCDay(); - if (weekDay === this.o.weekStart){ - html.push(''); - if (this.o.calendarWeeks){ - // ISO 8601: First week contains first thursday. - // ISO also states week starts on Monday, but we can be more abstract here. - var - // Start of current week: based on weekstart/current date - ws = new Date(+prevMonth + (this.o.weekStart - weekDay - 7) % 7 * 864e5), - // Thursday of this week - th = new Date(Number(ws) + (7 + 4 - ws.getUTCDay()) % 7 * 864e5), - // First Thursday of year, year from thursday - yth = new Date(Number(yth = UTCDate(th.getUTCFullYear(), 0, 1)) + (7 + 4 - yth.getUTCDay()) % 7 * 864e5), - // Calendar week: ms between thursdays, div ms per day, div 7 days - calWeek = (th - yth) / 864e5 / 7 + 1; - html.push(''); - } - } - clsName = this.getClassNames(prevMonth); - clsName.push('day'); - - var content = prevMonth.getUTCDate(); - - if (this.o.beforeShowDay !== $.noop){ - before = this.o.beforeShowDay(this._utc_to_local(prevMonth)); - if (before === undefined) - before = {}; - else if (typeof before === 'boolean') - before = {enabled: before}; - else if (typeof before === 'string') - before = {classes: before}; - if (before.enabled === false) - clsName.push('disabled'); - if (before.classes) - clsName = clsName.concat(before.classes.split(/\s+/)); - if (before.tooltip) - tooltip = before.tooltip; - if (before.content) - content = before.content; - } - - //Check if uniqueSort exists (supported by jquery >=1.12 and >=2.2) - //Fallback to unique function for older jquery versions - if ($.isFunction($.uniqueSort)) { - clsName = $.uniqueSort(clsName); - } else { - clsName = $.unique(clsName); - } - - html.push(''); - tooltip = null; - if (weekDay === this.o.weekEnd){ - html.push(''); - } - prevMonth.setUTCDate(prevMonth.getUTCDate() + 1); - } - this.picker.find('.datepicker-days tbody').html(html.join('')); - - var monthsTitle = dates[this.o.language].monthsTitle || dates['en'].monthsTitle || 'Months'; - var months = this.picker.find('.datepicker-months') - .find('.datepicker-switch') - .text(this.o.maxViewMode < 2 ? monthsTitle : year) - .end() - .find('tbody span').removeClass('active'); - - $.each(this.dates, function(i, d){ - if (d.getUTCFullYear() === year) - months.eq(d.getUTCMonth()).addClass('active'); - }); - - if (year < startYear || year > endYear){ - months.addClass('disabled'); - } - if (year === startYear){ - months.slice(0, startMonth).addClass('disabled'); - } - if (year === endYear){ - months.slice(endMonth+1).addClass('disabled'); - } - - if (this.o.beforeShowMonth !== $.noop){ - var that = this; - $.each(months, function(i, month){ - var moDate = new Date(year, i, 1); - var before = that.o.beforeShowMonth(moDate); - if (before === undefined) - before = {}; - else if (typeof before === 'boolean') - before = {enabled: before}; - else if (typeof before === 'string') - before = {classes: before}; - if (before.enabled === false && !$(month).hasClass('disabled')) - $(month).addClass('disabled'); - if (before.classes) - $(month).addClass(before.classes); - if (before.tooltip) - $(month).prop('title', before.tooltip); - }); - } - - // Generating decade/years picker - this._fill_yearsView( - '.datepicker-years', - 'year', - 10, - year, - startYear, - endYear, - this.o.beforeShowYear - ); - - // Generating century/decades picker - this._fill_yearsView( - '.datepicker-decades', - 'decade', - 100, - year, - startYear, - endYear, - this.o.beforeShowDecade - ); - - // Generating millennium/centuries picker - this._fill_yearsView( - '.datepicker-centuries', - 'century', - 1000, - year, - startYear, - endYear, - this.o.beforeShowCentury - ); - }, - - updateNavArrows: function(){ - if (!this._allow_update) - return; - - var d = new Date(this.viewDate), - year = d.getUTCFullYear(), - month = d.getUTCMonth(), - startYear = this.o.startDate !== -Infinity ? this.o.startDate.getUTCFullYear() : -Infinity, - startMonth = this.o.startDate !== -Infinity ? this.o.startDate.getUTCMonth() : -Infinity, - endYear = this.o.endDate !== Infinity ? this.o.endDate.getUTCFullYear() : Infinity, - endMonth = this.o.endDate !== Infinity ? this.o.endDate.getUTCMonth() : Infinity, - prevIsDisabled, - nextIsDisabled, - factor = 1; - switch (this.viewMode){ - case 4: - factor *= 10; - /* falls through */ - case 3: - factor *= 10; - /* falls through */ - case 2: - factor *= 10; - /* falls through */ - case 1: - prevIsDisabled = Math.floor(year / factor) * factor <= startYear; - nextIsDisabled = Math.floor(year / factor) * factor + factor > endYear; - break; - case 0: - prevIsDisabled = year <= startYear && month <= startMonth; - nextIsDisabled = year >= endYear && month >= endMonth; - break; - } - - this.picker.find('.prev').toggleClass('disabled', prevIsDisabled); - this.picker.find('.next').toggleClass('disabled', nextIsDisabled); - }, - - click: function(e){ - e.preventDefault(); - e.stopPropagation(); - - var target, dir, day, year, month; - target = $(e.target); - - // Clicked on the switch - if (target.hasClass('datepicker-switch') && this.viewMode !== this.o.maxViewMode){ - this.setViewMode(this.viewMode + 1); - } - - // Clicked on today button - if (target.hasClass('today') && !target.hasClass('day')){ - this.setViewMode(0); - this._setDate(UTCToday(), this.o.todayBtn === 'linked' ? null : 'view'); - } - - // Clicked on clear button - if (target.hasClass('clear')){ - this.clearDates(); - } - - if (!target.hasClass('disabled')){ - // Clicked on a month, year, decade, century - if (target.hasClass('month') - || target.hasClass('year') - || target.hasClass('decade') - || target.hasClass('century')) { - this.viewDate.setUTCDate(1); - - day = 1; - if (this.viewMode === 1){ - month = target.parent().find('span').index(target); - year = this.viewDate.getUTCFullYear(); - this.viewDate.setUTCMonth(month); - } else { - month = 0; - year = Number(target.text()); - this.viewDate.setUTCFullYear(year); - } - - this._trigger(DPGlobal.viewModes[this.viewMode - 1].e, this.viewDate); - - if (this.viewMode === this.o.minViewMode){ - this._setDate(UTCDate(year, month, day)); - } else { - this.setViewMode(this.viewMode - 1); - this.fill(); - } - } - } - - if (this.picker.is(':visible') && this._focused_from){ - this._focused_from.focus(); - } - delete this._focused_from; - }, - - dayCellClick: function(e){ - var $target = $(e.currentTarget); - var timestamp = $target.data('date'); - var date = new Date(timestamp); - - if (this.o.updateViewDate) { - if (date.getUTCFullYear() !== this.viewDate.getUTCFullYear()) { - this._trigger('changeYear', this.viewDate); - } - - if (date.getUTCMonth() !== this.viewDate.getUTCMonth()) { - this._trigger('changeMonth', this.viewDate); - } - } - this._setDate(date); - }, - - // Clicked on prev or next - navArrowsClick: function(e){ - var $target = $(e.currentTarget); - var dir = $target.hasClass('prev') ? -1 : 1; - if (this.viewMode !== 0){ - dir *= DPGlobal.viewModes[this.viewMode].navStep * 12; - } - this.viewDate = this.moveMonth(this.viewDate, dir); - this._trigger(DPGlobal.viewModes[this.viewMode].e, this.viewDate); - this.fill(); - }, - - _toggle_multidate: function(date){ - var ix = this.dates.contains(date); - if (!date){ - this.dates.clear(); - } - - if (ix !== -1){ - if (this.o.multidate === true || this.o.multidate > 1 || this.o.toggleActive){ - this.dates.remove(ix); - } - } else if (this.o.multidate === false) { - this.dates.clear(); - this.dates.push(date); - } - else { - this.dates.push(date); - } - - if (typeof this.o.multidate === 'number') - while (this.dates.length > this.o.multidate) - this.dates.remove(0); - }, - - _setDate: function(date, which){ - if (!which || which === 'date') - this._toggle_multidate(date && new Date(date)); - if ((!which && this.o.updateViewDate) || which === 'view') - this.viewDate = date && new Date(date); - - this.fill(); - this.setValue(); - if (!which || which !== 'view') { - this._trigger('changeDate'); - } - this.inputField.trigger('change'); - if (this.o.autoclose && (!which || which === 'date')){ - this.hide(); - } - }, - - moveDay: function(date, dir){ - var newDate = new Date(date); - newDate.setUTCDate(date.getUTCDate() + dir); - - return newDate; - }, - - moveWeek: function(date, dir){ - return this.moveDay(date, dir * 7); - }, - - moveMonth: function(date, dir){ - if (!isValidDate(date)) - return this.o.defaultViewDate; - if (!dir) - return date; - var new_date = new Date(date.valueOf()), - day = new_date.getUTCDate(), - month = new_date.getUTCMonth(), - mag = Math.abs(dir), - new_month, test; - dir = dir > 0 ? 1 : -1; - if (mag === 1){ - test = dir === -1 - // If going back one month, make sure month is not current month - // (eg, Mar 31 -> Feb 31 == Feb 28, not Mar 02) - ? function(){ - return new_date.getUTCMonth() === month; - } - // If going forward one month, make sure month is as expected - // (eg, Jan 31 -> Feb 31 == Feb 28, not Mar 02) - : function(){ - return new_date.getUTCMonth() !== new_month; - }; - new_month = month + dir; - new_date.setUTCMonth(new_month); - // Dec -> Jan (12) or Jan -> Dec (-1) -- limit expected date to 0-11 - new_month = (new_month + 12) % 12; - } - else { - // For magnitudes >1, move one month at a time... - for (var i=0; i < mag; i++) - // ...which might decrease the day (eg, Jan 31 to Feb 28, etc)... - new_date = this.moveMonth(new_date, dir); - // ...then reset the day, keeping it in the new month - new_month = new_date.getUTCMonth(); - new_date.setUTCDate(day); - test = function(){ - return new_month !== new_date.getUTCMonth(); - }; - } - // Common date-resetting loop -- if date is beyond end of month, make it - // end of month - while (test()){ - new_date.setUTCDate(--day); - new_date.setUTCMonth(new_month); - } - return new_date; - }, - - moveYear: function(date, dir){ - return this.moveMonth(date, dir*12); - }, - - moveAvailableDate: function(date, dir, fn){ - do { - date = this[fn](date, dir); - - if (!this.dateWithinRange(date)) - return false; - - fn = 'moveDay'; - } - while (this.dateIsDisabled(date)); - - return date; - }, - - weekOfDateIsDisabled: function(date){ - return $.inArray(date.getUTCDay(), this.o.daysOfWeekDisabled) !== -1; - }, - - dateIsDisabled: function(date){ - return ( - this.weekOfDateIsDisabled(date) || - $.grep(this.o.datesDisabled, function(d){ - return isUTCEquals(date, d); - }).length > 0 - ); - }, - - dateWithinRange: function(date){ - return date >= this.o.startDate && date <= this.o.endDate; - }, - - keydown: function(e){ - if (!this.picker.is(':visible')){ - if (e.keyCode === 40 || e.keyCode === 27) { // allow down to re-show picker - this.show(); - e.stopPropagation(); - } - return; - } - var dateChanged = false, - dir, newViewDate, - focusDate = this.focusDate || this.viewDate; - switch (e.keyCode){ - case 27: // escape - if (this.focusDate){ - this.focusDate = null; - this.viewDate = this.dates.get(-1) || this.viewDate; - this.fill(); - } - else - this.hide(); - e.preventDefault(); - e.stopPropagation(); - break; - case 37: // left - case 38: // up - case 39: // right - case 40: // down - if (!this.o.keyboardNavigation || this.o.daysOfWeekDisabled.length === 7) - break; - dir = e.keyCode === 37 || e.keyCode === 38 ? -1 : 1; - if (this.viewMode === 0) { - if (e.ctrlKey){ - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveYear'); - - if (newViewDate) - this._trigger('changeYear', this.viewDate); - } else if (e.shiftKey){ - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveMonth'); - - if (newViewDate) - this._trigger('changeMonth', this.viewDate); - } else if (e.keyCode === 37 || e.keyCode === 39){ - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveDay'); - } else if (!this.weekOfDateIsDisabled(focusDate)){ - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveWeek'); - } - } else if (this.viewMode === 1) { - if (e.keyCode === 38 || e.keyCode === 40) { - dir = dir * 4; - } - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveMonth'); - } else if (this.viewMode === 2) { - if (e.keyCode === 38 || e.keyCode === 40) { - dir = dir * 4; - } - newViewDate = this.moveAvailableDate(focusDate, dir, 'moveYear'); - } - if (newViewDate){ - this.focusDate = this.viewDate = newViewDate; - this.setValue(); - this.fill(); - e.preventDefault(); - } - break; - case 13: // enter - if (!this.o.forceParse) - break; - focusDate = this.focusDate || this.dates.get(-1) || this.viewDate; - if (this.o.keyboardNavigation) { - this._toggle_multidate(focusDate); - dateChanged = true; - } - this.focusDate = null; - this.viewDate = this.dates.get(-1) || this.viewDate; - this.setValue(); - this.fill(); - if (this.picker.is(':visible')){ - e.preventDefault(); - e.stopPropagation(); - if (this.o.autoclose) - this.hide(); - } - break; - case 9: // tab - this.focusDate = null; - this.viewDate = this.dates.get(-1) || this.viewDate; - this.fill(); - this.hide(); - break; - } - if (dateChanged){ - if (this.dates.length) - this._trigger('changeDate'); - else - this._trigger('clearDate'); - this.inputField.trigger('change'); - } - }, - - setViewMode: function(viewMode){ - this.viewMode = viewMode; - this.picker - .children('div') - .hide() - .filter('.datepicker-' + DPGlobal.viewModes[this.viewMode].clsName) - .show(); - this.updateNavArrows(); - this._trigger('changeViewMode', new Date(this.viewDate)); - } - }; - - var DateRangePicker = function(element, options){ - $.data(element, 'datepicker', this); - this.element = $(element); - this.inputs = $.map(options.inputs, function(i){ - return i.jquery ? i[0] : i; - }); - delete options.inputs; - - this.keepEmptyValues = options.keepEmptyValues; - delete options.keepEmptyValues; - - datepickerPlugin.call($(this.inputs), options) - .on('changeDate', $.proxy(this.dateUpdated, this)); - - this.pickers = $.map(this.inputs, function(i){ - return $.data(i, 'datepicker'); - }); - this.updateDates(); - }; - DateRangePicker.prototype = { - updateDates: function(){ - this.dates = $.map(this.pickers, function(i){ - return i.getUTCDate(); - }); - this.updateRanges(); - }, - updateRanges: function(){ - var range = $.map(this.dates, function(d){ - return d.valueOf(); - }); - $.each(this.pickers, function(i, p){ - p.setRange(range); - }); - }, - clearDates: function(){ - $.each(this.pickers, function(i, p){ - p.clearDates(); - }); - }, - dateUpdated: function(e){ - // `this.updating` is a workaround for preventing infinite recursion - // between `changeDate` triggering and `setUTCDate` calling. Until - // there is a better mechanism. - if (this.updating) - return; - this.updating = true; - - var dp = $.data(e.target, 'datepicker'); - - if (dp === undefined) { - return; - } - - var new_date = dp.getUTCDate(), - keep_empty_values = this.keepEmptyValues, - i = $.inArray(e.target, this.inputs), - j = i - 1, - k = i + 1, - l = this.inputs.length; - if (i === -1) - return; - - $.each(this.pickers, function(i, p){ - if (!p.getUTCDate() && (p === dp || !keep_empty_values)) - p.setUTCDate(new_date); - }); - - if (new_date < this.dates[j]){ - // Date being moved earlier/left - while (j >= 0 && new_date < this.dates[j]){ - this.pickers[j--].setUTCDate(new_date); - } - } else if (new_date > this.dates[k]){ - // Date being moved later/right - while (k < l && new_date > this.dates[k]){ - this.pickers[k++].setUTCDate(new_date); - } - } - this.updateDates(); - - delete this.updating; - }, - destroy: function(){ - $.map(this.pickers, function(p){ p.destroy(); }); - $(this.inputs).off('changeDate', this.dateUpdated); - delete this.element.data().datepicker; - }, - remove: alias('destroy', 'Method `remove` is deprecated and will be removed in version 2.0. Use `destroy` instead') - }; - - function opts_from_el(el, prefix){ - // Derive options from element data-attrs - var data = $(el).data(), - out = {}, inkey, - replace = new RegExp('^' + prefix.toLowerCase() + '([A-Z])'); - prefix = new RegExp('^' + prefix.toLowerCase()); - function re_lower(_,a){ - return a.toLowerCase(); - } - for (var key in data) - if (prefix.test(key)){ - inkey = key.replace(replace, re_lower); - out[inkey] = data[key]; - } - return out; - } - - function opts_from_locale(lang){ - // Derive options from locale plugins - var out = {}; - // Check if "de-DE" style date is available, if not language should - // fallback to 2 letter code eg "de" - if (!dates[lang]){ - lang = lang.split('-')[0]; - if (!dates[lang]) - return; - } - var d = dates[lang]; - $.each(locale_opts, function(i,k){ - if (k in d) - out[k] = d[k]; - }); - return out; - } - - var old = $.fn.datepicker; - var datepickerPlugin = function(option){ - var args = Array.apply(null, arguments); - args.shift(); - var internal_return; - this.each(function(){ - var $this = $(this), - data = $this.data('datepicker'), - options = typeof option === 'object' && option; - if (!data){ - var elopts = opts_from_el(this, 'date'), - // Preliminary otions - xopts = $.extend({}, defaults, elopts, options), - locopts = opts_from_locale(xopts.language), - // Options priority: js args, data-attrs, locales, defaults - opts = $.extend({}, defaults, locopts, elopts, options); - if ($this.hasClass('input-daterange') || opts.inputs){ - $.extend(opts, { - inputs: opts.inputs || $this.find('input').toArray() - }); - data = new DateRangePicker(this, opts); - } - else { - data = new Datepicker(this, opts); - } - $this.data('datepicker', data); - } - if (typeof option === 'string' && typeof data[option] === 'function'){ - internal_return = data[option].apply(data, args); - } - }); - - if ( - internal_return === undefined || - internal_return instanceof Datepicker || - internal_return instanceof DateRangePicker - ) - return this; - - if (this.length > 1) - throw new Error('Using only allowed for the collection of a single element (' + option + ' function)'); - else - return internal_return; - }; - $.fn.datepicker = datepickerPlugin; - - var defaults = $.fn.datepicker.defaults = { - assumeNearbyYear: false, - autoclose: false, - beforeShowDay: $.noop, - beforeShowMonth: $.noop, - beforeShowYear: $.noop, - beforeShowDecade: $.noop, - beforeShowCentury: $.noop, - calendarWeeks: false, - clearBtn: false, - toggleActive: false, - daysOfWeekDisabled: [], - daysOfWeekHighlighted: [], - datesDisabled: [], - endDate: Infinity, - forceParse: true, - format: 'mm/dd/yyyy', - keepEmptyValues: false, - keyboardNavigation: true, - language: 'en', - minViewMode: 0, - maxViewMode: 4, - multidate: false, - multidateSeparator: ',', - orientation: "auto", - rtl: false, - startDate: -Infinity, - startView: 0, - todayBtn: false, - todayHighlight: false, - updateViewDate: true, - weekStart: 0, - disableTouchKeyboard: false, - enableOnReadonly: true, - showOnFocus: true, - zIndexOffset: 10, - container: 'body', - immediateUpdates: false, - title: '', - templates: { - leftArrow: '«', - rightArrow: '»' - }, - showWeekDays: true - }; - var locale_opts = $.fn.datepicker.locale_opts = [ - 'format', - 'rtl', - 'weekStart' - ]; - $.fn.datepicker.Constructor = Datepicker; - var dates = $.fn.datepicker.dates = { - en: { - days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], - daysShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], - daysMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], - months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], - monthsShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], - today: "Today", - clear: "Clear", - titleFormat: "MM yyyy" - } - }; - - var DPGlobal = { - viewModes: [ - { - names: ['days', 'month'], - clsName: 'days', - e: 'changeMonth' - }, - { - names: ['months', 'year'], - clsName: 'months', - e: 'changeYear', - navStep: 1 - }, - { - names: ['years', 'decade'], - clsName: 'years', - e: 'changeDecade', - navStep: 10 - }, - { - names: ['decades', 'century'], - clsName: 'decades', - e: 'changeCentury', - navStep: 100 - }, - { - names: ['centuries', 'millennium'], - clsName: 'centuries', - e: 'changeMillennium', - navStep: 1000 - } - ], - validParts: /dd?|DD?|mm?|MM?|yy(?:yy)?/g, - nonpunctuation: /[^ -\/:-@\u5e74\u6708\u65e5\[-`{-~\t\n\r]+/g, - parseFormat: function(format){ - if (typeof format.toValue === 'function' && typeof format.toDisplay === 'function') - return format; - // IE treats \0 as a string end in inputs (truncating the value), - // so it's a bad format delimiter, anyway - var separators = format.replace(this.validParts, '\0').split('\0'), - parts = format.match(this.validParts); - if (!separators || !separators.length || !parts || parts.length === 0){ - throw new Error("Invalid date format."); - } - return {separators: separators, parts: parts}; - }, - parseDate: function(date, format, language, assumeNearby){ - if (!date) - return undefined; - if (date instanceof Date) - return date; - if (typeof format === 'string') - format = DPGlobal.parseFormat(format); - if (format.toValue) - return format.toValue(date, format, language); - var fn_map = { - d: 'moveDay', - m: 'moveMonth', - w: 'moveWeek', - y: 'moveYear' - }, - dateAliases = { - yesterday: '-1d', - today: '+0d', - tomorrow: '+1d' - }, - parts, part, dir, i, fn; - if (date in dateAliases){ - date = dateAliases[date]; - } - if (/^[\-+]\d+[dmwy]([\s,]+[\-+]\d+[dmwy])*$/i.test(date)){ - parts = date.match(/([\-+]\d+)([dmwy])/gi); - date = new Date(); - for (i=0; i < parts.length; i++){ - part = parts[i].match(/([\-+]\d+)([dmwy])/i); - dir = Number(part[1]); - fn = fn_map[part[2].toLowerCase()]; - date = Datepicker.prototype[fn](date, dir); - } - return Datepicker.prototype._zero_utc_time(date); - } - - parts = date && date.match(this.nonpunctuation) || []; - - function applyNearbyYear(year, threshold){ - if (threshold === true) - threshold = 10; - - // if year is 2 digits or less, than the user most likely is trying to get a recent century - if (year < 100){ - year += 2000; - // if the new year is more than threshold years in advance, use last century - if (year > ((new Date()).getFullYear()+threshold)){ - year -= 100; - } - } - - return year; - } - - var parsed = {}, - setters_order = ['yyyy', 'yy', 'M', 'MM', 'm', 'mm', 'd', 'dd'], - setters_map = { - yyyy: function(d,v){ - return d.setUTCFullYear(assumeNearby ? applyNearbyYear(v, assumeNearby) : v); - }, - m: function(d,v){ - if (isNaN(d)) - return d; - v -= 1; - while (v < 0) v += 12; - v %= 12; - d.setUTCMonth(v); - while (d.getUTCMonth() !== v) - d.setUTCDate(d.getUTCDate()-1); - return d; - }, - d: function(d,v){ - return d.setUTCDate(v); - } - }, - val, filtered; - setters_map['yy'] = setters_map['yyyy']; - setters_map['M'] = setters_map['MM'] = setters_map['mm'] = setters_map['m']; - setters_map['dd'] = setters_map['d']; - date = UTCToday(); - var fparts = format.parts.slice(); - // Remove noop parts - if (parts.length !== fparts.length){ - fparts = $(fparts).filter(function(i,p){ - return $.inArray(p, setters_order) !== -1; - }).toArray(); - } - // Process remainder - function match_part(){ - var m = this.slice(0, parts[i].length), - p = parts[i].slice(0, m.length); - return m.toLowerCase() === p.toLowerCase(); - } - if (parts.length === fparts.length){ - var cnt; - for (i=0, cnt = fparts.length; i < cnt; i++){ - val = parseInt(parts[i], 10); - part = fparts[i]; - if (isNaN(val)){ - switch (part){ - case 'MM': - filtered = $(dates[language].months).filter(match_part); - val = $.inArray(filtered[0], dates[language].months) + 1; - break; - case 'M': - filtered = $(dates[language].monthsShort).filter(match_part); - val = $.inArray(filtered[0], dates[language].monthsShort) + 1; - break; - } - } - parsed[part] = val; - } - var _date, s; - for (i=0; i < setters_order.length; i++){ - s = setters_order[i]; - if (s in parsed && !isNaN(parsed[s])){ - _date = new Date(date); - setters_map[s](_date, parsed[s]); - if (!isNaN(_date)) - date = _date; - } - } - } - return date; - }, - formatDate: function(date, format, language){ - if (!date) - return ''; - if (typeof format === 'string') - format = DPGlobal.parseFormat(format); - if (format.toDisplay) - return format.toDisplay(date, format, language); - var val = { - d: date.getUTCDate(), - D: dates[language].daysShort[date.getUTCDay()], - DD: dates[language].days[date.getUTCDay()], - m: date.getUTCMonth() + 1, - M: dates[language].monthsShort[date.getUTCMonth()], - MM: dates[language].months[date.getUTCMonth()], - yy: date.getUTCFullYear().toString().substring(2), - yyyy: date.getUTCFullYear() - }; - val.dd = (val.d < 10 ? '0' : '') + val.d; - val.mm = (val.m < 10 ? '0' : '') + val.m; - date = []; - var seps = $.extend([], format.separators); - for (var i=0, cnt = format.parts.length; i <= cnt; i++){ - if (seps.length) - date.push(seps.shift()); - date.push(val[format.parts[i]]); - } - return date.join(''); - }, - headTemplate: ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - '', - contTemplate: '', - footTemplate: ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - ''+ - '' - }; - DPGlobal.template = '
    '+ - '
    '+ - '
    Time
     '+dates[this.o.language].daysMin[(dowCnt++)%7]+'
    '+ calWeek +'' + content + '
    '+defaults.templates.leftArrow+''+defaults.templates.rightArrow+'
    '+ - DPGlobal.headTemplate+ - ''+ - DPGlobal.footTemplate+ - '
    '+ - '
    '+ - '
    '+ - ''+ - DPGlobal.headTemplate+ - DPGlobal.contTemplate+ - DPGlobal.footTemplate+ - '
    '+ - '
    '+ - '
    '+ - ''+ - DPGlobal.headTemplate+ - DPGlobal.contTemplate+ - DPGlobal.footTemplate+ - '
    '+ - '
    '+ - '
    '+ - ''+ - DPGlobal.headTemplate+ - DPGlobal.contTemplate+ - DPGlobal.footTemplate+ - '
    '+ - '
    '+ - '
    '+ - ''+ - DPGlobal.headTemplate+ - DPGlobal.contTemplate+ - DPGlobal.footTemplate+ - '
    '+ - '
    '+ - '
    '; - - $.fn.datepicker.DPGlobal = DPGlobal; - - - /* DATEPICKER NO CONFLICT - * =================== */ - - $.fn.datepicker.noConflict = function(){ - $.fn.datepicker = old; - return this; - }; - - /* DATEPICKER VERSION - * =================== */ - $.fn.datepicker.version = '1.9.0'; - - $.fn.datepicker.deprecated = function(msg){ - var console = window.console; - if (console && console.warn) { - console.warn('DEPRECATED: ' + msg); - } - }; - - - /* DATEPICKER DATA-API - * ================== */ - - $(document).on( - 'focus.datepicker.data-api click.datepicker.data-api', - '[data-provide="datepicker"]', - function(e){ - var $this = $(this); - if ($this.data('datepicker')) - return; - e.preventDefault(); - // component click requires us to explicitly show it - datepickerPlugin.call($this, 'show'); - } - ); - $(function(){ - datepickerPlugin.call($('[data-provide="datepicker-inline"]')); - }); - -})); diff --git a/NEMO/static/datetimepicker/bootstrap-datepicker3.css b/NEMO/static/datetimepicker/bootstrap-datepicker3.css deleted file mode 100644 index a98157c2..00000000 --- a/NEMO/static/datetimepicker/bootstrap-datepicker3.css +++ /dev/null @@ -1,683 +0,0 @@ -/*! - * Datepicker for Bootstrap v1.9.0 (https://github.com/uxsolutions/bootstrap-datepicker) - * - * Licensed under the Apache License v2.0 (http://www.apache.org/licenses/LICENSE-2.0) - */ - -.datepicker { - border-radius: 4px; - direction: ltr; -} -.datepicker-inline { - width: 220px; -} -.datepicker-rtl { - direction: rtl; -} -.datepicker-rtl.dropdown-menu { - left: auto; -} -.datepicker-rtl table tr td span { - float: right; -} -.datepicker-dropdown { - top: 0; - left: 0; - padding: 4px; -} -.datepicker-dropdown:before { - content: ''; - display: inline-block; - border-left: 7px solid transparent; - border-right: 7px solid transparent; - border-bottom: 7px solid rgba(0, 0, 0, 0.15); - border-top: 0; - border-bottom-color: rgba(0, 0, 0, 0.2); - position: absolute; -} -.datepicker-dropdown:after { - content: ''; - display: inline-block; - border-left: 6px solid transparent; - border-right: 6px solid transparent; - border-bottom: 6px solid #fff; - border-top: 0; - position: absolute; -} -.datepicker-dropdown.datepicker-orient-left:before { - left: 6px; -} -.datepicker-dropdown.datepicker-orient-left:after { - left: 7px; -} -.datepicker-dropdown.datepicker-orient-right:before { - right: 6px; -} -.datepicker-dropdown.datepicker-orient-right:after { - right: 7px; -} -.datepicker-dropdown.datepicker-orient-bottom:before { - top: -7px; -} -.datepicker-dropdown.datepicker-orient-bottom:after { - top: -6px; -} -.datepicker-dropdown.datepicker-orient-top:before { - bottom: -7px; - border-bottom: 0; - border-top: 7px solid rgba(0, 0, 0, 0.15); -} -.datepicker-dropdown.datepicker-orient-top:after { - bottom: -6px; - border-bottom: 0; - border-top: 6px solid #fff; -} -.datepicker table { - margin: 0; - -webkit-touch-callout: none; - -webkit-user-select: none; - -khtml-user-select: none; - -moz-user-select: none; - -ms-user-select: none; - user-select: none; -} -.datepicker table tr td, -.datepicker table tr th { - text-align: center; - width: 30px; - height: 30px; - border-radius: 4px; - border: none; -} -.table-striped .datepicker table tr td, -.table-striped .datepicker table tr th { - background-color: transparent; -} -.datepicker table tr td.old, -.datepicker table tr td.new { - color: #777777; -} -.datepicker table tr td.day:hover, -.datepicker table tr td.focused { - background: #eeeeee; - cursor: pointer; -} -.datepicker table tr td.disabled, -.datepicker table tr td.disabled:hover { - background: none; - color: #777777; - cursor: default; -} -.datepicker table tr td.highlighted { - color: #000; - background-color: #d9edf7; - border-color: #85c5e5; - border-radius: 0; -} -.datepicker table tr td.highlighted:focus, -.datepicker table tr td.highlighted.focus { - color: #000; - background-color: #afd9ee; - border-color: #298fc2; -} -.datepicker table tr td.highlighted:hover { - color: #000; - background-color: #afd9ee; - border-color: #52addb; -} -.datepicker table tr td.highlighted:active, -.datepicker table tr td.highlighted.active { - color: #000; - background-color: #afd9ee; - border-color: #52addb; -} -.datepicker table tr td.highlighted:active:hover, -.datepicker table tr td.highlighted.active:hover, -.datepicker table tr td.highlighted:active:focus, -.datepicker table tr td.highlighted.active:focus, -.datepicker table tr td.highlighted:active.focus, -.datepicker table tr td.highlighted.active.focus { - color: #000; - background-color: #91cbe8; - border-color: #298fc2; -} -.datepicker table tr td.highlighted.disabled:hover, -.datepicker table tr td.highlighted[disabled]:hover, -fieldset[disabled] .datepicker table tr td.highlighted:hover, -.datepicker table tr td.highlighted.disabled:focus, -.datepicker table tr td.highlighted[disabled]:focus, -fieldset[disabled] .datepicker table tr td.highlighted:focus, -.datepicker table tr td.highlighted.disabled.focus, -.datepicker table tr td.highlighted[disabled].focus, -fieldset[disabled] .datepicker table tr td.highlighted.focus { - background-color: #d9edf7; - border-color: #85c5e5; -} -.datepicker table tr td.highlighted.focused { - background: #afd9ee; -} -.datepicker table tr td.highlighted.disabled, -.datepicker table tr td.highlighted.disabled:active { - background: #d9edf7; - color: #777777; -} -.datepicker table tr td.today { - color: #000; - background-color: #ffdb99; - border-color: #ffb733; -} -.datepicker table tr td.today:focus, -.datepicker table tr td.today.focus { - color: #000; - background-color: #ffc966; - border-color: #b37400; -} -.datepicker table tr td.today:hover { - color: #000; - background-color: #ffc966; - border-color: #f59e00; -} -.datepicker table tr td.today:active, -.datepicker table tr td.today.active { - color: #000; - background-color: #ffc966; - border-color: #f59e00; -} -.datepicker table tr td.today:active:hover, -.datepicker table tr td.today.active:hover, -.datepicker table tr td.today:active:focus, -.datepicker table tr td.today.active:focus, -.datepicker table tr td.today:active.focus, -.datepicker table tr td.today.active.focus { - color: #000; - background-color: #ffbc42; - border-color: #b37400; -} -.datepicker table tr td.today.disabled:hover, -.datepicker table tr td.today[disabled]:hover, -fieldset[disabled] .datepicker table tr td.today:hover, -.datepicker table tr td.today.disabled:focus, -.datepicker table tr td.today[disabled]:focus, -fieldset[disabled] .datepicker table tr td.today:focus, -.datepicker table tr td.today.disabled.focus, -.datepicker table tr td.today[disabled].focus, -fieldset[disabled] .datepicker table tr td.today.focus { - background-color: #ffdb99; - border-color: #ffb733; -} -.datepicker table tr td.today.focused { - background: #ffc966; -} -.datepicker table tr td.today.disabled, -.datepicker table tr td.today.disabled:active { - background: #ffdb99; - color: #777777; -} -.datepicker table tr td.range { - color: #000; - background-color: #eeeeee; - border-color: #bbbbbb; - border-radius: 0; -} -.datepicker table tr td.range:focus, -.datepicker table tr td.range.focus { - color: #000; - background-color: #d5d5d5; - border-color: #7c7c7c; -} -.datepicker table tr td.range:hover { - color: #000; - background-color: #d5d5d5; - border-color: #9d9d9d; -} -.datepicker table tr td.range:active, -.datepicker table tr td.range.active { - color: #000; - background-color: #d5d5d5; - border-color: #9d9d9d; -} -.datepicker table tr td.range:active:hover, -.datepicker table tr td.range.active:hover, -.datepicker table tr td.range:active:focus, -.datepicker table tr td.range.active:focus, -.datepicker table tr td.range:active.focus, -.datepicker table tr td.range.active.focus { - color: #000; - background-color: #c3c3c3; - border-color: #7c7c7c; -} -.datepicker table tr td.range.disabled:hover, -.datepicker table tr td.range[disabled]:hover, -fieldset[disabled] .datepicker table tr td.range:hover, -.datepicker table tr td.range.disabled:focus, -.datepicker table tr td.range[disabled]:focus, -fieldset[disabled] .datepicker table tr td.range:focus, -.datepicker table tr td.range.disabled.focus, -.datepicker table tr td.range[disabled].focus, -fieldset[disabled] .datepicker table tr td.range.focus { - background-color: #eeeeee; - border-color: #bbbbbb; -} -.datepicker table tr td.range.focused { - background: #d5d5d5; -} -.datepicker table tr td.range.disabled, -.datepicker table tr td.range.disabled:active { - background: #eeeeee; - color: #777777; -} -.datepicker table tr td.range.highlighted { - color: #000; - background-color: #e4eef3; - border-color: #9dc1d3; -} -.datepicker table tr td.range.highlighted:focus, -.datepicker table tr td.range.highlighted.focus { - color: #000; - background-color: #c1d7e3; - border-color: #4b88a6; -} -.datepicker table tr td.range.highlighted:hover { - color: #000; - background-color: #c1d7e3; - border-color: #73a6c0; -} -.datepicker table tr td.range.highlighted:active, -.datepicker table tr td.range.highlighted.active { - color: #000; - background-color: #c1d7e3; - border-color: #73a6c0; -} -.datepicker table tr td.range.highlighted:active:hover, -.datepicker table tr td.range.highlighted.active:hover, -.datepicker table tr td.range.highlighted:active:focus, -.datepicker table tr td.range.highlighted.active:focus, -.datepicker table tr td.range.highlighted:active.focus, -.datepicker table tr td.range.highlighted.active.focus { - color: #000; - background-color: #a8c8d8; - border-color: #4b88a6; -} -.datepicker table tr td.range.highlighted.disabled:hover, -.datepicker table tr td.range.highlighted[disabled]:hover, -fieldset[disabled] .datepicker table tr td.range.highlighted:hover, -.datepicker table tr td.range.highlighted.disabled:focus, -.datepicker table tr td.range.highlighted[disabled]:focus, -fieldset[disabled] .datepicker table tr td.range.highlighted:focus, -.datepicker table tr td.range.highlighted.disabled.focus, -.datepicker table tr td.range.highlighted[disabled].focus, -fieldset[disabled] .datepicker table tr td.range.highlighted.focus { - background-color: #e4eef3; - border-color: #9dc1d3; -} -.datepicker table tr td.range.highlighted.focused { - background: #c1d7e3; -} -.datepicker table tr td.range.highlighted.disabled, -.datepicker table tr td.range.highlighted.disabled:active { - background: #e4eef3; - color: #777777; -} -.datepicker table tr td.range.today { - color: #000; - background-color: #f7ca77; - border-color: #f1a417; -} -.datepicker table tr td.range.today:focus, -.datepicker table tr td.range.today.focus { - color: #000; - background-color: #f4b747; - border-color: #815608; -} -.datepicker table tr td.range.today:hover { - color: #000; - background-color: #f4b747; - border-color: #bf800c; -} -.datepicker table tr td.range.today:active, -.datepicker table tr td.range.today.active { - color: #000; - background-color: #f4b747; - border-color: #bf800c; -} -.datepicker table tr td.range.today:active:hover, -.datepicker table tr td.range.today.active:hover, -.datepicker table tr td.range.today:active:focus, -.datepicker table tr td.range.today.active:focus, -.datepicker table tr td.range.today:active.focus, -.datepicker table tr td.range.today.active.focus { - color: #000; - background-color: #f2aa25; - border-color: #815608; -} -.datepicker table tr td.range.today.disabled:hover, -.datepicker table tr td.range.today[disabled]:hover, -fieldset[disabled] .datepicker table tr td.range.today:hover, -.datepicker table tr td.range.today.disabled:focus, -.datepicker table tr td.range.today[disabled]:focus, -fieldset[disabled] .datepicker table tr td.range.today:focus, -.datepicker table tr td.range.today.disabled.focus, -.datepicker table tr td.range.today[disabled].focus, -fieldset[disabled] .datepicker table tr td.range.today.focus { - background-color: #f7ca77; - border-color: #f1a417; -} -.datepicker table tr td.range.today.disabled, -.datepicker table tr td.range.today.disabled:active { - background: #f7ca77; - color: #777777; -} -.datepicker table tr td.selected, -.datepicker table tr td.selected.highlighted { - color: #fff; - background-color: #777777; - border-color: #555555; - text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25); -} -.datepicker table tr td.selected:focus, -.datepicker table tr td.selected.highlighted:focus, -.datepicker table tr td.selected.focus, -.datepicker table tr td.selected.highlighted.focus { - color: #fff; - background-color: #5e5e5e; - border-color: #161616; -} -.datepicker table tr td.selected:hover, -.datepicker table tr td.selected.highlighted:hover { - color: #fff; - background-color: #5e5e5e; - border-color: #373737; -} -.datepicker table tr td.selected:active, -.datepicker table tr td.selected.highlighted:active, -.datepicker table tr td.selected.active, -.datepicker table tr td.selected.highlighted.active { - color: #fff; - background-color: #5e5e5e; - border-color: #373737; -} -.datepicker table tr td.selected:active:hover, -.datepicker table tr td.selected.highlighted:active:hover, -.datepicker table tr td.selected.active:hover, -.datepicker table tr td.selected.highlighted.active:hover, -.datepicker table tr td.selected:active:focus, -.datepicker table tr td.selected.highlighted:active:focus, -.datepicker table tr td.selected.active:focus, -.datepicker table tr td.selected.highlighted.active:focus, -.datepicker table tr td.selected:active.focus, -.datepicker table tr td.selected.highlighted:active.focus, -.datepicker table tr td.selected.active.focus, -.datepicker table tr td.selected.highlighted.active.focus { - color: #fff; - background-color: #4c4c4c; - border-color: #161616; -} -.datepicker table tr td.selected.disabled:hover, -.datepicker table tr td.selected.highlighted.disabled:hover, -.datepicker table tr td.selected[disabled]:hover, -.datepicker table tr td.selected.highlighted[disabled]:hover, -fieldset[disabled] .datepicker table tr td.selected:hover, -fieldset[disabled] .datepicker table tr td.selected.highlighted:hover, -.datepicker table tr td.selected.disabled:focus, -.datepicker table tr td.selected.highlighted.disabled:focus, -.datepicker table tr td.selected[disabled]:focus, -.datepicker table tr td.selected.highlighted[disabled]:focus, -fieldset[disabled] .datepicker table tr td.selected:focus, -fieldset[disabled] .datepicker table tr td.selected.highlighted:focus, -.datepicker table tr td.selected.disabled.focus, -.datepicker table tr td.selected.highlighted.disabled.focus, -.datepicker table tr td.selected[disabled].focus, -.datepicker table tr td.selected.highlighted[disabled].focus, -fieldset[disabled] .datepicker table tr td.selected.focus, -fieldset[disabled] .datepicker table tr td.selected.highlighted.focus { - background-color: #777777; - border-color: #555555; -} -.datepicker table tr td.active, -.datepicker table tr td.active.highlighted { - color: #fff; - background-color: #337ab7; - border-color: #2e6da4; - text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25); -} -.datepicker table tr td.active:focus, -.datepicker table tr td.active.highlighted:focus, -.datepicker table tr td.active.focus, -.datepicker table tr td.active.highlighted.focus { - color: #fff; - background-color: #286090; - border-color: #122b40; -} -.datepicker table tr td.active:hover, -.datepicker table tr td.active.highlighted:hover { - color: #fff; - background-color: #286090; - border-color: #204d74; -} -.datepicker table tr td.active:active, -.datepicker table tr td.active.highlighted:active, -.datepicker table tr td.active.active, -.datepicker table tr td.active.highlighted.active { - color: #fff; - background-color: #286090; - border-color: #204d74; -} -.datepicker table tr td.active:active:hover, -.datepicker table tr td.active.highlighted:active:hover, -.datepicker table tr td.active.active:hover, -.datepicker table tr td.active.highlighted.active:hover, -.datepicker table tr td.active:active:focus, -.datepicker table tr td.active.highlighted:active:focus, -.datepicker table tr td.active.active:focus, -.datepicker table tr td.active.highlighted.active:focus, -.datepicker table tr td.active:active.focus, -.datepicker table tr td.active.highlighted:active.focus, -.datepicker table tr td.active.active.focus, -.datepicker table tr td.active.highlighted.active.focus { - color: #fff; - background-color: #204d74; - border-color: #122b40; -} -.datepicker table tr td.active.disabled:hover, -.datepicker table tr td.active.highlighted.disabled:hover, -.datepicker table tr td.active[disabled]:hover, -.datepicker table tr td.active.highlighted[disabled]:hover, -fieldset[disabled] .datepicker table tr td.active:hover, -fieldset[disabled] .datepicker table tr td.active.highlighted:hover, -.datepicker table tr td.active.disabled:focus, -.datepicker table tr td.active.highlighted.disabled:focus, -.datepicker table tr td.active[disabled]:focus, -.datepicker table tr td.active.highlighted[disabled]:focus, -fieldset[disabled] .datepicker table tr td.active:focus, -fieldset[disabled] .datepicker table tr td.active.highlighted:focus, -.datepicker table tr td.active.disabled.focus, -.datepicker table tr td.active.highlighted.disabled.focus, -.datepicker table tr td.active[disabled].focus, -.datepicker table tr td.active.highlighted[disabled].focus, -fieldset[disabled] .datepicker table tr td.active.focus, -fieldset[disabled] .datepicker table tr td.active.highlighted.focus { - background-color: #337ab7; - border-color: #2e6da4; -} -.datepicker table tr td span { - display: block; - width: 23%; - height: 54px; - line-height: 54px; - float: left; - margin: 1%; - cursor: pointer; - border-radius: 4px; -} -.datepicker table tr td span:hover, -.datepicker table tr td span.focused { - background: #eeeeee; -} -.datepicker table tr td span.disabled, -.datepicker table tr td span.disabled:hover { - background: none; - color: #777777; - cursor: default; -} -.datepicker table tr td span.active, -.datepicker table tr td span.active:hover, -.datepicker table tr td span.active.disabled, -.datepicker table tr td span.active.disabled:hover { - color: #fff; - background-color: #337ab7; - border-color: #2e6da4; - text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25); -} -.datepicker table tr td span.active:focus, -.datepicker table tr td span.active:hover:focus, -.datepicker table tr td span.active.disabled:focus, -.datepicker table tr td span.active.disabled:hover:focus, -.datepicker table tr td span.active.focus, -.datepicker table tr td span.active:hover.focus, -.datepicker table tr td span.active.disabled.focus, -.datepicker table tr td span.active.disabled:hover.focus { - color: #fff; - background-color: #286090; - border-color: #122b40; -} -.datepicker table tr td span.active:hover, -.datepicker table tr td span.active:hover:hover, -.datepicker table tr td span.active.disabled:hover, -.datepicker table tr td span.active.disabled:hover:hover { - color: #fff; - background-color: #286090; - border-color: #204d74; -} -.datepicker table tr td span.active:active, -.datepicker table tr td span.active:hover:active, -.datepicker table tr td span.active.disabled:active, -.datepicker table tr td span.active.disabled:hover:active, -.datepicker table tr td span.active.active, -.datepicker table tr td span.active:hover.active, -.datepicker table tr td span.active.disabled.active, -.datepicker table tr td span.active.disabled:hover.active { - color: #fff; - background-color: #286090; - border-color: #204d74; -} -.datepicker table tr td span.active:active:hover, -.datepicker table tr td span.active:hover:active:hover, -.datepicker table tr td span.active.disabled:active:hover, -.datepicker table tr td span.active.disabled:hover:active:hover, -.datepicker table tr td span.active.active:hover, -.datepicker table tr td span.active:hover.active:hover, -.datepicker table tr td span.active.disabled.active:hover, -.datepicker table tr td span.active.disabled:hover.active:hover, -.datepicker table tr td span.active:active:focus, -.datepicker table tr td span.active:hover:active:focus, -.datepicker table tr td span.active.disabled:active:focus, -.datepicker table tr td span.active.disabled:hover:active:focus, -.datepicker table tr td span.active.active:focus, -.datepicker table tr td span.active:hover.active:focus, -.datepicker table tr td span.active.disabled.active:focus, -.datepicker table tr td span.active.disabled:hover.active:focus, -.datepicker table tr td span.active:active.focus, -.datepicker table tr td span.active:hover:active.focus, -.datepicker table tr td span.active.disabled:active.focus, -.datepicker table tr td span.active.disabled:hover:active.focus, -.datepicker table tr td span.active.active.focus, -.datepicker table tr td span.active:hover.active.focus, -.datepicker table tr td span.active.disabled.active.focus, -.datepicker table tr td span.active.disabled:hover.active.focus { - color: #fff; - background-color: #204d74; - border-color: #122b40; -} -.datepicker table tr td span.active.disabled:hover, -.datepicker table tr td span.active:hover.disabled:hover, -.datepicker table tr td span.active.disabled.disabled:hover, -.datepicker table tr td span.active.disabled:hover.disabled:hover, -.datepicker table tr td span.active[disabled]:hover, -.datepicker table tr td span.active:hover[disabled]:hover, -.datepicker table tr td span.active.disabled[disabled]:hover, -.datepicker table tr td span.active.disabled:hover[disabled]:hover, -fieldset[disabled] .datepicker table tr td span.active:hover, -fieldset[disabled] .datepicker table tr td span.active:hover:hover, -fieldset[disabled] .datepicker table tr td span.active.disabled:hover, -fieldset[disabled] .datepicker table tr td span.active.disabled:hover:hover, -.datepicker table tr td span.active.disabled:focus, -.datepicker table tr td span.active:hover.disabled:focus, -.datepicker table tr td span.active.disabled.disabled:focus, -.datepicker table tr td span.active.disabled:hover.disabled:focus, -.datepicker table tr td span.active[disabled]:focus, -.datepicker table tr td span.active:hover[disabled]:focus, -.datepicker table tr td span.active.disabled[disabled]:focus, -.datepicker table tr td span.active.disabled:hover[disabled]:focus, -fieldset[disabled] .datepicker table tr td span.active:focus, -fieldset[disabled] .datepicker table tr td span.active:hover:focus, -fieldset[disabled] .datepicker table tr td span.active.disabled:focus, -fieldset[disabled] .datepicker table tr td span.active.disabled:hover:focus, -.datepicker table tr td span.active.disabled.focus, -.datepicker table tr td span.active:hover.disabled.focus, -.datepicker table tr td span.active.disabled.disabled.focus, -.datepicker table tr td span.active.disabled:hover.disabled.focus, -.datepicker table tr td span.active[disabled].focus, -.datepicker table tr td span.active:hover[disabled].focus, -.datepicker table tr td span.active.disabled[disabled].focus, -.datepicker table tr td span.active.disabled:hover[disabled].focus, -fieldset[disabled] .datepicker table tr td span.active.focus, -fieldset[disabled] .datepicker table tr td span.active:hover.focus, -fieldset[disabled] .datepicker table tr td span.active.disabled.focus, -fieldset[disabled] .datepicker table tr td span.active.disabled:hover.focus { - background-color: #337ab7; - border-color: #2e6da4; -} -.datepicker table tr td span.old, -.datepicker table tr td span.new { - color: #777777; -} -.datepicker .datepicker-switch { - width: 145px; -} -.datepicker .datepicker-switch, -.datepicker .prev, -.datepicker .next, -.datepicker tfoot tr th { - cursor: pointer; -} -.datepicker .datepicker-switch:hover, -.datepicker .prev:hover, -.datepicker .next:hover, -.datepicker tfoot tr th:hover { - background: #eeeeee; -} -.datepicker .prev.disabled, -.datepicker .next.disabled { - visibility: hidden; -} -.datepicker .cw { - font-size: 10px; - width: 12px; - padding: 0 2px 0 5px; - vertical-align: middle; -} -.input-group.date .input-group-addon { - cursor: pointer; -} -.input-daterange { - width: 100%; -} -.input-daterange input { - text-align: center; -} -.input-daterange input:first-child { - border-radius: 3px 0 0 3px; -} -.input-daterange input:last-child { - border-radius: 0 3px 3px 0; -} -.input-daterange .input-group-addon { - width: auto; - min-width: 16px; - padding: 4px 5px; - line-height: 1.42857143; - border-width: 1px 0; - margin-left: -5px; - margin-right: -5px; -} -/*# sourceMappingURL=bootstrap-datepicker3.css.map */ \ No newline at end of file diff --git a/NEMO/static/numpad/custom_numpad.jquery.js b/NEMO/static/numpad/custom_numpad.jquery.js index 853b173c..a24a4bac 100644 --- a/NEMO/static/numpad/custom_numpad.jquery.js +++ b/NEMO/static/numpad/custom_numpad.jquery.js @@ -11,7 +11,7 @@ * * Version: 1.4 * - * !!!!! Added readonly as option and boostrap style !!!!! + * !!!!! Added readonly as option and bootstrap style !!!!! */ (function($){ diff --git a/NEMO/templates/area_access/area_access.html b/NEMO/templates/area_access/area_access.html index 4d462550..d986c1cb 100644 --- a/NEMO/templates/area_access/area_access.html +++ b/NEMO/templates/area_access/area_access.html @@ -1,4 +1,5 @@ {% extends 'base.html' %} +{% load custom_tags_and_filters %} {% block title %}Area access{% endblock %} {% block extrahead %} {% load static %} @@ -19,12 +20,12 @@

    Area access

    - +
    - +
    @@ -66,7 +67,7 @@

    Area access

    {% else %} {% if start or end %} - No access records exist between {{ start }} and {{ end }}. + No access records exist {% if start and end %}between {{ start }} and {{ end }}{% elif start %}after {{ start }}{% else %}before {{ end }}{% endif %}. {% endif %} {% endif %}
    @@ -75,7 +76,7 @@

    Area access

    { var timepicker_properties = { - format: 'MM/DD/YYYY' + format: '{{ date_input_js_format }}' }; $('#start').datetimepicker(timepicker_properties); $('#end').datetimepicker(timepicker_properties); diff --git a/NEMO/templates/calendar/scheduled_outage_information.html b/NEMO/templates/calendar/scheduled_outage_information.html index ab181c94..3fc17c48 100644 --- a/NEMO/templates/calendar/scheduled_outage_information.html +++ b/NEMO/templates/calendar/scheduled_outage_information.html @@ -1,7 +1,8 @@ +{% load static %} +{% load custom_tags_and_filters %} {% block extrahead %} - {% load static %} - - + + {% endblock %}
    @@ -73,5 +74,5 @@

    Schedule an outage

    \ No newline at end of file diff --git a/NEMO/templates/remote_work.html b/NEMO/templates/remote_work.html index 48899f85..fb3a1afe 100644 --- a/NEMO/templates/remote_work.html +++ b/NEMO/templates/remote_work.html @@ -1,5 +1,6 @@ {% extends 'base.html' %} {% load static %} +{% load custom_tags_and_filters %} {% block title %}Remote work{% endblock %} {% block extrahead %} @@ -56,13 +57,13 @@

    Remote work

    - +
    - +
    @@ -111,6 +112,12 @@

    Staff charges

    {{ area_access_record.end|default_if_none:'' }} {% endfor %} + {% empty %} + + {% if start_date or end_date %} + No staff charges exist {% if start_date and end_date %}between {{ start_date }} and {{ end_date }}{% elif start_date %}after {{ start_date }}{% else %}before {{ end_date }}{% endif %}. + {% endif %} + {% endfor %} @@ -141,11 +148,19 @@

    Tool usage

    {{ u.tool }} {% if not u.validated %}{% endif %} + {% empty %} + + {% if start_date or end_date %} + No tool usage exist {% if start_date and end_date %}between {{ start_date }} and {{ end_date }}{% elif start_date %}after {{ start_date }}{% else %}before {{ end_date }}{% endif %}. + {% endif %} + {% endfor %} {% endblock %} \ No newline at end of file diff --git a/NEMO/templates/usage/usage_base.html b/NEMO/templates/usage/usage_base.html index 0497d651..b6287649 100644 --- a/NEMO/templates/usage/usage_base.html +++ b/NEMO/templates/usage/usage_base.html @@ -31,13 +31,13 @@

    Usage{% if billing_service %} and billing information{% endif %}

    - +
    - +
    {% if pi_projects %}
    @@ -69,16 +69,18 @@

    Usage{% if billing_service %} and billing information{% endif %} From eaf7aa04a036909386f1e2928b798b50c15f4a1b Mon Sep 17 00:00:00 2001 From: mrampant Date: Fri, 13 May 2022 12:53:25 -0400 Subject: [PATCH 54/82] - fixed some wrong js conditions. evaluating if ('{{ var }}') will turn into if ("None") which is true. add default_if_none to solve the issue --- .../templates/kiosk/tool_reservation.html | 24 +++++++++---------- NEMO/templates/mobile/new_reservation.html | 2 +- NEMO/templates/remote_work.html | 2 +- NEMO/templates/usage/usage_base.html | 2 +- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/NEMO/apps/kiosk/templates/kiosk/tool_reservation.html b/NEMO/apps/kiosk/templates/kiosk/tool_reservation.html index e9f01d2d..336fedb9 100644 --- a/NEMO/apps/kiosk/templates/kiosk/tool_reservation.html +++ b/NEMO/apps/kiosk/templates/kiosk/tool_reservation.html @@ -54,15 +54,15 @@

    When would you like to reserve the {{ tool }}?