From 6f7f72f784c8052ead32a3c26c9b96cc1a78d9f2 Mon Sep 17 00:00:00 2001 From: wumode Date: Tue, 17 Jun 2025 15:19:39 +0800 Subject: [PATCH] =?UTF-8?q?update(ClashRuleProvider):=20=E6=94=AF=E6=8C=81?= =?UTF-8?q?:=20=E8=A7=84=E5=88=99=E5=88=86=E9=A1=B5;=20=E5=AF=BC=E5=85=A5?= =?UTF-8?q?=E8=A7=84=E5=88=99;=20=E4=BB=A3=E7=90=86=E7=BB=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- package.v2.json | 5 +- plugins.v2/clashruleprovider/__init__.py | 393 +- .../clashruleprovider/clash_rule_parser.py | 105 +- plugins.v2/clashruleprovider/countries.json | 2485 + .../__federation_expose_Config-C3BpNVeC.js | 828 - .../__federation_expose_Config-DXzIavcD.css | 5 - .../__federation_expose_Dashboard-BkyO-3pr.js | 40514 ---------------- .../__federation_expose_Page-Bl7XNZ7k.css | 48 - .../__federation_expose_Page-DlQgf7u6.js | 1118 - .../dist/assets/remoteEntry.js | 10 +- 10 files changed, 2927 insertions(+), 42584 deletions(-) create mode 100755 plugins.v2/clashruleprovider/countries.json delete mode 100644 plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-C3BpNVeC.js delete mode 100644 plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-DXzIavcD.css delete mode 100644 plugins.v2/clashruleprovider/dist/assets/__federation_expose_Dashboard-BkyO-3pr.js delete mode 100644 plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-Bl7XNZ7k.css delete mode 100644 plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-DlQgf7u6.js diff --git a/package.v2.json b/package.v2.json index f3cb7fb..96250d2 100644 --- a/package.v2.json +++ b/package.v2.json @@ -446,12 +446,13 @@ "name": "Clash Rule Provider", "description": "随时为Clash添加一些额外的规则。", "labels": "工具", - "version": "0.1.0", + "version": "1.0.0", "icon": "Mihomo_Meta_A.png", "author": "wumode", "level": 1, "history": { - "v0.1.0": "新增ClashRuleProvider" + "v0.1.0": "新增ClashRuleProvider", + "v1.0.0": "支持: 规则分页; 导入规则; 代理组; 附加出站代理; 按区域分组" } }, "LexiAnnot": { diff --git a/plugins.v2/clashruleprovider/__init__.py b/plugins.v2/clashruleprovider/__init__.py index 97485e1..31aa35a 100644 --- a/plugins.v2/clashruleprovider/__init__.py +++ b/plugins.v2/clashruleprovider/__init__.py @@ -1,23 +1,27 @@ -import hashlib +import json import re -import time -from datetime import datetime, timedelta from typing import Any, Optional, List, Dict, Tuple, Union - -import pytz +import time import yaml +import hashlib +from fastapi import Body, Response +from datetime import datetime, timedelta +import pytz +import copy +import math + from apscheduler.schedulers.background import BackgroundScheduler from apscheduler.triggers.cron import CronTrigger -from fastapi import Body, Response +from app import schemas from app.core.config import settings -from app.core.event import eventmanager from app.log import logger from app.plugins import _PluginBase -from app.plugins.clashruleprovider.clash_rule_parser import Action, RuleType, ClashRule, MatchRule, LogicRule -from app.plugins.clashruleprovider.clash_rule_parser import ClashRuleParser -from app.schemas.types import EventType +from app.schemas.types import EventType, NotificationType from app.utils.http import RequestUtils +from app.plugins.clashruleprovider.clash_rule_parser import ClashRuleParser +from app.plugins.clashruleprovider.clash_rule_parser import Action, RuleType, ClashRule, MatchRule, LogicRule +from app.plugins.clashruleprovider.clash_rule_parser import ProxyGroupValidator class ClashRuleProvider(_PluginBase): @@ -26,10 +30,9 @@ class ClashRuleProvider(_PluginBase): # 插件描述 plugin_desc = "随时为Clash添加一些额外的规则。" # 插件图标 - plugin_icon = ("https://raw.githubusercontent.com/wumode/MoviePilot-Plugins/" - "refs/heads/imdbsource_assets/icons/Mihomo_Meta_A.png") + plugin_icon = "Mihomo_Meta_A.png" # 插件版本 - plugin_version = "0.1.0" + plugin_version = "1.0.0" # 插件作者 plugin_author = "wumode" # 作者主页 @@ -53,13 +56,14 @@ class ClashRuleProvider(_PluginBase): # Clash 面板密钥 _clash_dashboard_secret = None # MoviePilot URL - _movie_pilot_url = None + _movie_pilot_url = '' _cron = '' _timeout = 10 _retry_times = 3 _filter_keywords = [] _auto_update_subscriptions = True _ruleset_prefix = '📂<-' + _group_by_region = False # 插件数据 _clash_config = None @@ -68,17 +72,23 @@ class ClashRuleProvider(_PluginBase): _rule_provider: Dict[str, Any] = {} _subscription_info = {} _ruleset_names: Dict[str, str] = {} + _proxy_groups = [] + _extra_proxies = [] # protected variables _clash_rule_parser = None _ruleset_rule_parser = None _custom_rule_sets = None _scheduler: Optional[BackgroundScheduler] = None + _countries: Optional[List[Dict[str, str]]] = None + _proxy_groups_by_region: List[Dict[str, Any]] = [] def init_plugin(self, config: dict = None): self._clash_config = self.get_data("clash_config") self._ruleset_rules = self.get_data("ruleset_rules") self._top_rules = self.get_data("top_rules") + self._proxy_groups = self.get_data("proxy_groups") or [] + self._extra_proxies = self.get_data("extra_proxies") or [] self._subscription_info = self.get_data("subscription_info") or \ {"download": 0, "upload": 0, "total": 0, "expire": 0, "last_update": 0} self._rule_provider = self.get_data("rule_provider") or {} @@ -91,7 +101,7 @@ class ClashRuleProvider(_PluginBase): self._clash_dashboard_url = config.get("clash_dashboard_url") self._clash_dashboard_secret = config.get("clash_dashboard_secret") self._movie_pilot_url = config.get("movie_pilot_url") - if self._movie_pilot_url[-1] == '/': + if self._movie_pilot_url and self._movie_pilot_url[-1] == '/': self._movie_pilot_url = self._movie_pilot_url[:-1] self._cron = config.get("cron_string") self._timeout = config.get("timeout") @@ -99,9 +109,15 @@ class ClashRuleProvider(_PluginBase): self._filter_keywords = config.get("filter_keywords") self._ruleset_prefix = config.get("ruleset_prefix", "Custom_") self._auto_update_subscriptions = config.get("auto_update_subscriptions") + self._group_by_region = config.get("group_by_region") self._clash_rule_parser = ClashRuleParser() self._ruleset_rule_parser = ClashRuleParser() if self._enabled: + if self._group_by_region: + self._countries = ClashRuleProvider.__load_countries( + f"{settings.ROOT_PATH}/app/plugins/clashruleprovider/countries.json") + self._proxy_groups_by_region = ClashRuleProvider.__group_by_region(self._countries, + self._clash_config.get('proxies')) self.__parse_config() self._scheduler = BackgroundScheduler(timezone=settings.TZ) self._scheduler.start() @@ -124,7 +140,7 @@ class ClashRuleProvider(_PluginBase): "description": "测试连接" }, { - "path": "/clash_outbound", + "path": "/clash-outbound", "endpoint": self.get_clash_outbound, "methods": ["GET"], "auth": "bear", @@ -204,13 +220,61 @@ class ClashRuleProvider(_PluginBase): "description": "update clash rules" }, { - "path": "/rule_providers", + "path": "/rule-providers", "endpoint": self.get_rule_providers, "methods": ["GET"], "auth": "bear", "summary": "update rule providers", "description": "update rule providers" }, + { + "path": "/extra-proxies", + "endpoint": self.get_extra_proxies, + "methods": ["GET"], + "auth": "bear", + "summary": "extra proxies", + "description": "extra proxies" + }, + { + "path": "/extra-proxies", + "endpoint": self.delete_extra_proxy, + "methods": ["DELETE"], + "auth": "bear", + "summary": "delete a extra proxy", + "description": "delete a extra proxy" + }, + { + "path": "/extra-proxies", + "endpoint": self.add_extra_proxies, + "methods": ["POST"], + "auth": "bear", + "summary": "add extra proxies", + "description": "add extra proxies" + }, + { + "path": "/proxy-groups", + "endpoint": self.get_proxy_groups, + "methods": ["GET"], + "auth": "bear", + "summary": "proxy groups", + "description": "proxy groups" + }, + { + "path": "/proxy-group", + "endpoint": self.delete_proxy_group, + "methods": ["DELETE"], + "auth": "bear", + "summary": "delete a proxy group", + "description": "delete a proxy group" + }, + { + "path": "/proxy-group", + "endpoint": self.add_proxy_group, + "methods": ["POST"], + "auth": "bear", + "summary": "add a proxy group", + "description": "add a proxy group" + }, { "path": "/ruleset", "endpoint": self.get_ruleset, @@ -218,6 +282,14 @@ class ClashRuleProvider(_PluginBase): "summary": "update rule providers", "description": "update rule providers" }, + { + "path": "/import", + "endpoint": self.import_rules, + "methods": ["POST"], + "auth": "bear", + "summary": "import top rules", + "description": "import top rules" + }, { "path": "/config", "endpoint": self.get_clash_config, @@ -254,7 +326,7 @@ class ClashRuleProvider(_PluginBase): if self.get_state() and self._auto_update_subscriptions: return [{ "id": "ClashRuleProvider", - "name": "Clash Rule Provider 服务", + "name": "定时更新订阅", "trigger": CronTrigger.from_crontab(self._cron), "func": self.update_subscription_service, "kwargs": {} @@ -287,47 +359,47 @@ class ClashRuleProvider(_PluginBase): self.save_data('subscription_info', self._subscription_info) self.save_data('ruleset_names', self._ruleset_names) self.save_data('rule_provider', self._rule_provider) + self.save_data('proxy_groups', self._proxy_groups) + self.save_data('extra_proxies', self._extra_proxies) def __parse_config(self): - if not self._top_rules: - return + if self._top_rules is None: + self._top_rules = [] + if self._ruleset_rules is None: + self._ruleset_rules = [] self._clash_rule_parser.parse_rules_from_list(self._top_rules) - if not self._ruleset_rules: - return self._ruleset_rule_parser.parse_rules_from_list(self._ruleset_rules) - def test_connectivity(self, params: Dict[str, Any]) -> Dict[str, Any]: + def test_connectivity(self, params: Dict[str, Any]) -> schemas.Response: if not self._enabled: - return {"success": False, "message": ""} + return schemas.Response(success=False, message="") if not params.get('clash_dashboard_url') or not params.get('clash_dashboard_secret') \ or not params.get('sub_link'): - return {"success": False, "message": "missing params"} + return schemas.Response(success=True, message="missing params") clash_version_url = f"{params.get('clash_dashboard_url')}/version" ret = RequestUtils(accept_type="application/json", headers={"authorization": f"Bearer {params.get('clash_dashboard_secret')}"} ).get(clash_version_url) if not ret: - return {"success": False, "message": "无法连接到Clash"} + return schemas.Response(success=False, message="无法连接到Clash") ret = RequestUtils(accept_type="text/html", proxies=settings.PROXY if self._proxy else None ).get(params.get('sub_link')) if not ret: - return {"success": False, "message": f"Unable to get {params.get('sub_link')}"} - return {"success": True, "message": "测试连接成功"} + return schemas.Response(success=False, message=f"Unable to get {params.get('sub_link')}") + return schemas.Response(success=True, message="测试连接成功") def get_ruleset(self, name): if not self._ruleset_names.get(name): return None name = self._ruleset_names.get(name) rules = self.__get_ruleset(name) - # if rules or ruleset in self._rule_provider: - # self._rule_provider[ruleset] = rules res = yaml.dump({"payload": rules}, allow_unicode=True) return Response(content=res, media_type="text/yaml") - def get_clash_outbound(self): + def get_clash_outbound(self) -> schemas.Response: outbound = self.clash_outbound(self._clash_config) - return {"success": True, "message": None, "data": {"outbound": outbound}} + return schemas.Response(success=True, message="", data={"outbound": outbound}) def get_status(self): rule_size = len(self._clash_config.get("rules", [])) if self._clash_config else 0 @@ -342,7 +414,7 @@ class ClashRuleProvider(_PluginBase): def get_clash_config(self): config = self.clash_config() if not config: - return {"success": False, "message": ""} + return {'success': False, "message": ''} res = yaml.dump(config, allow_unicode=True) headers = {'Subscription-Userinfo': f'upload={self._subscription_info["upload"]}; ' f'download={self._subscription_info["download"]}; ' @@ -350,22 +422,35 @@ class ClashRuleProvider(_PluginBase): f'expire={self._subscription_info["expire"]}'} return Response(headers=headers, content=res, media_type="text/yaml") - def get_rules(self, rule_type: str) -> Dict[str, Any]: + def get_rules(self, rule_type: str) -> schemas.Response: if rule_type == 'ruleset': - return {"success": True, "message": None, "data": {"rules": self._ruleset_rule_parser.to_dict()}} - return {"success": True, "message": None, "data": {"rules": self._clash_rule_parser.to_dict()}} + return schemas.Response(success=True, message='', data={'rules': self._ruleset_rule_parser.to_dict()}) + return schemas.Response(success=True, message='', data={'rules': self._clash_rule_parser.to_dict()}) - def delete_rule(self, params: dict = Body(...)): + def delete_rule(self, params: dict = Body(...)) -> schemas.Response: if not self._enabled: - return {"success": False, "message": ""} + return schemas.Response(success=False, message='') if params.get('type') == 'ruleset': res = self.delete_rule_by_priority(params.get('priority'), self._ruleset_rule_parser) if res: self.__add_notification_job( f"{self._ruleset_prefix}{res.action.value if isinstance(res.action, Action) else res.action}") else: - res = self.delete_rule_by_priority(params.get('priority'), self._clash_rule_parser) - return {"success": res, "message": None} + self.delete_rule_by_priority(params.get('priority'), self._clash_rule_parser) + return schemas.Response(success=True, message='') + + def import_rules(self, params: Dict[str, Any]) -> schemas.Response: + if not self._enabled: + return schemas.Response(success=False, message='') + rules: List[str] = [] + if params.get('type') == 'YAML': + try: + imported_rules = yaml.load(params["payload"], Loader=yaml.SafeLoader) + rules = imported_rules.get("rules", []) + except yaml.YAMLError as err: + return schemas.Response(success=False, message=f'YAML error: {err}') + self.append_top_rules(rules) + return schemas.Response(success=True) def reorder_rules(self, params: Dict[str, Any]): if not self._enabled: @@ -413,31 +498,105 @@ class ClashRuleProvider(_PluginBase): res = self.add_rule_by_priority(params.get('rule_data'), self._clash_rule_parser) return {"success": bool(res), "message": None} - def get_subscription(self): + def get_subscription(self) -> schemas.Response: if not self._sub_links: - return None - return {"success": True, "message": None, "data": {"url": self._sub_links[0]}} + return schemas.Response(success=False, message=f"Invalid subscription links: {self._sub_links}") + return schemas.Response(success=True, data={"url": self._sub_links[0]}) def update_subscription(self, params: Dict[str, Any]): if not self._enabled: - return {"success": False, "message": ""} + return schemas.Response(success=False, message="") url = params.get('url') if not url: - return {"success": False, "message": "missing params"} - res = self.update_subscription_service() + return schemas.Response(success=False, message="missing params") + res = self.__update_subscription() if not res: - return {"success": True, "message": f"订阅链接 {self._sub_links[0]} 更新失败"} - return {"success": True, "message": "订阅更新成功"} + return schemas.Response(success=False, message=f"订阅链接 {self._sub_links[0]} 更新失败") + return schemas.Response(success=True, message='订阅更新成功败') - def get_rule_providers(self): - return {"success": True, "message": None, "data": self.rule_providers()} + def get_rule_providers(self) -> schemas.Response: + return schemas.Response(success=True, data=self.rule_providers()) - @staticmethod - def clash_outbound(clash_config: Dict[str, Any]) -> Optional[List]: + def get_proxy_groups(self) -> schemas.Response: + return schemas.Response(success=True, data={'proxy_groups': self._proxy_groups}) + + def get_extra_proxies(self) -> schemas.Response: + return schemas.Response(success=True, data={'extra_proxies': self._extra_proxies}) + + def add_extra_proxies(self, params: Dict[str, Any]): + if not self._enabled: + return schemas.Response(success=False, message='') + extra_proxies: List = [] + if params.get('type') == 'YAML': + try: + imported_proxies = yaml.load(params["payload"], Loader=yaml.SafeLoader) + extra_proxies = imported_proxies.get("proxies", []) + except yaml.YAMLError as err: + return schemas.Response(success=False, message=f'YAML error: {err}') + for proxy in extra_proxies: + name = proxy.get('name') + if not name or any(x.get('name') == name for x in self.clash_outbound(self._clash_config)): + logger.warning(f"The proxy name {proxy['name']} already exists. Skipping...") + continue + required_fields = {'name', 'type', 'server', 'port'} + if not required_fields.issubset(proxy.keys()): + missing = required_fields - proxy.keys() + logger.error(f"Required field is missing: {missing}") + continue + self._extra_proxies.append(proxy) + self.save_data('extra_proxies', self._extra_proxies) + return schemas.Response(success=True) + + def delete_extra_proxy(self, params: dict = Body(...)) -> schemas.Response: + if not self._enabled: + return schemas.Response(success=False, message='') + name = params.get('name') + self._extra_proxies = [item for item in self._extra_proxies if item.get('name') != name] + self.save_data('extra_proxies', self._extra_proxies) + return schemas.Response(success=True, message='') + + def add_proxy_group(self, params: Dict[str, Any]) -> schemas.Response: + if not self._enabled: + return schemas.Response(success=False, message='') + if 'proxy_group' not in params or params['proxy_group'] is None: + return schemas.Response(success=False, message="Missing params") + item = params['proxy_group'] + if not item.get('name') or any(x.get('name') == item.get('name') for x in self._proxy_groups): + return schemas.Response(success=False, message=f"The proxy group name {item.get('name')} already exists") + try: + ProxyGroupValidator.parse_obj(item) + except Exception as e: + error_message = f"Failed to parse proxy group: Invalid data={item}, error={repr(e)}" + logger.error(error_message) + return schemas.Response(success=False, message=str(error_message)) + new_item = {} + for k, v in item.items(): + if type(v) is str and len(v) == 0: + continue + if v is None: + continue + new_item[k] = v + self._proxy_groups.append(new_item) + self.save_data('proxy_groups', self._proxy_groups) + return schemas.Response(success=True) + + def delete_proxy_group(self, params: dict = Body(...)) -> schemas.Response: + if not self._enabled: + return schemas.Response(success=False, message='') + name = params.get('name') + self._proxy_groups = [item for item in self._proxy_groups if item.get('name') != name] + self.save_data('proxy_groups', self._proxy_groups) + return schemas.Response(success=True, message='') + + def clash_outbound(self, clash_config: Dict[str, Any]) -> Optional[List]: if not clash_config: return [] outbound = [{'name': proxy_group.get("name")} for proxy_group in clash_config.get("proxy-groups")] outbound.extend([{'name': proxy.get("name")} for proxy in clash_config.get("proxies")]) + if self._group_by_region: + outbound.extend([{'name': proxy_group.get("name")} for proxy_group in self._proxy_groups_by_region]) + outbound.extend([{'name': proxy.get("name")} for proxy in self._extra_proxies]) + outbound.extend([{'name': proxy_group.get("name")} for proxy_group in self._proxy_groups]) return outbound def rule_providers(self) -> Optional[Dict[str, Any]]: @@ -490,6 +649,17 @@ class ClashRuleProvider(_PluginBase): if not self._clash_rule_parser.has_rule(clash_rule): self._clash_rule_parser.insert_rule_at_priority(clash_rule, 0) + def append_top_rules(self, rules: List[str]) -> None: + clash_rules = [] + for rule in rules: + clash_rule = ClashRuleParser.parse_rule_line(rule) + if not clash_rule: + continue + clash_rules.append(clash_rule) + self._clash_rule_parser.append_rules(clash_rules) + self.__save_data() + return + def update_rule_by_priority(self, rule: Dict[str, Any], rule_parser: ClashRuleParser) -> bool: if not isinstance(rule.get("priority"), int): return False @@ -522,8 +692,40 @@ class ClashRuleProvider(_PluginBase): self.__save_data() return res - @eventmanager.register(EventType.PluginAction) - def update_subscription_service(self) -> bool: + @staticmethod + def format_bytes(bytes): + if bytes == 0: + return '0 B' + k = 1024 + sizes = ['B', 'KB', 'MB', 'GB', 'TB'] + i = math.floor(math.log(bytes) / math.log(k)) + return f"{bytes / math.pow(k, i):.2f} {sizes[i]}" + + @staticmethod + def format_expire_time(timestamp): + seconds_left = timestamp - int(time.time()) + days = seconds_left // 86400 + return f"{days}天后过期" if days > 0 else "已过期" + + def update_subscription_service(self): + res = self.__update_subscription() + if res: + used = self._subscription_info['download'] + self._subscription_info['upload'] + remaining = self._subscription_info['total'] - used + message = (f"订阅更新成功\n" + f"已用流量: {ClashRuleProvider.format_bytes(used)}\n" + f"剩余流量: {ClashRuleProvider.format_bytes(remaining)}\n" + f"总量: {ClashRuleProvider.format_bytes(self._subscription_info['total'])}\n" + f"过期时间: {ClashRuleProvider.format_expire_time(self._subscription_info['expire'])}") + else: + message = "订阅更新失败" + if self._notify: + self.post_message(title=f"【{self.plugin_name}】", + mtype=NotificationType.Plugin, + text=f"{message}" + ) + + def __update_subscription(self) -> bool: if not self._sub_links: return False url = self._sub_links[0] @@ -556,6 +758,50 @@ class ClashRuleProvider(_PluginBase): headers={"authorization": f"Bearer {self._clash_dashboard_secret}"} ).put(url) + @staticmethod + def __load_countries(file_path: str) -> List: + try: + countries = json.load(open(file_path)) + except Exception as e: + logger.error(f"插件加载错误：{e}") + return [] + return countries + + @staticmethod + def __group_by_region(countries: List, proxies) -> List[Dict[str, Any]]: + continents_nodes = {'Asia': [], 'Europe': [], 'SouthAmerica': [], 'NorthAmerica': [], 'Africa': [], + 'Oceania': [], 'AsiaExceptChina': []} + proxy_groups = [] + for proxy_node in proxies: + continent = ClashRuleProvider.__continent_name_from_node(countries, proxy_node['name']) + if not continent: + continue + continents_nodes[continent].append(proxy_node['name']) + for continent_nodes in continents_nodes: + if len(continents_nodes[continent_nodes]): + proxy_group = {'name': continent_nodes, 'type': 'select', 'proxies': continents_nodes[continent_nodes]} + proxy_groups.append(proxy_group) + for continent_node in continents_nodes['Asia']: + if any(x in continent_node for x in ('中国', '香港', 'CN')): + continue + continents_nodes['AsiaExceptChina'].append(continent_node) + proxy_group = {'name': 'AsiaExceptChina', 'type': 'select', 'proxies': continents_nodes['AsiaExceptChina']} + proxy_groups.append(proxy_group) + return proxy_groups + + @staticmethod + def __continent_name_from_node(countries: List[Dict[str, str]], node_name: str) -> Optional[str]: + continents_names = {'欧洲': 'Europe', + '亚洲': 'Asia', + '大洋洲': 'Oceania', + '非洲': 'Africa', + '北美洲': 'NorthAmerica', + '南美洲': 'SouthAmerica'} + for country in countries: + if country['chinese'] in node_name or country['english'].lower() in node_name.lower(): + return continents_names[country['continent']] + return None + def __add_notification_job(self, ruleset: str): if ruleset in self._rule_provider: self._scheduler.add_job(self.notify_clash, "date", @@ -581,20 +827,43 @@ class ClashRuleProvider(_PluginBase): removed_proxies = [] for proxy_group in clash_config.get("proxy-groups", []): proxy_group['proxies'] = [x for x in proxy_group.get('proxies') if x not in removed_proxies] - clash_config["proxy-groups"] = [x for x in clash_config.get("proxy-groups", []) if x.get("proxies")] + # clash_config["proxy-groups"] = [x for x in clash_config.get("proxy-groups", []) if x.get("proxies")] return clash_config def clash_config(self) -> Optional[Dict[str, Any]]: if not self._clash_config: - return + return None self.__insert_ruleset() self._top_rules = self._clash_rule_parser.to_string() - clash_config = self._clash_config.copy() + clash_config = copy.deepcopy(self._clash_config) + + # 添加代理组 + proxy_groups = copy.deepcopy(self._proxy_groups) + if proxy_groups: + if clash_config.get("proxy-groups"): + clash_config['proxy-groups'].extend(proxy_groups) + else: + clash_config['proxy-groups'] = proxy_groups + + # 添加额外节点 + if clash_config.get('proxies'): + clash_config['proxies'].extend(self._extra_proxies) + else: + clash_config['proxies'] = copy.deepcopy(self._extra_proxies) + + # 添加按大洲代理组 + if self._group_by_region: + if self._proxy_groups_by_region: + if clash_config.get("proxy-groups"): + clash_config['proxy-groups'].extend(self._proxy_groups_by_region) + else: + clash_config['proxy-groups'] = copy.deepcopy(self._proxy_groups_by_region) + top_rules = [] for rule in self._clash_rule_parser.rules: if (not isinstance(rule.action, Action) and not len([x for x in self.clash_outbound(clash_config) if rule.action == x.get("name", '')])): - logger.warn(f"出站 {rule.action} 不存在, 绕过 {rule.raw_rule}") + logger.warn(f"出站 {rule.action} 不存在, 跳过 {rule.raw_rule}") continue top_rules.append(rule.raw_rule) clash_config["rules"] = self._top_rules + clash_config.get("rules", []) @@ -616,9 +885,15 @@ class ClashRuleProvider(_PluginBase): clash_config['rule-providers'].update(self._rule_provider) else: clash_config['rule-providers'] = self._rule_provider + + key_to_delete = [] for key, item in self._ruleset_names.items(): if item not in clash_config['rule-providers']: - del self._ruleset_names[key] + key_to_delete.append(key) + for key in key_to_delete: + del self._ruleset_names[key] + if not clash_config.get("rule-providers"): + del clash_config["rule-providers"] self.save_data('ruleset_names', self._ruleset_names) self.save_data('rule_provider', self._rule_provider) return clash_config diff --git a/plugins.v2/clashruleprovider/clash_rule_parser.py b/plugins.v2/clashruleprovider/clash_rule_parser.py index 53d6bc2..bc2a04a 100644 --- a/plugins.v2/clashruleprovider/clash_rule_parser.py +++ b/plugins.v2/clashruleprovider/clash_rule_parser.py @@ -1,8 +1,96 @@ import re -from typing import List, Dict, Any, Optional, Union, Callable +from typing import List, Dict, Any, Optional, Union, Callable, Literal from dataclasses import dataclass from enum import Enum +from pydantic import BaseModel, Field, validator + + +class ProxyGroupBase(BaseModel): + """ + 包含所有代理组类型共有的通用字段。 + """ + # Required field + name: str = Field(..., description="The name of the proxy group.") + + # Proxy and provider references + proxies: Optional[List[str]] = Field(None, description="References to outbound proxies or other proxy groups.") + use: Optional[List[str]] = Field(None, description="References to proxy provider sets.") + + # Health check fields + url: Optional[str] = Field(None, description="Health check test address.") + interval: Optional[int] = Field(None, description="Health check interval in seconds.") + lazy: bool = Field(True, description="If not selected, no health checks are performed.") + timeout: Optional[int] = Field(5000, description="Health check timeout in milliseconds.") + max_failed_times: Optional[int] = Field(5, description="Maximum number of failures before a forced health check.") + expected_status: Optional[str] = Field(None, description="Expected HTTP response status code for health checks.") + + # Network and routing fields + disable_udp: Optional[bool] = Field(False, description="Disables UDP for this proxy group.") + interface_name: Optional[str] = Field(None, description="DEPRECATED. Specifies the outbound interface.") + routing_mark: Optional[int] = Field(None, description="DEPRECATED. The routing mark for outbound connections.") + + # Dynamic proxy inclusion + include_all: Optional[bool] = Field(False, description="Includes all outbound proxies and proxy sets.") + include_all_proxies: Optional[bool] = Field(False, description="Includes all outbound proxies.") + include_all_providers: Optional[bool] = Field(False, description="Includes all proxy provider sets.") + + # Filtering + filter: Optional[str] = Field(None, description="Regex to filter nodes from providers.") + exclude_filter: Optional[str] = Field(None, description="Regex to exclude nodes.") + exclude_type: Optional[str] = Field(None, description="Exclude nodes by adapter type, separated by '|'.") + + # UI fields + hidden: Optional[bool] = Field(False, description="Hides the proxy group in the API.") + icon: Optional[str] = Field(None, description="Icon string for the proxy group, for UI use.") + + + @validator('expected_status') + def validate_expected_status(cls, v: Optional[str]) -> Optional[str]: + if v is None or v == '*': + return v + pattern = re.compile(r'^\d{3}([-/]\d{3})*$') + if not pattern.match(v): + raise ValueError("Invalid format for expected-status.") + parts = re.split(r'[/]', v) + for part in parts: + if '-' in part: + start, end = part.split('-') + if not (start.isdigit() and end.isdigit() and 100 <= int(start) < 600 and 100 <= int(end) < 600 and int(start) <= int(end)): + raise ValueError(f"Invalid status code range: {part}") + elif not (part.isdigit() and 100 <= int(part) < 600): + raise ValueError(f"Invalid status code: {part}") + return v + +class SelectGroup(ProxyGroupBase): + type: Literal['select'] + +class RelayGroup(ProxyGroupBase): + type: Literal['relay'] + +class FallbackGroup(ProxyGroupBase): + type: Literal['fallback'] + +class UrlTestGroup(ProxyGroupBase): + type: Literal['url-test'] + tolerance: Optional[int] = Field(None, description="proxies switch tolerance, measured in milliseconds (ms).") + +class LoadBalanceGroup(ProxyGroupBase): + type: Literal['load-balance'] + strategy: Optional[Literal['round-robin', 'consistent-hashing', 'sticky-sessions']] = Field( + 'round-robin', + description="Load balancing strategy." + ) + +# --- Discriminated Union --- +ProxyGroupUnion = Union[SelectGroup, RelayGroup, FallbackGroup, UrlTestGroup, LoadBalanceGroup] + +class ProxyGroupValidator(BaseModel): + """ + 这是Pydantic V1的验证器。 + 它使用 __root__ 字段来处理可辨识联合。 + """ + __root__: ProxyGroupUnion class RuleType(Enum): """Enumeration of all supported Clash rule types""" @@ -282,8 +370,7 @@ class ClashRuleParser: return self.rules - @staticmethod - def validate_rule(rule: ClashRule) -> bool: + def validate_rule(self, rule: ClashRule) -> bool: """Validate a parsed rule""" try: # Basic validation based on rule type @@ -306,8 +393,7 @@ class ClashRuleParser: return True - except Exception as e: - print(f"Invalid rule '{rule.raw_rule}': {e}") + except Exception: return False def to_string(self) -> List[str]: @@ -370,6 +456,15 @@ class ClashRuleParser: # Re-sort rules to maintain order self.rules.sort(key=lambda r: r.priority) + def append_rules(self, rules: List[Union[ClashRule, LogicRule, MatchRule]]) -> None: + max_priority = max(rule.priority for rule in self.rules) if len(self.rules) else 0 + priority = max_priority + 1 + for rule in rules: + rule.priority = priority + self.rules.append(rule) + priority += 1 + self.rules.sort(key=lambda r: r.priority) + def insert_rule_at_priority(self, rule: Union[ClashRule, LogicRule, MatchRule], priority: int): """Insert a rule at a specific priority position, adjusting other rules""" # Adjust priorities of existing rules diff --git a/plugins.v2/clashruleprovider/countries.json b/plugins.v2/clashruleprovider/countries.json new file mode 100755 index 0000000..ce67b4a --- /dev/null +++ b/plugins.v2/clashruleprovider/countries.json @@ -0,0 +1,2485 @@ +[ +{ + "abbr": "AF", + "chinese": "阿富汗", + "code": "93", + "english": "Afghanistan", + "spell": "afuhan", + "continent": "亚洲", + "french": "Afghanistan", + "italian": "Afghanistan", + "spanish": "Afganistán", + "japanese": "アフガニスタン", + "russian": "Афганистан", + "germen": "Afghanistan" +}, +{ + "abbr": "AL", + "chinese": "阿尔巴尼亚", + "code": "355", + "english": "Albania", + "spell": "aerbaniya", + "continent": "亚洲", + "french": "Albanie", + "italian": "Albania", + "spanish": "Albania", + "japanese": "アルバニア", + "russian": "Албания", + "germen": "Albanien" +}, +{ + "abbr": "DZ", + "chinese": "阿尔及利亚", + "code": "213", + "english": "Algeria", + "spell": "aerjiliya", + "continent": "非洲", + "french": "Algérie", + "italian": "Algeria", + "spanish": "Argelia", + "japanese": "アルジェリア", + "russian": "Алжир", + "germen": "Algerien" +}, +{ + "abbr": "AO", + "chinese": "安哥拉", + "code": "244", + "english": "Angola", + "spell": "angela", + "continent": "非洲", + "french": "Angola", + "italian": "Angola", + "spanish": "Angola", + "japanese": "アンゴラ", + "russian": "Ангола", + "germen": "Angola" +}, +{ + "abbr": "AR", + "chinese": "阿根廷", + "code": "54", + "english": "Argentina", + "spell": "agenting", + "continent": "南美洲", + "french": "Argentine", + "italian": "Argentina", + "spanish": "Argentina", + "japanese": "アルゼンチン", + "russian": "Аргентина", + "germen": "Argentinien" +}, +{ + "abbr": "AM", + "chinese": "亚美尼亚", + "code": "374", + "english": "Armenia", + "spell": "yameiniya", + "french": "Arménie", + "italian": "Armenia", + "spanish": "Armenia", + "japanese": "アルメニア", + "russian": "Армения", + "germen": "Armenien" +}, +{ + "abbr": "AU", + "chinese": "澳大利亚", + "code": "61", + "english": "Australia", + "spell": "aodaliya", + "continent": "大洋洲", + "french": "Îles Cocos", + "italian": "Isole Cocos e Keeling", + "spanish": "Islas Cocos o Islas Keeling", + "japanese": "ココス（キーリング）諸島", + "russian": "Австралия", + "germen": "Kokosinseln" +}, +{ + "abbr": "AT", + "chinese": "奥地利", + "code": "43", + "english": "Austria", + "spell": "aodili", + "continent": "欧洲", + "french": "Autriche", + "italian": "Austria", + "spanish": "Austria", + "japanese": "オーストリア", + "russian": "Австрия", + "germen": "Österreich" +}, +{ + "abbr": "AZ", + "chinese": "阿塞拜疆", + "code": "994", + "english": "Azerbaijan", + "spell": "asaibaijiang", + "continent": "亚洲", + "french": "Azerbaïdjan", + "italian": "Azerbaijan", + "spanish": "Azerbaiyán", + "japanese": "アゼルバイジャン", + "russian": "Азербайджан", + "germen": "Aserbaidschan" +}, +{ + "abbr": "BH", + "chinese": "巴林", + "code": "973", + "english": "Bahrain", + "spell": "balin", + "continent": "亚洲", + "french": "Bahreïn", + "italian": "Bahrein", + "spanish": "Bahrein", + "japanese": "バーレーン", + "russian": "Бахрейн", + "germen": "Bahrain" +}, +{ + "abbr": "BD", + "chinese": "孟加拉国", + "code": "880", + "english": "Bangladesh", + "spell": "mengjialaguo", + "continent": "亚洲", + "french": "Bangladesh", + "italian": "Bangladesh", + "spanish": "Bangladesh", + "japanese": "バングラデシュ", + "russian": "Бангладеш", + "germen": "Bangladesch" +}, +{ + "abbr": "BY", + "chinese": "白俄罗斯", + "code": "375", + "english": "Belarus", + "spell": "baieluosi", + "french": "Biélorussie", + "italian": "Bielorussia", + "spanish": "Bielorrusia", + "japanese": "ベラルーシ", + "russian": "Белоруссия", + "germen": "Weißrussland" +}, +{ + "abbr": "BE", + "chinese": "比利时", + "code": "32", + "english": "Belgium", + "spell": "bilishi", + "continent": "欧洲", + "french": "Belgique", + "italian": "Belgio", + "spanish": "Bélgica", + "japanese": "ベルギー", + "russian": "Бельгия", + "germen": "Belgien" +}, +{ + "abbr": "BZ", + "chinese": "伯利兹", + "code": "501", + "english": "Belize", + "spell": "bolizi", + "french": "Belize", + "italian": "Belize", + "spanish": "Belice", + "japanese": "ベリーズ", + "russian": "Белиз", + "germen": "Belize" +}, +{ + "abbr": "BJ", + "chinese": "贝宁", + "code": "229", + "english": "Benin", + "spell": "beining", + "continent": "非洲", + "french": "Bénin", + "italian": "Benin", + "spanish": "Benín", + "japanese": "ベナン", + "russian": "Бенин", + "germen": "Benin" +}, +{ + "abbr": "BT", + "chinese": "不丹", + "code": "975", + "english": "Bhutan", + "spell": "budan", + "continent": "亚洲", + "french": "Bhoutan", + "italian": "Bhutan", + "spanish": "Bután", + "japanese": "ブータン", + "russian": "Бутан", + "germen": "Bhutan" +}, +{ + "abbr": "BO", + "chinese": "玻利维亚", + "code": "591", + "english": "Bolivia", + "spell": "boliweiya", + "continent": "南美洲", + "french": "Bolivie", + "italian": "Bolivia", + "spanish": "Bolivia", + "japanese": "ボリビア多民族国", + "russian": "Боливия", + "germen": "Bolivien" +}, +{ + "abbr": "BA", + "chinese": "波斯尼亚和黑塞哥维那", + "code": "387", + "english": "Bosnia and Herzegovina", + "spell": "bosiniyaheheisaigeweinei", + "french": "Bosnie-Herzégovine", + "italian": "Bosnia ed Erzegovina", + "spanish": "Bosnia y Herzegovina", + "japanese": "ボスニア・ヘルツェゴビナ", + "russian": "Босния и Герцеговина", + "germen": "Bosnien und Herzegowina" +}, +{ + "abbr": "BW", + "chinese": "博茨瓦纳", + "code": "267", + "english": "Botswana", + "spell": "bociwana", + "continent": "非洲", + "french": "Botswana", + "italian": "Botswana", + "spanish": "Botswana", + "japanese": "ボツワナ", + "russian": "Ботсвана", + "germen": "Botswana" +}, +{ + "abbr": "BR", + "chinese": "巴西", + "code": "55", + "english": "Brazil", + "spell": "baxi", + "continent": "南美洲", + "french": "Brésil", + "italian": "Brasile", + "spanish": "Brasil", + "japanese": "ブラジル", + "russian": "Бразилия", + "germen": "Brasilien" +}, +{ + "abbr": "VG", + "chinese": "英属维京群岛", + "code": "1284", + "english": "British Virgin Islands", + "spell": "yingshuweijingqundao", + "french": "Îles Vierges britanniques", + "italian": "Isole Vergini Britanniche", + "spanish": "Islas Vírgenes del Reino Unido", + "japanese": "イギリス領ヴァージン諸島", + "russian": "Британские Виргинские острова", + "germen": "Britische Jungferninseln" +}, +{ + "abbr": "BN", + "chinese": "文莱", + "code": "673", + "english": "Brunei", + "spell": "wenlai", + "continent": "亚洲", + "french": "Brunei", + "italian": "Brunei", + "spanish": "Brunei", + "japanese": "ブルネイ・ダルサラーム", + "russian": "Bulgaria", + "germen": "Brunei" +}, +{ + "abbr": "BG", + "chinese": "保加利亚", + "code": "359", + "english": "Bulgaria", + "spell": "baojialiya", + "continent": "欧洲", + "french": "Bulgarie", + "italian": "Bulgaria", + "spanish": "Bulgaria", + "japanese": "ブルガリア", + "russian": "Болгария", + "germen": "Bulgarien" +}, +{ + "abbr": "BF", + "chinese": "布基纳法索", + "code": "226", + "english": "Burkina-faso", + "spell": "bujinafasuo", + "french": "Burkina Faso", + "italian": "Burkina Faso", + "spanish": "Burkina Faso", + "japanese": "ブルキナファソ", + "russian": "Буркина-Фасо", + "germen": "Burkina Faso" +}, +{ + "abbr": "BI", + "chinese": "布隆迪", + "code": "257", + "english": "Burundi", + "spell": "bulongdi", + "continent": "非洲", + "french": "Burundi", + "italian": "Burundi", + "spanish": "Burundi", + "japanese": "ブルンジ", + "russian": "Бурунди", + "germen": "Burundi" +}, +{ + "abbr": "KH", + "chinese": "柬埔寨", + "code": "855", + "english": "Cambodia", + "spell": "jianpuzhai", + "continent": "亚洲", + "french": "Cambodge", + "italian": "Cambogia", + "spanish": "Camboya", + "japanese": "カンボジア", + "russian": "Камбоджа", + "germen": "Kambodscha" +}, +{ + "abbr": "CM", + "chinese": "喀麦隆", + "code": "237", + "english": "Cameroon", + "spell": "kamailong", + "continent": "非洲", + "french": "Cameroun", + "italian": "Camerun", + "spanish": "Camerún", + "japanese": "カメルーン", + "russian": "Камерун", + "germen": "Kamerun" +}, +{ + "abbr": "CA", + "chinese": "加拿大", + "code": "1", + "english": "Canada", + "spell": "jianada", + "continent": "北美洲", + "french": "États-Unis", + "italian": "Stati Uniti D\u0027America", + "spanish": "Estados Unidos", + "japanese": "アメリカ合衆国", + "russian": "Канада", + "germen": "Vereinigte Staaten von Amerika" +}, +{ + "abbr": "CV", + "chinese": "佛得角", + "code": "238", + "english": "Cape Verde", + "spell": "fodejiao", + "continent": "非洲", + "french": "Cap Vert", + "italian": "Capo Verde", + "spanish": "Cabo Verde", + "japanese": "カーボベルデ", + "russian": "Кабо-Верде", + "germen": "Kap Verde" +}, +{ + "abbr": "KY", + "chinese": "开曼群岛", + "code": "1345", + "english": "Cayman Islands", + "spell": "kaimanqundao", + "french": "Îles Caïmans", + "italian": "Isole Cayman", + "spanish": "Islas Caimán", + "japanese": "ケイマン諸島", + "russian": "Каймановы Острова", + "germen": "Kaimaninseln" +}, +{ + "abbr": "CF", + "chinese": "中非共和国", + "code": "236", + "english": "Central African Republic", + "spell": "zhongfeigongheguo", + "continent": "非洲", + "french": "République centrafricaine", + "italian": "Repubblica Centrafricana", + "spanish": "República Centroafricana", + "japanese": "中央アフリカ共和国", + "russian": "Центрально-Африканская Республика", + "germen": "Zentralafrikanische Republik" +}, +{ + "abbr": "TD", + "chinese": "乍得", + "code": "235", + "english": "Chad", + "spell": "zhade", + "french": "Tchad", + "italian": "Ciad", + "spanish": "Chad", + "japanese": "チャド", + "russian": "Чад", + "germen": "Tschad" +}, +{ + "abbr": "CL", + "chinese": "智利", + "code": "56", + "english": "Chile", + "spell": "zhili", + "continent": "南美洲", + "french": "Chili", + "italian": "Cile", + "spanish": "Chile", + "japanese": "チリ", + "russian": "Чили", + "germen": "Chile" +}, +{ + "abbr": "CN", + "chinese": "中国", + "code": "86", + "english": "China", + "spell": "zhongguo", + "continent": "亚洲", + "french": "Chine", + "italian": "Cina", + "spanish": "China", + "japanese": "中国", + "russian": "Китай", + "germen": "China" +}, +{ + "abbr": "CO", + "chinese": "哥伦比亚", + "code": "57", + "english": "Colombia", + "spell": "gelunbiya", + "continent": "南美洲", + "french": "Colombie", + "italian": "Colombia", + "spanish": "Colombia", + "japanese": "コロンビア", + "russian": "Колумбия", + "germen": "Kolumbien" +}, +{ + "abbr": "KM", + "chinese": "科摩罗", + "code": "269", + "english": "Comoros", + "spell": "kemoluo", + "french": "Comores", + "italian": "Comore", + "spanish": "Comoras", + "japanese": "コモロ", + "russian": "Коморские острова", + "germen": "Union der Komoren" +}, +{ + "abbr": "CG", + "chinese": "刚果(布)", + "code": "242", + "english": "Congo - Brazzaville", + "spell": "gangguo(bu)", + "continent": "非洲", + "french": "Congo", + "italian": "Congo", + "spanish": "Congo", + "japanese": "コンゴ共和国", + "russian": "Конго - Браззавиль", + "germen": "Kongo" +}, +{ + "abbr": "CD", + "chinese": "刚果(金)", + "code": "243", + "english": "Congo - Kinshasa", + "spell": "gangguo(jin)", + "french": "Congo (Rép. dém.)", + "italian": "Congo (Rep. Dem.)", + "spanish": "Congo (Rep. Dem.)", + "japanese": "コンゴ民主共和国", + "russian": "Конго - Киншаса", + "germen": "Kongo (Dem. Rep.)" +}, +{ + "abbr": "CR", + "chinese": "哥斯达黎加", + "code": "506", + "english": "Costa Rica", + "spell": "gesidalijia", + "continent": "北美洲", + "french": "Costa Rica", + "italian": "Costa Rica", + "spanish": "Costa Rica", + "japanese": "コスタリカ", + "russian": "Коста-Рика", + "germen": "Costa Rica" +}, +{ + "abbr": "HR", + "chinese": "克罗地亚", + "code": "385", + "english": "Croatia", + "spell": "keluodiya", + "continent": "欧洲", + "french": "Croatie", + "italian": "Croazia", + "spanish": "Croacia", + "japanese": "クロアチア", + "russian": "Хорватия", + "germen": "Kroatien" +}, +{ + "abbr": "CY", + "chinese": "塞浦路斯", + "code": "357", + "english": "Cyprus", + "spell": "saipulusi", + "continent": "亚洲", + "french": "Chypre", + "italian": "Cipro", + "spanish": "Chipre", + "japanese": "キプロス", + "russian": "Кипр", + "germen": "Zypern" +}, +{ + "abbr": "CZ", + "chinese": "捷克共和国", + "code": "420", + "english": "Czech Republic", + "spell": "jiekegongheguo", + "continent": "欧洲", + "french": "République tchèque", + "italian": "Repubblica Ceca", + "spanish": "República Checa", + "japanese": "チェコ", + "russian": "Чехия", + "germen": "Tschechische Republik" +}, +{ + "abbr": "DK", + "chinese": "丹麦", + "code": "45", + "english": "Denmark", + "spell": "danmai", + "continent": "欧洲", + "french": "Danemark", + "italian": "Danimarca", + "spanish": "Dinamarca", + "japanese": "デンマーク", + "russian": "Дания", + "germen": "Dänemark" +}, +{ + "abbr": "DJ", + "chinese": "吉布提", + "code": "253", + "english": "Djibouti", + "spell": "jibuti", + "french": "Djibouti", + "italian": "Gibuti", + "spanish": "Yibuti", + "japanese": "ジブチ", + "russian": "Джибути", + "germen": "Dschibuti" +}, +{ + "abbr": "DO", + "chinese": "多米尼加共和国", + "code": "1809", + "english": "Dominican Republic", + "spell": "duominijiagongheguo", + "french": "République dominicaine", + "italian": "Repubblica Dominicana", + "spanish": "República Dominicana", + "japanese": "ドミニカ共和国", + "russian": "Доминиканская Республика", + "germen": "Dominikanische Republik" +}, +{ + "abbr": "EC", + "chinese": "厄瓜多尔", + "code": "593", + "english": "Ecuador", + "spell": "eguaduoer", + "continent": "南美洲", + "french": "Équateur", + "italian": "Ecuador", + "spanish": "Ecuador", + "japanese": "エクアドル", + "russian": "Эквадор", + "germen": "Ecuador" +}, +{ + "abbr": "EG", + "chinese": "埃及", + "code": "20", + "english": "Egypt", + "spell": "aiji", + "continent": "非洲", + "french": "Égypte", + "italian": "Egitto", + "spanish": "Egipto", + "japanese": "エジプト", + "russian": "Египет", + "germen": "Ägypten" +}, +{ + "abbr": "SV", + "chinese": "萨尔瓦多", + "code": "503", + "english": "EI Salvador", + "spell": "saerwaduo", + "french": "Salvador", + "italian": "El Salvador", + "spanish": "El Salvador", + "japanese": "エルサルバドル", + "russian": "EI Сальвадор", + "germen": "El Salvador" +}, +{ + "abbr": "GQ", + "chinese": "赤道几内亚", + "code": "240", + "english": "Equatorial Guinea", + "spell": "chidaojineiya", + "continent": "非洲", + "french": "Guinée-Équatoriale", + "italian": "Guinea Equatoriale", + "spanish": "Guinea Ecuatorial", + "japanese": "赤道ギニア", + "russian": "Экваториальная Гвинея", + "germen": "Äquatorial-Guinea" +}, +{ + "abbr": "ER", + "chinese": "厄立特里亚", + "code": "291", + "english": "Eritrea", + "spell": "eliteliya", + "french": "Érythrée", + "italian": "Eritrea", + "spanish": "Eritrea", + "japanese": "エリトリア", + "russian": "Эритрея", + "germen": "Eritrea" +}, +{ + "abbr": "EE", + "chinese": "爱沙尼亚", + "code": "372", + "english": "Estonia", + "spell": "aishaniya", + "continent": "欧洲", + "french": "Estonie", + "italian": "Estonia", + "spanish": "Estonia", + "japanese": "エストニア", + "russian": "Эстония", + "germen": "Estland" +}, +{ + "abbr": "ET", + "chinese": "埃塞俄比亚", + "code": "251", + "english": "Ethiopia", + "spell": "aisaiebiya", + "continent": "非洲", + "french": "Éthiopie", + "italian": "Etiopia", + "spanish": "Etiopía", + "japanese": "エチオピア", + "russian": "Эфиопия", + "germen": "Äthiopien" +}, +{ + "abbr": "FJ", + "chinese": "斐济", + "code": "679", + "english": "Fiji", + "spell": "feiji", + "continent": "大洋洲", + "french": "Fidji", + "italian": "Figi", + "spanish": "Fiyi", + "japanese": "フィジー", + "russian": "Фиджи", + "germen": "Fidschi" +}, +{ + "abbr": "FI", + "chinese": "芬兰", + "code": "358", + "english": "Finland", + "spell": "fenlan", + "continent": "欧洲", + "french": "Finlande", + "italian": "Finlandia", + "spanish": "Finlandia", + "japanese": "フィンランド", + "russian": "Финляндия", + "germen": "Finnland" +}, +{ + "abbr": "FR", + "chinese": "法国", + "code": "33", + "english": "France", + "spell": "faguo", + "continent": "欧洲", + "french": "France", + "italian": "Francia", + "spanish": "Francia", + "japanese": "フランス", + "russian": "Франция", + "germen": "Frankreich" +}, +{ + "abbr": "GA", + "chinese": "加蓬", + "code": "241", + "english": "Gabon", + "spell": "jiapeng", + "continent": "非洲", + "french": "Gabon", + "italian": "Gabon", + "spanish": "Gabón", + "japanese": "ガボン", + "russian": "Габон", + "germen": "Gabun" +}, +{ + "abbr": "GM", + "chinese": "冈比亚", + "code": "220", + "english": "Gambia", + "spell": "gangbiya", + "continent": "非洲", + "french": "Gambie", + "italian": "Gambia", + "spanish": "Gambia", + "japanese": "ガンビア", + "russian": "Гамбия", + "germen": "Gambia" +}, +{ + "abbr": "GE", + "chinese": "格鲁吉亚", + "code": "995", + "english": "Georgia", + "spell": "gelujiya", + "french": "Géorgie", + "italian": "Georgia", + "spanish": "Georgia", + "japanese": "グルジア", + "russian": "Грузия", + "germen": "Georgien" +}, +{ + "abbr": "DE", + "chinese": "德国", + "code": "49", + "english": "Germany", + "spell": "deguo", + "continent": "欧洲", + "french": "Allemagne", + "italian": "Germania", + "spanish": "Alemania", + "japanese": "ドイツ", + "russian": "Германия", + "germen": "Deutschland" +}, +{ + "abbr": "GH", + "chinese": "加纳", + "code": "233", + "english": "Ghana", + "spell": "jiana", + "continent": "非洲", + "french": "Ghana", + "italian": "Ghana", + "spanish": "Ghana", + "japanese": "ガーナ", + "russian": "Гана", + "germen": "Ghana" +}, +{ + "abbr": "GR", + "chinese": "希腊", + "code": "30", + "english": "Greece", + "spell": "xila", + "continent": "欧洲", + "french": "Grèce", + "italian": "Grecia", + "spanish": "Grecia", + "japanese": "ギリシャ", + "russian": "Греция", + "germen": "Griechenland" +}, +{ + "abbr": "GL", + "chinese": "格陵兰", + "code": "299", + "english": "Greenland", + "spell": "gelinglan", + "french": "Groenland", + "italian": "Groenlandia", + "spanish": "Groenlandia", + "japanese": "グリーンランド", + "russian": "Гренландия", + "germen": "Grönland" +}, +{ + "abbr": "GT", + "chinese": "危地马拉", + "code": "502", + "english": "Guatemala", + "spell": "weidimala", + "continent": "北美洲", + "french": "Guatemala", + "italian": "Guatemala", + "spanish": "Guatemala", + "japanese": "グアテマラ", + "russian": "Гватемала", + "germen": "Guatemala" +}, +{ + "abbr": "GN", + "chinese": "几内亚", + "code": "224", + "english": "Guinea", + "spell": "jineiya", + "continent": "非洲", + "french": "Guinée", + "italian": "Guinea", + "spanish": "Guinea", + "japanese": "ギニア", + "russian": "Гвинея", + "germen": "Guinea" +}, +{ + "abbr": "GY", + "chinese": "圭亚那", + "code": "592", + "english": "Guyana", + "spell": "guiyanei", + "continent": "南美洲", + "french": "Guyane", + "italian": "Guyana", + "spanish": "Guyana", + "japanese": "ガイアナ", + "russian": "Гайана", + "germen": "Guyana" +}, +{ + "abbr": "HT", + "chinese": "海地", + "code": "509", + "english": "Haiti", + "spell": "haidi", + "continent": "北美洲", + "french": "Haïti", + "italian": "Haiti", + "spanish": "Haiti", + "japanese": "ハイチ", + "russian": "Гаити", + "germen": "Haiti" +}, +{ + "abbr": "HN", + "chinese": "洪都拉斯", + "code": "504", + "english": "Honduras", + "spell": "hongdoulasi", + "continent": "北美洲", + "french": "Honduras", + "italian": "Honduras", + "spanish": "Honduras", + "japanese": "ホンジュラス", + "russian": "Гондурас", + "germen": "Honduras" +}, +{ + "abbr": "HK", + "chinese": "中国香港特别行政区", + "code": "852", + "english": "Hongkong SAR China", + "spell": "zhongguoxianggangtebiexingzhengqu", + "continent": "亚洲", + "french": "Hong Kong", + "italian": "Hong Kong", + "spanish": "Hong Kong", + "japanese": "香港", + "russian": "Гонконг SAR Китай", + "germen": "Hong Kong" +}, +{ + "abbr": "HU", + "chinese": "匈牙利", + "code": "36", + "english": "Hungary", + "spell": "xiongyali", + "continent": "欧洲", + "french": "Hongrie", + "italian": "Ungheria", + "spanish": "Hungría", + "japanese": "ハンガリー", + "russian": "Венгрия", + "germen": "Ungarn" +}, +{ + "abbr": "IS", + "chinese": "冰岛", + "code": "354", + "english": "Iceland", + "spell": "bingdao", + "continent": "欧洲", + "french": "Islande", + "italian": "Islanda", + "spanish": "Islandia", + "japanese": "アイスランド", + "russian": "Исландия", + "germen": "Island" +}, +{ + "abbr": "IN", + "chinese": "印度", + "code": "91", + "english": "India", + "spell": "yindu", + "continent": "亚洲", + "french": "Inde", + "italian": "India", + "spanish": "India", + "japanese": "インド", + "russian": "Индия", + "germen": "Indien" +}, +{ + "abbr": "ID", + "chinese": "印度尼西亚", + "code": "62", + "english": "Indonesia", + "spell": "yindunixiya", + "continent": "亚洲", + "french": "Indonésie", + "italian": "Indonesia", + "spanish": "Indonesia", + "japanese": "インドネシア", + "russian": "Индонезия", + "germen": "Indonesien" +}, +{ + "abbr": "IR", + "chinese": "伊朗", + "code": "98", + "english": "Iran", + "spell": "yilang", + "continent": "亚洲", + "french": "Iran", + "italian": "Iran", + "spanish": "Iran", + "japanese": "イラン・イスラム共和国", + "russian": "Иран", + "germen": "Iran" +}, +{ + "abbr": "IQ", + "chinese": "伊拉克", + "code": "964", + "english": "Iraq", + "spell": "yilake", + "continent": "亚洲", + "french": "Irak", + "italian": "Iraq", + "spanish": "Irak", + "japanese": "イラク", + "russian": "Ирак", + "germen": "Irak" +}, +{ + "abbr": "IE", + "chinese": "爱尔兰", + "code": "353", + "english": "Ireland", + "spell": "aierlan", + "continent": "欧洲", + "french": "Irlande", + "italian": "Irlanda", + "spanish": "Irlanda", + "japanese": "アイルランド", + "russian": "Ирландия", + "germen": "Irland" +}, +{ + "abbr": "IM", + "chinese": "马恩岛", + "code": "44", + "english": "Isle of Man", + "spell": "maendao", + "french": "Royaume-Uni", + "italian": "Regno Unito", + "spanish": "Reino Unido", + "japanese": "イギリス", + "russian": "Остров Мэн", + "germen": "Vereinigtes Königreich" +}, +{ + "abbr": "IL", + "chinese": "以色列", + "code": "972", + "english": "Israel", + "spell": "yiselie", + "continent": "亚洲", + "french": "Israël", + "italian": "Israele", + "spanish": "Israel", + "japanese": "イスラエル", + "russian": "Израиль", + "germen": "Israel" +}, +{ + "abbr": "IT", + "chinese": "意大利", + "code": "39", + "english": "Italy", + "spell": "yidali", + "continent": "欧洲", + "french": "Italie", + "italian": "Italia", + "spanish": "Italia", + "japanese": "イタリア", + "russian": "Италия", + "germen": "Italien" +}, +{ + "abbr": "CI", + "chinese": "科特迪瓦", + "code": "225", + "english": "Ivory Coast", + "spell": "ketediwa", + "french": "Côte d\u0027Ivoire", + "italian": "Costa D\u0027Avorio", + "spanish": "Costa de Marfil", + "japanese": "コートジボワール", + "russian": "Кот-д'Ивуар", + "germen": "Elfenbeinküste" +}, +{ + "abbr": "JM", + "chinese": "牙买加", + "code": "1876", + "english": "Jamaica", + "spell": "yamaijia", + "continent": "北美洲", + "french": "Jamaïque", + "italian": "Giamaica", + "spanish": "Jamaica", + "japanese": "ジャマイカ", + "russian": "Ямайка", + "germen": "Jamaika" +}, +{ + "abbr": "JP", + "chinese": "日本", + "code": "81", + "english": "Japan", + "spell": "riben", + "continent": "亚洲", + "french": "Japon", + "italian": "Giappone", + "spanish": "Japón", + "japanese": "日本", + "russian": "Япония", + "germen": "Japan" +}, +{ + "abbr": "JO", + "chinese": "约旦", + "code": "962", + "english": "Jordan", + "spell": "yuedan", + "continent": "亚洲", + "french": "Jordanie", + "italian": "Giordania", + "spanish": "Jordania", + "japanese": "ヨルダン", + "russian": "Иордания", + "germen": "Jordanien" +}, +{ + "abbr": "KZ", + "chinese": "哈萨克斯坦", + "code": "7", + "english": "Kazakstan", + "spell": "hasakesitan", + "continent": "亚洲", + "french": "Russie", + "italian": "Russia", + "spanish": "Rusia", + "japanese": "ロシア連邦", + "russian": "Казахстан", + "germen": "Russland" +}, +{ + "abbr": "KE", + "chinese": "肯尼亚", + "code": "254", + "english": "Kenya", + "spell": "kenniya", + "continent": "非洲", + "french": "Kenya", + "italian": "Kenya", + "spanish": "Kenia", + "japanese": "ケニア", + "russian": "Кения", + "germen": "Kenia" +}, +{ + "abbr": "KR", + "chinese": "韩国", + "code": "82", + "english": "Korea", + "spell": "hanguo", + "continent": "亚洲", + "french": "Corée du Sud", + "italian": "Corea del Sud", + "spanish": "Corea del Sur", + "japanese": "大韓民国", + "russian": "Корея", + "germen": "Südkorea" +}, +{ + "abbr": "KW", + "chinese": "科威特", + "code": "965", + "english": "Kuwait", + "spell": "keweite", + "continent": "亚洲", + "french": "Koweït", + "italian": "Kuwait", + "spanish": "Kuwait", + "japanese": "クウェート", + "russian": "Кувейт", + "germen": "Kuwait" +}, +{ + "abbr": "KG", + "chinese": "吉尔吉斯斯坦", + "code": "996", + "english": "Kyrgyzstan", + "spell": "jierjisisitan", + "french": "Kirghizistan", + "italian": "Kirghizistan", + "spanish": "Kirguizistán", + "japanese": "キルギス", + "russian": "Киргизия", + "germen": "Kirgisistan" +}, +{ + "abbr": "LA", + "chinese": "老挝", + "code": "856", + "english": "Laos", + "spell": "laowo", + "continent": "亚洲", + "french": "Laos", + "italian": "Laos", + "spanish": "Laos", + "japanese": "ラオス人民民主共和国", + "russian": "Лаос", + "germen": "Laos" +}, +{ + "abbr": "LV", + "chinese": "拉脱维亚", + "code": "371", + "english": "Latvia", + "spell": "latuoweiya", + "continent": "欧洲", + "french": "Lettonie", + "italian": "Lettonia", + "spanish": "Letonia", + "japanese": "ラトビア", + "russian": "Латвия", + "germen": "Lettland" +}, +{ + "abbr": "LB", + "chinese": "黎巴嫩", + "code": "961", + "english": "Lebanon", + "spell": "libanen", + "continent": "亚洲", + "french": "Liban", + "italian": "Libano", + "spanish": "Líbano", + "japanese": "レバノン", + "russian": "Ливан", + "germen": "Libanon" +}, +{ + "abbr": "LS", + "chinese": "莱索托", + "code": "266", + "english": "Lesotho", + "spell": "laisuotuo", + "french": "Lesotho", + "italian": "Lesotho", + "spanish": "Lesotho", + "japanese": "レソト", + "russian": "Лесото", + "germen": "Lesotho" +}, +{ + "abbr": "LR", + "chinese": "利比里亚", + "code": "231", + "english": "Liberia", + "spell": "libiliya", + "french": "Liberia", + "italian": "Liberia", + "spanish": "Liberia", + "japanese": "リベリア", + "russian": "Либерия", + "germen": "Liberia" +}, +{ + "abbr": "LY", + "chinese": "利比亚", + "code": "218", + "english": "Libya", + "spell": "libiya", + "continent": "非洲", + "french": "Libye", + "italian": "Libia", + "spanish": "Libia", + "japanese": "リビア", + "russian": "Ливия", + "germen": "Libyen" +}, +{ + "abbr": "LT", + "chinese": "立陶宛", + "code": "370", + "english": "Lithuania", + "spell": "litaowan", + "continent": "欧洲", + "french": "Lituanie", + "italian": "Lituania", + "spanish": "Lituania", + "japanese": "リトアニア", + "russian": "Литва", + "germen": "Litauen" +}, +{ + "abbr": "LU", + "chinese": "卢森堡", + "code": "352", + "english": "Luxembourg", + "spell": "lusenbao", + "continent": "亚洲", + "french": "Luxembourg", + "italian": "Lussemburgo", + "spanish": "Luxemburgo", + "japanese": "ルクセンブルク", + "russian": "Люксембург", + "germen": "Luxemburg" +}, +{ + "abbr": "MO", + "chinese": "中国澳门特别行政区", + "code": "853", + "english": "Macao SAR China", + "spell": "zhongguoaomentebiexingzhengqu", + "continent": "亚洲", + "french": "Macao", + "italian": "Macao", + "spanish": "Macao", + "japanese": "マカオ", + "russian": "Макао SAR Китай", + "germen": "Macao" +}, +{ + "abbr": "MK", + "chinese": "马其顿", + "code": "389", + "english": "Macedonia", + "spell": "maqidun", + "french": "Macédoine", + "italian": "Macedonia", + "spanish": "Macedonia", + "japanese": "マケドニア旧ユーゴスラビア共和国", + "russian": "Македония", + "germen": "Mazedonien" +}, +{ + "abbr": "MG", + "chinese": "马达加斯加", + "code": "261", + "english": "Madagascar", + "spell": "madajiasijia", + "continent": "非洲", + "french": "Madagascar", + "italian": "Madagascar", + "spanish": "Madagascar", + "japanese": "マダガスカル", + "russian": "Мадагаскар", + "germen": "Madagaskar" +}, +{ + "abbr": "MW", + "chinese": "马拉维", + "code": "265", + "english": "Malawi", + "spell": "malawei", + "french": "Malawi", + "italian": "Malawi", + "spanish": "Malawi", + "japanese": "マラウイ", + "russian": "Малави", + "germen": "Malawi" +}, +{ + "abbr": "MY", + "chinese": "马来西亚", + "code": "60", + "english": "Malaysia", + "spell": "malaixiya", + "continent": "亚洲", + "french": "Malaisie", + "italian": "Malesia", + "spanish": "Malasia", + "japanese": "マレーシア", + "russian": "Малайзия", + "germen": "Malaysia" +}, +{ + "abbr": "MV", + "chinese": "马尔代夫", + "code": "960", + "english": "Maldives", + "spell": "maerdaifu", + "continent": "亚洲", + "french": "Maldives", + "italian": "Maldive", + "spanish": "Maldivas", + "japanese": "モルディブ", + "russian": "Мальдивы", + "germen": "Malediven" +}, +{ + "abbr": "ML", + "chinese": "马里", + "code": "223", + "english": "Mali", + "spell": "mali", + "continent": "非洲", + "french": "Mali", + "italian": "Mali", + "spanish": "Mali", + "japanese": "マリ", + "russian": "Мали", + "germen": "Mali" +}, +{ + "abbr": "MT", + "chinese": "马耳他", + "code": "356", + "english": "Malta", + "spell": "maerta", + "continent": "欧洲", + "french": "Malte", + "italian": "Malta", + "spanish": "Malta", + "japanese": "マルタ", + "russian": "Мальта", + "germen": "Malta" +}, +{ + "abbr": "MR", + "chinese": "毛利塔尼亚", + "code": "222", + "english": "Mauritania", + "spell": "maolitaniya", + "continent": "非洲", + "french": "Mauritanie", + "italian": "Mauritania", + "spanish": "Mauritania", + "japanese": "モーリタニア", + "russian": "Мавритания", + "germen": "Mauretanien" +}, +{ + "abbr": "MU", + "chinese": "毛里求斯", + "code": "230", + "english": "Mauritius", + "spell": "maoliqiusi", + "continent": "非洲", + "french": "Île Maurice", + "italian": "Mauritius", + "spanish": "Mauricio", + "japanese": "モーリシャス", + "russian": "Маврикий", + "germen": "Mauritius" +}, +{ + "abbr": "MX", + "chinese": "墨西哥", + "code": "52", + "english": "Mexico", + "spell": "moxige", + "continent": "北美洲", + "french": "Mexique", + "italian": "Messico", + "spanish": "México", + "japanese": "メキシコ", + "russian": "Мексика", + "germen": "Mexiko" +}, +{ + "abbr": "MD", + "chinese": "摩尔多瓦", + "code": "373", + "english": "Moldova", + "spell": "moerduowa", + "continent": "欧洲", + "french": "Moldavie", + "italian": "Moldavia", + "spanish": "Moldavia", + "japanese": "モルドバ共和国", + "russian": "Молдавия", + "germen": "Moldawie" +}, +{ + "abbr": "MC", + "chinese": "摩纳哥", + "code": "377", + "english": "Monaco", + "spell": "monage", + "continent": "欧洲", + "french": "Monaco", + "italian": "Principato di Monaco", + "spanish": "Mónaco", + "japanese": "モナコ", + "russian": "Монако", + "germen": "Monaco" +}, +{ + "abbr": "MN", + "chinese": "蒙古", + "code": "976", + "english": "Mongolia", + "spell": "menggu", + "continent": "亚洲", + "french": "Mongolie", + "italian": "Mongolia", + "spanish": "Mongolia", + "japanese": "モンゴル", + "russian": "Монголия", + "germen": "Mongolei" +}, +{ + "abbr": "ME", + "chinese": "黑山共和国", + "code": "382", + "english": "Montenegro", + "spell": "heishangongheguo", + "french": "Monténégro", + "italian": "Montenegro", + "spanish": "Montenegro", + "japanese": "モンテネグロ", + "russian": "Черногория", + "germen": "Montenegro" +}, +{ + "abbr": "MA", + "chinese": "摩洛哥", + "code": "212", + "english": "Morocco", + "spell": "moluoge", + "continent": "非洲", + "french": "Sahara Occidental", + "italian": "Sahara Occidentale", + "spanish": "Sahara Occidental", + "japanese": "西サハラ", + "russian": "Марокко", + "germen": "Westsahara" +}, +{ + "abbr": "MZ", + "chinese": "莫桑比克", + "code": "258", + "english": "Mozambique", + "spell": "mosangbike", + "continent": "非洲", + "french": "Mozambique", + "italian": "Mozambico", + "spanish": "Mozambique", + "japanese": "モザンビーク", + "russian": "Мозамбик", + "germen": "Mosambik" +}, +{ + "abbr": "MM", + "chinese": "缅甸", + "code": "95", + "english": "Myanmar(Burma)", + "spell": "miandian", + "french": "Myanmar", + "italian": "Birmania", + "spanish": "Myanmar", + "japanese": "ミャンマー", + "russian": "Мьянма (Бирма)", + "germen": "Myanmar" +}, +{ + "abbr": "NA", + "chinese": "纳米比亚", + "code": "264", + "english": "Namibia", + "spell": "namibiya", + "continent": "非洲", + "french": "Namibie", + "italian": "Namibia", + "spanish": "Namibia", + "japanese": "ナミビア", + "russian": "Намибия", + "germen": "Namibia" +}, +{ + "abbr": "NP", + "chinese": "尼泊尔", + "code": "977", + "english": "Nepal", + "spell": "niboer", + "continent": "亚洲", + "french": "Népal", + "italian": "Nepal", + "spanish": "Nepal", + "japanese": "ネパール", + "russian": "Непал", + "germen": "Népal" +}, +{ + "abbr": "NL", + "chinese": "荷兰", + "code": "31", + "english": "Netherlands", + "spell": "helan", + "continent": "欧洲", + "french": "Pays-Bas", + "italian": "Paesi Bassi", + "spanish": "Países Bajos", + "japanese": "オランダ", + "russian": "Нидерланды", + "germen": "Niederlande" +}, +{ + "abbr": "NZ", + "chinese": "新西兰", + "code": "64", + "english": "New Zealand", + "spell": "xinxilan", + "continent": "大洋洲", + "french": "Îles Pitcairn", + "italian": "Isole Pitcairn", + "spanish": "Islas Pitcairn", + "japanese": "ピトケアン", + "russian": "Новая Зеландия", + "germen": "Pitcairn" +}, +{ + "abbr": "NI", + "chinese": "尼加拉瓜", + "code": "505", + "english": "Nicaragua", + "spell": "nijialagua", + "continent": "北美洲", + "french": "Nicaragua", + "italian": "Nicaragua", + "spanish": "Nicaragua", + "japanese": "ニカラグア", + "russian": "Никарагуа", + "germen": "Nicaragua" +}, +{ + "abbr": "NE", + "chinese": "尼日尔", + "code": "227", + "english": "Niger", + "spell": "nirier", + "continent": "非洲", + "french": "Niger", + "italian": "Niger", + "spanish": "Níger", + "japanese": "ニジェール", + "russian": "Нигер", + "germen": "Niger" +}, +{ + "abbr": "NG", + "chinese": "尼日利亚", + "code": "234", + "english": "Nigeria", + "spell": "niriliya", + "continent": "非洲", + "french": "Nigéria", + "italian": "Nigeria", + "spanish": "Nigeria", + "japanese": "ナイジェリア", + "russian": "Нигерия", + "germen": "Nigeria" +}, +{ + "abbr": "KP", + "chinese": "朝鲜", + "code": "850", + "english": "North Korea", + "spell": "chaoxian", + "continent": "亚洲", + "french": "Corée du Nord", + "italian": "Corea del Nord", + "spanish": "Corea del Norte", + "japanese": "朝鮮民主主義人民共和国", + "russian": "Северная Корея", + "germen": "Nordkorea" +}, +{ + "abbr": "NO", + "chinese": "挪威", + "code": "47", + "english": "Norway", + "spell": "nuowei", + "continent": "欧洲", + "french": "Norvège", + "italian": "Norvegia", + "spanish": "Noruega", + "japanese": "ノルウェー", + "russian": "Норвегия", + "germen": "Norwegen" +}, +{ + "abbr": "OM", + "chinese": "阿曼", + "code": "968", + "english": "Oman", + "spell": "aman", + "continent": "亚洲", + "french": "Oman", + "italian": "oman", + "spanish": "Omán", + "japanese": "オマーン", + "russian": "Оман", + "germen": "Oman" +}, +{ + "abbr": "PK", + "chinese": "巴基斯坦", + "code": "92", + "english": "Pakistan", + "spell": "bajisitan", + "continent": "亚洲", + "french": "Pakistan", + "italian": "Pakistan", + "spanish": "Pakistán", + "japanese": "パキスタン", + "russian": "Пакистан", + "germen": "Pakistan" +}, +{ + "abbr": "PA", + "chinese": "巴拿马", + "code": "507", + "english": "Panama", + "spell": "banama", + "continent": "北美洲", + "french": "Panama", + "italian": "Panama", + "spanish": "Panamá", + "japanese": "パナマ", + "russian": "Панама", + "germen": "Panama" +}, +{ + "abbr": "PY", + "chinese": "巴拉圭", + "code": "595", + "english": "Paraguay", + "spell": "balagui", + "continent": "南美洲", + "french": "Paraguay", + "italian": "Paraguay", + "spanish": "Paraguay", + "japanese": "パラグアイ", + "russian": "Парагвай", + "germen": "Paraguay" +}, +{ + "abbr": "PE", + "chinese": "秘鲁", + "code": "51", + "english": "Peru", + "spell": "milu", + "continent": "南美洲", + "french": "Pérou", + "italian": "Perù", + "spanish": "Perú", + "japanese": "ペルー", + "russian": "Перу", + "germen": "Peru" +}, +{ + "abbr": "PH", + "chinese": "菲律宾", + "code": "63", + "english": "Philippines", + "spell": "feilvbin", + "continent": "亚洲", + "french": "Philippines", + "italian": "Filippine", + "spanish": "Filipinas", + "japanese": "フィリピン", + "russian": "Филиппины", + "germen": "Philippinen" +}, +{ + "abbr": "PL", + "chinese": "波兰", + "code": "48", + "english": "Poland", + "spell": "bolan", + "continent": "欧洲", + "french": "Pologne", + "italian": "Polonia", + "spanish": "Polonia", + "japanese": "ポーランド", + "russian": "Польша", + "germen": "Polen" +}, +{ + "abbr": "PT", + "chinese": "葡萄牙", + "code": "351", + "english": "Portugal", + "spell": "putaoya", + "continent": "欧洲", + "french": "Portugal", + "italian": "Portogallo", + "spanish": "Portugal", + "japanese": "ポルトガル", + "russian": "Португалия", + "germen": "Portugal" +}, +{ + "abbr": "PR", + "chinese": "波多黎各", + "code": "1787", + "english": "Puerto Rico", + "spell": "boduolige", + "french": "Porto Rico", + "italian": "Porto Rico", + "spanish": "Puerto Rico", + "japanese": "プエルトリコ", + "russian": "Пуэрто-Рико", + "germen": "Puerto Rico" +}, +{ + "abbr": "QA", + "chinese": "卡塔尔", + "code": "974", + "english": "Qatar", + "spell": "kataer", + "continent": "亚洲", + "french": "Qatar", + "italian": "Qatar", + "spanish": "Catar", + "japanese": "カタール", + "russian": "Катар", + "germen": "Katar" +}, +{ + "abbr": "RE", + "chinese": "留尼旺", + "code": "262", + "english": "Reunion", + "spell": "liuniwang", + "french": "Réunion", + "italian": "Riunione", + "spanish": "Reunión", + "japanese": "レユニオン", + "russian": "воссоединение", + "germen": "Réunion" +}, +{ + "abbr": "RO", + "chinese": "罗马尼亚", + "code": "40", + "english": "Romania", + "spell": "luomaniya", + "continent": "欧洲", + "french": "Roumanie", + "italian": "Romania", + "spanish": "Rumania", + "japanese": "ルーマニア", + "russian": "Румыния", + "germen": "Rumänien" +}, +{ + "abbr": "RU", + "chinese": "俄罗斯", + "code": "7", + "english": "Russia", + "spell": "eluosi", + "continent": "欧洲", + "french": "Russie", + "italian": "Russia", + "spanish": "Rusia", + "japanese": "ロシア連邦", + "russian": "Россия", + "germen": "Russland" +}, +{ + "abbr": "RW", + "chinese": "卢旺达", + "code": "250", + "english": "Rwanda", + "spell": "luwangda", + "continent": "非洲", + "french": "Rwanda", + "italian": "Ruanda", + "spanish": "Ruanda", + "japanese": "ルワンダ", + "russian": "Руанда", + "germen": "Ruanda" +}, +{ + "abbr": "SM", + "chinese": "圣马力诺", + "code": "378", + "english": "San Marino", + "spell": "shengmalinuo", + "continent": "欧洲", + "french": "Saint-Marin", + "italian": "San Marino", + "spanish": "San Marino", + "japanese": "サンマリノ", + "russian": "Сан-Марино", + "germen": "San Marino" +}, +{ + "abbr": "SA", + "chinese": "沙特阿拉伯", + "code": "966", + "english": "Saudi Arabia", + "spell": "shatealabo", + "continent": "亚洲", + "french": "Arabie Saoudite", + "italian": "Arabia Saudita", + "spanish": "Arabia Saudí", + "japanese": "サウジアラビア", + "russian": "Саудовская Аравия", + "germen": "Saudi-Arabien" +}, +{ + "abbr": "SN", + "chinese": "塞内加尔", + "code": "221", + "english": "Senegal", + "spell": "saineijiaer", + "continent": "非洲", + "french": "Sénégal", + "italian": "Senegal", + "spanish": "Senegal", + "japanese": "セネガル", + "russian": "Сенегал", + "germen": "Senegal" +}, +{ + "abbr": "RS", + "chinese": "塞尔维亚", + "code": "381", + "english": "Serbia", + "spell": "saierweiya", + "french": "Serbie", + "italian": "Serbia", + "spanish": "Serbia", + "japanese": "セルビア", + "russian": "Сербия", + "germen": "Serbien" +}, +{ + "abbr": "SL", + "chinese": "塞拉利昂", + "code": "232", + "english": "Sierra Leone", + "spell": "sailaliang", + "french": "Sierra Leone", + "italian": "Sierra Leone", + "spanish": "Sierra Leone", + "japanese": "シエラレオネ", + "russian": "Сьерра-Леоне", + "germen": "Sierra Leone" +}, +{ + "abbr": "SG", + "chinese": "新加坡", + "code": "65", + "english": "Singapore", + "spell": "xinjiapo", + "continent": "亚洲", + "french": "Singapour", + "italian": "Singapore", + "spanish": "Singapur", + "japanese": "シンガポール", + "russian": "Сингапур", + "germen": "Singapur" +}, +{ + "abbr": "SK", + "chinese": "斯洛伐克", + "code": "421", + "english": "Slovakia", + "spell": "siluofake", + "continent": "欧洲", + "french": "Slovaquie", + "italian": "Slovacchia", + "spanish": "República Eslovaca", + "japanese": "スロバキア", + "russian": "Словакия", + "germen": "Slowakei" +}, +{ + "abbr": "SI", + "chinese": "斯洛文尼亚", + "code": "386", + "english": "Slovenia", + "spell": "siluowenniya", + "french": "Slovénie", + "italian": "Slovenia", + "spanish": "Eslovenia", + "japanese": "スロベニア", + "russian": "Словения", + "germen": "Slowenien" +}, +{ + "abbr": "SO", + "chinese": "索马里", + "code": "252", + "english": "Somalia", + "spell": "suomali", + "continent": "非洲", + "french": "Somalie", + "italian": "Somalia", + "spanish": "Somalia", + "japanese": "ソマリア", + "russian": "Сомали", + "germen": "Somalia" +}, +{ + "abbr": "ZA", + "chinese": "南非", + "code": "27", + "english": "South Africa", + "spell": "nanfei", + "continent": "非洲", + "french": "Afrique du Sud", + "italian": "Sud Africa", + "spanish": "República de Sudáfrica", + "japanese": "南アフリカ", + "russian": "Южно-Африканская Республика (ЮАР)", + "germen": "Republik Südafrika" +}, +{ + "abbr": "ES", + "chinese": "西班牙", + "code": "34", + "english": "Spain", + "spell": "xibanya", + "continent": "欧洲", + "french": "Espagne", + "italian": "Spagna", + "spanish": "España", + "japanese": "スペイン", + "russian": "Испания", + "germen": "Spanien" +}, +{ + "abbr": "LK", + "chinese": "斯里兰卡", + "code": "94", + "english": "Sri Lanka", + "spell": "sililanka", + "french": "Sri Lanka", + "italian": "Sri Lanka", + "spanish": "Sri Lanka", + "japanese": "スリランカ", + "russian": "Шри-Ланка", + "germen": "Sri Lanka" +}, +{ + "abbr": "SD", + "chinese": "苏丹", + "code": "249", + "english": "Sudan", + "spell": "sudan", + "continent": "非洲", + "french": "Soudan", + "italian": "Sudan", + "spanish": "Sudán", + "japanese": "スーダン", + "russian": "Судан", + "germen": "Sudan" +}, +{ + "abbr": "SR", + "chinese": "苏里南", + "code": "597", + "english": "Suriname", + "spell": "sulinan", + "french": "Surinam", + "italian": "Suriname", + "spanish": "Surinam", + "japanese": "スリナム", + "russian": "Суринам", + "germen": "Suriname" +}, +{ + "abbr": "SZ", + "chinese": "斯威士兰", + "code": "268", + "english": "Swaziland", + "spell": "siweishilan", + "french": "Swaziland", + "italian": "Swaziland", + "spanish": "Suazilandia", + "japanese": "スワジランド", + "russian": "Свазиленд", + "germen": "Swasiland" +}, +{ + "abbr": "SE", + "chinese": "瑞典", + "code": "46", + "english": "Sweden", + "spell": "ruidian", + "continent": "欧洲", + "french": "Suède", + "italian": "Svezia", + "spanish": "Suecia", + "japanese": "スウェーデン", + "russian": "Швеция", + "germen": "Schweden" +}, +{ + "abbr": "CH", + "chinese": "瑞士", + "code": "41", + "english": "Switzerland", + "spell": "ruishi", + "continent": "欧洲", + "french": "Suisse", + "italian": "Svizzera", + "spanish": "Suiza", + "japanese": "スイス", + "russian": "Швейцария", + "germen": "Schweiz" +}, +{ + "abbr": "SY", + "chinese": "叙利亚", + "code": "963", + "english": "Syria", + "spell": "xuliya", + "continent": "亚洲", + "french": "Syrie", + "italian": "Siria", + "spanish": "Siria", + "japanese": "シリア・アラブ共和国", + "russian": "Сирия", + "germen": "Syrien" +}, +{ + "abbr": "TW", + "chinese": "中国台湾", + "code": "886", + "english": "Taiwan", + "spell": "zhongguotaiwan", + "continent": "亚洲", + "french": "Taïwan", + "italian": "Taiwan", + "spanish": "Taiwán", + "japanese": "台湾（中華民国）", + "russian": "Тайвань", + "germen": "Taiwan" +}, +{ + "abbr": "TJ", + "chinese": "塔吉克斯坦", + "code": "992", + "english": "Tajikstan", + "spell": "tajikesitan", + "continent": "亚洲", + "french": "Tadjikistan", + "italian": "Tagikistan", + "spanish": "Tayikistán", + "japanese": "タジキスタン", + "russian": "Таджикистан", + "germen": "Tadschikistan" +}, +{ + "abbr": "TZ", + "chinese": "坦桑尼亚", + "code": "255", + "english": "Tanzania", + "spell": "tansangniya", + "continent": "非洲", + "french": "Tanzanie", + "italian": "Tanzania", + "spanish": "Tanzania", + "japanese": "タンザニア", + "russian": "Танзания", + "germen": "Tansania" +}, +{ + "abbr": "TH", + "chinese": "泰国", + "code": "66", + "english": "Thailand", + "spell": "taiguo", + "continent": "亚洲", + "french": "Thaïlande", + "italian": "Tailandia", + "spanish": "Tailandia", + "japanese": "タイ", + "russian": "Таиланд", + "germen": "Thailand" +}, +{ + "abbr": "TG", + "chinese": "多哥", + "code": "228", + "english": "Togo", + "spell": "duoge", + "french": "Togo", + "italian": "Togo", + "spanish": "Togo", + "japanese": "トーゴ", + "russian": "Того", + "germen": "Togo" +}, +{ + "abbr": "TO", + "chinese": "汤加", + "code": "676", + "english": "Tonga", + "spell": "tangjia", + "continent": "大洋洲", + "french": "Tonga", + "italian": "Tonga", + "spanish": "Tonga", + "japanese": "トンガ", + "russian": "Тонга", + "germen": "Tonga" +}, +{ + "abbr": "TT", + "chinese": "特立尼达和多巴哥", + "code": "1868", + "english": "Trinidad and Tobago", + "spell": "telinidaheduobage", + "french": "Trinité et Tobago", + "italian": "Trinidad e Tobago", + "spanish": "Trinidad y Tobago", + "japanese": "トリニダード・トバゴ", + "russian": "Тринидад и Тобаго", + "germen": "Trinidad und Tobago" +}, +{ + "abbr": "TN", + "chinese": "突尼斯", + "code": "216", + "english": "Tunisia", + "spell": "tunisi", + "continent": "非洲", + "french": "Tunisie", + "italian": "Tunisia", + "spanish": "Túnez", + "japanese": "チュニジア", + "russian": "Тунис", + "germen": "Tunesien" +}, +{ + "abbr": "TR", + "chinese": "土耳其", + "code": "90", + "english": "Turkey", + "spell": "tuerqi", + "french": "Turquie", + "italian": "Turchia", + "spanish": "Turquía", + "japanese": "トルコ", + "russian": "Турция", + "germen": "Türkei", + "continent": "欧洲" +}, +{ + "abbr": "TM", + "chinese": "土库曼斯坦", + "code": "993", + "english": "Turkmenistan", + "spell": "tukumansitan", + "continent": "亚洲", + "french": "Turkménistan", + "italian": "Turkmenistan", + "spanish": "Turkmenistán", + "japanese": "トルクメニスタン", + "russian": "Туркменистан", + "germen": "Turkmenistan" +}, +{ + "abbr": "VI", + "chinese": "美属维尔京群岛", + "code": "1340", + "english": "U.S. Virgin Islands", + "spell": "meishuweierjingqundao", + "french": "Îles Vierges américaines", + "italian": "Isole Vergini americane", + "spanish": "Islas Vírgenes de EE.UU", + "japanese": "米領バージン諸島", + "russian": "Виргинские острова США", + "germen": "US Jungferninseln" +}, +{ + "abbr": "UG", + "chinese": "乌干达", + "code": "256", + "english": "Uganda", + "spell": "wuganda", + "continent": "非洲", + "french": "Uganda", + "italian": "Uganda", + "spanish": "Uganda", + "japanese": "ウガンダ", + "russian": "Уганда", + "germen": "Uganda" +}, +{ + "abbr": "UA", + "chinese": "乌克兰", + "code": "380", + "english": "Ukraine", + "spell": "wukelan", + "continent": "欧洲", + "french": "Ukraine", + "italian": "Ucraina", + "spanish": "Ucrania", + "japanese": "ウクライナ", + "russian": "Украина", + "germen": "Ukraine" +}, +{ + "abbr": "AE", + "chinese": "阿拉伯联合酋长国", + "code": "971", + "english": "United Arab Emirates", + "spell": "alabolianheqiuzhangguo", + "continent": "亚洲", + "french": "Émirats arabes unis", + "italian": "Emirati Arabi Uniti", + "spanish": "Emiratos Árabes Unidos", + "japanese": "アラブ首長国連邦", + "russian": "Объединённые Арабские Эмираты (ОАЭ)", + "germen": "Vereinigte Arabische Emirate" +}, +{ + "abbr": "GB", + "chinese": "英国", + "code": "44", + "english": "United Kiongdom", + "spell": "yingguo", + "continent": "欧洲", + "french": "Royaume-Uni", + "italian": "Regno Unito", + "spanish": "Reino Unido", + "japanese": "イギリス", + "russian": "Объединенное Королевство", + "germen": "Vereinigtes Königreich" +}, +{ + "abbr": "US", + "chinese": "美国", + "code": "1", + "english": "USA", + "spell": "meiguo", + "continent": "北美洲", + "french": "États-Unis", + "italian": "Stati Uniti D\u0027America", + "spanish": "Estados Unidos", + "japanese": "アメリカ合衆国", + "russian": "Соединенные Штаты Америки", + "germen": "Vereinigte Staaten von Amerika" +}, +{ + "abbr": "UY", + "chinese": "乌拉圭", + "code": "598", + "english": "Uruguay", + "spell": "wulagui", + "continent": "南美洲", + "french": "Uruguay", + "italian": "Uruguay", + "spanish": "Uruguay", + "japanese": "ウルグアイ", + "russian": "Уругвай", + "germen": "Uruguay" +}, +{ + "abbr": "UZ", + "chinese": "乌兹别克斯坦", + "code": "998", + "english": "Uzbekistan", + "spell": "wuzibiekesitan", + "continent": "亚洲", + "french": "Ouzbékistan", + "italian": "Uzbekistan", + "spanish": "Uzbekistán", + "japanese": "ウズベキスタン", + "russian": "Узбекистан", + "germen": "Usbekistan" +}, +{ + "abbr": "VA", + "chinese": "梵蒂冈城", + "code": "379", + "english": "Vatican City", + "spell": "fandigangcheng", + "continent": "欧洲", + "french": "voir Saint", + "italian": "Santa Sede", + "spanish": "Santa Sede", + "japanese": "聖座", + "russian": "Ватикан", + "germen": "Heiliger Stuhl" +}, +{ + "abbr": "VE", + "chinese": "委内瑞拉", + "code": "58", + "english": "Venezuela", + "spell": "weineiruila", + "continent": "北美洲", + "french": "Venezuela", + "italian": "Venezuela", + "spanish": "Venezuela", + "japanese": "ベネズエラ・ボリバル共和国", + "russian": "Венесуэла", + "germen": "Venezuela" +}, +{ + "abbr": "VN", + "chinese": "越南", + "code": "84", + "english": "Vietnam", + "spell": "yuenan", + "continent": "亚洲", + "french": "Viêt Nam", + "italian": "Vietnam", + "spanish": "Vietnam", + "japanese": "ベトナム", + "russian": "Вьетнам", + "germen": "Vietnam" +}, +{ + "abbr": "YE", + "chinese": "也门", + "code": "967", + "english": "Yemen", + "spell": "yemen", + "continent": "亚洲", + "french": "Yémen", + "italian": "Yemen", + "spanish": "Yemen", + "japanese": "イエメン", + "russian": "Йемен", + "germen": "Jemen" +}, +{ + "abbr": "YU", + "chinese": "南斯拉夫", + "code": "381", + "english": "Yugoslavia", + "spell": "nansilafu", + "continent": "欧洲", + "french": "Serbie", + "italian": "Serbia", + "spanish": "Serbia", + "japanese": "セルビア", + "russian": "Югославия", + "germen": "Serbien" +}, +{ + "abbr": "ZR", + "chinese": "扎伊尔", + "code": "243", + "english": "Zaire", + "spell": "zhayier", + "continent": "非洲", + "french": "Congo (Rép. dém.)", + "italian": "Congo (Rep. Dem.)", + "spanish": "Congo (Rep. Dem.)", + "japanese": "コンゴ民主共和国", + "russian": "Заир", + "germen": "Kongo (Dem. Rep.)" +}, +{ + "abbr": "ZM", + "chinese": "赞比亚", + "code": "260", + "english": "Zambia", + "spell": "zanbiya", + "continent": "非洲", + "french": "Zambie", + "italian": "Zambia", + "spanish": "Zambia", + "japanese": "ザンビア", + "russian": "Замбия", + "germen": "Sambia" +}, +{ + "abbr": "ZW", + "chinese": "津巴布韦", + "code": "263", + "english": "Zimbabwe", + "spell": "jinbabuwei", + "continent": "非洲", + "french": "Zimbabwe", + "italian": "Zimbabwe", + "spanish": "Zimbabue", + "japanese": "ジンバブエ", + "russian": "Зимбабве", + "germen": "Simbabwe" +}] diff --git a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-C3BpNVeC.js b/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-C3BpNVeC.js deleted file mode 100644 index 786195d..0000000 --- a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-C3BpNVeC.js +++ /dev/null @@ -1,828 +0,0 @@ -import { importShared } from './__federation_fn_import-JrT3xvdd.js'; -import { _ as _export_sfc } from './_plugin-vue_export-helper-pcqpp-6-.js'; - -const {createTextVNode:_createTextVNode,resolveComponent:_resolveComponent,withCtx:_withCtx,createVNode:_createVNode,toDisplayString:_toDisplayString,openBlock:_openBlock,createBlock:_createBlock,createCommentVNode:_createCommentVNode,createElementVNode:_createElementVNode,mergeProps:_mergeProps,withModifiers:_withModifiers,createElementBlock:_createElementBlock} = await importShared('vue'); - - -const _hoisted_1 = { class: "plugin-config" }; -const _hoisted_2 = { class: "d-flex align-center" }; -const _hoisted_3 = { class: "font-weight-medium" }; -const _hoisted_4 = { class: "text-body-2" }; - -const {ref,reactive,onMounted,computed} = await importShared('vue'); - - -// Props - -const _sfc_main = { - __name: 'Config', - props: { - initialConfig: { - type: Object, - default: () => ({}), - }, - api: { - type: Object, - default: () => { - }, - }, -}, - emits: ['save', 'close'], - setup(__props, { emit: __emit }) { - -const props = __props; - -// 状态变量 -const form = ref(null); -const isFormValid = ref(true); -const error = ref(null); -const saving = ref(false); -const testing = ref(false); -const showClashSecret = ref(false); -const selectedCronOption = ref('6hours'); - -// Test result state -const testResult = reactive({ - show: false, - success: false, - title: '', - message: '' -}); - -// Cron 选项 -const cronOptions = [ - {text: '每5分钟', value: '5min', cron: '*/5 * * * *'}, - {text: '每15分钟', value: '15min', cron: '*/15 * * * *'}, - {text: '每30分钟', value: '30min', cron: '*/30 * * * *'}, - {text: '每小时', value: '1hour', cron: '0 * * * *'}, - {text: '每2小时', value: '2hours', cron: '0 */2 * * *'}, - {text: '每6小时', value: '6hours', cron: '0 */6 * * *'}, - {text: '每12小时', value: '12hours', cron: '0 */12 * * *'}, - {text: '每天', value: '1day', cron: '0 0 * * *'}, - {text: '自定义', value: 'custom', cron: ''}, -]; - -// 默认配置 -const defaultConfig = { - enabled: false, - sub_links: [], - filter_keywords: ["公益性", "高延迟", "域名", "官网", "重启", "过期时间", "系统代理"], - clash_dashboard_url: '', - clash_dashboard_secret: '', - movie_pilot_url: '', - cron_string: '0 */6 * * *', - timeout: 10, - retry_times: 3, - proxy: false, - notify: false, - auto_update_subscriptions: true, - ruleset_prefix: '📂<-', -}; - -// 响应式配置对象 -const config = reactive({...defaultConfig}); - -// 自定义事件 -const emit = __emit; - -// 初始化 -onMounted(() => { - if (props.initialConfig) { - Object.keys(props.initialConfig).forEach(key => { - if (key in config) { - config[key] = props.initialConfig[key]; - } - }); - - // 设置对应的cron选项 - const cronOption = cronOptions.find(option => option.cron === config.cron_string); - if (cronOption) { - selectedCronOption.value = cronOption.value; - } else { - selectedCronOption.value = 'custom'; - } - } -}); - -// 验证函数 -function isValidUrl(url) { - try { - new URL(url); - return true - } catch { - return false - } -} - -function validateSubLinks(links) { - if (!links || links.length === 0) { - return '至少需要一个订阅链接' - } - - for (const link of links) { - if (!isValidUrl(link)) { - return `无效的订阅链接: ${link}` - } - } - return true -} - -function validateCronExpression(cronStr) { - if (!cronStr) return '请输入Cron表达式' - - // 简单的cron表达式验证 - const parts = cronStr.trim().split(/\s+/); - if (parts.length !== 5) { - return 'Cron表达式应包含5个部分 (分 时 日 月 周)' - } - return true -} - -// 更新cron字符串 -function updateCronString(optionValue) { - const option = cronOptions.find(opt => opt.value === optionValue); - if (option && option.cron) { - config.cron_string = option.cron; - } -} - -// 测试连接 -async function testConnection() { - testing.value = true; - error.value = null; - testResult.show = false; - - try { - // 验证必需的参数 - if (!config.clash_dashboard_url) { - throw new Error('请先配置 Clash 面板 URL') - } - if (!config.clash_dashboard_secret) { - throw new Error('请先配置 Clash 面板密钥') - } - if (!config.sub_links || config.sub_links.length === 0) { - throw new Error('请先配置至少一个订阅链接') - } - if (!config.movie_pilot_url || config.movie_pilot_url.length === 0) { - throw new Error('请先MoviePilot链接') - } - // 准备API请求参数 - const testParams = { - clash_dashboard_url: config.clash_dashboard_url, - clash_dashboard_secret: config.clash_dashboard_secret, - sub_link: config.sub_links[0] // 使用第一个订阅链接进行测试 - }; - - // 调用API进行连接测试 - const result = await props.api.post('/plugin/ClashRuleProvider/connectivity', testParams); - - // 根据返回结果显示相应消息 - if (result.success) { - testResult.success = true; - testResult.title = '连接测试成功！'; - testResult.message = 'Clash面板和订阅链接连接正常，配置验证通过'; - testResult.show = true; - - // Auto hide after 5 seconds - setTimeout(() => { - testResult.show = false; - }, 5000); - } else { - throw new Error(result.message || '连接测试失败，请检查配置') - } - - } catch (err) { - console.error('连接测试失败:', err); - testResult.success = false; - testResult.title = '连接测试失败'; - testResult.message = err.message; - testResult.show = true; - } finally { - testing.value = false; - } -} - -// 保存配置 -async function saveConfig() { - if (!isFormValid.value) { - error.value = '请修正表单中的错误'; - return - } - - saving.value = true; - error.value = null; - - try { - await new Promise(resolve => setTimeout(resolve, 1000)); - emit('save', {...config}); - } catch (err) { - console.error('保存配置失败:', err); - error.value = err.message || '保存配置失败'; - } finally { - saving.value = false; - } -} - -function extractDomain(url) { - try { - const domain = new URL(url).hostname; - return domain.startsWith('www.') ? domain.substring(4) : domain - } catch { - return url // 如果解析失败，返回原始URL - } -} - -// 重置表单 -function resetForm() { - Object.keys(defaultConfig).forEach(key => { - config[key] = defaultConfig[key]; - }); - selectedCronOption.value = '6hours'; - - if (form.value) { - form.value.resetValidation(); - } -} - -// 关闭组件 -function notifyClose() { - emit('close'); -} - -// 通知主应用切换到Page页面 -function notifySwitch() { - emit('switch'); -} - -return (_ctx, _cache) => { - const _component_v_card_title = _resolveComponent("v-card-title"); - const _component_v_icon = _resolveComponent("v-icon"); - const _component_v_btn = _resolveComponent("v-btn"); - const _component_v_card_item = _resolveComponent("v-card-item"); - const _component_v_alert = _resolveComponent("v-alert"); - const _component_v_switch = _resolveComponent("v-switch"); - const _component_v_col = _resolveComponent("v-col"); - const _component_v_row = _resolveComponent("v-row"); - const _component_v_chip = _resolveComponent("v-chip"); - const _component_v_combobox = _resolveComponent("v-combobox"); - const _component_v_text_field = _resolveComponent("v-text-field"); - const _component_v_select = _resolveComponent("v-select"); - const _component_v_expansion_panel_title = _resolveComponent("v-expansion-panel-title"); - const _component_v_expansion_panel_text = _resolveComponent("v-expansion-panel-text"); - const _component_v_expansion_panel = _resolveComponent("v-expansion-panel"); - const _component_v_expansion_panels = _resolveComponent("v-expansion-panels"); - const _component_v_form = _resolveComponent("v-form"); - const _component_v_card_text = _resolveComponent("v-card-text"); - const _component_v_spacer = _resolveComponent("v-spacer"); - const _component_v_card_actions = _resolveComponent("v-card-actions"); - const _component_v_card = _resolveComponent("v-card"); - - return (_openBlock(), _createElementBlock("div", _hoisted_1, [ - _createVNode(_component_v_card, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card_item, null, { - append: _withCtx(() => [ - _createVNode(_component_v_btn, { - icon: "", - color: "primary", - variant: "text", - onClick: notifyClose - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[18] || (_cache[18] = [ - _createTextVNode("mdi-close") - ])), - _: 1 - }) - ]), - _: 1 - }) - ]), - default: _withCtx(() => [ - _createVNode(_component_v_card_title, null, { - default: _withCtx(() => _cache[17] || (_cache[17] = [ - _createTextVNode("Clash Rule Provider 插件配置") - ])), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_card_text, { class: "overflow-y-auto" }, { - default: _withCtx(() => [ - (error.value) - ? (_openBlock(), _createBlock(_component_v_alert, { - key: 0, - type: "error", - class: "mb-4" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(error.value), 1) - ]), - _: 1 - })) - : _createCommentVNode("", true), - _createVNode(_component_v_form, { - ref_key: "form", - ref: form, - modelValue: isFormValid.value, - "onUpdate:modelValue": _cache[15] || (_cache[15] = $event => ((isFormValid).value = $event)), - onSubmit: _withModifiers(saveConfig, ["prevent"]) - }, { - default: _withCtx(() => [ - _cache[28] || (_cache[28] = _createElementVNode("div", { class: "text-subtitle-1 font-weight-bold mt-4 mb-2" }, "基本设置", -1)), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { - cols: "12", - md: "4" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_switch, { - modelValue: config.enabled, - "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((config.enabled) = $event)), - label: "启用插件", - color: "primary", - inset: "", - hint: "启用后插件将开始监控和同步", - "persistent-hint": "" - }, null, 8, ["modelValue"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { - cols: "12", - md: "4" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_switch, { - modelValue: config.proxy, - "onUpdate:modelValue": _cache[1] || (_cache[1] = $event => ((config.proxy) = $event)), - label: "启用代理", - color: "primary", - inset: "", - hint: "是否使用系统代理进行网络请求", - "persistent-hint": "" - }, null, 8, ["modelValue"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { - cols: "12", - md: "4" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_switch, { - modelValue: config.notify, - "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => ((config.notify) = $event)), - label: "启用通知", - color: "primary", - inset: "", - hint: "执行完成后发送通知消息", - "persistent-hint": "" - }, null, 8, ["modelValue"]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _cache[29] || (_cache[29] = _createElementVNode("div", { class: "text-subtitle-1 font-weight-bold mt-4 mb-2" }, "订阅配置", -1)), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_combobox, { - modelValue: config.sub_links, - "onUpdate:modelValue": _cache[3] || (_cache[3] = $event => ((config.sub_links) = $event)), - label: "订阅链接", - variant: "outlined", - multiple: "", - chips: "", - "closable-chips": "", - hint: "添加一个Clash订阅链接", - "persistent-hint": "", - rules: [validateSubLinks] - }, { - chip: _withCtx(({ props, item }) => [ - _createVNode(_component_v_chip, _mergeProps(props, { - closable: "", - size: "small" - }), { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(extractDomain(item.value)), 1) - ]), - _: 2 - }, 1040) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_combobox, { - modelValue: config.filter_keywords, - "onUpdate:modelValue": _cache[4] || (_cache[4] = $event => ((config.filter_keywords) = $event)), - label: "节点过滤关键词", - variant: "outlined", - multiple: "", - chips: "", - "closable-chips": "", - hint: "添加用于过滤节点的关键词", - "persistent-hint": "" - }, { - chip: _withCtx(({ props, item }) => [ - _createVNode(_component_v_chip, _mergeProps(props, { - closable: "", - size: "small", - color: "info" - }), { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(item.value), 1) - ]), - _: 2 - }, 1040) - ]), - _: 1 - }, 8, ["modelValue"]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _cache[30] || (_cache[30] = _createElementVNode("div", { class: "text-subtitle-1 font-weight-bold mt-4 mb-2" }, "Clash 面板设置", -1)), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.clash_dashboard_url, - "onUpdate:modelValue": _cache[5] || (_cache[5] = $event => ((config.clash_dashboard_url) = $event)), - label: "Clash 面板 URL", - variant: "outlined", - placeholder: "http://localhost:9090", - hint: "Clash 控制面板的访问地址", - "persistent-hint": "", - rules: [v => !v || isValidUrl(v) || '请输入有效的URL地址'] - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "primary" }, { - default: _withCtx(() => _cache[19] || (_cache[19] = [ - _createTextVNode("mdi-web") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.clash_dashboard_secret, - "onUpdate:modelValue": _cache[6] || (_cache[6] = $event => ((config.clash_dashboard_secret) = $event)), - label: "Clash 面板密钥", - variant: "outlined", - placeholder: "your-clash-secret", - hint: "用于访问Clash API的密钥", - "persistent-hint": "", - "append-inner-icon": showClashSecret.value ? 'mdi-eye-off' : 'mdi-eye', - type: showClashSecret.value ? 'text' : 'password', - "onClick:appendInner": _cache[7] || (_cache[7] = $event => (showClashSecret.value = !showClashSecret.value)) - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "warning" }, { - default: _withCtx(() => _cache[20] || (_cache[20] = [ - _createTextVNode("mdi-key") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "append-inner-icon", "type"]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _cache[31] || (_cache[31] = _createElementVNode("div", { class: "text-subtitle-1 font-weight-bold mt-4 mb-2" }, "MoviePilot 设置", -1)), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.movie_pilot_url, - "onUpdate:modelValue": _cache[8] || (_cache[8] = $event => ((config.movie_pilot_url) = $event)), - label: "MoviePilot URL", - variant: "outlined", - placeholder: "http://localhost:3001", - hint: "MoviePilot 服务的访问地址", - "persistent-hint": "", - rules: [v => !!v || 'MoviePilot URL不能为空', v => isValidUrl(v) || '请输入有效的URL地址'] - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "success" }, { - default: _withCtx(() => _cache[21] || (_cache[21] = [ - _createTextVNode("mdi-movie") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _cache[32] || (_cache[32] = _createElementVNode("div", { class: "text-subtitle-1 font-weight-bold mt-4 mb-2" }, "执行设置", -1)), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_select, { - modelValue: selectedCronOption.value, - "onUpdate:modelValue": [ - _cache[9] || (_cache[9] = $event => ((selectedCronOption).value = $event)), - updateCronString - ], - label: "执行周期", - items: cronOptions, - variant: "outlined", - "item-title": "text", - "item-value": "value", - hint: "选择插件执行的时间间隔", - "persistent-hint": "" - }, null, 8, ["modelValue"]) - ]), - _: 1 - }), - (selectedCronOption.value === 'custom') - ? (_openBlock(), _createBlock(_component_v_col, { - key: 0, - cols: "12" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.cron_string, - "onUpdate:modelValue": _cache[10] || (_cache[10] = $event => ((config.cron_string) = $event)), - label: "自定义 Cron 表达式", - variant: "outlined", - placeholder: "0 */6 * * *", - hint: "使用标准Cron表达式格式 (分 时 日 月 周)", - "persistent-hint": "", - rules: [validateCronExpression] - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "info" }, { - default: _withCtx(() => _cache[22] || (_cache[22] = [ - _createTextVNode("mdi-clock-outline") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - })) - : _createCommentVNode("", true), - _createVNode(_component_v_col, { - cols: "12", - md: "6" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.timeout, - "onUpdate:modelValue": _cache[11] || (_cache[11] = $event => ((config.timeout) = $event)), - modelModifiers: { number: true }, - label: "超时时间 (秒)", - variant: "outlined", - type: "number", - min: "1", - max: "300", - hint: "请求的超时时间", - "persistent-hint": "", - rules: [v => v > 0 || '超时时间必须大于0'] - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "warning" }, { - default: _withCtx(() => _cache[23] || (_cache[23] = [ - _createTextVNode("mdi-timer") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { - cols: "12", - md: "6" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.retry_times, - "onUpdate:modelValue": _cache[12] || (_cache[12] = $event => ((config.retry_times) = $event)), - modelModifiers: { number: true }, - label: "重试次数", - variant: "outlined", - type: "number", - min: "0", - max: "10", - hint: "失败时的重试次数", - "persistent-hint": "", - rules: [v => v >= 0 || '重试次数不能为负数'] - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "info" }, { - default: _withCtx(() => _cache[24] || (_cache[24] = [ - _createTextVNode("mdi-refresh") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue", "rules"]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_expansion_panels, { - variant: "accordion", - class: "mt-4" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_expansion_panel, null, { - default: _withCtx(() => [ - _createVNode(_component_v_expansion_panel_title, null, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { class: "mr-2" }, { - default: _withCtx(() => _cache[25] || (_cache[25] = [ - _createTextVNode("mdi-cog") - ])), - _: 1 - }), - _cache[26] || (_cache[26] = _createTextVNode(" 高级选项 ")) - ]), - _: 1 - }), - _createVNode(_component_v_expansion_panel_text, null, { - default: _withCtx(() => [ - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_switch, { - modelValue: config.auto_update_subscriptions, - "onUpdate:modelValue": _cache[13] || (_cache[13] = $event => ((config.auto_update_subscriptions) = $event)), - label: "自动更新订阅", - color: "primary", - inset: "", - hint: "定期自动更新Clash订阅配置" - }, null, 8, ["modelValue"]) - ]), - _: 1 - }), - _createVNode(_component_v_col, { cols: "12" }, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: config.ruleset_prefix, - "onUpdate:modelValue": _cache[14] || (_cache[14] = $event => ((config.ruleset_prefix) = $event)), - label: "规则集前缀", - variant: "outlined", - placeholder: "📂<-", - hint: "为生成的规则集添加前缀", - "persistent-hint": "" - }, { - "prepend-inner": _withCtx(() => [ - _createVNode(_component_v_icon, { color: "info" }, { - default: _withCtx(() => _cache[27] || (_cache[27] = [ - _createTextVNode("mdi-prefix") - ])), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue"]) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue"]) - ]), - _: 1 - }), - _createVNode(_component_v_card_actions, null, { - default: _withCtx(() => [ - _createVNode(_component_v_btn, { - color: "primary", - onClick: notifySwitch - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[33] || (_cache[33] = [ - _createTextVNode("mdi-view-dashboard-edit") - ])), - _: 1 - }), - _cache[34] || (_cache[34] = _createTextVNode(" 规则 ")) - ]), - _: 1 - }), - _createVNode(_component_v_btn, { - color: "secondary", - onClick: resetForm - }, { - default: _withCtx(() => _cache[35] || (_cache[35] = [ - _createTextVNode("重置") - ])), - _: 1 - }), - _createVNode(_component_v_btn, { - color: "info", - onClick: testConnection, - loading: testing.value - }, { - default: _withCtx(() => _cache[36] || (_cache[36] = [ - _createTextVNode("测试连接") - ])), - _: 1 - }, 8, ["loading"]), - _createVNode(_component_v_spacer), - _createVNode(_component_v_btn, { - color: "primary", - disabled: !isFormValid.value, - onClick: saveConfig, - loading: saving.value - }, { - default: _withCtx(() => _cache[37] || (_cache[37] = [ - _createTextVNode(" 保存配置 ") - ])), - _: 1 - }, 8, ["disabled", "loading"]) - ]), - _: 1 - }), - (testResult.show) - ? (_openBlock(), _createBlock(_component_v_alert, { - key: 0, - type: testResult.success ? 'success' : 'error', - variant: "tonal", - closable: "", - class: "ma-4 mt-0", - "onClick:close": _cache[16] || (_cache[16] = $event => (testResult.show = false)) - }, { - default: _withCtx(() => [ - _createElementVNode("div", _hoisted_2, [ - _createVNode(_component_v_icon, { class: "mr-2" }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(testResult.success ? 'mdi-check-circle' : 'mdi-alert-circle'), 1) - ]), - _: 1 - }), - _createElementVNode("div", null, [ - _createElementVNode("div", _hoisted_3, _toDisplayString(testResult.title), 1), - _createElementVNode("div", _hoisted_4, _toDisplayString(testResult.message), 1) - ]) - ]) - ]), - _: 1 - }, 8, ["type"])) - : _createCommentVNode("", true) - ]), - _: 1 - }) - ])) -} -} - -}; -const ConfigComponent = /*#__PURE__*/_export_sfc(_sfc_main, [['__scopeId',"data-v-0e64dae0"]]); - -export { ConfigComponent as default }; diff --git a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-DXzIavcD.css b/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-DXzIavcD.css deleted file mode 100644 index aadcf97..0000000 --- a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Config-DXzIavcD.css +++ /dev/null @@ -1,5 +0,0 @@ - -.plugin-config[data-v-0e64dae0] { - max-width: 800px; - margin: 0 auto; -} diff --git a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Dashboard-BkyO-3pr.js b/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Dashboard-BkyO-3pr.js deleted file mode 100644 index ef6abb8..0000000 --- a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Dashboard-BkyO-3pr.js +++ /dev/null @@ -1,40514 +0,0 @@ -import { importShared } from './__federation_fn_import-JrT3xvdd.js'; -import { f as defineComponent, A as h, bC as shallowRef, bF as toRefs, a5 as computed$1, g as getCurrentInstance, w as watch, b6 as watchEffect, j as onMounted$1, aD as onBeforeUnmount, n as nextTick, au as inject, br as isRef, u as unref } from './runtime-core.esm-bundler-BQhfUSSX.js'; - -await importShared('vue'); - -/*! ***************************************************************************** -Copyright (c) Microsoft Corporation. - -Permission to use, copy, modify, and/or distribute this software for any -purpose with or without fee is hereby granted. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH -REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY -AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, -INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM -LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR -OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR -PERFORMANCE OF THIS SOFTWARE. -***************************************************************************** */ -/* global Reflect, Promise */ - -var extendStatics = function(d, b) { - extendStatics = Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || - function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; - return extendStatics(d, b); -}; - -function __extends(d, b) { - if (typeof b !== "function" && b !== null) - throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); - extendStatics(d, b); - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); -} - -var Browser = (function () { - function Browser() { - this.firefox = false; - this.ie = false; - this.edge = false; - this.newEdge = false; - this.weChat = false; - } - return Browser; -}()); -var Env = (function () { - function Env() { - this.browser = new Browser(); - this.node = false; - this.wxa = false; - this.worker = false; - this.svgSupported = false; - this.touchEventsSupported = false; - this.pointerEventsSupported = false; - this.domSupported = false; - this.transformSupported = false; - this.transform3dSupported = false; - this.hasGlobalWindow = typeof window !== 'undefined'; - } - return Env; -}()); -var env = new Env(); -if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') { - env.wxa = true; - env.touchEventsSupported = true; -} -else if (typeof document === 'undefined' && typeof self !== 'undefined') { - env.worker = true; -} -else if (!env.hasGlobalWindow || 'Deno' in window) { - env.node = true; - env.svgSupported = true; -} -else { - detect(navigator.userAgent, env); -} -function detect(ua, env) { - var browser = env.browser; - var firefox = ua.match(/Firefox\/([\d.]+)/); - var ie = ua.match(/MSIE\s([\d.]+)/) - || ua.match(/Trident\/.+?rv:(([\d.]+))/); - var edge = ua.match(/Edge?\/([\d.]+)/); - var weChat = (/micromessenger/i).test(ua); - if (firefox) { - browser.firefox = true; - browser.version = firefox[1]; - } - if (ie) { - browser.ie = true; - browser.version = ie[1]; - } - if (edge) { - browser.edge = true; - browser.version = edge[1]; - browser.newEdge = +edge[1].split('.')[0] > 18; - } - if (weChat) { - browser.weChat = true; - } - env.svgSupported = typeof SVGRect !== 'undefined'; - env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge; - env.pointerEventsSupported = 'onpointerdown' in window - && (browser.edge || (browser.ie && +browser.version >= 11)); - env.domSupported = typeof document !== 'undefined'; - var style = document.documentElement.style; - env.transform3dSupported = ((browser.ie && 'transition' in style) - || browser.edge - || (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix())) - || 'MozPerspective' in style) - && !('OTransition' in style); - env.transformSupported = env.transform3dSupported - || (browser.ie && +browser.version >= 9); -} - -var DEFAULT_FONT_SIZE = 12; -var DEFAULT_FONT_FAMILY = 'sans-serif'; -var DEFAULT_FONT = DEFAULT_FONT_SIZE + "px " + DEFAULT_FONT_FAMILY; -var OFFSET = 20; -var SCALE = 100; -var defaultWidthMapStr = "007LLmW'55;N0500LLLLLLLLLL00NNNLzWW\\\\WQb\\0FWLg\\bWb\\WQ\\WrWWQ000CL5LLFLL0LL**F*gLLLL5F0LF\\FFF5.5N"; -function getTextWidthMap(mapStr) { - var map = {}; - if (typeof JSON === 'undefined') { - return map; - } - for (var i = 0; i < mapStr.length; i++) { - var char = String.fromCharCode(i + 32); - var size = (mapStr.charCodeAt(i) - OFFSET) / SCALE; - map[char] = size; - } - return map; -} -var DEFAULT_TEXT_WIDTH_MAP = getTextWidthMap(defaultWidthMapStr); -var platformApi = { - createCanvas: function () { - return typeof document !== 'undefined' - && document.createElement('canvas'); - }, - measureText: (function () { - var _ctx; - var _cachedFont; - return function (text, font) { - if (!_ctx) { - var canvas = platformApi.createCanvas(); - _ctx = canvas && canvas.getContext('2d'); - } - if (_ctx) { - if (_cachedFont !== font) { - _cachedFont = _ctx.font = font || DEFAULT_FONT; - } - return _ctx.measureText(text); - } - else { - text = text || ''; - font = font || DEFAULT_FONT; - var res = /((?:\d+)?\.?\d*)px/.exec(font); - var fontSize = res && +res[1] || DEFAULT_FONT_SIZE; - var width = 0; - if (font.indexOf('mono') >= 0) { - width = fontSize * text.length; - } - else { - for (var i = 0; i < text.length; i++) { - var preCalcWidth = DEFAULT_TEXT_WIDTH_MAP[text[i]]; - width += preCalcWidth == null ? fontSize : (preCalcWidth * fontSize); - } - } - return { width: width }; - } - }; - })(), - loadImage: function (src, onload, onerror) { - var image = new Image(); - image.onload = onload; - image.onerror = onerror; - image.src = src; - return image; - } -}; - -var BUILTIN_OBJECT = reduce([ - 'Function', - 'RegExp', - 'Date', - 'Error', - 'CanvasGradient', - 'CanvasPattern', - 'Image', - 'Canvas' -], function (obj, val) { - obj['[object ' + val + ']'] = true; - return obj; -}, {}); -var TYPED_ARRAY = reduce([ - 'Int8', - 'Uint8', - 'Uint8Clamped', - 'Int16', - 'Uint16', - 'Int32', - 'Uint32', - 'Float32', - 'Float64' -], function (obj, val) { - obj['[object ' + val + 'Array]'] = true; - return obj; -}, {}); -var objToString = Object.prototype.toString; -var arrayProto = Array.prototype; -var nativeForEach = arrayProto.forEach; -var nativeFilter = arrayProto.filter; -var nativeSlice = arrayProto.slice; -var nativeMap = arrayProto.map; -var ctorFunction = function () { }.constructor; -var protoFunction = ctorFunction ? ctorFunction.prototype : null; -var protoKey = '__proto__'; -var idStart = 0x0907; -function guid() { - return idStart++; -} -function logError() { - var args = []; - for (var _i = 0; _i < arguments.length; _i++) { - args[_i] = arguments[_i]; - } - if (typeof console !== 'undefined') { - console.error.apply(console, args); - } -} -function clone$2(source) { - if (source == null || typeof source !== 'object') { - return source; - } - var result = source; - var typeStr = objToString.call(source); - if (typeStr === '[object Array]') { - if (!isPrimitive(source)) { - result = []; - for (var i = 0, len = source.length; i < len; i++) { - result[i] = clone$2(source[i]); - } - } - } - else if (TYPED_ARRAY[typeStr]) { - if (!isPrimitive(source)) { - var Ctor = source.constructor; - if (Ctor.from) { - result = Ctor.from(source); - } - else { - result = new Ctor(source.length); - for (var i = 0, len = source.length; i < len; i++) { - result[i] = source[i]; - } - } - } - } - else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) { - result = {}; - for (var key in source) { - if (source.hasOwnProperty(key) && key !== protoKey) { - result[key] = clone$2(source[key]); - } - } - } - return result; -} -function merge(target, source, overwrite) { - if (!isObject$2(source) || !isObject$2(target)) { - return overwrite ? clone$2(source) : target; - } - for (var key in source) { - if (source.hasOwnProperty(key) && key !== protoKey) { - var targetProp = target[key]; - var sourceProp = source[key]; - if (isObject$2(sourceProp) - && isObject$2(targetProp) - && !isArray(sourceProp) - && !isArray(targetProp) - && !isDom(sourceProp) - && !isDom(targetProp) - && !isBuiltInObject(sourceProp) - && !isBuiltInObject(targetProp) - && !isPrimitive(sourceProp) - && !isPrimitive(targetProp)) { - merge(targetProp, sourceProp, overwrite); - } - else if (overwrite || !(key in target)) { - target[key] = clone$2(source[key]); - } - } - } - return target; -} -function extend(target, source) { - if (Object.assign) { - Object.assign(target, source); - } - else { - for (var key in source) { - if (source.hasOwnProperty(key) && key !== protoKey) { - target[key] = source[key]; - } - } - } - return target; -} -function defaults(target, source, overlay) { - var keysArr = keys(source); - for (var i = 0, len = keysArr.length; i < len; i++) { - var key = keysArr[i]; - if ((target[key] == null)) { - target[key] = source[key]; - } - } - return target; -} -function indexOf(array, value) { - if (array) { - if (array.indexOf) { - return array.indexOf(value); - } - for (var i = 0, len = array.length; i < len; i++) { - if (array[i] === value) { - return i; - } - } - } - return -1; -} -function inherits(clazz, baseClazz) { - var clazzPrototype = clazz.prototype; - function F() { } - F.prototype = baseClazz.prototype; - clazz.prototype = new F(); - for (var prop in clazzPrototype) { - if (clazzPrototype.hasOwnProperty(prop)) { - clazz.prototype[prop] = clazzPrototype[prop]; - } - } - clazz.prototype.constructor = clazz; - clazz.superClass = baseClazz; -} -function mixin(target, source, override) { - target = 'prototype' in target ? target.prototype : target; - source = 'prototype' in source ? source.prototype : source; - if (Object.getOwnPropertyNames) { - var keyList = Object.getOwnPropertyNames(source); - for (var i = 0; i < keyList.length; i++) { - var key = keyList[i]; - if (key !== 'constructor') { - if ((target[key] == null)) { - target[key] = source[key]; - } - } - } - } - else { - defaults(target, source); - } -} -function isArrayLike(data) { - if (!data) { - return false; - } - if (typeof data === 'string') { - return false; - } - return typeof data.length === 'number'; -} -function each$4(arr, cb, context) { - if (!(arr && cb)) { - return; - } - if (arr.forEach && arr.forEach === nativeForEach) { - arr.forEach(cb, context); - } - else if (arr.length === +arr.length) { - for (var i = 0, len = arr.length; i < len; i++) { - cb.call(context, arr[i], i, arr); - } - } - else { - for (var key in arr) { - if (arr.hasOwnProperty(key)) { - cb.call(context, arr[key], key, arr); - } - } - } -} -function map$1(arr, cb, context) { - if (!arr) { - return []; - } - if (!cb) { - return slice(arr); - } - if (arr.map && arr.map === nativeMap) { - return arr.map(cb, context); - } - else { - var result = []; - for (var i = 0, len = arr.length; i < len; i++) { - result.push(cb.call(context, arr[i], i, arr)); - } - return result; - } -} -function reduce(arr, cb, memo, context) { - if (!(arr && cb)) { - return; - } - for (var i = 0, len = arr.length; i < len; i++) { - memo = cb.call(context, memo, arr[i], i, arr); - } - return memo; -} -function filter(arr, cb, context) { - if (!arr) { - return []; - } - if (!cb) { - return slice(arr); - } - if (arr.filter && arr.filter === nativeFilter) { - return arr.filter(cb, context); - } - else { - var result = []; - for (var i = 0, len = arr.length; i < len; i++) { - if (cb.call(context, arr[i], i, arr)) { - result.push(arr[i]); - } - } - return result; - } -} -function keys(obj) { - if (!obj) { - return []; - } - if (Object.keys) { - return Object.keys(obj); - } - var keyList = []; - for (var key in obj) { - if (obj.hasOwnProperty(key)) { - keyList.push(key); - } - } - return keyList; -} -function bindPolyfill(func, context) { - var args = []; - for (var _i = 2; _i < arguments.length; _i++) { - args[_i - 2] = arguments[_i]; - } - return function () { - return func.apply(context, args.concat(nativeSlice.call(arguments))); - }; -} -var bind$1 = (protoFunction && isFunction(protoFunction.bind)) - ? protoFunction.call.bind(protoFunction.bind) - : bindPolyfill; -function curry$1(func) { - var args = []; - for (var _i = 1; _i < arguments.length; _i++) { - args[_i - 1] = arguments[_i]; - } - return function () { - return func.apply(this, args.concat(nativeSlice.call(arguments))); - }; -} -function isArray(value) { - if (Array.isArray) { - return Array.isArray(value); - } - return objToString.call(value) === '[object Array]'; -} -function isFunction(value) { - return typeof value === 'function'; -} -function isString(value) { - return typeof value === 'string'; -} -function isStringSafe(value) { - return objToString.call(value) === '[object String]'; -} -function isNumber(value) { - return typeof value === 'number'; -} -function isObject$2(value) { - var type = typeof value; - return type === 'function' || (!!value && type === 'object'); -} -function isBuiltInObject(value) { - return !!BUILTIN_OBJECT[objToString.call(value)]; -} -function isTypedArray(value) { - return !!TYPED_ARRAY[objToString.call(value)]; -} -function isDom(value) { - return typeof value === 'object' - && typeof value.nodeType === 'number' - && typeof value.ownerDocument === 'object'; -} -function isGradientObject(value) { - return value.colorStops != null; -} -function isImagePatternObject(value) { - return value.image != null; -} -function eqNaN(value) { - return value !== value; -} -function retrieve() { - var args = []; - for (var _i = 0; _i < arguments.length; _i++) { - args[_i] = arguments[_i]; - } - for (var i = 0, len = args.length; i < len; i++) { - if (args[i] != null) { - return args[i]; - } - } -} -function retrieve2(value0, value1) { - return value0 != null - ? value0 - : value1; -} -function retrieve3(value0, value1, value2) { - return value0 != null - ? value0 - : value1 != null - ? value1 - : value2; -} -function slice(arr) { - var args = []; - for (var _i = 1; _i < arguments.length; _i++) { - args[_i - 1] = arguments[_i]; - } - return nativeSlice.apply(arr, args); -} -function normalizeCssArray$1(val) { - if (typeof (val) === 'number') { - return [val, val, val, val]; - } - var len = val.length; - if (len === 2) { - return [val[0], val[1], val[0], val[1]]; - } - else if (len === 3) { - return [val[0], val[1], val[2], val[1]]; - } - return val; -} -function assert(condition, message) { - if (!condition) { - throw new Error(message); - } -} -function trim(str) { - if (str == null) { - return null; - } - else if (typeof str.trim === 'function') { - return str.trim(); - } - else { - return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); - } -} -var primitiveKey = '__ec_primitive__'; -function setAsPrimitive(obj) { - obj[primitiveKey] = true; -} -function isPrimitive(obj) { - return obj[primitiveKey]; -} -var MapPolyfill = (function () { - function MapPolyfill() { - this.data = {}; - } - MapPolyfill.prototype["delete"] = function (key) { - var existed = this.has(key); - if (existed) { - delete this.data[key]; - } - return existed; - }; - MapPolyfill.prototype.has = function (key) { - return this.data.hasOwnProperty(key); - }; - MapPolyfill.prototype.get = function (key) { - return this.data[key]; - }; - MapPolyfill.prototype.set = function (key, value) { - this.data[key] = value; - return this; - }; - MapPolyfill.prototype.keys = function () { - return keys(this.data); - }; - MapPolyfill.prototype.forEach = function (callback) { - var data = this.data; - for (var key in data) { - if (data.hasOwnProperty(key)) { - callback(data[key], key); - } - } - }; - return MapPolyfill; -}()); -var isNativeMapSupported = typeof Map === 'function'; -function maybeNativeMap() { - return (isNativeMapSupported ? new Map() : new MapPolyfill()); -} -var HashMap = (function () { - function HashMap(obj) { - var isArr = isArray(obj); - this.data = maybeNativeMap(); - var thisMap = this; - (obj instanceof HashMap) - ? obj.each(visit) - : (obj && each$4(obj, visit)); - function visit(value, key) { - isArr ? thisMap.set(value, key) : thisMap.set(key, value); - } - } - HashMap.prototype.hasKey = function (key) { - return this.data.has(key); - }; - HashMap.prototype.get = function (key) { - return this.data.get(key); - }; - HashMap.prototype.set = function (key, value) { - this.data.set(key, value); - return value; - }; - HashMap.prototype.each = function (cb, context) { - this.data.forEach(function (value, key) { - cb.call(context, value, key); - }); - }; - HashMap.prototype.keys = function () { - var keys = this.data.keys(); - return isNativeMapSupported - ? Array.from(keys) - : keys; - }; - HashMap.prototype.removeKey = function (key) { - this.data["delete"](key); - }; - return HashMap; -}()); -function createHashMap(obj) { - return new HashMap(obj); -} -function concatArray(a, b) { - var newArray = new a.constructor(a.length + b.length); - for (var i = 0; i < a.length; i++) { - newArray[i] = a[i]; - } - var offset = a.length; - for (var i = 0; i < b.length; i++) { - newArray[i + offset] = b[i]; - } - return newArray; -} -function createObject(proto, properties) { - var obj; - if (Object.create) { - obj = Object.create(proto); - } - else { - var StyleCtor = function () { }; - StyleCtor.prototype = proto; - obj = new StyleCtor(); - } - if (properties) { - extend(obj, properties); - } - return obj; -} -function disableUserSelect(dom) { - var domStyle = dom.style; - domStyle.webkitUserSelect = 'none'; - domStyle.userSelect = 'none'; - domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)'; - domStyle['-webkit-touch-callout'] = 'none'; -} -function hasOwn(own, prop) { - return own.hasOwnProperty(prop); -} -function noop() { } -var RADIAN_TO_DEGREE = 180 / Math.PI; - -function create$1(x, y) { - if (x == null) { - x = 0; - } - if (y == null) { - y = 0; - } - return [x, y]; -} -function clone$1(v) { - return [v[0], v[1]]; -} -function add(out, v1, v2) { - out[0] = v1[0] + v2[0]; - out[1] = v1[1] + v2[1]; - return out; -} -function sub(out, v1, v2) { - out[0] = v1[0] - v2[0]; - out[1] = v1[1] - v2[1]; - return out; -} -function len(v) { - return Math.sqrt(lenSquare(v)); -} -function lenSquare(v) { - return v[0] * v[0] + v[1] * v[1]; -} -function scale$2(out, v, s) { - out[0] = v[0] * s; - out[1] = v[1] * s; - return out; -} -function normalize$1(out, v) { - var d = len(v); - if (d === 0) { - out[0] = 0; - out[1] = 0; - } - else { - out[0] = v[0] / d; - out[1] = v[1] / d; - } - return out; -} -function distance(v1, v2) { - return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) - + (v1[1] - v2[1]) * (v1[1] - v2[1])); -} -var dist$1 = distance; -function distanceSquare(v1, v2) { - return (v1[0] - v2[0]) * (v1[0] - v2[0]) - + (v1[1] - v2[1]) * (v1[1] - v2[1]); -} -var distSquare = distanceSquare; -function lerp$1(out, v1, v2, t) { - out[0] = v1[0] + t * (v2[0] - v1[0]); - out[1] = v1[1] + t * (v2[1] - v1[1]); - return out; -} -function applyTransform$1(out, v, m) { - var x = v[0]; - var y = v[1]; - out[0] = m[0] * x + m[2] * y + m[4]; - out[1] = m[1] * x + m[3] * y + m[5]; - return out; -} -function min$1(out, v1, v2) { - out[0] = Math.min(v1[0], v2[0]); - out[1] = Math.min(v1[1], v2[1]); - return out; -} -function max$1(out, v1, v2) { - out[0] = Math.max(v1[0], v2[0]); - out[1] = Math.max(v1[1], v2[1]); - return out; -} - -var Param = (function () { - function Param(target, e) { - this.target = target; - this.topTarget = e && e.topTarget; - } - return Param; -}()); -var Draggable = (function () { - function Draggable(handler) { - this.handler = handler; - handler.on('mousedown', this._dragStart, this); - handler.on('mousemove', this._drag, this); - handler.on('mouseup', this._dragEnd, this); - } - Draggable.prototype._dragStart = function (e) { - var draggingTarget = e.target; - while (draggingTarget && !draggingTarget.draggable) { - draggingTarget = draggingTarget.parent || draggingTarget.__hostTarget; - } - if (draggingTarget) { - this._draggingTarget = draggingTarget; - draggingTarget.dragging = true; - this._x = e.offsetX; - this._y = e.offsetY; - this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event); - } - }; - Draggable.prototype._drag = function (e) { - var draggingTarget = this._draggingTarget; - if (draggingTarget) { - var x = e.offsetX; - var y = e.offsetY; - var dx = x - this._x; - var dy = y - this._y; - this._x = x; - this._y = y; - draggingTarget.drift(dx, dy, e); - this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event); - var dropTarget = this.handler.findHover(x, y, draggingTarget).target; - var lastDropTarget = this._dropTarget; - this._dropTarget = dropTarget; - if (draggingTarget !== dropTarget) { - if (lastDropTarget && dropTarget !== lastDropTarget) { - this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event); - } - if (dropTarget && dropTarget !== lastDropTarget) { - this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event); - } - } - } - }; - Draggable.prototype._dragEnd = function (e) { - var draggingTarget = this._draggingTarget; - if (draggingTarget) { - draggingTarget.dragging = false; - } - this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event); - if (this._dropTarget) { - this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event); - } - this._draggingTarget = null; - this._dropTarget = null; - }; - return Draggable; -}()); - -var Eventful = (function () { - function Eventful(eventProcessors) { - if (eventProcessors) { - this._$eventProcessor = eventProcessors; - } - } - Eventful.prototype.on = function (event, query, handler, context) { - if (!this._$handlers) { - this._$handlers = {}; - } - var _h = this._$handlers; - if (typeof query === 'function') { - context = handler; - handler = query; - query = null; - } - if (!handler || !event) { - return this; - } - var eventProcessor = this._$eventProcessor; - if (query != null && eventProcessor && eventProcessor.normalizeQuery) { - query = eventProcessor.normalizeQuery(query); - } - if (!_h[event]) { - _h[event] = []; - } - for (var i = 0; i < _h[event].length; i++) { - if (_h[event][i].h === handler) { - return this; - } - } - var wrap = { - h: handler, - query: query, - ctx: (context || this), - callAtLast: handler.zrEventfulCallAtLast - }; - var lastIndex = _h[event].length - 1; - var lastWrap = _h[event][lastIndex]; - (lastWrap && lastWrap.callAtLast) - ? _h[event].splice(lastIndex, 0, wrap) - : _h[event].push(wrap); - return this; - }; - Eventful.prototype.isSilent = function (eventName) { - var _h = this._$handlers; - return !_h || !_h[eventName] || !_h[eventName].length; - }; - Eventful.prototype.off = function (eventType, handler) { - var _h = this._$handlers; - if (!_h) { - return this; - } - if (!eventType) { - this._$handlers = {}; - return this; - } - if (handler) { - if (_h[eventType]) { - var newList = []; - for (var i = 0, l = _h[eventType].length; i < l; i++) { - if (_h[eventType][i].h !== handler) { - newList.push(_h[eventType][i]); - } - } - _h[eventType] = newList; - } - if (_h[eventType] && _h[eventType].length === 0) { - delete _h[eventType]; - } - } - else { - delete _h[eventType]; - } - return this; - }; - Eventful.prototype.trigger = function (eventType) { - var args = []; - for (var _i = 1; _i < arguments.length; _i++) { - args[_i - 1] = arguments[_i]; - } - if (!this._$handlers) { - return this; - } - var _h = this._$handlers[eventType]; - var eventProcessor = this._$eventProcessor; - if (_h) { - var argLen = args.length; - var len = _h.length; - for (var i = 0; i < len; i++) { - var hItem = _h[i]; - if (eventProcessor - && eventProcessor.filter - && hItem.query != null - && !eventProcessor.filter(eventType, hItem.query)) { - continue; - } - switch (argLen) { - case 0: - hItem.h.call(hItem.ctx); - break; - case 1: - hItem.h.call(hItem.ctx, args[0]); - break; - case 2: - hItem.h.call(hItem.ctx, args[0], args[1]); - break; - default: - hItem.h.apply(hItem.ctx, args); - break; - } - } - } - eventProcessor && eventProcessor.afterTrigger - && eventProcessor.afterTrigger(eventType); - return this; - }; - Eventful.prototype.triggerWithContext = function (type) { - var args = []; - for (var _i = 1; _i < arguments.length; _i++) { - args[_i - 1] = arguments[_i]; - } - if (!this._$handlers) { - return this; - } - var _h = this._$handlers[type]; - var eventProcessor = this._$eventProcessor; - if (_h) { - var argLen = args.length; - var ctx = args[argLen - 1]; - var len = _h.length; - for (var i = 0; i < len; i++) { - var hItem = _h[i]; - if (eventProcessor - && eventProcessor.filter - && hItem.query != null - && !eventProcessor.filter(type, hItem.query)) { - continue; - } - switch (argLen) { - case 0: - hItem.h.call(ctx); - break; - case 1: - hItem.h.call(ctx, args[0]); - break; - case 2: - hItem.h.call(ctx, args[0], args[1]); - break; - default: - hItem.h.apply(ctx, args.slice(1, argLen - 1)); - break; - } - } - } - eventProcessor && eventProcessor.afterTrigger - && eventProcessor.afterTrigger(type); - return this; - }; - return Eventful; -}()); - -var LN2 = Math.log(2); -function determinant(rows, rank, rowStart, rowMask, colMask, detCache) { - var cacheKey = rowMask + '-' + colMask; - var fullRank = rows.length; - if (detCache.hasOwnProperty(cacheKey)) { - return detCache[cacheKey]; - } - if (rank === 1) { - var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2); - return rows[rowStart][colStart]; - } - var subRowMask = rowMask | (1 << rowStart); - var subRowStart = rowStart + 1; - while (rowMask & (1 << subRowStart)) { - subRowStart++; - } - var sum = 0; - for (var j = 0, colLocalIdx = 0; j < fullRank; j++) { - var colTag = 1 << j; - if (!(colTag & colMask)) { - sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j] - * determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache); - colLocalIdx++; - } - } - detCache[cacheKey] = sum; - return sum; -} -function buildTransformer(src, dest) { - var mA = [ - [src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]], - [0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]], - [src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]], - [0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]], - [src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]], - [0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]], - [src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]], - [0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]] - ]; - var detCache = {}; - var det = determinant(mA, 8, 0, 0, 0, detCache); - if (det === 0) { - return; - } - var vh = []; - for (var i = 0; i < 8; i++) { - for (var j = 0; j < 8; j++) { - vh[j] == null && (vh[j] = 0); - vh[j] += ((i + j) % 2 ? -1 : 1) - * determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache) - / det * dest[i]; - } - } - return function (out, srcPointX, srcPointY) { - var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1; - out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk; - out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk; - }; -} - -var EVENT_SAVED_PROP = '___zrEVENTSAVED'; -var _calcOut$1 = []; -function transformLocalCoord(out, elFrom, elTarget, inX, inY) { - return transformCoordWithViewport(_calcOut$1, elFrom, inX, inY, true) - && transformCoordWithViewport(out, elTarget, _calcOut$1[0], _calcOut$1[1]); -} -function transformCoordWithViewport(out, el, inX, inY, inverse) { - if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) { - var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {}); - var markers = prepareCoordMarkers(el, saved); - var transformer = preparePointerTransformer(markers, saved, inverse); - if (transformer) { - transformer(out, inX, inY); - return true; - } - } - return false; -} -function prepareCoordMarkers(el, saved) { - var markers = saved.markers; - if (markers) { - return markers; - } - markers = saved.markers = []; - var propLR = ['left', 'right']; - var propTB = ['top', 'bottom']; - for (var i = 0; i < 4; i++) { - var marker = document.createElement('div'); - var stl = marker.style; - var idxLR = i % 2; - var idxTB = (i >> 1) % 2; - stl.cssText = [ - 'position: absolute', - 'visibility: hidden', - 'padding: 0', - 'margin: 0', - 'border-width: 0', - 'user-select: none', - 'width:0', - 'height:0', - propLR[idxLR] + ':0', - propTB[idxTB] + ':0', - propLR[1 - idxLR] + ':auto', - propTB[1 - idxTB] + ':auto', - '' - ].join('!important;'); - el.appendChild(marker); - markers.push(marker); - } - return markers; -} -function preparePointerTransformer(markers, saved, inverse) { - var transformerName = inverse ? 'invTrans' : 'trans'; - var transformer = saved[transformerName]; - var oldSrcCoords = saved.srcCoords; - var srcCoords = []; - var destCoords = []; - var oldCoordTheSame = true; - for (var i = 0; i < 4; i++) { - var rect = markers[i].getBoundingClientRect(); - var ii = 2 * i; - var x = rect.left; - var y = rect.top; - srcCoords.push(x, y); - oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1]; - destCoords.push(markers[i].offsetLeft, markers[i].offsetTop); - } - return (oldCoordTheSame && transformer) - ? transformer - : (saved.srcCoords = srcCoords, - saved[transformerName] = inverse - ? buildTransformer(destCoords, srcCoords) - : buildTransformer(srcCoords, destCoords)); -} -function isCanvasEl(el) { - return el.nodeName.toUpperCase() === 'CANVAS'; -} -var replaceReg = /([&<>"'])/g; -var replaceMap = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - '\'': ''' -}; -function encodeHTML(source) { - return source == null - ? '' - : (source + '').replace(replaceReg, function (str, c) { - return replaceMap[c]; - }); -} - -var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/; -var _calcOut = []; -var firefoxNotSupportOffsetXY = env.browser.firefox - && +env.browser.version.split('.')[0] < 39; -function clientToLocal(el, e, out, calculate) { - out = out || {}; - if (calculate) { - calculateZrXY(el, e, out); - } - else if (firefoxNotSupportOffsetXY - && e.layerX != null - && e.layerX !== e.offsetX) { - out.zrX = e.layerX; - out.zrY = e.layerY; - } - else if (e.offsetX != null) { - out.zrX = e.offsetX; - out.zrY = e.offsetY; - } - else { - calculateZrXY(el, e, out); - } - return out; -} -function calculateZrXY(el, e, out) { - if (env.domSupported && el.getBoundingClientRect) { - var ex = e.clientX; - var ey = e.clientY; - if (isCanvasEl(el)) { - var box = el.getBoundingClientRect(); - out.zrX = ex - box.left; - out.zrY = ey - box.top; - return; - } - else { - if (transformCoordWithViewport(_calcOut, el, ex, ey)) { - out.zrX = _calcOut[0]; - out.zrY = _calcOut[1]; - return; - } - } - } - out.zrX = out.zrY = 0; -} -function getNativeEvent(e) { - return e - || window.event; -} -function normalizeEvent(el, e, calculate) { - e = getNativeEvent(e); - if (e.zrX != null) { - return e; - } - var eventType = e.type; - var isTouch = eventType && eventType.indexOf('touch') >= 0; - if (!isTouch) { - clientToLocal(el, e, e, calculate); - var wheelDelta = getWheelDeltaMayPolyfill(e); - e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3; - } - else { - var touch = eventType !== 'touchend' - ? e.targetTouches[0] - : e.changedTouches[0]; - touch && clientToLocal(el, touch, e, calculate); - } - var button = e.button; - if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) { - e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0))); - } - return e; -} -function getWheelDeltaMayPolyfill(e) { - var rawWheelDelta = e.wheelDelta; - if (rawWheelDelta) { - return rawWheelDelta; - } - var deltaX = e.deltaX; - var deltaY = e.deltaY; - if (deltaX == null || deltaY == null) { - return rawWheelDelta; - } - var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX); - var sign = deltaY > 0 ? -1 - : deltaY < 0 ? 1 - : deltaX > 0 ? -1 - : 1; - return 3 * delta * sign; -} -function addEventListener(el, name, handler, opt) { - el.addEventListener(name, handler, opt); -} -function removeEventListener(el, name, handler, opt) { - el.removeEventListener(name, handler, opt); -} -var stop = function (e) { - e.preventDefault(); - e.stopPropagation(); - e.cancelBubble = true; -}; - -var GestureMgr = (function () { - function GestureMgr() { - this._track = []; - } - GestureMgr.prototype.recognize = function (event, target, root) { - this._doTrack(event, target, root); - return this._recognize(event); - }; - GestureMgr.prototype.clear = function () { - this._track.length = 0; - return this; - }; - GestureMgr.prototype._doTrack = function (event, target, root) { - var touches = event.touches; - if (!touches) { - return; - } - var trackItem = { - points: [], - touches: [], - target: target, - event: event - }; - for (var i = 0, len = touches.length; i < len; i++) { - var touch = touches[i]; - var pos = clientToLocal(root, touch, {}); - trackItem.points.push([pos.zrX, pos.zrY]); - trackItem.touches.push(touch); - } - this._track.push(trackItem); - }; - GestureMgr.prototype._recognize = function (event) { - for (var eventName in recognizers) { - if (recognizers.hasOwnProperty(eventName)) { - var gestureInfo = recognizers[eventName](this._track, event); - if (gestureInfo) { - return gestureInfo; - } - } - } - }; - return GestureMgr; -}()); -function dist(pointPair) { - var dx = pointPair[1][0] - pointPair[0][0]; - var dy = pointPair[1][1] - pointPair[0][1]; - return Math.sqrt(dx * dx + dy * dy); -} -function center(pointPair) { - return [ - (pointPair[0][0] + pointPair[1][0]) / 2, - (pointPair[0][1] + pointPair[1][1]) / 2 - ]; -} -var recognizers = { - pinch: function (tracks, event) { - var trackLen = tracks.length; - if (!trackLen) { - return; - } - var pinchEnd = (tracks[trackLen - 1] || {}).points; - var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd; - if (pinchPre - && pinchPre.length > 1 - && pinchEnd - && pinchEnd.length > 1) { - var pinchScale = dist(pinchEnd) / dist(pinchPre); - !isFinite(pinchScale) && (pinchScale = 1); - event.pinchScale = pinchScale; - var pinchCenter = center(pinchEnd); - event.pinchX = pinchCenter[0]; - event.pinchY = pinchCenter[1]; - return { - type: 'pinch', - target: tracks[0].target, - event: event - }; - } - } -}; - -function create() { - return [1, 0, 0, 1, 0, 0]; -} -function identity(out) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 1; - out[4] = 0; - out[5] = 0; - return out; -} -function copy(out, m) { - out[0] = m[0]; - out[1] = m[1]; - out[2] = m[2]; - out[3] = m[3]; - out[4] = m[4]; - out[5] = m[5]; - return out; -} -function mul(out, m1, m2) { - var out0 = m1[0] * m2[0] + m1[2] * m2[1]; - var out1 = m1[1] * m2[0] + m1[3] * m2[1]; - var out2 = m1[0] * m2[2] + m1[2] * m2[3]; - var out3 = m1[1] * m2[2] + m1[3] * m2[3]; - var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4]; - var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5]; - out[0] = out0; - out[1] = out1; - out[2] = out2; - out[3] = out3; - out[4] = out4; - out[5] = out5; - return out; -} -function translate(out, a, v) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - out[4] = a[4] + v[0]; - out[5] = a[5] + v[1]; - return out; -} -function rotate(out, a, rad, pivot) { - if (pivot === void 0) { pivot = [0, 0]; } - var aa = a[0]; - var ac = a[2]; - var atx = a[4]; - var ab = a[1]; - var ad = a[3]; - var aty = a[5]; - var st = Math.sin(rad); - var ct = Math.cos(rad); - out[0] = aa * ct + ab * st; - out[1] = -aa * st + ab * ct; - out[2] = ac * ct + ad * st; - out[3] = -ac * st + ct * ad; - out[4] = ct * (atx - pivot[0]) + st * (aty - pivot[1]) + pivot[0]; - out[5] = ct * (aty - pivot[1]) - st * (atx - pivot[0]) + pivot[1]; - return out; -} -function scale$1(out, a, v) { - var vx = v[0]; - var vy = v[1]; - out[0] = a[0] * vx; - out[1] = a[1] * vy; - out[2] = a[2] * vx; - out[3] = a[3] * vy; - out[4] = a[4] * vx; - out[5] = a[5] * vy; - return out; -} -function invert(out, a) { - var aa = a[0]; - var ac = a[2]; - var atx = a[4]; - var ab = a[1]; - var ad = a[3]; - var aty = a[5]; - var det = aa * ad - ab * ac; - if (!det) { - return null; - } - det = 1.0 / det; - out[0] = ad * det; - out[1] = -ab * det; - out[2] = -ac * det; - out[3] = aa * det; - out[4] = (ac * aty - ad * atx) * det; - out[5] = (ab * atx - aa * aty) * det; - return out; -} - -var Point = (function () { - function Point(x, y) { - this.x = x || 0; - this.y = y || 0; - } - Point.prototype.copy = function (other) { - this.x = other.x; - this.y = other.y; - return this; - }; - Point.prototype.clone = function () { - return new Point(this.x, this.y); - }; - Point.prototype.set = function (x, y) { - this.x = x; - this.y = y; - return this; - }; - Point.prototype.equal = function (other) { - return other.x === this.x && other.y === this.y; - }; - Point.prototype.add = function (other) { - this.x += other.x; - this.y += other.y; - return this; - }; - Point.prototype.scale = function (scalar) { - this.x *= scalar; - this.y *= scalar; - }; - Point.prototype.scaleAndAdd = function (other, scalar) { - this.x += other.x * scalar; - this.y += other.y * scalar; - }; - Point.prototype.sub = function (other) { - this.x -= other.x; - this.y -= other.y; - return this; - }; - Point.prototype.dot = function (other) { - return this.x * other.x + this.y * other.y; - }; - Point.prototype.len = function () { - return Math.sqrt(this.x * this.x + this.y * this.y); - }; - Point.prototype.lenSquare = function () { - return this.x * this.x + this.y * this.y; - }; - Point.prototype.normalize = function () { - var len = this.len(); - this.x /= len; - this.y /= len; - return this; - }; - Point.prototype.distance = function (other) { - var dx = this.x - other.x; - var dy = this.y - other.y; - return Math.sqrt(dx * dx + dy * dy); - }; - Point.prototype.distanceSquare = function (other) { - var dx = this.x - other.x; - var dy = this.y - other.y; - return dx * dx + dy * dy; - }; - Point.prototype.negate = function () { - this.x = -this.x; - this.y = -this.y; - return this; - }; - Point.prototype.transform = function (m) { - if (!m) { - return; - } - var x = this.x; - var y = this.y; - this.x = m[0] * x + m[2] * y + m[4]; - this.y = m[1] * x + m[3] * y + m[5]; - return this; - }; - Point.prototype.toArray = function (out) { - out[0] = this.x; - out[1] = this.y; - return out; - }; - Point.prototype.fromArray = function (input) { - this.x = input[0]; - this.y = input[1]; - }; - Point.set = function (p, x, y) { - p.x = x; - p.y = y; - }; - Point.copy = function (p, p2) { - p.x = p2.x; - p.y = p2.y; - }; - Point.len = function (p) { - return Math.sqrt(p.x * p.x + p.y * p.y); - }; - Point.lenSquare = function (p) { - return p.x * p.x + p.y * p.y; - }; - Point.dot = function (p0, p1) { - return p0.x * p1.x + p0.y * p1.y; - }; - Point.add = function (out, p0, p1) { - out.x = p0.x + p1.x; - out.y = p0.y + p1.y; - }; - Point.sub = function (out, p0, p1) { - out.x = p0.x - p1.x; - out.y = p0.y - p1.y; - }; - Point.scale = function (out, p0, scalar) { - out.x = p0.x * scalar; - out.y = p0.y * scalar; - }; - Point.scaleAndAdd = function (out, p0, p1, scalar) { - out.x = p0.x + p1.x * scalar; - out.y = p0.y + p1.y * scalar; - }; - Point.lerp = function (out, p0, p1, t) { - var onet = 1 - t; - out.x = onet * p0.x + t * p1.x; - out.y = onet * p0.y + t * p1.y; - }; - return Point; -}()); - -var mathMin$5 = Math.min; -var mathMax$5 = Math.max; -var lt = new Point(); -var rb = new Point(); -var lb = new Point(); -var rt = new Point(); -var minTv$1 = new Point(); -var maxTv$1 = new Point(); -var BoundingRect = (function () { - function BoundingRect(x, y, width, height) { - if (width < 0) { - x = x + width; - width = -width; - } - if (height < 0) { - y = y + height; - height = -height; - } - this.x = x; - this.y = y; - this.width = width; - this.height = height; - } - BoundingRect.prototype.union = function (other) { - var x = mathMin$5(other.x, this.x); - var y = mathMin$5(other.y, this.y); - if (isFinite(this.x) && isFinite(this.width)) { - this.width = mathMax$5(other.x + other.width, this.x + this.width) - x; - } - else { - this.width = other.width; - } - if (isFinite(this.y) && isFinite(this.height)) { - this.height = mathMax$5(other.y + other.height, this.y + this.height) - y; - } - else { - this.height = other.height; - } - this.x = x; - this.y = y; - }; - BoundingRect.prototype.applyTransform = function (m) { - BoundingRect.applyTransform(this, this, m); - }; - BoundingRect.prototype.calculateTransform = function (b) { - var a = this; - var sx = b.width / a.width; - var sy = b.height / a.height; - var m = create(); - translate(m, m, [-a.x, -a.y]); - scale$1(m, m, [sx, sy]); - translate(m, m, [b.x, b.y]); - return m; - }; - BoundingRect.prototype.intersect = function (b, mtv) { - if (!b) { - return false; - } - if (!(b instanceof BoundingRect)) { - b = BoundingRect.create(b); - } - var a = this; - var ax0 = a.x; - var ax1 = a.x + a.width; - var ay0 = a.y; - var ay1 = a.y + a.height; - var bx0 = b.x; - var bx1 = b.x + b.width; - var by0 = b.y; - var by1 = b.y + b.height; - var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0); - if (mtv) { - var dMin = Infinity; - var dMax = 0; - var d0 = Math.abs(ax1 - bx0); - var d1 = Math.abs(bx1 - ax0); - var d2 = Math.abs(ay1 - by0); - var d3 = Math.abs(by1 - ay0); - var dx = Math.min(d0, d1); - var dy = Math.min(d2, d3); - if (ax1 < bx0 || bx1 < ax0) { - if (dx > dMax) { - dMax = dx; - if (d0 < d1) { - Point.set(maxTv$1, -d0, 0); - } - else { - Point.set(maxTv$1, d1, 0); - } - } - } - else { - if (dx < dMin) { - dMin = dx; - if (d0 < d1) { - Point.set(minTv$1, d0, 0); - } - else { - Point.set(minTv$1, -d1, 0); - } - } - } - if (ay1 < by0 || by1 < ay0) { - if (dy > dMax) { - dMax = dy; - if (d2 < d3) { - Point.set(maxTv$1, 0, -d2); - } - else { - Point.set(maxTv$1, 0, d3); - } - } - } - else { - if (dx < dMin) { - dMin = dx; - if (d2 < d3) { - Point.set(minTv$1, 0, d2); - } - else { - Point.set(minTv$1, 0, -d3); - } - } - } - } - if (mtv) { - Point.copy(mtv, overlap ? minTv$1 : maxTv$1); - } - return overlap; - }; - BoundingRect.prototype.contain = function (x, y) { - var rect = this; - return x >= rect.x - && x <= (rect.x + rect.width) - && y >= rect.y - && y <= (rect.y + rect.height); - }; - BoundingRect.prototype.clone = function () { - return new BoundingRect(this.x, this.y, this.width, this.height); - }; - BoundingRect.prototype.copy = function (other) { - BoundingRect.copy(this, other); - }; - BoundingRect.prototype.plain = function () { - return { - x: this.x, - y: this.y, - width: this.width, - height: this.height - }; - }; - BoundingRect.prototype.isFinite = function () { - return isFinite(this.x) - && isFinite(this.y) - && isFinite(this.width) - && isFinite(this.height); - }; - BoundingRect.prototype.isZero = function () { - return this.width === 0 || this.height === 0; - }; - BoundingRect.create = function (rect) { - return new BoundingRect(rect.x, rect.y, rect.width, rect.height); - }; - BoundingRect.copy = function (target, source) { - target.x = source.x; - target.y = source.y; - target.width = source.width; - target.height = source.height; - }; - BoundingRect.applyTransform = function (target, source, m) { - if (!m) { - if (target !== source) { - BoundingRect.copy(target, source); - } - return; - } - if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) { - var sx = m[0]; - var sy = m[3]; - var tx = m[4]; - var ty = m[5]; - target.x = source.x * sx + tx; - target.y = source.y * sy + ty; - target.width = source.width * sx; - target.height = source.height * sy; - if (target.width < 0) { - target.x += target.width; - target.width = -target.width; - } - if (target.height < 0) { - target.y += target.height; - target.height = -target.height; - } - return; - } - lt.x = lb.x = source.x; - lt.y = rt.y = source.y; - rb.x = rt.x = source.x + source.width; - rb.y = lb.y = source.y + source.height; - lt.transform(m); - rt.transform(m); - rb.transform(m); - lb.transform(m); - target.x = mathMin$5(lt.x, rb.x, lb.x, rt.x); - target.y = mathMin$5(lt.y, rb.y, lb.y, rt.y); - var maxX = mathMax$5(lt.x, rb.x, lb.x, rt.x); - var maxY = mathMax$5(lt.y, rb.y, lb.y, rt.y); - target.width = maxX - target.x; - target.height = maxY - target.y; - }; - return BoundingRect; -}()); - -var SILENT = 'silent'; -function makeEventPacket(eveType, targetInfo, event) { - return { - type: eveType, - event: event, - target: targetInfo.target, - topTarget: targetInfo.topTarget, - cancelBubble: false, - offsetX: event.zrX, - offsetY: event.zrY, - gestureEvent: event.gestureEvent, - pinchX: event.pinchX, - pinchY: event.pinchY, - pinchScale: event.pinchScale, - wheelDelta: event.zrDelta, - zrByTouch: event.zrByTouch, - which: event.which, - stop: stopEvent - }; -} -function stopEvent() { - stop(this.event); -} -var EmptyProxy = (function (_super) { - __extends(EmptyProxy, _super); - function EmptyProxy() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.handler = null; - return _this; - } - EmptyProxy.prototype.dispose = function () { }; - EmptyProxy.prototype.setCursor = function () { }; - return EmptyProxy; -}(Eventful)); -var HoveredResult = (function () { - function HoveredResult(x, y) { - this.x = x; - this.y = y; - } - return HoveredResult; -}()); -var handlerNames = [ - 'click', 'dblclick', 'mousewheel', 'mouseout', - 'mouseup', 'mousedown', 'mousemove', 'contextmenu' -]; -var tmpRect$1 = new BoundingRect(0, 0, 0, 0); -var Handler = (function (_super) { - __extends(Handler, _super); - function Handler(storage, painter, proxy, painterRoot, pointerSize) { - var _this = _super.call(this) || this; - _this._hovered = new HoveredResult(0, 0); - _this.storage = storage; - _this.painter = painter; - _this.painterRoot = painterRoot; - _this._pointerSize = pointerSize; - proxy = proxy || new EmptyProxy(); - _this.proxy = null; - _this.setHandlerProxy(proxy); - _this._draggingMgr = new Draggable(_this); - return _this; - } - Handler.prototype.setHandlerProxy = function (proxy) { - if (this.proxy) { - this.proxy.dispose(); - } - if (proxy) { - each$4(handlerNames, function (name) { - proxy.on && proxy.on(name, this[name], this); - }, this); - proxy.handler = this; - } - this.proxy = proxy; - }; - Handler.prototype.mousemove = function (event) { - var x = event.zrX; - var y = event.zrY; - var isOutside = isOutsideBoundary(this, x, y); - var lastHovered = this._hovered; - var lastHoveredTarget = lastHovered.target; - if (lastHoveredTarget && !lastHoveredTarget.__zr) { - lastHovered = this.findHover(lastHovered.x, lastHovered.y); - lastHoveredTarget = lastHovered.target; - } - var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y); - var hoveredTarget = hovered.target; - var proxy = this.proxy; - proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : 'default'); - if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) { - this.dispatchToElement(lastHovered, 'mouseout', event); - } - this.dispatchToElement(hovered, 'mousemove', event); - if (hoveredTarget && hoveredTarget !== lastHoveredTarget) { - this.dispatchToElement(hovered, 'mouseover', event); - } - }; - Handler.prototype.mouseout = function (event) { - var eventControl = event.zrEventControl; - if (eventControl !== 'only_globalout') { - this.dispatchToElement(this._hovered, 'mouseout', event); - } - if (eventControl !== 'no_globalout') { - this.trigger('globalout', { type: 'globalout', event: event }); - } - }; - Handler.prototype.resize = function () { - this._hovered = new HoveredResult(0, 0); - }; - Handler.prototype.dispatch = function (eventName, eventArgs) { - var handler = this[eventName]; - handler && handler.call(this, eventArgs); - }; - Handler.prototype.dispose = function () { - this.proxy.dispose(); - this.storage = null; - this.proxy = null; - this.painter = null; - }; - Handler.prototype.setCursorStyle = function (cursorStyle) { - var proxy = this.proxy; - proxy.setCursor && proxy.setCursor(cursorStyle); - }; - Handler.prototype.dispatchToElement = function (targetInfo, eventName, event) { - targetInfo = targetInfo || {}; - var el = targetInfo.target; - if (el && el.silent) { - return; - } - var eventKey = ('on' + eventName); - var eventPacket = makeEventPacket(eventName, targetInfo, event); - while (el) { - el[eventKey] - && (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket)); - el.trigger(eventName, eventPacket); - el = el.__hostTarget ? el.__hostTarget : el.parent; - if (eventPacket.cancelBubble) { - break; - } - } - if (!eventPacket.cancelBubble) { - this.trigger(eventName, eventPacket); - if (this.painter && this.painter.eachOtherLayer) { - this.painter.eachOtherLayer(function (layer) { - if (typeof (layer[eventKey]) === 'function') { - layer[eventKey].call(layer, eventPacket); - } - if (layer.trigger) { - layer.trigger(eventName, eventPacket); - } - }); - } - } - }; - Handler.prototype.findHover = function (x, y, exclude) { - var list = this.storage.getDisplayList(); - var out = new HoveredResult(x, y); - setHoverTarget(list, out, x, y, exclude); - if (this._pointerSize && !out.target) { - var candidates = []; - var pointerSize = this._pointerSize; - var targetSizeHalf = pointerSize / 2; - var pointerRect = new BoundingRect(x - targetSizeHalf, y - targetSizeHalf, pointerSize, pointerSize); - for (var i = list.length - 1; i >= 0; i--) { - var el = list[i]; - if (el !== exclude - && !el.ignore - && !el.ignoreCoarsePointer - && (!el.parent || !el.parent.ignoreCoarsePointer)) { - tmpRect$1.copy(el.getBoundingRect()); - if (el.transform) { - tmpRect$1.applyTransform(el.transform); - } - if (tmpRect$1.intersect(pointerRect)) { - candidates.push(el); - } - } - } - if (candidates.length) { - var rStep = 4; - var thetaStep = Math.PI / 12; - var PI2 = Math.PI * 2; - for (var r = 0; r < targetSizeHalf; r += rStep) { - for (var theta = 0; theta < PI2; theta += thetaStep) { - var x1 = x + r * Math.cos(theta); - var y1 = y + r * Math.sin(theta); - setHoverTarget(candidates, out, x1, y1, exclude); - if (out.target) { - return out; - } - } - } - } - } - return out; - }; - Handler.prototype.processGesture = function (event, stage) { - if (!this._gestureMgr) { - this._gestureMgr = new GestureMgr(); - } - var gestureMgr = this._gestureMgr; - stage === 'start' && gestureMgr.clear(); - var gestureInfo = gestureMgr.recognize(event, this.findHover(event.zrX, event.zrY, null).target, this.proxy.dom); - stage === 'end' && gestureMgr.clear(); - if (gestureInfo) { - var type = gestureInfo.type; - event.gestureEvent = type; - var res = new HoveredResult(); - res.target = gestureInfo.target; - this.dispatchToElement(res, type, gestureInfo.event); - } - }; - return Handler; -}(Eventful)); -each$4(['click', 'mousedown', 'mouseup', 'mousewheel', 'dblclick', 'contextmenu'], function (name) { - Handler.prototype[name] = function (event) { - var x = event.zrX; - var y = event.zrY; - var isOutside = isOutsideBoundary(this, x, y); - var hovered; - var hoveredTarget; - if (name !== 'mouseup' || !isOutside) { - hovered = this.findHover(x, y); - hoveredTarget = hovered.target; - } - if (name === 'mousedown') { - this._downEl = hoveredTarget; - this._downPoint = [event.zrX, event.zrY]; - this._upEl = hoveredTarget; - } - else if (name === 'mouseup') { - this._upEl = hoveredTarget; - } - else if (name === 'click') { - if (this._downEl !== this._upEl - || !this._downPoint - || dist$1(this._downPoint, [event.zrX, event.zrY]) > 4) { - return; - } - this._downPoint = null; - } - this.dispatchToElement(hovered, name, event); - }; -}); -function isHover(displayable, x, y) { - if (displayable[displayable.rectHover ? 'rectContain' : 'contain'](x, y)) { - var el = displayable; - var isSilent = void 0; - var ignoreClip = false; - while (el) { - if (el.ignoreClip) { - ignoreClip = true; - } - if (!ignoreClip) { - var clipPath = el.getClipPath(); - if (clipPath && !clipPath.contain(x, y)) { - return false; - } - } - if (el.silent) { - isSilent = true; - } - var hostEl = el.__hostTarget; - el = hostEl ? hostEl : el.parent; - } - return isSilent ? SILENT : true; - } - return false; -} -function setHoverTarget(list, out, x, y, exclude) { - for (var i = list.length - 1; i >= 0; i--) { - var el = list[i]; - var hoverCheckResult = void 0; - if (el !== exclude - && !el.ignore - && (hoverCheckResult = isHover(el, x, y))) { - !out.topTarget && (out.topTarget = el); - if (hoverCheckResult !== SILENT) { - out.target = el; - break; - } - } - } -} -function isOutsideBoundary(handlerInstance, x, y) { - var painter = handlerInstance.painter; - return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight(); -} - -var DEFAULT_MIN_MERGE = 32; -var DEFAULT_MIN_GALLOPING = 7; -function minRunLength(n) { - var r = 0; - while (n >= DEFAULT_MIN_MERGE) { - r |= n & 1; - n >>= 1; - } - return n + r; -} -function makeAscendingRun(array, lo, hi, compare) { - var runHi = lo + 1; - if (runHi === hi) { - return 1; - } - if (compare(array[runHi++], array[lo]) < 0) { - while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) { - runHi++; - } - reverseRun(array, lo, runHi); - } - else { - while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) { - runHi++; - } - } - return runHi - lo; -} -function reverseRun(array, lo, hi) { - hi--; - while (lo < hi) { - var t = array[lo]; - array[lo++] = array[hi]; - array[hi--] = t; - } -} -function binaryInsertionSort(array, lo, hi, start, compare) { - if (start === lo) { - start++; - } - for (; start < hi; start++) { - var pivot = array[start]; - var left = lo; - var right = start; - var mid; - while (left < right) { - mid = left + right >>> 1; - if (compare(pivot, array[mid]) < 0) { - right = mid; - } - else { - left = mid + 1; - } - } - var n = start - left; - switch (n) { - case 3: - array[left + 3] = array[left + 2]; - case 2: - array[left + 2] = array[left + 1]; - case 1: - array[left + 1] = array[left]; - break; - default: - while (n > 0) { - array[left + n] = array[left + n - 1]; - n--; - } - } - array[left] = pivot; - } -} -function gallopLeft(value, array, start, length, hint, compare) { - var lastOffset = 0; - var maxOffset = 0; - var offset = 1; - if (compare(value, array[start + hint]) > 0) { - maxOffset = length - hint; - while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) { - lastOffset = offset; - offset = (offset << 1) + 1; - if (offset <= 0) { - offset = maxOffset; - } - } - if (offset > maxOffset) { - offset = maxOffset; - } - lastOffset += hint; - offset += hint; - } - else { - maxOffset = hint + 1; - while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) { - lastOffset = offset; - offset = (offset << 1) + 1; - if (offset <= 0) { - offset = maxOffset; - } - } - if (offset > maxOffset) { - offset = maxOffset; - } - var tmp = lastOffset; - lastOffset = hint - offset; - offset = hint - tmp; - } - lastOffset++; - while (lastOffset < offset) { - var m = lastOffset + (offset - lastOffset >>> 1); - if (compare(value, array[start + m]) > 0) { - lastOffset = m + 1; - } - else { - offset = m; - } - } - return offset; -} -function gallopRight(value, array, start, length, hint, compare) { - var lastOffset = 0; - var maxOffset = 0; - var offset = 1; - if (compare(value, array[start + hint]) < 0) { - maxOffset = hint + 1; - while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) { - lastOffset = offset; - offset = (offset << 1) + 1; - if (offset <= 0) { - offset = maxOffset; - } - } - if (offset > maxOffset) { - offset = maxOffset; - } - var tmp = lastOffset; - lastOffset = hint - offset; - offset = hint - tmp; - } - else { - maxOffset = length - hint; - while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) { - lastOffset = offset; - offset = (offset << 1) + 1; - if (offset <= 0) { - offset = maxOffset; - } - } - if (offset > maxOffset) { - offset = maxOffset; - } - lastOffset += hint; - offset += hint; - } - lastOffset++; - while (lastOffset < offset) { - var m = lastOffset + (offset - lastOffset >>> 1); - if (compare(value, array[start + m]) < 0) { - offset = m; - } - else { - lastOffset = m + 1; - } - } - return offset; -} -function TimSort(array, compare) { - var minGallop = DEFAULT_MIN_GALLOPING; - var runStart; - var runLength; - var stackSize = 0; - var tmp = []; - runStart = []; - runLength = []; - function pushRun(_runStart, _runLength) { - runStart[stackSize] = _runStart; - runLength[stackSize] = _runLength; - stackSize += 1; - } - function mergeRuns() { - while (stackSize > 1) { - var n = stackSize - 2; - if ((n >= 1 && runLength[n - 1] <= runLength[n] + runLength[n + 1]) - || (n >= 2 && runLength[n - 2] <= runLength[n] + runLength[n - 1])) { - if (runLength[n - 1] < runLength[n + 1]) { - n--; - } - } - else if (runLength[n] > runLength[n + 1]) { - break; - } - mergeAt(n); - } - } - function forceMergeRuns() { - while (stackSize > 1) { - var n = stackSize - 2; - if (n > 0 && runLength[n - 1] < runLength[n + 1]) { - n--; - } - mergeAt(n); - } - } - function mergeAt(i) { - var start1 = runStart[i]; - var length1 = runLength[i]; - var start2 = runStart[i + 1]; - var length2 = runLength[i + 1]; - runLength[i] = length1 + length2; - if (i === stackSize - 3) { - runStart[i + 1] = runStart[i + 2]; - runLength[i + 1] = runLength[i + 2]; - } - stackSize--; - var k = gallopRight(array[start2], array, start1, length1, 0, compare); - start1 += k; - length1 -= k; - if (length1 === 0) { - return; - } - length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare); - if (length2 === 0) { - return; - } - if (length1 <= length2) { - mergeLow(start1, length1, start2, length2); - } - else { - mergeHigh(start1, length1, start2, length2); - } - } - function mergeLow(start1, length1, start2, length2) { - var i = 0; - for (i = 0; i < length1; i++) { - tmp[i] = array[start1 + i]; - } - var cursor1 = 0; - var cursor2 = start2; - var dest = start1; - array[dest++] = array[cursor2++]; - if (--length2 === 0) { - for (i = 0; i < length1; i++) { - array[dest + i] = tmp[cursor1 + i]; - } - return; - } - if (length1 === 1) { - for (i = 0; i < length2; i++) { - array[dest + i] = array[cursor2 + i]; - } - array[dest + length2] = tmp[cursor1]; - return; - } - var _minGallop = minGallop; - var count1; - var count2; - var exit; - while (1) { - count1 = 0; - count2 = 0; - exit = false; - do { - if (compare(array[cursor2], tmp[cursor1]) < 0) { - array[dest++] = array[cursor2++]; - count2++; - count1 = 0; - if (--length2 === 0) { - exit = true; - break; - } - } - else { - array[dest++] = tmp[cursor1++]; - count1++; - count2 = 0; - if (--length1 === 1) { - exit = true; - break; - } - } - } while ((count1 | count2) < _minGallop); - if (exit) { - break; - } - do { - count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare); - if (count1 !== 0) { - for (i = 0; i < count1; i++) { - array[dest + i] = tmp[cursor1 + i]; - } - dest += count1; - cursor1 += count1; - length1 -= count1; - if (length1 <= 1) { - exit = true; - break; - } - } - array[dest++] = array[cursor2++]; - if (--length2 === 0) { - exit = true; - break; - } - count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare); - if (count2 !== 0) { - for (i = 0; i < count2; i++) { - array[dest + i] = array[cursor2 + i]; - } - dest += count2; - cursor2 += count2; - length2 -= count2; - if (length2 === 0) { - exit = true; - break; - } - } - array[dest++] = tmp[cursor1++]; - if (--length1 === 1) { - exit = true; - break; - } - _minGallop--; - } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING); - if (exit) { - break; - } - if (_minGallop < 0) { - _minGallop = 0; - } - _minGallop += 2; - } - minGallop = _minGallop; - minGallop < 1 && (minGallop = 1); - if (length1 === 1) { - for (i = 0; i < length2; i++) { - array[dest + i] = array[cursor2 + i]; - } - array[dest + length2] = tmp[cursor1]; - } - else if (length1 === 0) { - throw new Error(); - } - else { - for (i = 0; i < length1; i++) { - array[dest + i] = tmp[cursor1 + i]; - } - } - } - function mergeHigh(start1, length1, start2, length2) { - var i = 0; - for (i = 0; i < length2; i++) { - tmp[i] = array[start2 + i]; - } - var cursor1 = start1 + length1 - 1; - var cursor2 = length2 - 1; - var dest = start2 + length2 - 1; - var customCursor = 0; - var customDest = 0; - array[dest--] = array[cursor1--]; - if (--length1 === 0) { - customCursor = dest - (length2 - 1); - for (i = 0; i < length2; i++) { - array[customCursor + i] = tmp[i]; - } - return; - } - if (length2 === 1) { - dest -= length1; - cursor1 -= length1; - customDest = dest + 1; - customCursor = cursor1 + 1; - for (i = length1 - 1; i >= 0; i--) { - array[customDest + i] = array[customCursor + i]; - } - array[dest] = tmp[cursor2]; - return; - } - var _minGallop = minGallop; - while (true) { - var count1 = 0; - var count2 = 0; - var exit = false; - do { - if (compare(tmp[cursor2], array[cursor1]) < 0) { - array[dest--] = array[cursor1--]; - count1++; - count2 = 0; - if (--length1 === 0) { - exit = true; - break; - } - } - else { - array[dest--] = tmp[cursor2--]; - count2++; - count1 = 0; - if (--length2 === 1) { - exit = true; - break; - } - } - } while ((count1 | count2) < _minGallop); - if (exit) { - break; - } - do { - count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare); - if (count1 !== 0) { - dest -= count1; - cursor1 -= count1; - length1 -= count1; - customDest = dest + 1; - customCursor = cursor1 + 1; - for (i = count1 - 1; i >= 0; i--) { - array[customDest + i] = array[customCursor + i]; - } - if (length1 === 0) { - exit = true; - break; - } - } - array[dest--] = tmp[cursor2--]; - if (--length2 === 1) { - exit = true; - break; - } - count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare); - if (count2 !== 0) { - dest -= count2; - cursor2 -= count2; - length2 -= count2; - customDest = dest + 1; - customCursor = cursor2 + 1; - for (i = 0; i < count2; i++) { - array[customDest + i] = tmp[customCursor + i]; - } - if (length2 <= 1) { - exit = true; - break; - } - } - array[dest--] = array[cursor1--]; - if (--length1 === 0) { - exit = true; - break; - } - _minGallop--; - } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING); - if (exit) { - break; - } - if (_minGallop < 0) { - _minGallop = 0; - } - _minGallop += 2; - } - minGallop = _minGallop; - if (minGallop < 1) { - minGallop = 1; - } - if (length2 === 1) { - dest -= length1; - cursor1 -= length1; - customDest = dest + 1; - customCursor = cursor1 + 1; - for (i = length1 - 1; i >= 0; i--) { - array[customDest + i] = array[customCursor + i]; - } - array[dest] = tmp[cursor2]; - } - else if (length2 === 0) { - throw new Error(); - } - else { - customCursor = dest - (length2 - 1); - for (i = 0; i < length2; i++) { - array[customCursor + i] = tmp[i]; - } - } - } - return { - mergeRuns: mergeRuns, - forceMergeRuns: forceMergeRuns, - pushRun: pushRun - }; -} -function sort(array, compare, lo, hi) { - if (!lo) { - lo = 0; - } - if (!hi) { - hi = array.length; - } - var remaining = hi - lo; - if (remaining < 2) { - return; - } - var runLength = 0; - if (remaining < DEFAULT_MIN_MERGE) { - runLength = makeAscendingRun(array, lo, hi, compare); - binaryInsertionSort(array, lo, hi, lo + runLength, compare); - return; - } - var ts = TimSort(array, compare); - var minRun = minRunLength(remaining); - do { - runLength = makeAscendingRun(array, lo, hi, compare); - if (runLength < minRun) { - var force = remaining; - if (force > minRun) { - force = minRun; - } - binaryInsertionSort(array, lo, lo + force, lo + runLength, compare); - runLength = force; - } - ts.pushRun(lo, runLength); - ts.mergeRuns(); - remaining -= runLength; - lo += runLength; - } while (remaining !== 0); - ts.forceMergeRuns(); -} - -var REDRAW_BIT = 1; -var STYLE_CHANGED_BIT = 2; -var SHAPE_CHANGED_BIT = 4; - -var invalidZErrorLogged = false; -function logInvalidZError() { - if (invalidZErrorLogged) { - return; - } - invalidZErrorLogged = true; - console.warn('z / z2 / zlevel of displayable is invalid, which may cause unexpected errors'); -} -function shapeCompareFunc(a, b) { - if (a.zlevel === b.zlevel) { - if (a.z === b.z) { - return a.z2 - b.z2; - } - return a.z - b.z; - } - return a.zlevel - b.zlevel; -} -var Storage = (function () { - function Storage() { - this._roots = []; - this._displayList = []; - this._displayListLen = 0; - this.displayableSortFunc = shapeCompareFunc; - } - Storage.prototype.traverse = function (cb, context) { - for (var i = 0; i < this._roots.length; i++) { - this._roots[i].traverse(cb, context); - } - }; - Storage.prototype.getDisplayList = function (update, includeIgnore) { - includeIgnore = includeIgnore || false; - var displayList = this._displayList; - if (update || !displayList.length) { - this.updateDisplayList(includeIgnore); - } - return displayList; - }; - Storage.prototype.updateDisplayList = function (includeIgnore) { - this._displayListLen = 0; - var roots = this._roots; - var displayList = this._displayList; - for (var i = 0, len = roots.length; i < len; i++) { - this._updateAndAddDisplayable(roots[i], null, includeIgnore); - } - displayList.length = this._displayListLen; - sort(displayList, shapeCompareFunc); - }; - Storage.prototype._updateAndAddDisplayable = function (el, clipPaths, includeIgnore) { - if (el.ignore && !includeIgnore) { - return; - } - el.beforeUpdate(); - el.update(); - el.afterUpdate(); - var userSetClipPath = el.getClipPath(); - if (el.ignoreClip) { - clipPaths = null; - } - else if (userSetClipPath) { - if (clipPaths) { - clipPaths = clipPaths.slice(); - } - else { - clipPaths = []; - } - var currentClipPath = userSetClipPath; - var parentClipPath = el; - while (currentClipPath) { - currentClipPath.parent = parentClipPath; - currentClipPath.updateTransform(); - clipPaths.push(currentClipPath); - parentClipPath = currentClipPath; - currentClipPath = currentClipPath.getClipPath(); - } - } - if (el.childrenRef) { - var children = el.childrenRef(); - for (var i = 0; i < children.length; i++) { - var child = children[i]; - if (el.__dirty) { - child.__dirty |= REDRAW_BIT; - } - this._updateAndAddDisplayable(child, clipPaths, includeIgnore); - } - el.__dirty = 0; - } - else { - var disp = el; - if (clipPaths && clipPaths.length) { - disp.__clipPaths = clipPaths; - } - else if (disp.__clipPaths && disp.__clipPaths.length > 0) { - disp.__clipPaths = []; - } - if (isNaN(disp.z)) { - logInvalidZError(); - disp.z = 0; - } - if (isNaN(disp.z2)) { - logInvalidZError(); - disp.z2 = 0; - } - if (isNaN(disp.zlevel)) { - logInvalidZError(); - disp.zlevel = 0; - } - this._displayList[this._displayListLen++] = disp; - } - var decalEl = el.getDecalElement && el.getDecalElement(); - if (decalEl) { - this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore); - } - var textGuide = el.getTextGuideLine(); - if (textGuide) { - this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore); - } - var textEl = el.getTextContent(); - if (textEl) { - this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore); - } - }; - Storage.prototype.addRoot = function (el) { - if (el.__zr && el.__zr.storage === this) { - return; - } - this._roots.push(el); - }; - Storage.prototype.delRoot = function (el) { - if (el instanceof Array) { - for (var i = 0, l = el.length; i < l; i++) { - this.delRoot(el[i]); - } - return; - } - var idx = indexOf(this._roots, el); - if (idx >= 0) { - this._roots.splice(idx, 1); - } - }; - Storage.prototype.delAllRoots = function () { - this._roots = []; - this._displayList = []; - this._displayListLen = 0; - return; - }; - Storage.prototype.getRoots = function () { - return this._roots; - }; - Storage.prototype.dispose = function () { - this._displayList = null; - this._roots = null; - }; - return Storage; -}()); - -var requestAnimationFrame$1; -requestAnimationFrame$1 = (env.hasGlobalWindow - && ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window)) - || (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window)) - || window.mozRequestAnimationFrame - || window.webkitRequestAnimationFrame)) || function (func) { - return setTimeout(func, 16); -}; - -var easingFuncs = { - linear: function (k) { - return k; - }, - quadraticIn: function (k) { - return k * k; - }, - quadraticOut: function (k) { - return k * (2 - k); - }, - quadraticInOut: function (k) { - if ((k *= 2) < 1) { - return 0.5 * k * k; - } - return -0.5 * (--k * (k - 2) - 1); - }, - cubicIn: function (k) { - return k * k * k; - }, - cubicOut: function (k) { - return --k * k * k + 1; - }, - cubicInOut: function (k) { - if ((k *= 2) < 1) { - return 0.5 * k * k * k; - } - return 0.5 * ((k -= 2) * k * k + 2); - }, - quarticIn: function (k) { - return k * k * k * k; - }, - quarticOut: function (k) { - return 1 - (--k * k * k * k); - }, - quarticInOut: function (k) { - if ((k *= 2) < 1) { - return 0.5 * k * k * k * k; - } - return -0.5 * ((k -= 2) * k * k * k - 2); - }, - quinticIn: function (k) { - return k * k * k * k * k; - }, - quinticOut: function (k) { - return --k * k * k * k * k + 1; - }, - quinticInOut: function (k) { - if ((k *= 2) < 1) { - return 0.5 * k * k * k * k * k; - } - return 0.5 * ((k -= 2) * k * k * k * k + 2); - }, - sinusoidalIn: function (k) { - return 1 - Math.cos(k * Math.PI / 2); - }, - sinusoidalOut: function (k) { - return Math.sin(k * Math.PI / 2); - }, - sinusoidalInOut: function (k) { - return 0.5 * (1 - Math.cos(Math.PI * k)); - }, - exponentialIn: function (k) { - return k === 0 ? 0 : Math.pow(1024, k - 1); - }, - exponentialOut: function (k) { - return k === 1 ? 1 : 1 - Math.pow(2, -10 * k); - }, - exponentialInOut: function (k) { - if (k === 0) { - return 0; - } - if (k === 1) { - return 1; - } - if ((k *= 2) < 1) { - return 0.5 * Math.pow(1024, k - 1); - } - return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2); - }, - circularIn: function (k) { - return 1 - Math.sqrt(1 - k * k); - }, - circularOut: function (k) { - return Math.sqrt(1 - (--k * k)); - }, - circularInOut: function (k) { - if ((k *= 2) < 1) { - return -0.5 * (Math.sqrt(1 - k * k) - 1); - } - return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1); - }, - elasticIn: function (k) { - var s; - var a = 0.1; - var p = 0.4; - if (k === 0) { - return 0; - } - if (k === 1) { - return 1; - } - if (!a || a < 1) { - a = 1; - s = p / 4; - } - else { - s = p * Math.asin(1 / a) / (2 * Math.PI); - } - return -(a * Math.pow(2, 10 * (k -= 1)) - * Math.sin((k - s) * (2 * Math.PI) / p)); - }, - elasticOut: function (k) { - var s; - var a = 0.1; - var p = 0.4; - if (k === 0) { - return 0; - } - if (k === 1) { - return 1; - } - if (!a || a < 1) { - a = 1; - s = p / 4; - } - else { - s = p * Math.asin(1 / a) / (2 * Math.PI); - } - return (a * Math.pow(2, -10 * k) - * Math.sin((k - s) * (2 * Math.PI) / p) + 1); - }, - elasticInOut: function (k) { - var s; - var a = 0.1; - var p = 0.4; - if (k === 0) { - return 0; - } - if (k === 1) { - return 1; - } - if (!a || a < 1) { - a = 1; - s = p / 4; - } - else { - s = p * Math.asin(1 / a) / (2 * Math.PI); - } - if ((k *= 2) < 1) { - return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) - * Math.sin((k - s) * (2 * Math.PI) / p)); - } - return a * Math.pow(2, -10 * (k -= 1)) - * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1; - }, - backIn: function (k) { - var s = 1.70158; - return k * k * ((s + 1) * k - s); - }, - backOut: function (k) { - var s = 1.70158; - return --k * k * ((s + 1) * k + s) + 1; - }, - backInOut: function (k) { - var s = 1.70158 * 1.525; - if ((k *= 2) < 1) { - return 0.5 * (k * k * ((s + 1) * k - s)); - } - return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2); - }, - bounceIn: function (k) { - return 1 - easingFuncs.bounceOut(1 - k); - }, - bounceOut: function (k) { - if (k < (1 / 2.75)) { - return 7.5625 * k * k; - } - else if (k < (2 / 2.75)) { - return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75; - } - else if (k < (2.5 / 2.75)) { - return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375; - } - else { - return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375; - } - }, - bounceInOut: function (k) { - if (k < 0.5) { - return easingFuncs.bounceIn(k * 2) * 0.5; - } - return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5; - } -}; - -var mathPow$1 = Math.pow; -var mathSqrt$3 = Math.sqrt; -var EPSILON$2 = 1e-8; -var EPSILON_NUMERIC = 1e-4; -var THREE_SQRT = mathSqrt$3(3); -var ONE_THIRD = 1 / 3; -var _v0 = create$1(); -var _v1 = create$1(); -var _v2 = create$1(); -function isAroundZero(val) { - return val > -1e-8 && val < EPSILON$2; -} -function isNotAroundZero$1(val) { - return val > EPSILON$2 || val < -1e-8; -} -function cubicAt(p0, p1, p2, p3, t) { - var onet = 1 - t; - return onet * onet * (onet * p0 + 3 * t * p1) - + t * t * (t * p3 + 3 * onet * p2); -} -function cubicDerivativeAt(p0, p1, p2, p3, t) { - var onet = 1 - t; - return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet - + (p3 - p2) * t * t); -} -function cubicRootAt(p0, p1, p2, p3, val, roots) { - var a = p3 + 3 * (p1 - p2) - p0; - var b = 3 * (p2 - p1 * 2 + p0); - var c = 3 * (p1 - p0); - var d = p0 - val; - var A = b * b - 3 * a * c; - var B = b * c - 9 * a * d; - var C = c * c - 3 * b * d; - var n = 0; - if (isAroundZero(A) && isAroundZero(B)) { - if (isAroundZero(b)) { - roots[0] = 0; - } - else { - var t1 = -c / b; - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - } - } - else { - var disc = B * B - 4 * A * C; - if (isAroundZero(disc)) { - var K = B / A; - var t1 = -b / a + K; - var t2 = -K / 2; - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - if (t2 >= 0 && t2 <= 1) { - roots[n++] = t2; - } - } - else if (disc > 0) { - var discSqrt = mathSqrt$3(disc); - var Y1 = A * b + 1.5 * a * (-B + discSqrt); - var Y2 = A * b + 1.5 * a * (-B - discSqrt); - if (Y1 < 0) { - Y1 = -mathPow$1(-Y1, ONE_THIRD); - } - else { - Y1 = mathPow$1(Y1, ONE_THIRD); - } - if (Y2 < 0) { - Y2 = -mathPow$1(-Y2, ONE_THIRD); - } - else { - Y2 = mathPow$1(Y2, ONE_THIRD); - } - var t1 = (-b - (Y1 + Y2)) / (3 * a); - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - } - else { - var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt$3(A * A * A)); - var theta = Math.acos(T) / 3; - var ASqrt = mathSqrt$3(A); - var tmp = Math.cos(theta); - var t1 = (-b - 2 * ASqrt * tmp) / (3 * a); - var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a); - var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a); - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - if (t2 >= 0 && t2 <= 1) { - roots[n++] = t2; - } - if (t3 >= 0 && t3 <= 1) { - roots[n++] = t3; - } - } - } - return n; -} -function cubicExtrema(p0, p1, p2, p3, extrema) { - var b = 6 * p2 - 12 * p1 + 6 * p0; - var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2; - var c = 3 * p1 - 3 * p0; - var n = 0; - if (isAroundZero(a)) { - if (isNotAroundZero$1(b)) { - var t1 = -c / b; - if (t1 >= 0 && t1 <= 1) { - extrema[n++] = t1; - } - } - } - else { - var disc = b * b - 4 * a * c; - if (isAroundZero(disc)) { - extrema[0] = -b / (2 * a); - } - else if (disc > 0) { - var discSqrt = mathSqrt$3(disc); - var t1 = (-b + discSqrt) / (2 * a); - var t2 = (-b - discSqrt) / (2 * a); - if (t1 >= 0 && t1 <= 1) { - extrema[n++] = t1; - } - if (t2 >= 0 && t2 <= 1) { - extrema[n++] = t2; - } - } - } - return n; -} -function cubicSubdivide(p0, p1, p2, p3, t, out) { - var p01 = (p1 - p0) * t + p0; - var p12 = (p2 - p1) * t + p1; - var p23 = (p3 - p2) * t + p2; - var p012 = (p12 - p01) * t + p01; - var p123 = (p23 - p12) * t + p12; - var p0123 = (p123 - p012) * t + p012; - out[0] = p0; - out[1] = p01; - out[2] = p012; - out[3] = p0123; - out[4] = p0123; - out[5] = p123; - out[6] = p23; - out[7] = p3; -} -function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) { - var t; - var interval = 0.005; - var d = Infinity; - var prev; - var next; - var d1; - var d2; - _v0[0] = x; - _v0[1] = y; - for (var _t = 0; _t < 1; _t += 0.05) { - _v1[0] = cubicAt(x0, x1, x2, x3, _t); - _v1[1] = cubicAt(y0, y1, y2, y3, _t); - d1 = distSquare(_v0, _v1); - if (d1 < d) { - t = _t; - d = d1; - } - } - d = Infinity; - for (var i = 0; i < 32; i++) { - if (interval < EPSILON_NUMERIC) { - break; - } - prev = t - interval; - next = t + interval; - _v1[0] = cubicAt(x0, x1, x2, x3, prev); - _v1[1] = cubicAt(y0, y1, y2, y3, prev); - d1 = distSquare(_v1, _v0); - if (prev >= 0 && d1 < d) { - t = prev; - d = d1; - } - else { - _v2[0] = cubicAt(x0, x1, x2, x3, next); - _v2[1] = cubicAt(y0, y1, y2, y3, next); - d2 = distSquare(_v2, _v0); - if (next <= 1 && d2 < d) { - t = next; - d = d2; - } - else { - interval *= 0.5; - } - } - } - return mathSqrt$3(d); -} -function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) { - var px = x0; - var py = y0; - var d = 0; - var step = 1 / iteration; - for (var i = 1; i <= iteration; i++) { - var t = i * step; - var x = cubicAt(x0, x1, x2, x3, t); - var y = cubicAt(y0, y1, y2, y3, t); - var dx = x - px; - var dy = y - py; - d += Math.sqrt(dx * dx + dy * dy); - px = x; - py = y; - } - return d; -} -function quadraticAt(p0, p1, p2, t) { - var onet = 1 - t; - return onet * (onet * p0 + 2 * t * p1) + t * t * p2; -} -function quadraticDerivativeAt(p0, p1, p2, t) { - return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1)); -} -function quadraticRootAt(p0, p1, p2, val, roots) { - var a = p0 - 2 * p1 + p2; - var b = 2 * (p1 - p0); - var c = p0 - val; - var n = 0; - if (isAroundZero(a)) { - if (isNotAroundZero$1(b)) { - var t1 = -c / b; - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - } - } - else { - var disc = b * b - 4 * a * c; - if (isAroundZero(disc)) { - var t1 = -b / (2 * a); - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - } - else if (disc > 0) { - var discSqrt = mathSqrt$3(disc); - var t1 = (-b + discSqrt) / (2 * a); - var t2 = (-b - discSqrt) / (2 * a); - if (t1 >= 0 && t1 <= 1) { - roots[n++] = t1; - } - if (t2 >= 0 && t2 <= 1) { - roots[n++] = t2; - } - } - } - return n; -} -function quadraticExtremum(p0, p1, p2) { - var divider = p0 + p2 - 2 * p1; - if (divider === 0) { - return 0.5; - } - else { - return (p0 - p1) / divider; - } -} -function quadraticSubdivide(p0, p1, p2, t, out) { - var p01 = (p1 - p0) * t + p0; - var p12 = (p2 - p1) * t + p1; - var p012 = (p12 - p01) * t + p01; - out[0] = p0; - out[1] = p01; - out[2] = p012; - out[3] = p012; - out[4] = p12; - out[5] = p2; -} -function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) { - var t; - var interval = 0.005; - var d = Infinity; - _v0[0] = x; - _v0[1] = y; - for (var _t = 0; _t < 1; _t += 0.05) { - _v1[0] = quadraticAt(x0, x1, x2, _t); - _v1[1] = quadraticAt(y0, y1, y2, _t); - var d1 = distSquare(_v0, _v1); - if (d1 < d) { - t = _t; - d = d1; - } - } - d = Infinity; - for (var i = 0; i < 32; i++) { - if (interval < EPSILON_NUMERIC) { - break; - } - var prev = t - interval; - var next = t + interval; - _v1[0] = quadraticAt(x0, x1, x2, prev); - _v1[1] = quadraticAt(y0, y1, y2, prev); - var d1 = distSquare(_v1, _v0); - if (prev >= 0 && d1 < d) { - t = prev; - d = d1; - } - else { - _v2[0] = quadraticAt(x0, x1, x2, next); - _v2[1] = quadraticAt(y0, y1, y2, next); - var d2 = distSquare(_v2, _v0); - if (next <= 1 && d2 < d) { - t = next; - d = d2; - } - else { - interval *= 0.5; - } - } - } - return mathSqrt$3(d); -} -function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) { - var px = x0; - var py = y0; - var d = 0; - var step = 1 / iteration; - for (var i = 1; i <= iteration; i++) { - var t = i * step; - var x = quadraticAt(x0, x1, x2, t); - var y = quadraticAt(y0, y1, y2, t); - var dx = x - px; - var dy = y - py; - d += Math.sqrt(dx * dx + dy * dy); - px = x; - py = y; - } - return d; -} - -var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/; -function createCubicEasingFunc(cubicEasingStr) { - var cubic = cubicEasingStr && regexp.exec(cubicEasingStr); - if (cubic) { - var points = cubic[1].split(','); - var a_1 = +trim(points[0]); - var b_1 = +trim(points[1]); - var c_1 = +trim(points[2]); - var d_1 = +trim(points[3]); - if (isNaN(a_1 + b_1 + c_1 + d_1)) { - return; - } - var roots_1 = []; - return function (p) { - return p <= 0 - ? 0 : p >= 1 - ? 1 - : cubicRootAt(0, a_1, c_1, 1, p, roots_1) && cubicAt(0, b_1, d_1, 1, roots_1[0]); - }; - } -} - -var Clip = (function () { - function Clip(opts) { - this._inited = false; - this._startTime = 0; - this._pausedTime = 0; - this._paused = false; - this._life = opts.life || 1000; - this._delay = opts.delay || 0; - this.loop = opts.loop || false; - this.onframe = opts.onframe || noop; - this.ondestroy = opts.ondestroy || noop; - this.onrestart = opts.onrestart || noop; - opts.easing && this.setEasing(opts.easing); - } - Clip.prototype.step = function (globalTime, deltaTime) { - if (!this._inited) { - this._startTime = globalTime + this._delay; - this._inited = true; - } - if (this._paused) { - this._pausedTime += deltaTime; - return; - } - var life = this._life; - var elapsedTime = globalTime - this._startTime - this._pausedTime; - var percent = elapsedTime / life; - if (percent < 0) { - percent = 0; - } - percent = Math.min(percent, 1); - var easingFunc = this.easingFunc; - var schedule = easingFunc ? easingFunc(percent) : percent; - this.onframe(schedule); - if (percent === 1) { - if (this.loop) { - var remainder = elapsedTime % life; - this._startTime = globalTime - remainder; - this._pausedTime = 0; - this.onrestart(); - } - else { - return true; - } - } - return false; - }; - Clip.prototype.pause = function () { - this._paused = true; - }; - Clip.prototype.resume = function () { - this._paused = false; - }; - Clip.prototype.setEasing = function (easing) { - this.easing = easing; - this.easingFunc = isFunction(easing) - ? easing - : easingFuncs[easing] || createCubicEasingFunc(easing); - }; - return Clip; -}()); - -var Entry = (function () { - function Entry(val) { - this.value = val; - } - return Entry; -}()); -var LinkedList = (function () { - function LinkedList() { - this._len = 0; - } - LinkedList.prototype.insert = function (val) { - var entry = new Entry(val); - this.insertEntry(entry); - return entry; - }; - LinkedList.prototype.insertEntry = function (entry) { - if (!this.head) { - this.head = this.tail = entry; - } - else { - this.tail.next = entry; - entry.prev = this.tail; - entry.next = null; - this.tail = entry; - } - this._len++; - }; - LinkedList.prototype.remove = function (entry) { - var prev = entry.prev; - var next = entry.next; - if (prev) { - prev.next = next; - } - else { - this.head = next; - } - if (next) { - next.prev = prev; - } - else { - this.tail = prev; - } - entry.next = entry.prev = null; - this._len--; - }; - LinkedList.prototype.len = function () { - return this._len; - }; - LinkedList.prototype.clear = function () { - this.head = this.tail = null; - this._len = 0; - }; - return LinkedList; -}()); -var LRU = (function () { - function LRU(maxSize) { - this._list = new LinkedList(); - this._maxSize = 10; - this._map = {}; - this._maxSize = maxSize; - } - LRU.prototype.put = function (key, value) { - var list = this._list; - var map = this._map; - var removed = null; - if (map[key] == null) { - var len = list.len(); - var entry = this._lastRemovedEntry; - if (len >= this._maxSize && len > 0) { - var leastUsedEntry = list.head; - list.remove(leastUsedEntry); - delete map[leastUsedEntry.key]; - removed = leastUsedEntry.value; - this._lastRemovedEntry = leastUsedEntry; - } - if (entry) { - entry.value = value; - } - else { - entry = new Entry(value); - } - entry.key = key; - list.insertEntry(entry); - map[key] = entry; - } - return removed; - }; - LRU.prototype.get = function (key) { - var entry = this._map[key]; - var list = this._list; - if (entry != null) { - if (entry !== list.tail) { - list.remove(entry); - list.insertEntry(entry); - } - return entry.value; - } - }; - LRU.prototype.clear = function () { - this._list.clear(); - this._map = {}; - }; - LRU.prototype.len = function () { - return this._list.len(); - }; - return LRU; -}()); - -var kCSSColorTable = { - 'transparent': [0, 0, 0, 0], 'aliceblue': [240, 248, 255, 1], - 'antiquewhite': [250, 235, 215, 1], 'aqua': [0, 255, 255, 1], - 'aquamarine': [127, 255, 212, 1], 'azure': [240, 255, 255, 1], - 'beige': [245, 245, 220, 1], 'bisque': [255, 228, 196, 1], - 'black': [0, 0, 0, 1], 'blanchedalmond': [255, 235, 205, 1], - 'blue': [0, 0, 255, 1], 'blueviolet': [138, 43, 226, 1], - 'brown': [165, 42, 42, 1], 'burlywood': [222, 184, 135, 1], - 'cadetblue': [95, 158, 160, 1], 'chartreuse': [127, 255, 0, 1], - 'chocolate': [210, 105, 30, 1], 'coral': [255, 127, 80, 1], - 'cornflowerblue': [100, 149, 237, 1], 'cornsilk': [255, 248, 220, 1], - 'crimson': [220, 20, 60, 1], 'cyan': [0, 255, 255, 1], - 'darkblue': [0, 0, 139, 1], 'darkcyan': [0, 139, 139, 1], - 'darkgoldenrod': [184, 134, 11, 1], 'darkgray': [169, 169, 169, 1], - 'darkgreen': [0, 100, 0, 1], 'darkgrey': [169, 169, 169, 1], - 'darkkhaki': [189, 183, 107, 1], 'darkmagenta': [139, 0, 139, 1], - 'darkolivegreen': [85, 107, 47, 1], 'darkorange': [255, 140, 0, 1], - 'darkorchid': [153, 50, 204, 1], 'darkred': [139, 0, 0, 1], - 'darksalmon': [233, 150, 122, 1], 'darkseagreen': [143, 188, 143, 1], - 'darkslateblue': [72, 61, 139, 1], 'darkslategray': [47, 79, 79, 1], - 'darkslategrey': [47, 79, 79, 1], 'darkturquoise': [0, 206, 209, 1], - 'darkviolet': [148, 0, 211, 1], 'deeppink': [255, 20, 147, 1], - 'deepskyblue': [0, 191, 255, 1], 'dimgray': [105, 105, 105, 1], - 'dimgrey': [105, 105, 105, 1], 'dodgerblue': [30, 144, 255, 1], - 'firebrick': [178, 34, 34, 1], 'floralwhite': [255, 250, 240, 1], - 'forestgreen': [34, 139, 34, 1], 'fuchsia': [255, 0, 255, 1], - 'gainsboro': [220, 220, 220, 1], 'ghostwhite': [248, 248, 255, 1], - 'gold': [255, 215, 0, 1], 'goldenrod': [218, 165, 32, 1], - 'gray': [128, 128, 128, 1], 'green': [0, 128, 0, 1], - 'greenyellow': [173, 255, 47, 1], 'grey': [128, 128, 128, 1], - 'honeydew': [240, 255, 240, 1], 'hotpink': [255, 105, 180, 1], - 'indianred': [205, 92, 92, 1], 'indigo': [75, 0, 130, 1], - 'ivory': [255, 255, 240, 1], 'khaki': [240, 230, 140, 1], - 'lavender': [230, 230, 250, 1], 'lavenderblush': [255, 240, 245, 1], - 'lawngreen': [124, 252, 0, 1], 'lemonchiffon': [255, 250, 205, 1], - 'lightblue': [173, 216, 230, 1], 'lightcoral': [240, 128, 128, 1], - 'lightcyan': [224, 255, 255, 1], 'lightgoldenrodyellow': [250, 250, 210, 1], - 'lightgray': [211, 211, 211, 1], 'lightgreen': [144, 238, 144, 1], - 'lightgrey': [211, 211, 211, 1], 'lightpink': [255, 182, 193, 1], - 'lightsalmon': [255, 160, 122, 1], 'lightseagreen': [32, 178, 170, 1], - 'lightskyblue': [135, 206, 250, 1], 'lightslategray': [119, 136, 153, 1], - 'lightslategrey': [119, 136, 153, 1], 'lightsteelblue': [176, 196, 222, 1], - 'lightyellow': [255, 255, 224, 1], 'lime': [0, 255, 0, 1], - 'limegreen': [50, 205, 50, 1], 'linen': [250, 240, 230, 1], - 'magenta': [255, 0, 255, 1], 'maroon': [128, 0, 0, 1], - 'mediumaquamarine': [102, 205, 170, 1], 'mediumblue': [0, 0, 205, 1], - 'mediumorchid': [186, 85, 211, 1], 'mediumpurple': [147, 112, 219, 1], - 'mediumseagreen': [60, 179, 113, 1], 'mediumslateblue': [123, 104, 238, 1], - 'mediumspringgreen': [0, 250, 154, 1], 'mediumturquoise': [72, 209, 204, 1], - 'mediumvioletred': [199, 21, 133, 1], 'midnightblue': [25, 25, 112, 1], - 'mintcream': [245, 255, 250, 1], 'mistyrose': [255, 228, 225, 1], - 'moccasin': [255, 228, 181, 1], 'navajowhite': [255, 222, 173, 1], - 'navy': [0, 0, 128, 1], 'oldlace': [253, 245, 230, 1], - 'olive': [128, 128, 0, 1], 'olivedrab': [107, 142, 35, 1], - 'orange': [255, 165, 0, 1], 'orangered': [255, 69, 0, 1], - 'orchid': [218, 112, 214, 1], 'palegoldenrod': [238, 232, 170, 1], - 'palegreen': [152, 251, 152, 1], 'paleturquoise': [175, 238, 238, 1], - 'palevioletred': [219, 112, 147, 1], 'papayawhip': [255, 239, 213, 1], - 'peachpuff': [255, 218, 185, 1], 'peru': [205, 133, 63, 1], - 'pink': [255, 192, 203, 1], 'plum': [221, 160, 221, 1], - 'powderblue': [176, 224, 230, 1], 'purple': [128, 0, 128, 1], - 'red': [255, 0, 0, 1], 'rosybrown': [188, 143, 143, 1], - 'royalblue': [65, 105, 225, 1], 'saddlebrown': [139, 69, 19, 1], - 'salmon': [250, 128, 114, 1], 'sandybrown': [244, 164, 96, 1], - 'seagreen': [46, 139, 87, 1], 'seashell': [255, 245, 238, 1], - 'sienna': [160, 82, 45, 1], 'silver': [192, 192, 192, 1], - 'skyblue': [135, 206, 235, 1], 'slateblue': [106, 90, 205, 1], - 'slategray': [112, 128, 144, 1], 'slategrey': [112, 128, 144, 1], - 'snow': [255, 250, 250, 1], 'springgreen': [0, 255, 127, 1], - 'steelblue': [70, 130, 180, 1], 'tan': [210, 180, 140, 1], - 'teal': [0, 128, 128, 1], 'thistle': [216, 191, 216, 1], - 'tomato': [255, 99, 71, 1], 'turquoise': [64, 224, 208, 1], - 'violet': [238, 130, 238, 1], 'wheat': [245, 222, 179, 1], - 'white': [255, 255, 255, 1], 'whitesmoke': [245, 245, 245, 1], - 'yellow': [255, 255, 0, 1], 'yellowgreen': [154, 205, 50, 1] -}; -function clampCssByte(i) { - i = Math.round(i); - return i < 0 ? 0 : i > 255 ? 255 : i; -} -function clampCssFloat(f) { - return f < 0 ? 0 : f > 1 ? 1 : f; -} -function parseCssInt(val) { - var str = val; - if (str.length && str.charAt(str.length - 1) === '%') { - return clampCssByte(parseFloat(str) / 100 * 255); - } - return clampCssByte(parseInt(str, 10)); -} -function parseCssFloat(val) { - var str = val; - if (str.length && str.charAt(str.length - 1) === '%') { - return clampCssFloat(parseFloat(str) / 100); - } - return clampCssFloat(parseFloat(str)); -} -function cssHueToRgb(m1, m2, h) { - if (h < 0) { - h += 1; - } - else if (h > 1) { - h -= 1; - } - if (h * 6 < 1) { - return m1 + (m2 - m1) * h * 6; - } - if (h * 2 < 1) { - return m2; - } - if (h * 3 < 2) { - return m1 + (m2 - m1) * (2 / 3 - h) * 6; - } - return m1; -} -function lerpNumber(a, b, p) { - return a + (b - a) * p; -} -function setRgba(out, r, g, b, a) { - out[0] = r; - out[1] = g; - out[2] = b; - out[3] = a; - return out; -} -function copyRgba(out, a) { - out[0] = a[0]; - out[1] = a[1]; - out[2] = a[2]; - out[3] = a[3]; - return out; -} -var colorCache = new LRU(20); -var lastRemovedArr = null; -function putToCache(colorStr, rgbaArr) { - if (lastRemovedArr) { - copyRgba(lastRemovedArr, rgbaArr); - } - lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || (rgbaArr.slice())); -} -function parse(colorStr, rgbaArr) { - if (!colorStr) { - return; - } - rgbaArr = rgbaArr || []; - var cached = colorCache.get(colorStr); - if (cached) { - return copyRgba(rgbaArr, cached); - } - colorStr = colorStr + ''; - var str = colorStr.replace(/ /g, '').toLowerCase(); - if (str in kCSSColorTable) { - copyRgba(rgbaArr, kCSSColorTable[str]); - putToCache(colorStr, rgbaArr); - return rgbaArr; - } - var strLen = str.length; - if (str.charAt(0) === '#') { - if (strLen === 4 || strLen === 5) { - var iv = parseInt(str.slice(1, 4), 16); - if (!(iv >= 0 && iv <= 0xfff)) { - setRgba(rgbaArr, 0, 0, 0, 1); - return; - } - setRgba(rgbaArr, ((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8), (iv & 0xf0) | ((iv & 0xf0) >> 4), (iv & 0xf) | ((iv & 0xf) << 4), strLen === 5 ? parseInt(str.slice(4), 16) / 0xf : 1); - putToCache(colorStr, rgbaArr); - return rgbaArr; - } - else if (strLen === 7 || strLen === 9) { - var iv = parseInt(str.slice(1, 7), 16); - if (!(iv >= 0 && iv <= 0xffffff)) { - setRgba(rgbaArr, 0, 0, 0, 1); - return; - } - setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, strLen === 9 ? parseInt(str.slice(7), 16) / 0xff : 1); - putToCache(colorStr, rgbaArr); - return rgbaArr; - } - return; - } - var op = str.indexOf('('); - var ep = str.indexOf(')'); - if (op !== -1 && ep + 1 === strLen) { - var fname = str.substr(0, op); - var params = str.substr(op + 1, ep - (op + 1)).split(','); - var alpha = 1; - switch (fname) { - case 'rgba': - if (params.length !== 4) { - return params.length === 3 - ? setRgba(rgbaArr, +params[0], +params[1], +params[2], 1) - : setRgba(rgbaArr, 0, 0, 0, 1); - } - alpha = parseCssFloat(params.pop()); - case 'rgb': - if (params.length >= 3) { - setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), params.length === 3 ? alpha : parseCssFloat(params[3])); - putToCache(colorStr, rgbaArr); - return rgbaArr; - } - else { - setRgba(rgbaArr, 0, 0, 0, 1); - return; - } - case 'hsla': - if (params.length !== 4) { - setRgba(rgbaArr, 0, 0, 0, 1); - return; - } - params[3] = parseCssFloat(params[3]); - hsla2rgba(params, rgbaArr); - putToCache(colorStr, rgbaArr); - return rgbaArr; - case 'hsl': - if (params.length !== 3) { - setRgba(rgbaArr, 0, 0, 0, 1); - return; - } - hsla2rgba(params, rgbaArr); - putToCache(colorStr, rgbaArr); - return rgbaArr; - default: - return; - } - } - setRgba(rgbaArr, 0, 0, 0, 1); - return; -} -function hsla2rgba(hsla, rgba) { - var h = (((parseFloat(hsla[0]) % 360) + 360) % 360) / 360; - var s = parseCssFloat(hsla[1]); - var l = parseCssFloat(hsla[2]); - var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s; - var m1 = l * 2 - m2; - rgba = rgba || []; - setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1); - if (hsla.length === 4) { - rgba[3] = hsla[3]; - } - return rgba; -} -function lift(color, level) { - var colorArr = parse(color); - if (colorArr) { - for (var i = 0; i < 3; i++) { - { - colorArr[i] = colorArr[i] * (1 - level) | 0; - } - if (colorArr[i] > 255) { - colorArr[i] = 255; - } - else if (colorArr[i] < 0) { - colorArr[i] = 0; - } - } - return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb'); - } -} -function lerp(normalizedValue, colors, fullOutput) { - if (!(colors && colors.length) - || !(normalizedValue >= 0 && normalizedValue <= 1)) { - return; - } - var value = normalizedValue * (colors.length - 1); - var leftIndex = Math.floor(value); - var rightIndex = Math.ceil(value); - var leftColor = parse(colors[leftIndex]); - var rightColor = parse(colors[rightIndex]); - var dv = value - leftIndex; - var color = stringify([ - clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)), - clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)), - clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)), - clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv)) - ], 'rgba'); - return fullOutput - ? { - color: color, - leftIndex: leftIndex, - rightIndex: rightIndex, - value: value - } - : color; -} -function stringify(arrColor, type) { - if (!arrColor || !arrColor.length) { - return; - } - var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2]; - if (type === 'rgba' || type === 'hsva' || type === 'hsla') { - colorStr += ',' + arrColor[3]; - } - return type + '(' + colorStr + ')'; -} -function lum(color, backgroundLum) { - var arr = parse(color); - return arr - ? (0.299 * arr[0] + 0.587 * arr[1] + 0.114 * arr[2]) * arr[3] / 255 - + (1 - arr[3]) * backgroundLum - : 0; -} -var liftedColorCache = new LRU(100); -function liftColor(color) { - if (isString(color)) { - var liftedColor = liftedColorCache.get(color); - if (!liftedColor) { - liftedColor = lift(color, -0.1); - liftedColorCache.put(color, liftedColor); - } - return liftedColor; - } - else if (isGradientObject(color)) { - var ret = extend({}, color); - ret.colorStops = map$1(color.colorStops, function (stop) { return ({ - offset: stop.offset, - color: lift(stop.color, -0.1) - }); }); - return ret; - } - return color; -} - -function isLinearGradient(val) { - return val.type === "linear"; -} -function isRadialGradient(val) { - return val.type === "radial"; -} -(function() { - if (env.hasGlobalWindow && isFunction(window.btoa)) { - return function(str) { - return window.btoa(unescape(encodeURIComponent(str))); - }; - } - if (typeof Buffer !== "undefined") { - return function(str) { - return Buffer.from(str).toString("base64"); - }; - } - return function(str) { - return null; - }; -})(); - -var arraySlice = Array.prototype.slice; -function interpolateNumber$1(p0, p1, percent) { - return (p1 - p0) * percent + p0; -} -function interpolate1DArray(out, p0, p1, percent) { - var len = p0.length; - for (var i = 0; i < len; i++) { - out[i] = interpolateNumber$1(p0[i], p1[i], percent); - } - return out; -} -function interpolate2DArray(out, p0, p1, percent) { - var len = p0.length; - var len2 = len && p0[0].length; - for (var i = 0; i < len; i++) { - if (!out[i]) { - out[i] = []; - } - for (var j = 0; j < len2; j++) { - out[i][j] = interpolateNumber$1(p0[i][j], p1[i][j], percent); - } - } - return out; -} -function add1DArray(out, p0, p1, sign) { - var len = p0.length; - for (var i = 0; i < len; i++) { - out[i] = p0[i] + p1[i] * sign; - } - return out; -} -function add2DArray(out, p0, p1, sign) { - var len = p0.length; - var len2 = len && p0[0].length; - for (var i = 0; i < len; i++) { - if (!out[i]) { - out[i] = []; - } - for (var j = 0; j < len2; j++) { - out[i][j] = p0[i][j] + p1[i][j] * sign; - } - } - return out; -} -function fillColorStops(val0, val1) { - var len0 = val0.length; - var len1 = val1.length; - var shorterArr = len0 > len1 ? val1 : val0; - var shorterLen = Math.min(len0, len1); - var last = shorterArr[shorterLen - 1] || { color: [0, 0, 0, 0], offset: 0 }; - for (var i = shorterLen; i < Math.max(len0, len1); i++) { - shorterArr.push({ - offset: last.offset, - color: last.color.slice() - }); - } -} -function fillArray(val0, val1, arrDim) { - var arr0 = val0; - var arr1 = val1; - if (!arr0.push || !arr1.push) { - return; - } - var arr0Len = arr0.length; - var arr1Len = arr1.length; - if (arr0Len !== arr1Len) { - var isPreviousLarger = arr0Len > arr1Len; - if (isPreviousLarger) { - arr0.length = arr1Len; - } - else { - for (var i = arr0Len; i < arr1Len; i++) { - arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i])); - } - } - } - var len2 = arr0[0] && arr0[0].length; - for (var i = 0; i < arr0.length; i++) { - if (arrDim === 1) { - if (isNaN(arr0[i])) { - arr0[i] = arr1[i]; - } - } - else { - for (var j = 0; j < len2; j++) { - if (isNaN(arr0[i][j])) { - arr0[i][j] = arr1[i][j]; - } - } - } - } -} -function cloneValue(value) { - if (isArrayLike(value)) { - var len = value.length; - if (isArrayLike(value[0])) { - var ret = []; - for (var i = 0; i < len; i++) { - ret.push(arraySlice.call(value[i])); - } - return ret; - } - return arraySlice.call(value); - } - return value; -} -function rgba2String(rgba) { - rgba[0] = Math.floor(rgba[0]) || 0; - rgba[1] = Math.floor(rgba[1]) || 0; - rgba[2] = Math.floor(rgba[2]) || 0; - rgba[3] = rgba[3] == null ? 1 : rgba[3]; - return 'rgba(' + rgba.join(',') + ')'; -} -function guessArrayDim(value) { - return isArrayLike(value && value[0]) ? 2 : 1; -} -var VALUE_TYPE_NUMBER = 0; -var VALUE_TYPE_1D_ARRAY = 1; -var VALUE_TYPE_2D_ARRAY = 2; -var VALUE_TYPE_COLOR = 3; -var VALUE_TYPE_LINEAR_GRADIENT = 4; -var VALUE_TYPE_RADIAL_GRADIENT = 5; -var VALUE_TYPE_UNKOWN = 6; -function isGradientValueType(valType) { - return valType === VALUE_TYPE_LINEAR_GRADIENT || valType === VALUE_TYPE_RADIAL_GRADIENT; -} -function isArrayValueType(valType) { - return valType === VALUE_TYPE_1D_ARRAY || valType === VALUE_TYPE_2D_ARRAY; -} -var tmpRgba = [0, 0, 0, 0]; -var Track = (function () { - function Track(propName) { - this.keyframes = []; - this.discrete = false; - this._invalid = false; - this._needsSort = false; - this._lastFr = 0; - this._lastFrP = 0; - this.propName = propName; - } - Track.prototype.isFinished = function () { - return this._finished; - }; - Track.prototype.setFinished = function () { - this._finished = true; - if (this._additiveTrack) { - this._additiveTrack.setFinished(); - } - }; - Track.prototype.needsAnimate = function () { - return this.keyframes.length >= 1; - }; - Track.prototype.getAdditiveTrack = function () { - return this._additiveTrack; - }; - Track.prototype.addKeyframe = function (time, rawValue, easing) { - this._needsSort = true; - var keyframes = this.keyframes; - var len = keyframes.length; - var discrete = false; - var valType = VALUE_TYPE_UNKOWN; - var value = rawValue; - if (isArrayLike(rawValue)) { - var arrayDim = guessArrayDim(rawValue); - valType = arrayDim; - if (arrayDim === 1 && !isNumber(rawValue[0]) - || arrayDim === 2 && !isNumber(rawValue[0][0])) { - discrete = true; - } - } - else { - if (isNumber(rawValue) && !eqNaN(rawValue)) { - valType = VALUE_TYPE_NUMBER; - } - else if (isString(rawValue)) { - if (!isNaN(+rawValue)) { - valType = VALUE_TYPE_NUMBER; - } - else { - var colorArray = parse(rawValue); - if (colorArray) { - value = colorArray; - valType = VALUE_TYPE_COLOR; - } - } - } - else if (isGradientObject(rawValue)) { - var parsedGradient = extend({}, value); - parsedGradient.colorStops = map$1(rawValue.colorStops, function (colorStop) { return ({ - offset: colorStop.offset, - color: parse(colorStop.color) - }); }); - if (isLinearGradient(rawValue)) { - valType = VALUE_TYPE_LINEAR_GRADIENT; - } - else if (isRadialGradient(rawValue)) { - valType = VALUE_TYPE_RADIAL_GRADIENT; - } - value = parsedGradient; - } - } - if (len === 0) { - this.valType = valType; - } - else if (valType !== this.valType || valType === VALUE_TYPE_UNKOWN) { - discrete = true; - } - this.discrete = this.discrete || discrete; - var kf = { - time: time, - value: value, - rawValue: rawValue, - percent: 0 - }; - if (easing) { - kf.easing = easing; - kf.easingFunc = isFunction(easing) - ? easing - : easingFuncs[easing] || createCubicEasingFunc(easing); - } - keyframes.push(kf); - return kf; - }; - Track.prototype.prepare = function (maxTime, additiveTrack) { - var kfs = this.keyframes; - if (this._needsSort) { - kfs.sort(function (a, b) { - return a.time - b.time; - }); - } - var valType = this.valType; - var kfsLen = kfs.length; - var lastKf = kfs[kfsLen - 1]; - var isDiscrete = this.discrete; - var isArr = isArrayValueType(valType); - var isGradient = isGradientValueType(valType); - for (var i = 0; i < kfsLen; i++) { - var kf = kfs[i]; - var value = kf.value; - var lastValue = lastKf.value; - kf.percent = kf.time / maxTime; - if (!isDiscrete) { - if (isArr && i !== kfsLen - 1) { - fillArray(value, lastValue, valType); - } - else if (isGradient) { - fillColorStops(value.colorStops, lastValue.colorStops); - } - } - } - if (!isDiscrete - && valType !== VALUE_TYPE_RADIAL_GRADIENT - && additiveTrack - && this.needsAnimate() - && additiveTrack.needsAnimate() - && valType === additiveTrack.valType - && !additiveTrack._finished) { - this._additiveTrack = additiveTrack; - var startValue = kfs[0].value; - for (var i = 0; i < kfsLen; i++) { - if (valType === VALUE_TYPE_NUMBER) { - kfs[i].additiveValue = kfs[i].value - startValue; - } - else if (valType === VALUE_TYPE_COLOR) { - kfs[i].additiveValue = - add1DArray([], kfs[i].value, startValue, -1); - } - else if (isArrayValueType(valType)) { - kfs[i].additiveValue = valType === VALUE_TYPE_1D_ARRAY - ? add1DArray([], kfs[i].value, startValue, -1) - : add2DArray([], kfs[i].value, startValue, -1); - } - } - } - }; - Track.prototype.step = function (target, percent) { - if (this._finished) { - return; - } - if (this._additiveTrack && this._additiveTrack._finished) { - this._additiveTrack = null; - } - var isAdditive = this._additiveTrack != null; - var valueKey = isAdditive ? 'additiveValue' : 'value'; - var valType = this.valType; - var keyframes = this.keyframes; - var kfsNum = keyframes.length; - var propName = this.propName; - var isValueColor = valType === VALUE_TYPE_COLOR; - var frameIdx; - var lastFrame = this._lastFr; - var mathMin = Math.min; - var frame; - var nextFrame; - if (kfsNum === 1) { - frame = nextFrame = keyframes[0]; - } - else { - if (percent < 0) { - frameIdx = 0; - } - else if (percent < this._lastFrP) { - var start = mathMin(lastFrame + 1, kfsNum - 1); - for (frameIdx = start; frameIdx >= 0; frameIdx--) { - if (keyframes[frameIdx].percent <= percent) { - break; - } - } - frameIdx = mathMin(frameIdx, kfsNum - 2); - } - else { - for (frameIdx = lastFrame; frameIdx < kfsNum; frameIdx++) { - if (keyframes[frameIdx].percent > percent) { - break; - } - } - frameIdx = mathMin(frameIdx - 1, kfsNum - 2); - } - nextFrame = keyframes[frameIdx + 1]; - frame = keyframes[frameIdx]; - } - if (!(frame && nextFrame)) { - return; - } - this._lastFr = frameIdx; - this._lastFrP = percent; - var interval = (nextFrame.percent - frame.percent); - var w = interval === 0 ? 1 : mathMin((percent - frame.percent) / interval, 1); - if (nextFrame.easingFunc) { - w = nextFrame.easingFunc(w); - } - var targetArr = isAdditive ? this._additiveValue - : (isValueColor ? tmpRgba : target[propName]); - if ((isArrayValueType(valType) || isValueColor) && !targetArr) { - targetArr = this._additiveValue = []; - } - if (this.discrete) { - target[propName] = w < 1 ? frame.rawValue : nextFrame.rawValue; - } - else if (isArrayValueType(valType)) { - valType === VALUE_TYPE_1D_ARRAY - ? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w) - : interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w); - } - else if (isGradientValueType(valType)) { - var val = frame[valueKey]; - var nextVal_1 = nextFrame[valueKey]; - var isLinearGradient_1 = valType === VALUE_TYPE_LINEAR_GRADIENT; - target[propName] = { - type: isLinearGradient_1 ? 'linear' : 'radial', - x: interpolateNumber$1(val.x, nextVal_1.x, w), - y: interpolateNumber$1(val.y, nextVal_1.y, w), - colorStops: map$1(val.colorStops, function (colorStop, idx) { - var nextColorStop = nextVal_1.colorStops[idx]; - return { - offset: interpolateNumber$1(colorStop.offset, nextColorStop.offset, w), - color: rgba2String(interpolate1DArray([], colorStop.color, nextColorStop.color, w)) - }; - }), - global: nextVal_1.global - }; - if (isLinearGradient_1) { - target[propName].x2 = interpolateNumber$1(val.x2, nextVal_1.x2, w); - target[propName].y2 = interpolateNumber$1(val.y2, nextVal_1.y2, w); - } - else { - target[propName].r = interpolateNumber$1(val.r, nextVal_1.r, w); - } - } - else if (isValueColor) { - interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w); - if (!isAdditive) { - target[propName] = rgba2String(targetArr); - } - } - else { - var value = interpolateNumber$1(frame[valueKey], nextFrame[valueKey], w); - if (isAdditive) { - this._additiveValue = value; - } - else { - target[propName] = value; - } - } - if (isAdditive) { - this._addToTarget(target); - } - }; - Track.prototype._addToTarget = function (target) { - var valType = this.valType; - var propName = this.propName; - var additiveValue = this._additiveValue; - if (valType === VALUE_TYPE_NUMBER) { - target[propName] = target[propName] + additiveValue; - } - else if (valType === VALUE_TYPE_COLOR) { - parse(target[propName], tmpRgba); - add1DArray(tmpRgba, tmpRgba, additiveValue, 1); - target[propName] = rgba2String(tmpRgba); - } - else if (valType === VALUE_TYPE_1D_ARRAY) { - add1DArray(target[propName], target[propName], additiveValue, 1); - } - else if (valType === VALUE_TYPE_2D_ARRAY) { - add2DArray(target[propName], target[propName], additiveValue, 1); - } - }; - return Track; -}()); -var Animator = (function () { - function Animator(target, loop, allowDiscreteAnimation, additiveTo) { - this._tracks = {}; - this._trackKeys = []; - this._maxTime = 0; - this._started = 0; - this._clip = null; - this._target = target; - this._loop = loop; - if (loop && additiveTo) { - logError('Can\' use additive animation on looped animation.'); - return; - } - this._additiveAnimators = additiveTo; - this._allowDiscrete = allowDiscreteAnimation; - } - Animator.prototype.getMaxTime = function () { - return this._maxTime; - }; - Animator.prototype.getDelay = function () { - return this._delay; - }; - Animator.prototype.getLoop = function () { - return this._loop; - }; - Animator.prototype.getTarget = function () { - return this._target; - }; - Animator.prototype.changeTarget = function (target) { - this._target = target; - }; - Animator.prototype.when = function (time, props, easing) { - return this.whenWithKeys(time, props, keys(props), easing); - }; - Animator.prototype.whenWithKeys = function (time, props, propNames, easing) { - var tracks = this._tracks; - for (var i = 0; i < propNames.length; i++) { - var propName = propNames[i]; - var track = tracks[propName]; - if (!track) { - track = tracks[propName] = new Track(propName); - var initialValue = void 0; - var additiveTrack = this._getAdditiveTrack(propName); - if (additiveTrack) { - var addtiveTrackKfs = additiveTrack.keyframes; - var lastFinalKf = addtiveTrackKfs[addtiveTrackKfs.length - 1]; - initialValue = lastFinalKf && lastFinalKf.value; - if (additiveTrack.valType === VALUE_TYPE_COLOR && initialValue) { - initialValue = rgba2String(initialValue); - } - } - else { - initialValue = this._target[propName]; - } - if (initialValue == null) { - continue; - } - if (time > 0) { - track.addKeyframe(0, cloneValue(initialValue), easing); - } - this._trackKeys.push(propName); - } - track.addKeyframe(time, cloneValue(props[propName]), easing); - } - this._maxTime = Math.max(this._maxTime, time); - return this; - }; - Animator.prototype.pause = function () { - this._clip.pause(); - this._paused = true; - }; - Animator.prototype.resume = function () { - this._clip.resume(); - this._paused = false; - }; - Animator.prototype.isPaused = function () { - return !!this._paused; - }; - Animator.prototype.duration = function (duration) { - this._maxTime = duration; - this._force = true; - return this; - }; - Animator.prototype._doneCallback = function () { - this._setTracksFinished(); - this._clip = null; - var doneList = this._doneCbs; - if (doneList) { - var len = doneList.length; - for (var i = 0; i < len; i++) { - doneList[i].call(this); - } - } - }; - Animator.prototype._abortedCallback = function () { - this._setTracksFinished(); - var animation = this.animation; - var abortedList = this._abortedCbs; - if (animation) { - animation.removeClip(this._clip); - } - this._clip = null; - if (abortedList) { - for (var i = 0; i < abortedList.length; i++) { - abortedList[i].call(this); - } - } - }; - Animator.prototype._setTracksFinished = function () { - var tracks = this._tracks; - var tracksKeys = this._trackKeys; - for (var i = 0; i < tracksKeys.length; i++) { - tracks[tracksKeys[i]].setFinished(); - } - }; - Animator.prototype._getAdditiveTrack = function (trackName) { - var additiveTrack; - var additiveAnimators = this._additiveAnimators; - if (additiveAnimators) { - for (var i = 0; i < additiveAnimators.length; i++) { - var track = additiveAnimators[i].getTrack(trackName); - if (track) { - additiveTrack = track; - } - } - } - return additiveTrack; - }; - Animator.prototype.start = function (easing) { - if (this._started > 0) { - return; - } - this._started = 1; - var self = this; - var tracks = []; - var maxTime = this._maxTime || 0; - for (var i = 0; i < this._trackKeys.length; i++) { - var propName = this._trackKeys[i]; - var track = this._tracks[propName]; - var additiveTrack = this._getAdditiveTrack(propName); - var kfs = track.keyframes; - var kfsNum = kfs.length; - track.prepare(maxTime, additiveTrack); - if (track.needsAnimate()) { - if (!this._allowDiscrete && track.discrete) { - var lastKf = kfs[kfsNum - 1]; - if (lastKf) { - self._target[track.propName] = lastKf.rawValue; - } - track.setFinished(); - } - else { - tracks.push(track); - } - } - } - if (tracks.length || this._force) { - var clip = new Clip({ - life: maxTime, - loop: this._loop, - delay: this._delay || 0, - onframe: function (percent) { - self._started = 2; - var additiveAnimators = self._additiveAnimators; - if (additiveAnimators) { - var stillHasAdditiveAnimator = false; - for (var i = 0; i < additiveAnimators.length; i++) { - if (additiveAnimators[i]._clip) { - stillHasAdditiveAnimator = true; - break; - } - } - if (!stillHasAdditiveAnimator) { - self._additiveAnimators = null; - } - } - for (var i = 0; i < tracks.length; i++) { - tracks[i].step(self._target, percent); - } - var onframeList = self._onframeCbs; - if (onframeList) { - for (var i = 0; i < onframeList.length; i++) { - onframeList[i](self._target, percent); - } - } - }, - ondestroy: function () { - self._doneCallback(); - } - }); - this._clip = clip; - if (this.animation) { - this.animation.addClip(clip); - } - if (easing) { - clip.setEasing(easing); - } - } - else { - this._doneCallback(); - } - return this; - }; - Animator.prototype.stop = function (forwardToLast) { - if (!this._clip) { - return; - } - var clip = this._clip; - if (forwardToLast) { - clip.onframe(1); - } - this._abortedCallback(); - }; - Animator.prototype.delay = function (time) { - this._delay = time; - return this; - }; - Animator.prototype.during = function (cb) { - if (cb) { - if (!this._onframeCbs) { - this._onframeCbs = []; - } - this._onframeCbs.push(cb); - } - return this; - }; - Animator.prototype.done = function (cb) { - if (cb) { - if (!this._doneCbs) { - this._doneCbs = []; - } - this._doneCbs.push(cb); - } - return this; - }; - Animator.prototype.aborted = function (cb) { - if (cb) { - if (!this._abortedCbs) { - this._abortedCbs = []; - } - this._abortedCbs.push(cb); - } - return this; - }; - Animator.prototype.getClip = function () { - return this._clip; - }; - Animator.prototype.getTrack = function (propName) { - return this._tracks[propName]; - }; - Animator.prototype.getTracks = function () { - var _this = this; - return map$1(this._trackKeys, function (key) { return _this._tracks[key]; }); - }; - Animator.prototype.stopTracks = function (propNames, forwardToLast) { - if (!propNames.length || !this._clip) { - return true; - } - var tracks = this._tracks; - var tracksKeys = this._trackKeys; - for (var i = 0; i < propNames.length; i++) { - var track = tracks[propNames[i]]; - if (track && !track.isFinished()) { - if (forwardToLast) { - track.step(this._target, 1); - } - else if (this._started === 1) { - track.step(this._target, 0); - } - track.setFinished(); - } - } - var allAborted = true; - for (var i = 0; i < tracksKeys.length; i++) { - if (!tracks[tracksKeys[i]].isFinished()) { - allAborted = false; - break; - } - } - if (allAborted) { - this._abortedCallback(); - } - return allAborted; - }; - Animator.prototype.saveTo = function (target, trackKeys, firstOrLast) { - if (!target) { - return; - } - trackKeys = trackKeys || this._trackKeys; - for (var i = 0; i < trackKeys.length; i++) { - var propName = trackKeys[i]; - var track = this._tracks[propName]; - if (!track || track.isFinished()) { - continue; - } - var kfs = track.keyframes; - var kf = kfs[firstOrLast ? 0 : kfs.length - 1]; - if (kf) { - target[propName] = cloneValue(kf.rawValue); - } - } - }; - Animator.prototype.__changeFinalValue = function (finalProps, trackKeys) { - trackKeys = trackKeys || keys(finalProps); - for (var i = 0; i < trackKeys.length; i++) { - var propName = trackKeys[i]; - var track = this._tracks[propName]; - if (!track) { - continue; - } - var kfs = track.keyframes; - if (kfs.length > 1) { - var lastKf = kfs.pop(); - track.addKeyframe(lastKf.time, finalProps[propName]); - track.prepare(this._maxTime, track.getAdditiveTrack()); - } - } - }; - return Animator; -}()); - -function getTime() { - return new Date().getTime(); -} -var Animation = (function (_super) { - __extends(Animation, _super); - function Animation(opts) { - var _this = _super.call(this) || this; - _this._running = false; - _this._time = 0; - _this._pausedTime = 0; - _this._pauseStart = 0; - _this._paused = false; - opts = opts || {}; - _this.stage = opts.stage || {}; - return _this; - } - Animation.prototype.addClip = function (clip) { - if (clip.animation) { - this.removeClip(clip); - } - if (!this._head) { - this._head = this._tail = clip; - } - else { - this._tail.next = clip; - clip.prev = this._tail; - clip.next = null; - this._tail = clip; - } - clip.animation = this; - }; - Animation.prototype.addAnimator = function (animator) { - animator.animation = this; - var clip = animator.getClip(); - if (clip) { - this.addClip(clip); - } - }; - Animation.prototype.removeClip = function (clip) { - if (!clip.animation) { - return; - } - var prev = clip.prev; - var next = clip.next; - if (prev) { - prev.next = next; - } - else { - this._head = next; - } - if (next) { - next.prev = prev; - } - else { - this._tail = prev; - } - clip.next = clip.prev = clip.animation = null; - }; - Animation.prototype.removeAnimator = function (animator) { - var clip = animator.getClip(); - if (clip) { - this.removeClip(clip); - } - animator.animation = null; - }; - Animation.prototype.update = function (notTriggerFrameAndStageUpdate) { - var time = getTime() - this._pausedTime; - var delta = time - this._time; - var clip = this._head; - while (clip) { - var nextClip = clip.next; - var finished = clip.step(time, delta); - if (finished) { - clip.ondestroy(); - this.removeClip(clip); - clip = nextClip; - } - else { - clip = nextClip; - } - } - this._time = time; - if (!notTriggerFrameAndStageUpdate) { - this.trigger('frame', delta); - this.stage.update && this.stage.update(); - } - }; - Animation.prototype._startLoop = function () { - var self = this; - this._running = true; - function step() { - if (self._running) { - requestAnimationFrame$1(step); - !self._paused && self.update(); - } - } - requestAnimationFrame$1(step); - }; - Animation.prototype.start = function () { - if (this._running) { - return; - } - this._time = getTime(); - this._pausedTime = 0; - this._startLoop(); - }; - Animation.prototype.stop = function () { - this._running = false; - }; - Animation.prototype.pause = function () { - if (!this._paused) { - this._pauseStart = getTime(); - this._paused = true; - } - }; - Animation.prototype.resume = function () { - if (this._paused) { - this._pausedTime += getTime() - this._pauseStart; - this._paused = false; - } - }; - Animation.prototype.clear = function () { - var clip = this._head; - while (clip) { - var nextClip = clip.next; - clip.prev = clip.next = clip.animation = null; - clip = nextClip; - } - this._head = this._tail = null; - }; - Animation.prototype.isFinished = function () { - return this._head == null; - }; - Animation.prototype.animate = function (target, options) { - options = options || {}; - this.start(); - var animator = new Animator(target, options.loop); - this.addAnimator(animator); - return animator; - }; - return Animation; -}(Eventful)); - -var TOUCH_CLICK_DELAY = 300; -var globalEventSupported = env.domSupported; -var localNativeListenerNames = (function () { - var mouseHandlerNames = [ - 'click', 'dblclick', 'mousewheel', 'wheel', 'mouseout', - 'mouseup', 'mousedown', 'mousemove', 'contextmenu' - ]; - var touchHandlerNames = [ - 'touchstart', 'touchend', 'touchmove' - ]; - var pointerEventNameMap = { - pointerdown: 1, pointerup: 1, pointermove: 1, pointerout: 1 - }; - var pointerHandlerNames = map$1(mouseHandlerNames, function (name) { - var nm = name.replace('mouse', 'pointer'); - return pointerEventNameMap.hasOwnProperty(nm) ? nm : name; - }); - return { - mouse: mouseHandlerNames, - touch: touchHandlerNames, - pointer: pointerHandlerNames - }; -})(); -var globalNativeListenerNames = { - mouse: ['mousemove', 'mouseup'], - pointer: ['pointermove', 'pointerup'] -}; -var wheelEventSupported = false; -function isPointerFromTouch(event) { - var pointerType = event.pointerType; - return pointerType === 'pen' || pointerType === 'touch'; -} -function setTouchTimer(scope) { - scope.touching = true; - if (scope.touchTimer != null) { - clearTimeout(scope.touchTimer); - scope.touchTimer = null; - } - scope.touchTimer = setTimeout(function () { - scope.touching = false; - scope.touchTimer = null; - }, 700); -} -function markTouch(event) { - event && (event.zrByTouch = true); -} -function normalizeGlobalEvent(instance, event) { - return normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event), true); -} -function isLocalEl(instance, el) { - var elTmp = el; - var isLocal = false; - while (elTmp && elTmp.nodeType !== 9 - && !(isLocal = elTmp.domBelongToZr - || (elTmp !== el && elTmp === instance.painterRoot))) { - elTmp = elTmp.parentNode; - } - return isLocal; -} -var FakeGlobalEvent = (function () { - function FakeGlobalEvent(instance, event) { - this.stopPropagation = noop; - this.stopImmediatePropagation = noop; - this.preventDefault = noop; - this.type = event.type; - this.target = this.currentTarget = instance.dom; - this.pointerType = event.pointerType; - this.clientX = event.clientX; - this.clientY = event.clientY; - } - return FakeGlobalEvent; -}()); -var localDOMHandlers = { - mousedown: function (event) { - event = normalizeEvent(this.dom, event); - this.__mayPointerCapture = [event.zrX, event.zrY]; - this.trigger('mousedown', event); - }, - mousemove: function (event) { - event = normalizeEvent(this.dom, event); - var downPoint = this.__mayPointerCapture; - if (downPoint && (event.zrX !== downPoint[0] || event.zrY !== downPoint[1])) { - this.__togglePointerCapture(true); - } - this.trigger('mousemove', event); - }, - mouseup: function (event) { - event = normalizeEvent(this.dom, event); - this.__togglePointerCapture(false); - this.trigger('mouseup', event); - }, - mouseout: function (event) { - event = normalizeEvent(this.dom, event); - var element = event.toElement || event.relatedTarget; - if (!isLocalEl(this, element)) { - if (this.__pointerCapturing) { - event.zrEventControl = 'no_globalout'; - } - this.trigger('mouseout', event); - } - }, - wheel: function (event) { - wheelEventSupported = true; - event = normalizeEvent(this.dom, event); - this.trigger('mousewheel', event); - }, - mousewheel: function (event) { - if (wheelEventSupported) { - return; - } - event = normalizeEvent(this.dom, event); - this.trigger('mousewheel', event); - }, - touchstart: function (event) { - event = normalizeEvent(this.dom, event); - markTouch(event); - this.__lastTouchMoment = new Date(); - this.handler.processGesture(event, 'start'); - localDOMHandlers.mousemove.call(this, event); - localDOMHandlers.mousedown.call(this, event); - }, - touchmove: function (event) { - event = normalizeEvent(this.dom, event); - markTouch(event); - this.handler.processGesture(event, 'change'); - localDOMHandlers.mousemove.call(this, event); - }, - touchend: function (event) { - event = normalizeEvent(this.dom, event); - markTouch(event); - this.handler.processGesture(event, 'end'); - localDOMHandlers.mouseup.call(this, event); - if (+new Date() - (+this.__lastTouchMoment) < TOUCH_CLICK_DELAY) { - localDOMHandlers.click.call(this, event); - } - }, - pointerdown: function (event) { - localDOMHandlers.mousedown.call(this, event); - }, - pointermove: function (event) { - if (!isPointerFromTouch(event)) { - localDOMHandlers.mousemove.call(this, event); - } - }, - pointerup: function (event) { - localDOMHandlers.mouseup.call(this, event); - }, - pointerout: function (event) { - if (!isPointerFromTouch(event)) { - localDOMHandlers.mouseout.call(this, event); - } - } -}; -each$4(['click', 'dblclick', 'contextmenu'], function (name) { - localDOMHandlers[name] = function (event) { - event = normalizeEvent(this.dom, event); - this.trigger(name, event); - }; -}); -var globalDOMHandlers = { - pointermove: function (event) { - if (!isPointerFromTouch(event)) { - globalDOMHandlers.mousemove.call(this, event); - } - }, - pointerup: function (event) { - globalDOMHandlers.mouseup.call(this, event); - }, - mousemove: function (event) { - this.trigger('mousemove', event); - }, - mouseup: function (event) { - var pointerCaptureReleasing = this.__pointerCapturing; - this.__togglePointerCapture(false); - this.trigger('mouseup', event); - if (pointerCaptureReleasing) { - event.zrEventControl = 'only_globalout'; - this.trigger('mouseout', event); - } - } -}; -function mountLocalDOMEventListeners(instance, scope) { - var domHandlers = scope.domHandlers; - if (env.pointerEventsSupported) { - each$4(localNativeListenerNames.pointer, function (nativeEventName) { - mountSingleDOMEventListener(scope, nativeEventName, function (event) { - domHandlers[nativeEventName].call(instance, event); - }); - }); - } - else { - if (env.touchEventsSupported) { - each$4(localNativeListenerNames.touch, function (nativeEventName) { - mountSingleDOMEventListener(scope, nativeEventName, function (event) { - domHandlers[nativeEventName].call(instance, event); - setTouchTimer(scope); - }); - }); - } - each$4(localNativeListenerNames.mouse, function (nativeEventName) { - mountSingleDOMEventListener(scope, nativeEventName, function (event) { - event = getNativeEvent(event); - if (!scope.touching) { - domHandlers[nativeEventName].call(instance, event); - } - }); - }); - } -} -function mountGlobalDOMEventListeners(instance, scope) { - if (env.pointerEventsSupported) { - each$4(globalNativeListenerNames.pointer, mount); - } - else if (!env.touchEventsSupported) { - each$4(globalNativeListenerNames.mouse, mount); - } - function mount(nativeEventName) { - function nativeEventListener(event) { - event = getNativeEvent(event); - if (!isLocalEl(instance, event.target)) { - event = normalizeGlobalEvent(instance, event); - scope.domHandlers[nativeEventName].call(instance, event); - } - } - mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true }); - } -} -function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) { - scope.mounted[nativeEventName] = listener; - scope.listenerOpts[nativeEventName] = opt; - addEventListener(scope.domTarget, nativeEventName, listener, opt); -} -function unmountDOMEventListeners(scope) { - var mounted = scope.mounted; - for (var nativeEventName in mounted) { - if (mounted.hasOwnProperty(nativeEventName)) { - removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]); - } - } - scope.mounted = {}; -} -var DOMHandlerScope = (function () { - function DOMHandlerScope(domTarget, domHandlers) { - this.mounted = {}; - this.listenerOpts = {}; - this.touching = false; - this.domTarget = domTarget; - this.domHandlers = domHandlers; - } - return DOMHandlerScope; -}()); -var HandlerDomProxy = (function (_super) { - __extends(HandlerDomProxy, _super); - function HandlerDomProxy(dom, painterRoot) { - var _this = _super.call(this) || this; - _this.__pointerCapturing = false; - _this.dom = dom; - _this.painterRoot = painterRoot; - _this._localHandlerScope = new DOMHandlerScope(dom, localDOMHandlers); - if (globalEventSupported) { - _this._globalHandlerScope = new DOMHandlerScope(document, globalDOMHandlers); - } - mountLocalDOMEventListeners(_this, _this._localHandlerScope); - return _this; - } - HandlerDomProxy.prototype.dispose = function () { - unmountDOMEventListeners(this._localHandlerScope); - if (globalEventSupported) { - unmountDOMEventListeners(this._globalHandlerScope); - } - }; - HandlerDomProxy.prototype.setCursor = function (cursorStyle) { - this.dom.style && (this.dom.style.cursor = cursorStyle || 'default'); - }; - HandlerDomProxy.prototype.__togglePointerCapture = function (isPointerCapturing) { - this.__mayPointerCapture = null; - if (globalEventSupported - && ((+this.__pointerCapturing) ^ (+isPointerCapturing))) { - this.__pointerCapturing = isPointerCapturing; - var globalHandlerScope = this._globalHandlerScope; - isPointerCapturing - ? mountGlobalDOMEventListeners(this, globalHandlerScope) - : unmountDOMEventListeners(globalHandlerScope); - } - }; - return HandlerDomProxy; -}(Eventful)); - -var dpr = 1; -if (env.hasGlobalWindow) { - dpr = Math.max(window.devicePixelRatio - || (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI) - || 1, 1); -} -var devicePixelRatio = dpr; -var DARK_MODE_THRESHOLD = 0.4; -var DARK_LABEL_COLOR = '#333'; -var LIGHT_LABEL_COLOR = '#ccc'; -var LIGHTER_LABEL_COLOR = '#eee'; - -var mIdentity = identity; -var EPSILON$1 = 5e-5; -function isNotAroundZero(val) { - return val > EPSILON$1 || val < -5e-5; -} -var scaleTmp = []; -var tmpTransform = []; -var originTransform = create(); -var abs = Math.abs; -var Transformable = (function () { - function Transformable() { - } - Transformable.prototype.getLocalTransform = function (m) { - return Transformable.getLocalTransform(this, m); - }; - Transformable.prototype.setPosition = function (arr) { - this.x = arr[0]; - this.y = arr[1]; - }; - Transformable.prototype.setScale = function (arr) { - this.scaleX = arr[0]; - this.scaleY = arr[1]; - }; - Transformable.prototype.setSkew = function (arr) { - this.skewX = arr[0]; - this.skewY = arr[1]; - }; - Transformable.prototype.setOrigin = function (arr) { - this.originX = arr[0]; - this.originY = arr[1]; - }; - Transformable.prototype.needLocalTransform = function () { - return isNotAroundZero(this.rotation) - || isNotAroundZero(this.x) - || isNotAroundZero(this.y) - || isNotAroundZero(this.scaleX - 1) - || isNotAroundZero(this.scaleY - 1) - || isNotAroundZero(this.skewX) - || isNotAroundZero(this.skewY); - }; - Transformable.prototype.updateTransform = function () { - var parentTransform = this.parent && this.parent.transform; - var needLocalTransform = this.needLocalTransform(); - var m = this.transform; - if (!(needLocalTransform || parentTransform)) { - if (m) { - mIdentity(m); - this.invTransform = null; - } - return; - } - m = m || create(); - if (needLocalTransform) { - this.getLocalTransform(m); - } - else { - mIdentity(m); - } - if (parentTransform) { - if (needLocalTransform) { - mul(m, parentTransform, m); - } - else { - copy(m, parentTransform); - } - } - this.transform = m; - this._resolveGlobalScaleRatio(m); - }; - Transformable.prototype._resolveGlobalScaleRatio = function (m) { - var globalScaleRatio = this.globalScaleRatio; - if (globalScaleRatio != null && globalScaleRatio !== 1) { - this.getGlobalScale(scaleTmp); - var relX = scaleTmp[0] < 0 ? -1 : 1; - var relY = scaleTmp[1] < 0 ? -1 : 1; - var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0; - var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0; - m[0] *= sx; - m[1] *= sx; - m[2] *= sy; - m[3] *= sy; - } - this.invTransform = this.invTransform || create(); - invert(this.invTransform, m); - }; - Transformable.prototype.getComputedTransform = function () { - var transformNode = this; - var ancestors = []; - while (transformNode) { - ancestors.push(transformNode); - transformNode = transformNode.parent; - } - while (transformNode = ancestors.pop()) { - transformNode.updateTransform(); - } - return this.transform; - }; - Transformable.prototype.setLocalTransform = function (m) { - if (!m) { - return; - } - var sx = m[0] * m[0] + m[1] * m[1]; - var sy = m[2] * m[2] + m[3] * m[3]; - var rotation = Math.atan2(m[1], m[0]); - var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]); - sy = Math.sqrt(sy) * Math.cos(shearX); - sx = Math.sqrt(sx); - this.skewX = shearX; - this.skewY = 0; - this.rotation = -rotation; - this.x = +m[4]; - this.y = +m[5]; - this.scaleX = sx; - this.scaleY = sy; - this.originX = 0; - this.originY = 0; - }; - Transformable.prototype.decomposeTransform = function () { - if (!this.transform) { - return; - } - var parent = this.parent; - var m = this.transform; - if (parent && parent.transform) { - parent.invTransform = parent.invTransform || create(); - mul(tmpTransform, parent.invTransform, m); - m = tmpTransform; - } - var ox = this.originX; - var oy = this.originY; - if (ox || oy) { - originTransform[4] = ox; - originTransform[5] = oy; - mul(tmpTransform, m, originTransform); - tmpTransform[4] -= ox; - tmpTransform[5] -= oy; - m = tmpTransform; - } - this.setLocalTransform(m); - }; - Transformable.prototype.getGlobalScale = function (out) { - var m = this.transform; - out = out || []; - if (!m) { - out[0] = 1; - out[1] = 1; - return out; - } - out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]); - out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]); - if (m[0] < 0) { - out[0] = -out[0]; - } - if (m[3] < 0) { - out[1] = -out[1]; - } - return out; - }; - Transformable.prototype.transformCoordToLocal = function (x, y) { - var v2 = [x, y]; - var invTransform = this.invTransform; - if (invTransform) { - applyTransform$1(v2, v2, invTransform); - } - return v2; - }; - Transformable.prototype.transformCoordToGlobal = function (x, y) { - var v2 = [x, y]; - var transform = this.transform; - if (transform) { - applyTransform$1(v2, v2, transform); - } - return v2; - }; - Transformable.prototype.getLineScale = function () { - var m = this.transform; - return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10 - ? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1])) - : 1; - }; - Transformable.prototype.copyTransform = function (source) { - copyTransform(this, source); - }; - Transformable.getLocalTransform = function (target, m) { - m = m || []; - var ox = target.originX || 0; - var oy = target.originY || 0; - var sx = target.scaleX; - var sy = target.scaleY; - var ax = target.anchorX; - var ay = target.anchorY; - var rotation = target.rotation || 0; - var x = target.x; - var y = target.y; - var skewX = target.skewX ? Math.tan(target.skewX) : 0; - var skewY = target.skewY ? Math.tan(-target.skewY) : 0; - if (ox || oy || ax || ay) { - var dx = ox + ax; - var dy = oy + ay; - m[4] = -dx * sx - skewX * dy * sy; - m[5] = -dy * sy - skewY * dx * sx; - } - else { - m[4] = m[5] = 0; - } - m[0] = sx; - m[3] = sy; - m[1] = skewY * sx; - m[2] = skewX * sy; - rotation && rotate(m, m, rotation); - m[4] += ox + x; - m[5] += oy + y; - return m; - }; - Transformable.initDefaultProps = (function () { - var proto = Transformable.prototype; - proto.scaleX = - proto.scaleY = - proto.globalScaleRatio = 1; - proto.x = - proto.y = - proto.originX = - proto.originY = - proto.skewX = - proto.skewY = - proto.rotation = - proto.anchorX = - proto.anchorY = 0; - })(); - return Transformable; -}()); -var TRANSFORMABLE_PROPS = [ - 'x', 'y', 'originX', 'originY', 'anchorX', 'anchorY', 'rotation', 'scaleX', 'scaleY', 'skewX', 'skewY' -]; -function copyTransform(target, source) { - for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) { - var propName = TRANSFORMABLE_PROPS[i]; - target[propName] = source[propName]; - } -} - -var textWidthCache = {}; -function getWidth(text, font) { - font = font || DEFAULT_FONT; - var cacheOfFont = textWidthCache[font]; - if (!cacheOfFont) { - cacheOfFont = textWidthCache[font] = new LRU(500); - } - var width = cacheOfFont.get(text); - if (width == null) { - width = platformApi.measureText(text, font).width; - cacheOfFont.put(text, width); - } - return width; -} -function innerGetBoundingRect(text, font, textAlign, textBaseline) { - var width = getWidth(text, font); - var height = getLineHeight(font); - var x = adjustTextX(0, width, textAlign); - var y = adjustTextY(0, height, textBaseline); - var rect = new BoundingRect(x, y, width, height); - return rect; -} -function getBoundingRect(text, font, textAlign, textBaseline) { - var textLines = ((text || '') + '').split('\n'); - var len = textLines.length; - if (len === 1) { - return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline); - } - else { - var uniondRect = new BoundingRect(0, 0, 0, 0); - for (var i = 0; i < textLines.length; i++) { - var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline); - i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect); - } - return uniondRect; - } -} -function adjustTextX(x, width, textAlign) { - if (textAlign === 'right') { - x -= width; - } - else if (textAlign === 'center') { - x -= width / 2; - } - return x; -} -function adjustTextY(y, height, verticalAlign) { - if (verticalAlign === 'middle') { - y -= height / 2; - } - else if (verticalAlign === 'bottom') { - y -= height; - } - return y; -} -function getLineHeight(font) { - return getWidth('国', font); -} -function parsePercent$1(value, maxValue) { - if (typeof value === 'string') { - if (value.lastIndexOf('%') >= 0) { - return parseFloat(value) / 100 * maxValue; - } - return parseFloat(value); - } - return value; -} -function calculateTextPosition(out, opts, rect) { - var textPosition = opts.position || 'inside'; - var distance = opts.distance != null ? opts.distance : 5; - var height = rect.height; - var width = rect.width; - var halfHeight = height / 2; - var x = rect.x; - var y = rect.y; - var textAlign = 'left'; - var textVerticalAlign = 'top'; - if (textPosition instanceof Array) { - x += parsePercent$1(textPosition[0], rect.width); - y += parsePercent$1(textPosition[1], rect.height); - textAlign = null; - textVerticalAlign = null; - } - else { - switch (textPosition) { - case 'left': - x -= distance; - y += halfHeight; - textAlign = 'right'; - textVerticalAlign = 'middle'; - break; - case 'right': - x += distance + width; - y += halfHeight; - textVerticalAlign = 'middle'; - break; - case 'top': - x += width / 2; - y -= distance; - textAlign = 'center'; - textVerticalAlign = 'bottom'; - break; - case 'bottom': - x += width / 2; - y += height + distance; - textAlign = 'center'; - break; - case 'inside': - x += width / 2; - y += halfHeight; - textAlign = 'center'; - textVerticalAlign = 'middle'; - break; - case 'insideLeft': - x += distance; - y += halfHeight; - textVerticalAlign = 'middle'; - break; - case 'insideRight': - x += width - distance; - y += halfHeight; - textAlign = 'right'; - textVerticalAlign = 'middle'; - break; - case 'insideTop': - x += width / 2; - y += distance; - textAlign = 'center'; - break; - case 'insideBottom': - x += width / 2; - y += height - distance; - textAlign = 'center'; - textVerticalAlign = 'bottom'; - break; - case 'insideTopLeft': - x += distance; - y += distance; - break; - case 'insideTopRight': - x += width - distance; - y += distance; - textAlign = 'right'; - break; - case 'insideBottomLeft': - x += distance; - y += height - distance; - textVerticalAlign = 'bottom'; - break; - case 'insideBottomRight': - x += width - distance; - y += height - distance; - textAlign = 'right'; - textVerticalAlign = 'bottom'; - break; - } - } - out = out || {}; - out.x = x; - out.y = y; - out.align = textAlign; - out.verticalAlign = textVerticalAlign; - return out; -} - -var PRESERVED_NORMAL_STATE = "__zr_normal__"; -var PRIMARY_STATES_KEYS$1 = TRANSFORMABLE_PROPS.concat(["ignore"]); -var DEFAULT_ANIMATABLE_MAP = reduce(TRANSFORMABLE_PROPS, function(obj, key) { - obj[key] = true; - return obj; -}, { ignore: false }); -var tmpTextPosCalcRes = {}; -var tmpBoundingRect = new BoundingRect(0, 0, 0, 0); -var Element = function() { - function Element2(props) { - this.id = guid(); - this.animators = []; - this.currentStates = []; - this.states = {}; - this._init(props); - } - Element2.prototype._init = function(props) { - this.attr(props); - }; - Element2.prototype.drift = function(dx, dy, e) { - switch (this.draggable) { - case "horizontal": - dy = 0; - break; - case "vertical": - dx = 0; - break; - } - var m = this.transform; - if (!m) { - m = this.transform = [1, 0, 0, 1, 0, 0]; - } - m[4] += dx; - m[5] += dy; - this.decomposeTransform(); - this.markRedraw(); - }; - Element2.prototype.beforeUpdate = function() { - }; - Element2.prototype.afterUpdate = function() { - }; - Element2.prototype.update = function() { - this.updateTransform(); - if (this.__dirty) { - this.updateInnerText(); - } - }; - Element2.prototype.updateInnerText = function(forceUpdate) { - var textEl = this._textContent; - if (textEl && (!textEl.ignore || forceUpdate)) { - if (!this.textConfig) { - this.textConfig = {}; - } - var textConfig = this.textConfig; - var isLocal = textConfig.local; - var innerTransformable = textEl.innerTransformable; - var textAlign = void 0; - var textVerticalAlign = void 0; - var textStyleChanged = false; - innerTransformable.parent = isLocal ? this : null; - var innerOrigin = false; - innerTransformable.copyTransform(textEl); - if (textConfig.position != null) { - var layoutRect = tmpBoundingRect; - if (textConfig.layoutRect) { - layoutRect.copy(textConfig.layoutRect); - } else { - layoutRect.copy(this.getBoundingRect()); - } - if (!isLocal) { - layoutRect.applyTransform(this.transform); - } - if (this.calculateTextPosition) { - this.calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect); - } else { - calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect); - } - innerTransformable.x = tmpTextPosCalcRes.x; - innerTransformable.y = tmpTextPosCalcRes.y; - textAlign = tmpTextPosCalcRes.align; - textVerticalAlign = tmpTextPosCalcRes.verticalAlign; - var textOrigin = textConfig.origin; - if (textOrigin && textConfig.rotation != null) { - var relOriginX = void 0; - var relOriginY = void 0; - if (textOrigin === "center") { - relOriginX = layoutRect.width * 0.5; - relOriginY = layoutRect.height * 0.5; - } else { - relOriginX = parsePercent$1(textOrigin[0], layoutRect.width); - relOriginY = parsePercent$1(textOrigin[1], layoutRect.height); - } - innerOrigin = true; - innerTransformable.originX = -innerTransformable.x + relOriginX + (isLocal ? 0 : layoutRect.x); - innerTransformable.originY = -innerTransformable.y + relOriginY + (isLocal ? 0 : layoutRect.y); - } - } - if (textConfig.rotation != null) { - innerTransformable.rotation = textConfig.rotation; - } - var textOffset = textConfig.offset; - if (textOffset) { - innerTransformable.x += textOffset[0]; - innerTransformable.y += textOffset[1]; - if (!innerOrigin) { - innerTransformable.originX = -textOffset[0]; - innerTransformable.originY = -textOffset[1]; - } - } - var isInside = textConfig.inside == null ? typeof textConfig.position === "string" && textConfig.position.indexOf("inside") >= 0 : textConfig.inside; - var innerTextDefaultStyle = this._innerTextDefaultStyle || (this._innerTextDefaultStyle = {}); - var textFill = void 0; - var textStroke = void 0; - var autoStroke = void 0; - if (isInside && this.canBeInsideText()) { - textFill = textConfig.insideFill; - textStroke = textConfig.insideStroke; - if (textFill == null || textFill === "auto") { - textFill = this.getInsideTextFill(); - } - if (textStroke == null || textStroke === "auto") { - textStroke = this.getInsideTextStroke(textFill); - autoStroke = true; - } - } else { - textFill = textConfig.outsideFill; - textStroke = textConfig.outsideStroke; - if (textFill == null || textFill === "auto") { - textFill = this.getOutsideFill(); - } - if (textStroke == null || textStroke === "auto") { - textStroke = this.getOutsideStroke(textFill); - autoStroke = true; - } - } - textFill = textFill || "#000"; - if (textFill !== innerTextDefaultStyle.fill || textStroke !== innerTextDefaultStyle.stroke || autoStroke !== innerTextDefaultStyle.autoStroke || textAlign !== innerTextDefaultStyle.align || textVerticalAlign !== innerTextDefaultStyle.verticalAlign) { - textStyleChanged = true; - innerTextDefaultStyle.fill = textFill; - innerTextDefaultStyle.stroke = textStroke; - innerTextDefaultStyle.autoStroke = autoStroke; - innerTextDefaultStyle.align = textAlign; - innerTextDefaultStyle.verticalAlign = textVerticalAlign; - textEl.setDefaultTextStyle(innerTextDefaultStyle); - } - textEl.__dirty |= REDRAW_BIT; - if (textStyleChanged) { - textEl.dirtyStyle(true); - } - } - }; - Element2.prototype.canBeInsideText = function() { - return true; - }; - Element2.prototype.getInsideTextFill = function() { - return "#fff"; - }; - Element2.prototype.getInsideTextStroke = function(textFill) { - return "#000"; - }; - Element2.prototype.getOutsideFill = function() { - return this.__zr && this.__zr.isDarkMode() ? LIGHT_LABEL_COLOR : DARK_LABEL_COLOR; - }; - Element2.prototype.getOutsideStroke = function(textFill) { - var backgroundColor = this.__zr && this.__zr.getBackgroundColor(); - var colorArr = typeof backgroundColor === "string" && parse(backgroundColor); - if (!colorArr) { - colorArr = [255, 255, 255, 1]; - } - var alpha = colorArr[3]; - var isDark = this.__zr.isDarkMode(); - for (var i = 0; i < 3; i++) { - colorArr[i] = colorArr[i] * alpha + (isDark ? 0 : 255) * (1 - alpha); - } - colorArr[3] = 1; - return stringify(colorArr, "rgba"); - }; - Element2.prototype.traverse = function(cb, context) { - }; - Element2.prototype.attrKV = function(key, value) { - if (key === "textConfig") { - this.setTextConfig(value); - } else if (key === "textContent") { - this.setTextContent(value); - } else if (key === "clipPath") { - this.setClipPath(value); - } else if (key === "extra") { - this.extra = this.extra || {}; - extend(this.extra, value); - } else { - this[key] = value; - } - }; - Element2.prototype.hide = function() { - this.ignore = true; - this.markRedraw(); - }; - Element2.prototype.show = function() { - this.ignore = false; - this.markRedraw(); - }; - Element2.prototype.attr = function(keyOrObj, value) { - if (typeof keyOrObj === "string") { - this.attrKV(keyOrObj, value); - } else if (isObject$2(keyOrObj)) { - var obj = keyOrObj; - var keysArr = keys(obj); - for (var i = 0; i < keysArr.length; i++) { - var key = keysArr[i]; - this.attrKV(key, keyOrObj[key]); - } - } - this.markRedraw(); - return this; - }; - Element2.prototype.saveCurrentToNormalState = function(toState) { - this._innerSaveToNormal(toState); - var normalState = this._normalState; - for (var i = 0; i < this.animators.length; i++) { - var animator = this.animators[i]; - var fromStateTransition = animator.__fromStateTransition; - if (animator.getLoop() || fromStateTransition && fromStateTransition !== PRESERVED_NORMAL_STATE) { - continue; - } - var targetName = animator.targetName; - var target = targetName ? normalState[targetName] : normalState; - animator.saveTo(target); - } - }; - Element2.prototype._innerSaveToNormal = function(toState) { - var normalState = this._normalState; - if (!normalState) { - normalState = this._normalState = {}; - } - if (toState.textConfig && !normalState.textConfig) { - normalState.textConfig = this.textConfig; - } - this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS$1); - }; - Element2.prototype._savePrimaryToNormal = function(toState, normalState, primaryKeys) { - for (var i = 0; i < primaryKeys.length; i++) { - var key = primaryKeys[i]; - if (toState[key] != null && !(key in normalState)) { - normalState[key] = this[key]; - } - } - }; - Element2.prototype.hasState = function() { - return this.currentStates.length > 0; - }; - Element2.prototype.getState = function(name) { - return this.states[name]; - }; - Element2.prototype.ensureState = function(name) { - var states = this.states; - if (!states[name]) { - states[name] = {}; - } - return states[name]; - }; - Element2.prototype.clearStates = function(noAnimation) { - this.useState(PRESERVED_NORMAL_STATE, false, noAnimation); - }; - Element2.prototype.useState = function(stateName, keepCurrentStates, noAnimation, forceUseHoverLayer) { - var toNormalState = stateName === PRESERVED_NORMAL_STATE; - var hasStates = this.hasState(); - if (!hasStates && toNormalState) { - return; - } - var currentStates = this.currentStates; - var animationCfg = this.stateTransition; - if (indexOf(currentStates, stateName) >= 0 && (keepCurrentStates || currentStates.length === 1)) { - return; - } - var state; - if (this.stateProxy && !toNormalState) { - state = this.stateProxy(stateName); - } - if (!state) { - state = this.states && this.states[stateName]; - } - if (!state && !toNormalState) { - logError("State " + stateName + " not exists."); - return; - } - if (!toNormalState) { - this.saveCurrentToNormalState(state); - } - var useHoverLayer = !!(state && state.hoverLayer || forceUseHoverLayer); - if (useHoverLayer) { - this._toggleHoverLayerFlag(true); - } - this._applyStateObj(stateName, state, this._normalState, keepCurrentStates, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg); - var textContent = this._textContent; - var textGuide = this._textGuide; - if (textContent) { - textContent.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer); - } - if (textGuide) { - textGuide.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer); - } - if (toNormalState) { - this.currentStates = []; - this._normalState = {}; - } else { - if (!keepCurrentStates) { - this.currentStates = [stateName]; - } else { - this.currentStates.push(stateName); - } - } - this._updateAnimationTargets(); - this.markRedraw(); - if (!useHoverLayer && this.__inHover) { - this._toggleHoverLayerFlag(false); - this.__dirty &= -2; - } - return state; - }; - Element2.prototype.useStates = function(states, noAnimation, forceUseHoverLayer) { - if (!states.length) { - this.clearStates(); - } else { - var stateObjects = []; - var currentStates = this.currentStates; - var len = states.length; - var notChange = len === currentStates.length; - if (notChange) { - for (var i = 0; i < len; i++) { - if (states[i] !== currentStates[i]) { - notChange = false; - break; - } - } - } - if (notChange) { - return; - } - for (var i = 0; i < len; i++) { - var stateName = states[i]; - var stateObj = void 0; - if (this.stateProxy) { - stateObj = this.stateProxy(stateName, states); - } - if (!stateObj) { - stateObj = this.states[stateName]; - } - if (stateObj) { - stateObjects.push(stateObj); - } - } - var lastStateObj = stateObjects[len - 1]; - var useHoverLayer = !!(lastStateObj && lastStateObj.hoverLayer || forceUseHoverLayer); - if (useHoverLayer) { - this._toggleHoverLayerFlag(true); - } - var mergedState = this._mergeStates(stateObjects); - var animationCfg = this.stateTransition; - this.saveCurrentToNormalState(mergedState); - this._applyStateObj(states.join(","), mergedState, this._normalState, false, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg); - var textContent = this._textContent; - var textGuide = this._textGuide; - if (textContent) { - textContent.useStates(states, noAnimation, useHoverLayer); - } - if (textGuide) { - textGuide.useStates(states, noAnimation, useHoverLayer); - } - this._updateAnimationTargets(); - this.currentStates = states.slice(); - this.markRedraw(); - if (!useHoverLayer && this.__inHover) { - this._toggleHoverLayerFlag(false); - this.__dirty &= -2; - } - } - }; - Element2.prototype.isSilent = function() { - var isSilent = this.silent; - var ancestor = this.parent; - while (!isSilent && ancestor) { - if (ancestor.silent) { - isSilent = true; - break; - } - ancestor = ancestor.parent; - } - return isSilent; - }; - Element2.prototype._updateAnimationTargets = function() { - for (var i = 0; i < this.animators.length; i++) { - var animator = this.animators[i]; - if (animator.targetName) { - animator.changeTarget(this[animator.targetName]); - } - } - }; - Element2.prototype.removeState = function(state) { - var idx = indexOf(this.currentStates, state); - if (idx >= 0) { - var currentStates = this.currentStates.slice(); - currentStates.splice(idx, 1); - this.useStates(currentStates); - } - }; - Element2.prototype.replaceState = function(oldState, newState, forceAdd) { - var currentStates = this.currentStates.slice(); - var idx = indexOf(currentStates, oldState); - var newStateExists = indexOf(currentStates, newState) >= 0; - if (idx >= 0) { - if (!newStateExists) { - currentStates[idx] = newState; - } else { - currentStates.splice(idx, 1); - } - } else if (forceAdd && !newStateExists) { - currentStates.push(newState); - } - this.useStates(currentStates); - }; - Element2.prototype.toggleState = function(state, enable) { - if (enable) { - this.useState(state, true); - } else { - this.removeState(state); - } - }; - Element2.prototype._mergeStates = function(states) { - var mergedState = {}; - var mergedTextConfig; - for (var i = 0; i < states.length; i++) { - var state = states[i]; - extend(mergedState, state); - if (state.textConfig) { - mergedTextConfig = mergedTextConfig || {}; - extend(mergedTextConfig, state.textConfig); - } - } - if (mergedTextConfig) { - mergedState.textConfig = mergedTextConfig; - } - return mergedState; - }; - Element2.prototype._applyStateObj = function(stateName, state, normalState, keepCurrentStates, transition, animationCfg) { - var needsRestoreToNormal = !(state && keepCurrentStates); - if (state && state.textConfig) { - this.textConfig = extend({}, keepCurrentStates ? this.textConfig : normalState.textConfig); - extend(this.textConfig, state.textConfig); - } else if (needsRestoreToNormal) { - if (normalState.textConfig) { - this.textConfig = normalState.textConfig; - } - } - var transitionTarget = {}; - var hasTransition = false; - for (var i = 0; i < PRIMARY_STATES_KEYS$1.length; i++) { - var key = PRIMARY_STATES_KEYS$1[i]; - var propNeedsTransition = transition && DEFAULT_ANIMATABLE_MAP[key]; - if (state && state[key] != null) { - if (propNeedsTransition) { - hasTransition = true; - transitionTarget[key] = state[key]; - } else { - this[key] = state[key]; - } - } else if (needsRestoreToNormal) { - if (normalState[key] != null) { - if (propNeedsTransition) { - hasTransition = true; - transitionTarget[key] = normalState[key]; - } else { - this[key] = normalState[key]; - } - } - } - } - if (!transition) { - for (var i = 0; i < this.animators.length; i++) { - var animator = this.animators[i]; - var targetName = animator.targetName; - if (!animator.getLoop()) { - animator.__changeFinalValue(targetName ? (state || normalState)[targetName] : state || normalState); - } - } - } - if (hasTransition) { - this._transitionState(stateName, transitionTarget, animationCfg); - } - }; - Element2.prototype._attachComponent = function(componentEl) { - if (componentEl.__zr && !componentEl.__hostTarget) { - return; - } - if (componentEl === this) { - return; - } - var zr = this.__zr; - if (zr) { - componentEl.addSelfToZr(zr); - } - componentEl.__zr = zr; - componentEl.__hostTarget = this; - }; - Element2.prototype._detachComponent = function(componentEl) { - if (componentEl.__zr) { - componentEl.removeSelfFromZr(componentEl.__zr); - } - componentEl.__zr = null; - componentEl.__hostTarget = null; - }; - Element2.prototype.getClipPath = function() { - return this._clipPath; - }; - Element2.prototype.setClipPath = function(clipPath) { - if (this._clipPath && this._clipPath !== clipPath) { - this.removeClipPath(); - } - this._attachComponent(clipPath); - this._clipPath = clipPath; - this.markRedraw(); - }; - Element2.prototype.removeClipPath = function() { - var clipPath = this._clipPath; - if (clipPath) { - this._detachComponent(clipPath); - this._clipPath = null; - this.markRedraw(); - } - }; - Element2.prototype.getTextContent = function() { - return this._textContent; - }; - Element2.prototype.setTextContent = function(textEl) { - var previousTextContent = this._textContent; - if (previousTextContent === textEl) { - return; - } - if (previousTextContent && previousTextContent !== textEl) { - this.removeTextContent(); - } - textEl.innerTransformable = new Transformable(); - this._attachComponent(textEl); - this._textContent = textEl; - this.markRedraw(); - }; - Element2.prototype.setTextConfig = function(cfg) { - if (!this.textConfig) { - this.textConfig = {}; - } - extend(this.textConfig, cfg); - this.markRedraw(); - }; - Element2.prototype.removeTextConfig = function() { - this.textConfig = null; - this.markRedraw(); - }; - Element2.prototype.removeTextContent = function() { - var textEl = this._textContent; - if (textEl) { - textEl.innerTransformable = null; - this._detachComponent(textEl); - this._textContent = null; - this._innerTextDefaultStyle = null; - this.markRedraw(); - } - }; - Element2.prototype.getTextGuideLine = function() { - return this._textGuide; - }; - Element2.prototype.setTextGuideLine = function(guideLine) { - if (this._textGuide && this._textGuide !== guideLine) { - this.removeTextGuideLine(); - } - this._attachComponent(guideLine); - this._textGuide = guideLine; - this.markRedraw(); - }; - Element2.prototype.removeTextGuideLine = function() { - var textGuide = this._textGuide; - if (textGuide) { - this._detachComponent(textGuide); - this._textGuide = null; - this.markRedraw(); - } - }; - Element2.prototype.markRedraw = function() { - this.__dirty |= REDRAW_BIT; - var zr = this.__zr; - if (zr) { - if (this.__inHover) { - zr.refreshHover(); - } else { - zr.refresh(); - } - } - if (this.__hostTarget) { - this.__hostTarget.markRedraw(); - } - }; - Element2.prototype.dirty = function() { - this.markRedraw(); - }; - Element2.prototype._toggleHoverLayerFlag = function(inHover) { - this.__inHover = inHover; - var textContent = this._textContent; - var textGuide = this._textGuide; - if (textContent) { - textContent.__inHover = inHover; - } - if (textGuide) { - textGuide.__inHover = inHover; - } - }; - Element2.prototype.addSelfToZr = function(zr) { - if (this.__zr === zr) { - return; - } - this.__zr = zr; - var animators = this.animators; - if (animators) { - for (var i = 0; i < animators.length; i++) { - zr.animation.addAnimator(animators[i]); - } - } - if (this._clipPath) { - this._clipPath.addSelfToZr(zr); - } - if (this._textContent) { - this._textContent.addSelfToZr(zr); - } - if (this._textGuide) { - this._textGuide.addSelfToZr(zr); - } - }; - Element2.prototype.removeSelfFromZr = function(zr) { - if (!this.__zr) { - return; - } - this.__zr = null; - var animators = this.animators; - if (animators) { - for (var i = 0; i < animators.length; i++) { - zr.animation.removeAnimator(animators[i]); - } - } - if (this._clipPath) { - this._clipPath.removeSelfFromZr(zr); - } - if (this._textContent) { - this._textContent.removeSelfFromZr(zr); - } - if (this._textGuide) { - this._textGuide.removeSelfFromZr(zr); - } - }; - Element2.prototype.animate = function(key, loop, allowDiscreteAnimation) { - var target = key ? this[key] : this; - var animator = new Animator(target, loop, allowDiscreteAnimation); - key && (animator.targetName = key); - this.addAnimator(animator, key); - return animator; - }; - Element2.prototype.addAnimator = function(animator, key) { - var zr = this.__zr; - var el = this; - animator.during(function() { - el.updateDuringAnimation(key); - }).done(function() { - var animators = el.animators; - var idx = indexOf(animators, animator); - if (idx >= 0) { - animators.splice(idx, 1); - } - }); - this.animators.push(animator); - if (zr) { - zr.animation.addAnimator(animator); - } - zr && zr.wakeUp(); - }; - Element2.prototype.updateDuringAnimation = function(key) { - this.markRedraw(); - }; - Element2.prototype.stopAnimation = function(scope, forwardToLast) { - var animators = this.animators; - var len = animators.length; - var leftAnimators = []; - for (var i = 0; i < len; i++) { - var animator = animators[i]; - if (!scope || scope === animator.scope) { - animator.stop(forwardToLast); - } else { - leftAnimators.push(animator); - } - } - this.animators = leftAnimators; - return this; - }; - Element2.prototype.animateTo = function(target, cfg, animationProps) { - animateTo(this, target, cfg, animationProps); - }; - Element2.prototype.animateFrom = function(target, cfg, animationProps) { - animateTo(this, target, cfg, animationProps, true); - }; - Element2.prototype._transitionState = function(stateName, target, cfg, animationProps) { - var animators = animateTo(this, target, cfg, animationProps); - for (var i = 0; i < animators.length; i++) { - animators[i].__fromStateTransition = stateName; - } - }; - Element2.prototype.getBoundingRect = function() { - return null; - }; - Element2.prototype.getPaintRect = function() { - return null; - }; - Element2.initDefaultProps = function() { - var elProto = Element2.prototype; - elProto.type = "element"; - elProto.name = ""; - elProto.ignore = elProto.silent = elProto.isGroup = elProto.draggable = elProto.dragging = elProto.ignoreClip = elProto.__inHover = false; - elProto.__dirty = REDRAW_BIT; - function createLegacyProperty(key, privateKey, xKey, yKey) { - Object.defineProperty(elProto, key, { - get: function() { - if (!this[privateKey]) { - var pos = this[privateKey] = []; - enhanceArray(this, pos); - } - return this[privateKey]; - }, - set: function(pos) { - this[xKey] = pos[0]; - this[yKey] = pos[1]; - this[privateKey] = pos; - enhanceArray(this, pos); - } - }); - function enhanceArray(self, pos) { - Object.defineProperty(pos, 0, { - get: function() { - return self[xKey]; - }, - set: function(val) { - self[xKey] = val; - } - }); - Object.defineProperty(pos, 1, { - get: function() { - return self[yKey]; - }, - set: function(val) { - self[yKey] = val; - } - }); - } - } - if (Object.defineProperty) { - createLegacyProperty("position", "_legacyPos", "x", "y"); - createLegacyProperty("scale", "_legacyScale", "scaleX", "scaleY"); - createLegacyProperty("origin", "_legacyOrigin", "originX", "originY"); - } - }(); - return Element2; -}(); -mixin(Element, Eventful); -mixin(Element, Transformable); -function animateTo(animatable, target, cfg, animationProps, reverse) { - cfg = cfg || {}; - var animators = []; - animateToShallow(animatable, "", animatable, target, cfg, animationProps, animators, reverse); - var finishCount = animators.length; - var doneHappened = false; - var cfgDone = cfg.done; - var cfgAborted = cfg.aborted; - var doneCb = function() { - doneHappened = true; - finishCount--; - if (finishCount <= 0) { - doneHappened ? cfgDone && cfgDone() : cfgAborted && cfgAborted(); - } - }; - var abortedCb = function() { - finishCount--; - if (finishCount <= 0) { - doneHappened ? cfgDone && cfgDone() : cfgAborted && cfgAborted(); - } - }; - if (!finishCount) { - cfgDone && cfgDone(); - } - if (animators.length > 0 && cfg.during) { - animators[0].during(function(target2, percent) { - cfg.during(percent); - }); - } - for (var i = 0; i < animators.length; i++) { - var animator = animators[i]; - if (doneCb) { - animator.done(doneCb); - } - if (abortedCb) { - animator.aborted(abortedCb); - } - if (cfg.force) { - animator.duration(cfg.duration); - } - animator.start(cfg.easing); - } - return animators; -} -function copyArrShallow(source, target, len) { - for (var i = 0; i < len; i++) { - source[i] = target[i]; - } -} -function is2DArray(value) { - return isArrayLike(value[0]); -} -function copyValue(target, source, key) { - if (isArrayLike(source[key])) { - if (!isArrayLike(target[key])) { - target[key] = []; - } - if (isTypedArray(source[key])) { - var len = source[key].length; - if (target[key].length !== len) { - target[key] = new source[key].constructor(len); - copyArrShallow(target[key], source[key], len); - } - } else { - var sourceArr = source[key]; - var targetArr = target[key]; - var len0 = sourceArr.length; - if (is2DArray(sourceArr)) { - var len1 = sourceArr[0].length; - for (var i = 0; i < len0; i++) { - if (!targetArr[i]) { - targetArr[i] = Array.prototype.slice.call(sourceArr[i]); - } else { - copyArrShallow(targetArr[i], sourceArr[i], len1); - } - } - } else { - copyArrShallow(targetArr, sourceArr, len0); - } - targetArr.length = sourceArr.length; - } - } else { - target[key] = source[key]; - } -} -function isValueSame(val1, val2) { - return val1 === val2 || isArrayLike(val1) && isArrayLike(val2) && is1DArraySame(val1, val2); -} -function is1DArraySame(arr0, arr1) { - var len = arr0.length; - if (len !== arr1.length) { - return false; - } - for (var i = 0; i < len; i++) { - if (arr0[i] !== arr1[i]) { - return false; - } - } - return true; -} -function animateToShallow(animatable, topKey, animateObj, target, cfg, animationProps, animators, reverse) { - var targetKeys = keys(target); - var duration = cfg.duration; - var delay = cfg.delay; - var additive = cfg.additive; - var setToFinal = cfg.setToFinal; - var animateAll = !isObject$2(animationProps); - var existsAnimators = animatable.animators; - var animationKeys = []; - for (var k = 0; k < targetKeys.length; k++) { - var innerKey = targetKeys[k]; - var targetVal = target[innerKey]; - if (targetVal != null && animateObj[innerKey] != null && (animateAll || animationProps[innerKey])) { - if (isObject$2(targetVal) && !isArrayLike(targetVal) && !isGradientObject(targetVal)) { - if (topKey) { - if (!reverse) { - animateObj[innerKey] = targetVal; - animatable.updateDuringAnimation(topKey); - } - continue; - } - animateToShallow(animatable, innerKey, animateObj[innerKey], targetVal, cfg, animationProps && animationProps[innerKey], animators, reverse); - } else { - animationKeys.push(innerKey); - } - } else if (!reverse) { - animateObj[innerKey] = targetVal; - animatable.updateDuringAnimation(topKey); - animationKeys.push(innerKey); - } - } - var keyLen = animationKeys.length; - if (!additive && keyLen) { - for (var i = 0; i < existsAnimators.length; i++) { - var animator = existsAnimators[i]; - if (animator.targetName === topKey) { - var allAborted = animator.stopTracks(animationKeys); - if (allAborted) { - var idx = indexOf(existsAnimators, animator); - existsAnimators.splice(idx, 1); - } - } - } - } - if (!cfg.force) { - animationKeys = filter(animationKeys, function(key) { - return !isValueSame(target[key], animateObj[key]); - }); - keyLen = animationKeys.length; - } - if (keyLen > 0 || cfg.force && !animators.length) { - var revertedSource = void 0; - var reversedTarget = void 0; - var sourceClone = void 0; - if (reverse) { - reversedTarget = {}; - if (setToFinal) { - revertedSource = {}; - } - for (var i = 0; i < keyLen; i++) { - var innerKey = animationKeys[i]; - reversedTarget[innerKey] = animateObj[innerKey]; - if (setToFinal) { - revertedSource[innerKey] = target[innerKey]; - } else { - animateObj[innerKey] = target[innerKey]; - } - } - } else if (setToFinal) { - sourceClone = {}; - for (var i = 0; i < keyLen; i++) { - var innerKey = animationKeys[i]; - sourceClone[innerKey] = cloneValue(animateObj[innerKey]); - copyValue(animateObj, target, innerKey); - } - } - var animator = new Animator(animateObj, false, false, additive ? filter(existsAnimators, function(animator2) { - return animator2.targetName === topKey; - }) : null); - animator.targetName = topKey; - if (cfg.scope) { - animator.scope = cfg.scope; - } - if (setToFinal && revertedSource) { - animator.whenWithKeys(0, revertedSource, animationKeys); - } - if (sourceClone) { - animator.whenWithKeys(0, sourceClone, animationKeys); - } - animator.whenWithKeys(duration == null ? 500 : duration, reverse ? reversedTarget : target, animationKeys).delay(delay || 0); - animatable.addAnimator(animator, topKey); - animators.push(animator); - } -} - -var Group$2 = function(_super) { - __extends(Group2, _super); - function Group2(opts) { - var _this = _super.call(this) || this; - _this.isGroup = true; - _this._children = []; - _this.attr(opts); - return _this; - } - Group2.prototype.childrenRef = function() { - return this._children; - }; - Group2.prototype.children = function() { - return this._children.slice(); - }; - Group2.prototype.childAt = function(idx) { - return this._children[idx]; - }; - Group2.prototype.childOfName = function(name) { - var children = this._children; - for (var i = 0; i < children.length; i++) { - if (children[i].name === name) { - return children[i]; - } - } - }; - Group2.prototype.childCount = function() { - return this._children.length; - }; - Group2.prototype.add = function(child) { - if (child) { - if (child !== this && child.parent !== this) { - this._children.push(child); - this._doAdd(child); - } - } - return this; - }; - Group2.prototype.addBefore = function(child, nextSibling) { - if (child && child !== this && child.parent !== this && nextSibling && nextSibling.parent === this) { - var children = this._children; - var idx = children.indexOf(nextSibling); - if (idx >= 0) { - children.splice(idx, 0, child); - this._doAdd(child); - } - } - return this; - }; - Group2.prototype.replace = function(oldChild, newChild) { - var idx = indexOf(this._children, oldChild); - if (idx >= 0) { - this.replaceAt(newChild, idx); - } - return this; - }; - Group2.prototype.replaceAt = function(child, index) { - var children = this._children; - var old = children[index]; - if (child && child !== this && child.parent !== this && child !== old) { - children[index] = child; - old.parent = null; - var zr = this.__zr; - if (zr) { - old.removeSelfFromZr(zr); - } - this._doAdd(child); - } - return this; - }; - Group2.prototype._doAdd = function(child) { - if (child.parent) { - child.parent.remove(child); - } - child.parent = this; - var zr = this.__zr; - if (zr && zr !== child.__zr) { - child.addSelfToZr(zr); - } - zr && zr.refresh(); - }; - Group2.prototype.remove = function(child) { - var zr = this.__zr; - var children = this._children; - var idx = indexOf(children, child); - if (idx < 0) { - return this; - } - children.splice(idx, 1); - child.parent = null; - if (zr) { - child.removeSelfFromZr(zr); - } - zr && zr.refresh(); - return this; - }; - Group2.prototype.removeAll = function() { - var children = this._children; - var zr = this.__zr; - for (var i = 0; i < children.length; i++) { - var child = children[i]; - if (zr) { - child.removeSelfFromZr(zr); - } - child.parent = null; - } - children.length = 0; - return this; - }; - Group2.prototype.eachChild = function(cb, context) { - var children = this._children; - for (var i = 0; i < children.length; i++) { - var child = children[i]; - cb.call(context, child, i); - } - return this; - }; - Group2.prototype.traverse = function(cb, context) { - for (var i = 0; i < this._children.length; i++) { - var child = this._children[i]; - var stopped = cb.call(context, child); - if (child.isGroup && !stopped) { - child.traverse(cb, context); - } - } - return this; - }; - Group2.prototype.addSelfToZr = function(zr) { - _super.prototype.addSelfToZr.call(this, zr); - for (var i = 0; i < this._children.length; i++) { - var child = this._children[i]; - child.addSelfToZr(zr); - } - }; - Group2.prototype.removeSelfFromZr = function(zr) { - _super.prototype.removeSelfFromZr.call(this, zr); - for (var i = 0; i < this._children.length; i++) { - var child = this._children[i]; - child.removeSelfFromZr(zr); - } - }; - Group2.prototype.getBoundingRect = function(includeChildren) { - var tmpRect = new BoundingRect(0, 0, 0, 0); - var children = includeChildren || this._children; - var tmpMat = []; - var rect = null; - for (var i = 0; i < children.length; i++) { - var child = children[i]; - if (child.ignore || child.invisible) { - continue; - } - var childRect = child.getBoundingRect(); - var transform = child.getLocalTransform(tmpMat); - if (transform) { - BoundingRect.applyTransform(tmpRect, childRect, transform); - rect = rect || tmpRect.clone(); - rect.union(tmpRect); - } else { - rect = rect || childRect.clone(); - rect.union(childRect); - } - } - return rect || tmpRect; - }; - return Group2; -}(Element); -Group$2.prototype.type = "group"; - -/*! -* ZRender, a high performance 2d drawing library. -* -* Copyright (c) 2013, Baidu Inc. -* All rights reserved. -* -* LICENSE -* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt -*/ -var painterCtors = {}; -var instances$1 = {}; -function delInstance(id) { - delete instances$1[id]; -} -function isDarkMode(backgroundColor) { - if (!backgroundColor) { - return false; - } - if (typeof backgroundColor === "string") { - return lum(backgroundColor, 1) < DARK_MODE_THRESHOLD; - } else if (backgroundColor.colorStops) { - var colorStops = backgroundColor.colorStops; - var totalLum = 0; - var len = colorStops.length; - for (var i = 0; i < len; i++) { - totalLum += lum(colorStops[i].color, 1); - } - totalLum /= len; - return totalLum < DARK_MODE_THRESHOLD; - } - return false; -} -var ZRender = function() { - function ZRender2(id, dom, opts) { - var _this = this; - this._sleepAfterStill = 10; - this._stillFrameAccum = 0; - this._needsRefresh = true; - this._needsRefreshHover = true; - this._darkMode = false; - opts = opts || {}; - this.dom = dom; - this.id = id; - var storage = new Storage(); - var rendererType = opts.renderer || "canvas"; - if (!painterCtors[rendererType]) { - rendererType = keys(painterCtors)[0]; - } - opts.useDirtyRect = opts.useDirtyRect == null ? false : opts.useDirtyRect; - var painter = new painterCtors[rendererType](dom, storage, opts, id); - var ssrMode = opts.ssr || painter.ssrOnly; - this.storage = storage; - this.painter = painter; - var handlerProxy = !env.node && !env.worker && !ssrMode ? new HandlerDomProxy(painter.getViewportRoot(), painter.root) : null; - var useCoarsePointer = opts.useCoarsePointer; - var usePointerSize = useCoarsePointer == null || useCoarsePointer === "auto" ? env.touchEventsSupported : !!useCoarsePointer; - var defaultPointerSize = 44; - var pointerSize; - if (usePointerSize) { - pointerSize = retrieve2(opts.pointerSize, defaultPointerSize); - } - this.handler = new Handler(storage, painter, handlerProxy, painter.root, pointerSize); - this.animation = new Animation({ - stage: { - update: ssrMode ? null : function() { - return _this._flush(true); - } - } - }); - if (!ssrMode) { - this.animation.start(); - } - } - ZRender2.prototype.add = function(el) { - if (this._disposed || !el) { - return; - } - this.storage.addRoot(el); - el.addSelfToZr(this); - this.refresh(); - }; - ZRender2.prototype.remove = function(el) { - if (this._disposed || !el) { - return; - } - this.storage.delRoot(el); - el.removeSelfFromZr(this); - this.refresh(); - }; - ZRender2.prototype.configLayer = function(zLevel, config) { - if (this._disposed) { - return; - } - if (this.painter.configLayer) { - this.painter.configLayer(zLevel, config); - } - this.refresh(); - }; - ZRender2.prototype.setBackgroundColor = function(backgroundColor) { - if (this._disposed) { - return; - } - if (this.painter.setBackgroundColor) { - this.painter.setBackgroundColor(backgroundColor); - } - this.refresh(); - this._backgroundColor = backgroundColor; - this._darkMode = isDarkMode(backgroundColor); - }; - ZRender2.prototype.getBackgroundColor = function() { - return this._backgroundColor; - }; - ZRender2.prototype.setDarkMode = function(darkMode) { - this._darkMode = darkMode; - }; - ZRender2.prototype.isDarkMode = function() { - return this._darkMode; - }; - ZRender2.prototype.refreshImmediately = function(fromInside) { - if (this._disposed) { - return; - } - if (!fromInside) { - this.animation.update(true); - } - this._needsRefresh = false; - this.painter.refresh(); - this._needsRefresh = false; - }; - ZRender2.prototype.refresh = function() { - if (this._disposed) { - return; - } - this._needsRefresh = true; - this.animation.start(); - }; - ZRender2.prototype.flush = function() { - if (this._disposed) { - return; - } - this._flush(false); - }; - ZRender2.prototype._flush = function(fromInside) { - var triggerRendered; - var start = getTime(); - if (this._needsRefresh) { - triggerRendered = true; - this.refreshImmediately(fromInside); - } - if (this._needsRefreshHover) { - triggerRendered = true; - this.refreshHoverImmediately(); - } - var end = getTime(); - if (triggerRendered) { - this._stillFrameAccum = 0; - this.trigger("rendered", { - elapsedTime: end - start - }); - } else if (this._sleepAfterStill > 0) { - this._stillFrameAccum++; - if (this._stillFrameAccum > this._sleepAfterStill) { - this.animation.stop(); - } - } - }; - ZRender2.prototype.setSleepAfterStill = function(stillFramesCount) { - this._sleepAfterStill = stillFramesCount; - }; - ZRender2.prototype.wakeUp = function() { - if (this._disposed) { - return; - } - this.animation.start(); - this._stillFrameAccum = 0; - }; - ZRender2.prototype.refreshHover = function() { - this._needsRefreshHover = true; - }; - ZRender2.prototype.refreshHoverImmediately = function() { - if (this._disposed) { - return; - } - this._needsRefreshHover = false; - if (this.painter.refreshHover && this.painter.getType() === "canvas") { - this.painter.refreshHover(); - } - }; - ZRender2.prototype.resize = function(opts) { - if (this._disposed) { - return; - } - opts = opts || {}; - this.painter.resize(opts.width, opts.height); - this.handler.resize(); - }; - ZRender2.prototype.clearAnimation = function() { - if (this._disposed) { - return; - } - this.animation.clear(); - }; - ZRender2.prototype.getWidth = function() { - if (this._disposed) { - return; - } - return this.painter.getWidth(); - }; - ZRender2.prototype.getHeight = function() { - if (this._disposed) { - return; - } - return this.painter.getHeight(); - }; - ZRender2.prototype.setCursorStyle = function(cursorStyle) { - if (this._disposed) { - return; - } - this.handler.setCursorStyle(cursorStyle); - }; - ZRender2.prototype.findHover = function(x, y) { - if (this._disposed) { - return; - } - return this.handler.findHover(x, y); - }; - ZRender2.prototype.on = function(eventName, eventHandler, context) { - if (!this._disposed) { - this.handler.on(eventName, eventHandler, context); - } - return this; - }; - ZRender2.prototype.off = function(eventName, eventHandler) { - if (this._disposed) { - return; - } - this.handler.off(eventName, eventHandler); - }; - ZRender2.prototype.trigger = function(eventName, event) { - if (this._disposed) { - return; - } - this.handler.trigger(eventName, event); - }; - ZRender2.prototype.clear = function() { - if (this._disposed) { - return; - } - var roots = this.storage.getRoots(); - for (var i = 0; i < roots.length; i++) { - if (roots[i] instanceof Group$2) { - roots[i].removeSelfFromZr(this); - } - } - this.storage.delAllRoots(); - this.painter.clear(); - }; - ZRender2.prototype.dispose = function() { - if (this._disposed) { - return; - } - this.animation.stop(); - this.clear(); - this.storage.dispose(); - this.painter.dispose(); - this.handler.dispose(); - this.animation = this.storage = this.painter = this.handler = null; - this._disposed = true; - delInstance(this.id); - }; - return ZRender2; -}(); -function init$1(dom, opts) { - var zr = new ZRender(guid(), dom, opts); - instances$1[zr.id] = zr; - return zr; -} -function registerPainter(name, Ctor) { - painterCtors[name] = Ctor; -} - -var RADIAN_EPSILON = 1e-4; -// Although chrome already enlarge this number to 100 for `toFixed`, but -// we sill follow the spec for compatibility. -var ROUND_SUPPORTED_PRECISION_MAX = 20; -function _trim(str) { - return str.replace(/^\s+|\s+$/g, ''); -} -/** - * Linear mapping a value from domain to range - * @param val - * @param domain Domain extent domain[0] can be bigger than domain[1] - * @param range Range extent range[0] can be bigger than range[1] - * @param clamp Default to be false - */ -function linearMap(val, domain, range, clamp) { - var d0 = domain[0]; - var d1 = domain[1]; - var r0 = range[0]; - var r1 = range[1]; - var subDomain = d1 - d0; - var subRange = r1 - r0; - if (subDomain === 0) { - return subRange === 0 ? r0 : (r0 + r1) / 2; - } - // Avoid accuracy problem in edge, such as - // 146.39 - 62.83 === 83.55999999999999. - // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError - // It is a little verbose for efficiency considering this method - // is a hotspot. - if (clamp) { - if (subDomain > 0) { - if (val <= d0) { - return r0; - } else if (val >= d1) { - return r1; - } - } else { - if (val >= d0) { - return r0; - } else if (val <= d1) { - return r1; - } - } - } else { - if (val === d0) { - return r0; - } - if (val === d1) { - return r1; - } - } - return (val - d0) / subDomain * subRange + r0; -} -/** - * Convert a percent string to absolute number. - * Returns NaN if percent is not a valid string or number - */ -function parsePercent(percent, all) { - switch (percent) { - case 'center': - case 'middle': - percent = '50%'; - break; - case 'left': - case 'top': - percent = '0%'; - break; - case 'right': - case 'bottom': - percent = '100%'; - break; - } - if (isString(percent)) { - if (_trim(percent).match(/%$/)) { - return parseFloat(percent) / 100 * all; - } - return parseFloat(percent); - } - return percent == null ? NaN : +percent; -} -function round$1(x, precision, returnStr) { - if (precision == null) { - precision = 10; - } - // Avoid range error - precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX); - // PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01' - x = (+x).toFixed(precision); - return returnStr ? x : +x; -} -/** - * Get precision. - */ -function getPrecision(val) { - val = +val; - if (isNaN(val)) { - return 0; - } - // It is much faster than methods converting number to string as follows - // let tmp = val.toString(); - // return tmp.length - 1 - tmp.indexOf('.'); - // especially when precision is low - // Notice: - // (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`. - // (see https://jsbench.me/2vkpcekkvw/1) - // (2) If the val is less than for example 1e-15, the result may be incorrect. - // (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`) - if (val > 1e-14) { - var e = 1; - for (var i = 0; i < 15; i++, e *= 10) { - if (Math.round(val * e) / e === val) { - return i; - } - } - } - return getPrecisionSafe(val); -} -/** - * Get precision with slow but safe method - */ -function getPrecisionSafe(val) { - // toLowerCase for: '3.4E-12' - var str = val.toString().toLowerCase(); - // Consider scientific notation: '3.4e-12' '3.4e+12' - var eIndex = str.indexOf('e'); - var exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0; - var significandPartLen = eIndex > 0 ? eIndex : str.length; - var dotIndex = str.indexOf('.'); - var decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex; - return Math.max(0, decimalPartLen - exp); -} -/** - * Minimal dicernible data precisioin according to a single pixel. - */ -function getPixelPrecision(dataExtent, pixelExtent) { - var log = Math.log; - var LN10 = Math.LN10; - var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10); - var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10); - // toFixed() digits argument must be between 0 and 20. - var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20); - return !isFinite(precision) ? 20 : precision; -} -/** - * Get a data of given precision, assuring the sum of percentages - * in valueList is 1. - * The largest remainder method is used. - * https://en.wikipedia.org/wiki/Largest_remainder_method - * - * @param valueList a list of all data - * @param precision integer number showing digits of precision - * @return {Array} - */ -function getPercentSeats(valueList, precision) { - var sum = reduce(valueList, function (acc, val) { - return acc + (isNaN(val) ? 0 : val); - }, 0); - if (sum === 0) { - return []; - } - var digits = Math.pow(10, precision); - var votesPerQuota = map$1(valueList, function (val) { - return (isNaN(val) ? 0 : val) / sum * digits * 100; - }); - var targetSeats = digits * 100; - var seats = map$1(votesPerQuota, function (votes) { - // Assign automatic seats. - return Math.floor(votes); - }); - var currentSum = reduce(seats, function (acc, val) { - return acc + val; - }, 0); - var remainder = map$1(votesPerQuota, function (votes, idx) { - return votes - seats[idx]; - }); - // Has remainding votes. - while (currentSum < targetSeats) { - // Find next largest remainder. - var max = Number.NEGATIVE_INFINITY; - var maxId = null; - for (var i = 0, len = remainder.length; i < len; ++i) { - if (remainder[i] > max) { - max = remainder[i]; - maxId = i; - } - } - // Add a vote to max remainder. - ++seats[maxId]; - remainder[maxId] = 0; - ++currentSum; - } - return map$1(seats, function (seat) { - return seat / digits; - }); -} -/** - * Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004 - * See - */ -function addSafe(val0, val1) { - var maxPrecision = Math.max(getPrecision(val0), getPrecision(val1)); - // const multiplier = Math.pow(10, maxPrecision); - // return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier; - var sum = val0 + val1; - // // PENDING: support more? - return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX ? sum : round$1(sum, maxPrecision); -} -/** - * To 0 - 2 * PI, considering negative radian. - */ -function remRadian(radian) { - var pi2 = Math.PI * 2; - return (radian % pi2 + pi2) % pi2; -} -/** - * @param {type} radian - * @return {boolean} - */ -function isRadianAroundZero(val) { - return val > -1e-4 && val < RADIAN_EPSILON; -} -// eslint-disable-next-line -var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line -/** - * @param value valid type: number | string | Date, otherwise return `new Date(NaN)` - * These values can be accepted: - * + An instance of Date, represent a time in its own time zone. - * + Or string in a subset of ISO 8601, only including: - * + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06', - * + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123', - * + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00', - * all of which will be treated as local time if time zone is not specified - * (see ). - * + Or other string format, including (all of which will be treated as local time): - * '2012', '2012-3-1', '2012/3/1', '2012/03/01', - * '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123' - * + a timestamp, which represent a time in UTC. - * @return date Never be null/undefined. If invalid, return `new Date(NaN)`. - */ -function parseDate(value) { - if (value instanceof Date) { - return value; - } else if (isString(value)) { - // Different browsers parse date in different way, so we parse it manually. - // Some other issues: - // new Date('1970-01-01') is UTC, - // new Date('1970/01/01') and new Date('1970-1-01') is local. - // See issue #3623 - var match = TIME_REG.exec(value); - if (!match) { - // return Invalid Date. - return new Date(NaN); - } - // Use local time when no timezone offset is specified. - if (!match[8]) { - // match[n] can only be string or undefined. - // But take care of '12' + 1 => '121'. - return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0); - } - // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time, - // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment). - // For example, system timezone is set as "Time Zone: America/Toronto", - // then these code will get different result: - // `new Date(1478411999999).getTimezoneOffset(); // get 240` - // `new Date(1478412000000).getTimezoneOffset(); // get 300` - // So we should not use `new Date`, but use `Date.UTC`. - else { - var hour = +match[4] || 0; - if (match[8].toUpperCase() !== 'Z') { - hour -= +match[8].slice(0, 3); - } - return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0)); - } - } else if (value == null) { - return new Date(NaN); - } - return new Date(Math.round(value)); -} -/** - * Quantity of a number. e.g. 0.1, 1, 10, 100 - * - * @param val - * @return - */ -function quantity(val) { - return Math.pow(10, quantityExponent(val)); -} -/** - * Exponent of the quantity of a number - * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3 - * - * @param val non-negative value - * @return - */ -function quantityExponent(val) { - if (val === 0) { - return 0; - } - var exp = Math.floor(Math.log(val) / Math.LN10); - /** - * exp is expected to be the rounded-down result of the base-10 log of val. - * But due to the precision loss with Math.log(val), we need to restore it - * using 10^exp to make sure we can get val back from exp. #11249 - */ - if (val / Math.pow(10, exp) >= 10) { - exp++; - } - return exp; -} -/** - * find a “nice” number approximately equal to x. Round the number if round = true, - * take ceiling if round = false. The primary observation is that the “nicest” - * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers. - * - * See "Nice Numbers for Graph Labels" of Graphic Gems. - * - * @param val Non-negative value. - * @param round - * @return Niced number - */ -function nice(val, round) { - var exponent = quantityExponent(val); - var exp10 = Math.pow(10, exponent); - var f = val / exp10; // 1 <= f < 10 - var nf; - { - if (f < 1.5) { - nf = 1; - } else if (f < 2.5) { - nf = 2; - } else if (f < 4) { - nf = 3; - } else if (f < 7) { - nf = 5; - } else { - nf = 10; - } - } - val = nf * exp10; - // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754). - // 20 is the uppper bound of toFixed. - return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val; -} -/** - * [Numeric is defined as]: - * `parseFloat(val) == val` - * For example: - * numeric: - * typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity, - * and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec) - * not-numeric: - * null, undefined, [], {}, true, false, 'NaN', NaN, '123ab', - * empty string, string with only white-spaces or line-terminal (see es spec), - * 0x12, '0x12', '-0x12', 012, '012', '-012', - * non-string, ... - * - * @test See full test cases in `test/ut/spec/util/number.js`. - * @return Must be a typeof number. If not numeric, return NaN. - */ -function numericToNumber(val) { - var valFloat = parseFloat(val); - return valFloat == val // eslint-disable-line eqeqeq - && (valFloat !== 0 || !isString(val) || val.indexOf('x') <= 0) // For case ' 0x0 '. - ? valFloat : NaN; -} -/** - * Definition of "numeric": see `numericToNumber`. - */ -function isNumeric(val) { - return !isNaN(numericToNumber(val)); -} -/** - * Use random base to prevent users hard code depending on - * this auto generated marker id. - * @return An positive integer. - */ -function getRandomIdBase() { - return Math.round(Math.random() * 9); -} -/** - * Get the greatest common divisor. - * - * @param {number} a one number - * @param {number} b the other number - */ -function getGreatestCommonDividor(a, b) { - if (b === 0) { - return a; - } - return getGreatestCommonDividor(b, a % b); -} -/** - * Get the least common multiple. - * - * @param {number} a one number - * @param {number} b the other number - */ -function getLeastCommonMultiple(a, b) { - if (a == null) { - return b; - } - if (b == null) { - return a; - } - return a * b / getGreatestCommonDividor(a, b); -} - -function throwError(msg) { - throw new Error(msg); -} - -function interpolateNumber(p0, p1, percent) { - return (p1 - p0) * percent + p0; -} -var DUMMY_COMPONENT_NAME_PREFIX = "series\0"; -var INTERNAL_COMPONENT_ID_PREFIX = "\0_ec_\0"; -function normalizeToArray(value) { - return value instanceof Array ? value : value == null ? [] : [value]; -} -function defaultEmphasis(opt, key, subOpts) { - if (opt) { - opt[key] = opt[key] || {}; - opt.emphasis = opt.emphasis || {}; - opt.emphasis[key] = opt.emphasis[key] || {}; - for (var i = 0, len = subOpts.length; i < len; i++) { - var subOptName = subOpts[i]; - if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) { - opt.emphasis[key][subOptName] = opt[key][subOptName]; - } - } - } -} -var TEXT_STYLE_OPTIONS = ["fontStyle", "fontWeight", "fontSize", "fontFamily", "rich", "tag", "color", "textBorderColor", "textBorderWidth", "width", "height", "lineHeight", "align", "verticalAlign", "baseline", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY", "textShadowColor", "textShadowBlur", "textShadowOffsetX", "textShadowOffsetY", "backgroundColor", "borderColor", "borderWidth", "borderRadius", "padding"]; -function getDataItemValue(dataItem) { - return isObject$2(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem; -} -function isDataItemOption(dataItem) { - return isObject$2(dataItem) && !(dataItem instanceof Array); -} -function mappingToExists(existings, newCmptOptions, mode) { - var isNormalMergeMode = mode === "normalMerge"; - var isReplaceMergeMode = mode === "replaceMerge"; - var isReplaceAllMode = mode === "replaceAll"; - existings = existings || []; - newCmptOptions = (newCmptOptions || []).slice(); - var existingIdIdxMap = createHashMap(); - each$4(newCmptOptions, function(cmptOption, index) { - if (!isObject$2(cmptOption)) { - newCmptOptions[index] = null; - return; - } - }); - var result = prepareResult(existings, existingIdIdxMap, mode); - if (isNormalMergeMode || isReplaceMergeMode) { - mappingById(result, existings, existingIdIdxMap, newCmptOptions); - } - if (isNormalMergeMode) { - mappingByName(result, newCmptOptions); - } - if (isNormalMergeMode || isReplaceMergeMode) { - mappingByIndex(result, newCmptOptions, isReplaceMergeMode); - } else if (isReplaceAllMode) { - mappingInReplaceAllMode(result, newCmptOptions); - } - makeIdAndName(result); - return result; -} -function prepareResult(existings, existingIdIdxMap, mode) { - var result = []; - if (mode === "replaceAll") { - return result; - } - for (var index = 0; index < existings.length; index++) { - var existing = existings[index]; - if (existing && existing.id != null) { - existingIdIdxMap.set(existing.id, index); - } - result.push({ - existing: mode === "replaceMerge" || isComponentIdInternal(existing) ? null : existing, - newOption: null, - keyInfo: null, - brandNew: null - }); - } - return result; -} -function mappingById(result, existings, existingIdIdxMap, newCmptOptions) { - each$4(newCmptOptions, function(cmptOption, index) { - if (!cmptOption || cmptOption.id == null) { - return; - } - var optionId = makeComparableKey(cmptOption.id); - var existingIdx = existingIdIdxMap.get(optionId); - if (existingIdx != null) { - var resultItem = result[existingIdx]; - assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".'); - resultItem.newOption = cmptOption; - resultItem.existing = existings[existingIdx]; - newCmptOptions[index] = null; - } - }); -} -function mappingByName(result, newCmptOptions) { - each$4(newCmptOptions, function(cmptOption, index) { - if (!cmptOption || cmptOption.name == null) { - return; - } - for (var i = 0; i < result.length; i++) { - var existing = result[i].existing; - if (!result[i].newOption && existing && (existing.id == null || cmptOption.id == null) && !isComponentIdInternal(cmptOption) && !isComponentIdInternal(existing) && keyExistAndEqual("name", existing, cmptOption)) { - result[i].newOption = cmptOption; - newCmptOptions[index] = null; - return; - } - } - }); -} -function mappingByIndex(result, newCmptOptions, brandNew) { - each$4(newCmptOptions, function(cmptOption) { - if (!cmptOption) { - return; - } - var resultItem; - var nextIdx = 0; - while ( - // Be `!resultItem` only when `nextIdx >= result.length`. - (resultItem = result[nextIdx]) && (resultItem.newOption || isComponentIdInternal(resultItem.existing) || // In mode "replaceMerge", here no not-mapped-non-internal-existing. - resultItem.existing && cmptOption.id != null && !keyExistAndEqual("id", cmptOption, resultItem.existing)) - ) { - nextIdx++; - } - if (resultItem) { - resultItem.newOption = cmptOption; - resultItem.brandNew = brandNew; - } else { - result.push({ - newOption: cmptOption, - brandNew, - existing: null, - keyInfo: null - }); - } - nextIdx++; - }); -} -function mappingInReplaceAllMode(result, newCmptOptions) { - each$4(newCmptOptions, function(cmptOption) { - result.push({ - newOption: cmptOption, - brandNew: true, - existing: null, - keyInfo: null - }); - }); -} -function makeIdAndName(mapResult) { - var idMap = createHashMap(); - each$4(mapResult, function(item) { - var existing = item.existing; - existing && idMap.set(existing.id, item); - }); - each$4(mapResult, function(item) { - var opt = item.newOption; - assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, "id duplicates: " + (opt && opt.id)); - opt && opt.id != null && idMap.set(opt.id, item); - !item.keyInfo && (item.keyInfo = {}); - }); - each$4(mapResult, function(item, index) { - var existing = item.existing; - var opt = item.newOption; - var keyInfo = item.keyInfo; - if (!isObject$2(opt)) { - return; - } - keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name : DUMMY_COMPONENT_NAME_PREFIX + index; - if (existing) { - keyInfo.id = makeComparableKey(existing.id); - } else if (opt.id != null) { - keyInfo.id = makeComparableKey(opt.id); - } else { - var idNum = 0; - do { - keyInfo.id = "\0" + keyInfo.name + "\0" + idNum++; - } while (idMap.get(keyInfo.id)); - } - idMap.set(keyInfo.id, item); - }); -} -function keyExistAndEqual(attr, obj1, obj2) { - var key1 = convertOptionIdName(obj1[attr], null); - var key2 = convertOptionIdName(obj2[attr], null); - return key1 != null && key2 != null && key1 === key2; -} -function makeComparableKey(val) { - return convertOptionIdName(val, ""); -} -function convertOptionIdName(idOrName, defaultValue) { - if (idOrName == null) { - return defaultValue; - } - return isString(idOrName) ? idOrName : isNumber(idOrName) || isStringSafe(idOrName) ? idOrName + "" : defaultValue; -} -function isNameSpecified(componentModel) { - var name = componentModel.name; - return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX)); -} -function isComponentIdInternal(cmptOption) { - return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0; -} -function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) { - each$4(mappingResult, function(item) { - var newOption = item.newOption; - if (isObject$2(newOption)) { - item.keyInfo.mainType = mainType; - item.keyInfo.subType = determineSubType(mainType, newOption, item.existing, componentModelCtor); - } - }); -} -function determineSubType(mainType, newCmptOption, existComponent, componentModelCtor) { - var subType = newCmptOption.type ? newCmptOption.type : existComponent ? existComponent.subType : componentModelCtor.determineSubType(mainType, newCmptOption); - return subType; -} -function queryDataIndex(data, payload) { - if (payload.dataIndexInside != null) { - return payload.dataIndexInside; - } else if (payload.dataIndex != null) { - return isArray(payload.dataIndex) ? map$1(payload.dataIndex, function(value) { - return data.indexOfRawIndex(value); - }) : data.indexOfRawIndex(payload.dataIndex); - } else if (payload.name != null) { - return isArray(payload.name) ? map$1(payload.name, function(value) { - return data.indexOfName(value); - }) : data.indexOfName(payload.name); - } -} -function makeInner() { - var key = "__ec_inner_" + innerUniqueIndex++; - return function(hostObj) { - return hostObj[key] || (hostObj[key] = {}); - }; -} -var innerUniqueIndex = getRandomIdBase(); -function parseFinder(ecModel, finderInput, opt) { - var _a = preParseFinder(finderInput, opt), mainTypeSpecified = _a.mainTypeSpecified, queryOptionMap = _a.queryOptionMap, others = _a.others; - var result = others; - var defaultMainType = opt ? opt.defaultMainType : null; - if (!mainTypeSpecified && defaultMainType) { - queryOptionMap.set(defaultMainType, {}); - } - queryOptionMap.each(function(queryOption, mainType) { - var queryResult = queryReferringComponents(ecModel, mainType, queryOption, { - useDefault: defaultMainType === mainType, - enableAll: opt && opt.enableAll != null ? opt.enableAll : true, - enableNone: opt && opt.enableNone != null ? opt.enableNone : true - }); - result[mainType + "Models"] = queryResult.models; - result[mainType + "Model"] = queryResult.models[0]; - }); - return result; -} -function preParseFinder(finderInput, opt) { - var finder; - if (isString(finderInput)) { - var obj = {}; - obj[finderInput + "Index"] = 0; - finder = obj; - } else { - finder = finderInput; - } - var queryOptionMap = createHashMap(); - var others = {}; - var mainTypeSpecified = false; - each$4(finder, function(value, key) { - if (key === "dataIndex" || key === "dataIndexInside") { - others[key] = value; - return; - } - var parsedKey = key.match(/^(\w+)(Index|Id|Name)$/) || []; - var mainType = parsedKey[1]; - var queryType = (parsedKey[2] || "").toLowerCase(); - if (!mainType || !queryType || opt && opt.includeMainTypes && indexOf(opt.includeMainTypes, mainType) < 0) { - return; - } - mainTypeSpecified = mainTypeSpecified || !!mainType; - var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {}); - queryOption[queryType] = value; - }); - return { - mainTypeSpecified, - queryOptionMap, - others - }; -} -var SINGLE_REFERRING = { - useDefault: true, - enableAll: false, - enableNone: false -}; -function queryReferringComponents(ecModel, mainType, userOption, opt) { - opt = opt || SINGLE_REFERRING; - var indexOption = userOption.index; - var idOption = userOption.id; - var nameOption = userOption.name; - var result = { - models: null, - specified: indexOption != null || idOption != null || nameOption != null - }; - if (!result.specified) { - var firstCmpt = void 0; - result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : []; - return result; - } - if (indexOption === "none" || indexOption === false) { - assert(opt.enableNone, '`"none"` or `false` is not a valid value on index option.'); - result.models = []; - return result; - } - if (indexOption === "all") { - assert(opt.enableAll, '`"all"` is not a valid value on index option.'); - indexOption = idOption = nameOption = null; - } - result.models = ecModel.queryComponents({ - mainType, - index: indexOption, - id: idOption, - name: nameOption - }); - return result; -} -function setAttribute(dom, key, value) { - dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value; -} -function getAttribute(dom, key) { - return dom.getAttribute ? dom.getAttribute(key) : dom[key]; -} -function getTooltipRenderMode(renderModeOption) { - if (renderModeOption === "auto") { - return env.domSupported ? "html" : "richText"; - } else { - return renderModeOption || "html"; - } -} -function interpolateRawValues(data, precision, sourceValue, targetValue, percent) { - var isAutoPrecision = precision == null || precision === "auto"; - if (targetValue == null) { - return targetValue; - } - if (isNumber(targetValue)) { - var value = interpolateNumber(sourceValue || 0, targetValue, percent); - return round$1(value, isAutoPrecision ? Math.max(getPrecision(sourceValue || 0), getPrecision(targetValue)) : precision); - } else if (isString(targetValue)) { - return percent < 1 ? sourceValue : targetValue; - } else { - var interpolated = []; - var leftArr = sourceValue; - var rightArr = targetValue; - var length_1 = Math.max(leftArr ? leftArr.length : 0, rightArr.length); - for (var i = 0; i < length_1; ++i) { - var info = data.getDimensionInfo(i); - if (info && info.type === "ordinal") { - interpolated[i] = (percent < 1 && leftArr ? leftArr : rightArr)[i]; - } else { - var leftVal = leftArr && leftArr[i] ? leftArr[i] : 0; - var rightVal = rightArr[i]; - var value = interpolateNumber(leftVal, rightVal, percent); - interpolated[i] = round$1(value, isAutoPrecision ? Math.max(getPrecision(leftVal), getPrecision(rightVal)) : precision); - } - } - return interpolated; - } -} - -var TYPE_DELIMITER = "."; -var IS_CONTAINER = "___EC__COMPONENT__CONTAINER___"; -var IS_EXTENDED_CLASS = "___EC__EXTENDED_CLASS___"; -function parseClassType(componentType) { - var ret = { - main: "", - sub: "" - }; - if (componentType) { - var typeArr = componentType.split(TYPE_DELIMITER); - ret.main = typeArr[0] || ""; - ret.sub = typeArr[1] || ""; - } - return ret; -} -function checkClassType(componentType) { - assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal'); -} -function isExtendedClass(clz) { - return !!(clz && clz[IS_EXTENDED_CLASS]); -} -function enableClassExtend(rootClz, mandatoryMethods) { - rootClz.$constructor = rootClz; - rootClz.extend = function(proto) { - var superClass = this; - var ExtendedClass; - if (isESClass(superClass)) { - ExtendedClass = /** @class */ - function(_super) { - __extends(class_1, _super); - function class_1() { - return _super.apply(this, arguments) || this; - } - return class_1; - }(superClass); - } else { - ExtendedClass = function() { - (proto.$constructor || superClass).apply(this, arguments); - }; - inherits(ExtendedClass, this); - } - extend(ExtendedClass.prototype, proto); - ExtendedClass[IS_EXTENDED_CLASS] = true; - ExtendedClass.extend = this.extend; - ExtendedClass.superCall = superCall; - ExtendedClass.superApply = superApply; - ExtendedClass.superClass = superClass; - return ExtendedClass; - }; -} -function isESClass(fn) { - return isFunction(fn) && /^class\s/.test(Function.prototype.toString.call(fn)); -} -function mountExtend(SubClz, SupperClz) { - SubClz.extend = SupperClz.extend; -} -var classBase = Math.round(Math.random() * 10); -function enableClassCheck(target) { - var classAttr = ["__\0is_clz", classBase++].join("_"); - target.prototype[classAttr] = true; - target.isInstance = function(obj) { - return !!(obj && obj[classAttr]); - }; -} -function superCall(context, methodName) { - var args = []; - for (var _i = 2; _i < arguments.length; _i++) { - args[_i - 2] = arguments[_i]; - } - return this.superClass.prototype[methodName].apply(context, args); -} -function superApply(context, methodName, args) { - return this.superClass.prototype[methodName].apply(context, args); -} -function enableClassManagement(target) { - var storage = {}; - target.registerClass = function(clz) { - var componentFullType = clz.type || clz.prototype.type; - if (componentFullType) { - checkClassType(componentFullType); - clz.prototype.type = componentFullType; - var componentTypeInfo = parseClassType(componentFullType); - if (!componentTypeInfo.sub) { - storage[componentTypeInfo.main] = clz; - } else if (componentTypeInfo.sub !== IS_CONTAINER) { - var container = makeContainer(componentTypeInfo); - container[componentTypeInfo.sub] = clz; - } - } - return clz; - }; - target.getClass = function(mainType, subType, throwWhenNotFound) { - var clz = storage[mainType]; - if (clz && clz[IS_CONTAINER]) { - clz = subType ? clz[subType] : null; - } - if (throwWhenNotFound && !clz) { - throw new Error(!subType ? mainType + ".type should be specified." : "Component " + mainType + "." + (subType || "") + " is used but not imported."); - } - return clz; - }; - target.getClassesByMainType = function(componentType) { - var componentTypeInfo = parseClassType(componentType); - var result = []; - var obj = storage[componentTypeInfo.main]; - if (obj && obj[IS_CONTAINER]) { - each$4(obj, function(o, type) { - type !== IS_CONTAINER && result.push(o); - }); - } else { - result.push(obj); - } - return result; - }; - target.hasClass = function(componentType) { - var componentTypeInfo = parseClassType(componentType); - return !!storage[componentTypeInfo.main]; - }; - target.getAllClassMainTypes = function() { - var types = []; - each$4(storage, function(obj, type) { - types.push(type); - }); - return types; - }; - target.hasSubTypes = function(componentType) { - var componentTypeInfo = parseClassType(componentType); - var obj = storage[componentTypeInfo.main]; - return obj && obj[IS_CONTAINER]; - }; - function makeContainer(componentTypeInfo) { - var container = storage[componentTypeInfo.main]; - if (!container || !container[IS_CONTAINER]) { - container = storage[componentTypeInfo.main] = {}; - container[IS_CONTAINER] = true; - } - return container; - } -} - -function makeStyleMapper(properties, ignoreParent) { - // Normalize - for (var i = 0; i < properties.length; i++) { - if (!properties[i][1]) { - properties[i][1] = properties[i][0]; - } - } - ignoreParent = ignoreParent || false; - return function (model, excludes, includes) { - var style = {}; - for (var i = 0; i < properties.length; i++) { - var propName = properties[i][1]; - if (excludes && indexOf(excludes, propName) >= 0 || includes && indexOf(includes, propName) < 0) { - continue; - } - var val = model.getShallow(propName, ignoreParent); - if (val != null) { - style[properties[i][0]] = val; - } - } - // TODO Text or image? - return style; - }; -} - -var AREA_STYLE_KEY_MAP = [['fill', 'color'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['opacity'], ['shadowColor'] -// Option decal is in `DecalObject` but style.decal is in `PatternObject`. -// So do not transfer decal directly. -]; -var getAreaStyle = makeStyleMapper(AREA_STYLE_KEY_MAP); -var AreaStyleMixin = /** @class */function () { - function AreaStyleMixin() {} - AreaStyleMixin.prototype.getAreaStyle = function (excludes, includes) { - return getAreaStyle(this, excludes, includes); - }; - return AreaStyleMixin; -}(); - -var globalImageCache = new LRU(50); -function findExistImage(newImageOrSrc) { - if (typeof newImageOrSrc === 'string') { - var cachedImgObj = globalImageCache.get(newImageOrSrc); - return cachedImgObj && cachedImgObj.image; - } - else { - return newImageOrSrc; - } -} -function createOrUpdateImage(newImageOrSrc, image, hostEl, onload, cbPayload) { - if (!newImageOrSrc) { - return image; - } - else if (typeof newImageOrSrc === 'string') { - if ((image && image.__zrImageSrc === newImageOrSrc) || !hostEl) { - return image; - } - var cachedImgObj = globalImageCache.get(newImageOrSrc); - var pendingWrap = { hostEl: hostEl, cb: onload, cbPayload: cbPayload }; - if (cachedImgObj) { - image = cachedImgObj.image; - !isImageReady(image) && cachedImgObj.pending.push(pendingWrap); - } - else { - image = platformApi.loadImage(newImageOrSrc, imageOnLoad, imageOnLoad); - image.__zrImageSrc = newImageOrSrc; - globalImageCache.put(newImageOrSrc, image.__cachedImgObj = { - image: image, - pending: [pendingWrap] - }); - } - return image; - } - else { - return newImageOrSrc; - } -} -function imageOnLoad() { - var cachedImgObj = this.__cachedImgObj; - this.onload = this.onerror = this.__cachedImgObj = null; - for (var i = 0; i < cachedImgObj.pending.length; i++) { - var pendingWrap = cachedImgObj.pending[i]; - var cb = pendingWrap.cb; - cb && cb(this, pendingWrap.cbPayload); - pendingWrap.hostEl.dirty(); - } - cachedImgObj.pending.length = 0; -} -function isImageReady(image) { - return image && image.width && image.height; -} - -var STYLE_REG = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g; -function truncateText2(out, text, containerWidth, font, ellipsis, options) { - if (!containerWidth) { - out.text = ''; - out.isTruncated = false; - return; - } - var textLines = (text + '').split('\n'); - options = prepareTruncateOptions(containerWidth, font, ellipsis, options); - var isTruncated = false; - var truncateOut = {}; - for (var i = 0, len = textLines.length; i < len; i++) { - truncateSingleLine(truncateOut, textLines[i], options); - textLines[i] = truncateOut.textLine; - isTruncated = isTruncated || truncateOut.isTruncated; - } - out.text = textLines.join('\n'); - out.isTruncated = isTruncated; -} -function prepareTruncateOptions(containerWidth, font, ellipsis, options) { - options = options || {}; - var preparedOpts = extend({}, options); - preparedOpts.font = font; - ellipsis = retrieve2(ellipsis, '...'); - preparedOpts.maxIterations = retrieve2(options.maxIterations, 2); - var minChar = preparedOpts.minChar = retrieve2(options.minChar, 0); - preparedOpts.cnCharWidth = getWidth('国', font); - var ascCharWidth = preparedOpts.ascCharWidth = getWidth('a', font); - preparedOpts.placeholder = retrieve2(options.placeholder, ''); - var contentWidth = containerWidth = Math.max(0, containerWidth - 1); - for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) { - contentWidth -= ascCharWidth; - } - var ellipsisWidth = getWidth(ellipsis, font); - if (ellipsisWidth > contentWidth) { - ellipsis = ''; - ellipsisWidth = 0; - } - contentWidth = containerWidth - ellipsisWidth; - preparedOpts.ellipsis = ellipsis; - preparedOpts.ellipsisWidth = ellipsisWidth; - preparedOpts.contentWidth = contentWidth; - preparedOpts.containerWidth = containerWidth; - return preparedOpts; -} -function truncateSingleLine(out, textLine, options) { - var containerWidth = options.containerWidth; - var font = options.font; - var contentWidth = options.contentWidth; - if (!containerWidth) { - out.textLine = ''; - out.isTruncated = false; - return; - } - var lineWidth = getWidth(textLine, font); - if (lineWidth <= containerWidth) { - out.textLine = textLine; - out.isTruncated = false; - return; - } - for (var j = 0;; j++) { - if (lineWidth <= contentWidth || j >= options.maxIterations) { - textLine += options.ellipsis; - break; - } - var subLength = j === 0 - ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth) - : lineWidth > 0 - ? Math.floor(textLine.length * contentWidth / lineWidth) - : 0; - textLine = textLine.substr(0, subLength); - lineWidth = getWidth(textLine, font); - } - if (textLine === '') { - textLine = options.placeholder; - } - out.textLine = textLine; - out.isTruncated = true; -} -function estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) { - var width = 0; - var i = 0; - for (var len = text.length; i < len && width < contentWidth; i++) { - var charCode = text.charCodeAt(i); - width += (0 <= charCode && charCode <= 127) ? ascCharWidth : cnCharWidth; - } - return i; -} -function parsePlainText(text, style) { - text != null && (text += ''); - var overflow = style.overflow; - var padding = style.padding; - var font = style.font; - var truncate = overflow === 'truncate'; - var calculatedLineHeight = getLineHeight(font); - var lineHeight = retrieve2(style.lineHeight, calculatedLineHeight); - var bgColorDrawn = !!(style.backgroundColor); - var truncateLineOverflow = style.lineOverflow === 'truncate'; - var isTruncated = false; - var width = style.width; - var lines; - if (width != null && (overflow === 'break' || overflow === 'breakAll')) { - lines = text ? wrapText(text, style.font, width, overflow === 'breakAll', 0).lines : []; - } - else { - lines = text ? text.split('\n') : []; - } - var contentHeight = lines.length * lineHeight; - var height = retrieve2(style.height, contentHeight); - if (contentHeight > height && truncateLineOverflow) { - var lineCount = Math.floor(height / lineHeight); - isTruncated = isTruncated || (lines.length > lineCount); - lines = lines.slice(0, lineCount); - } - if (text && truncate && width != null) { - var options = prepareTruncateOptions(width, font, style.ellipsis, { - minChar: style.truncateMinChar, - placeholder: style.placeholder - }); - var singleOut = {}; - for (var i = 0; i < lines.length; i++) { - truncateSingleLine(singleOut, lines[i], options); - lines[i] = singleOut.textLine; - isTruncated = isTruncated || singleOut.isTruncated; - } - } - var outerHeight = height; - var contentWidth = 0; - for (var i = 0; i < lines.length; i++) { - contentWidth = Math.max(getWidth(lines[i], font), contentWidth); - } - if (width == null) { - width = contentWidth; - } - var outerWidth = contentWidth; - if (padding) { - outerHeight += padding[0] + padding[2]; - outerWidth += padding[1] + padding[3]; - width += padding[1] + padding[3]; - } - if (bgColorDrawn) { - outerWidth = width; - } - return { - lines: lines, - height: height, - outerWidth: outerWidth, - outerHeight: outerHeight, - lineHeight: lineHeight, - calculatedLineHeight: calculatedLineHeight, - contentWidth: contentWidth, - contentHeight: contentHeight, - width: width, - isTruncated: isTruncated - }; -} -var RichTextToken = (function () { - function RichTextToken() { - } - return RichTextToken; -}()); -var RichTextLine = (function () { - function RichTextLine(tokens) { - this.tokens = []; - if (tokens) { - this.tokens = tokens; - } - } - return RichTextLine; -}()); -var RichTextContentBlock = (function () { - function RichTextContentBlock() { - this.width = 0; - this.height = 0; - this.contentWidth = 0; - this.contentHeight = 0; - this.outerWidth = 0; - this.outerHeight = 0; - this.lines = []; - this.isTruncated = false; - } - return RichTextContentBlock; -}()); -function parseRichText(text, style) { - var contentBlock = new RichTextContentBlock(); - text != null && (text += ''); - if (!text) { - return contentBlock; - } - var topWidth = style.width; - var topHeight = style.height; - var overflow = style.overflow; - var wrapInfo = (overflow === 'break' || overflow === 'breakAll') && topWidth != null - ? { width: topWidth, accumWidth: 0, breakAll: overflow === 'breakAll' } - : null; - var lastIndex = STYLE_REG.lastIndex = 0; - var result; - while ((result = STYLE_REG.exec(text)) != null) { - var matchedIndex = result.index; - if (matchedIndex > lastIndex) { - pushTokens(contentBlock, text.substring(lastIndex, matchedIndex), style, wrapInfo); - } - pushTokens(contentBlock, result[2], style, wrapInfo, result[1]); - lastIndex = STYLE_REG.lastIndex; - } - if (lastIndex < text.length) { - pushTokens(contentBlock, text.substring(lastIndex, text.length), style, wrapInfo); - } - var pendingList = []; - var calculatedHeight = 0; - var calculatedWidth = 0; - var stlPadding = style.padding; - var truncate = overflow === 'truncate'; - var truncateLine = style.lineOverflow === 'truncate'; - var tmpTruncateOut = {}; - function finishLine(line, lineWidth, lineHeight) { - line.width = lineWidth; - line.lineHeight = lineHeight; - calculatedHeight += lineHeight; - calculatedWidth = Math.max(calculatedWidth, lineWidth); - } - outer: for (var i = 0; i < contentBlock.lines.length; i++) { - var line = contentBlock.lines[i]; - var lineHeight = 0; - var lineWidth = 0; - for (var j = 0; j < line.tokens.length; j++) { - var token = line.tokens[j]; - var tokenStyle = token.styleName && style.rich[token.styleName] || {}; - var textPadding = token.textPadding = tokenStyle.padding; - var paddingH = textPadding ? textPadding[1] + textPadding[3] : 0; - var font = token.font = tokenStyle.font || style.font; - token.contentHeight = getLineHeight(font); - var tokenHeight = retrieve2(tokenStyle.height, token.contentHeight); - token.innerHeight = tokenHeight; - textPadding && (tokenHeight += textPadding[0] + textPadding[2]); - token.height = tokenHeight; - token.lineHeight = retrieve3(tokenStyle.lineHeight, style.lineHeight, tokenHeight); - token.align = tokenStyle && tokenStyle.align || style.align; - token.verticalAlign = tokenStyle && tokenStyle.verticalAlign || 'middle'; - if (truncateLine && topHeight != null && calculatedHeight + token.lineHeight > topHeight) { - var originalLength = contentBlock.lines.length; - if (j > 0) { - line.tokens = line.tokens.slice(0, j); - finishLine(line, lineWidth, lineHeight); - contentBlock.lines = contentBlock.lines.slice(0, i + 1); - } - else { - contentBlock.lines = contentBlock.lines.slice(0, i); - } - contentBlock.isTruncated = contentBlock.isTruncated || (contentBlock.lines.length < originalLength); - break outer; - } - var styleTokenWidth = tokenStyle.width; - var tokenWidthNotSpecified = styleTokenWidth == null || styleTokenWidth === 'auto'; - if (typeof styleTokenWidth === 'string' && styleTokenWidth.charAt(styleTokenWidth.length - 1) === '%') { - token.percentWidth = styleTokenWidth; - pendingList.push(token); - token.contentWidth = getWidth(token.text, font); - } - else { - if (tokenWidthNotSpecified) { - var textBackgroundColor = tokenStyle.backgroundColor; - var bgImg = textBackgroundColor && textBackgroundColor.image; - if (bgImg) { - bgImg = findExistImage(bgImg); - if (isImageReady(bgImg)) { - token.width = Math.max(token.width, bgImg.width * tokenHeight / bgImg.height); - } - } - } - var remainTruncWidth = truncate && topWidth != null - ? topWidth - lineWidth : null; - if (remainTruncWidth != null && remainTruncWidth < token.width) { - if (!tokenWidthNotSpecified || remainTruncWidth < paddingH) { - token.text = ''; - token.width = token.contentWidth = 0; - } - else { - truncateText2(tmpTruncateOut, token.text, remainTruncWidth - paddingH, font, style.ellipsis, { minChar: style.truncateMinChar }); - token.text = tmpTruncateOut.text; - contentBlock.isTruncated = contentBlock.isTruncated || tmpTruncateOut.isTruncated; - token.width = token.contentWidth = getWidth(token.text, font); - } - } - else { - token.contentWidth = getWidth(token.text, font); - } - } - token.width += paddingH; - lineWidth += token.width; - tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight)); - } - finishLine(line, lineWidth, lineHeight); - } - contentBlock.outerWidth = contentBlock.width = retrieve2(topWidth, calculatedWidth); - contentBlock.outerHeight = contentBlock.height = retrieve2(topHeight, calculatedHeight); - contentBlock.contentHeight = calculatedHeight; - contentBlock.contentWidth = calculatedWidth; - if (stlPadding) { - contentBlock.outerWidth += stlPadding[1] + stlPadding[3]; - contentBlock.outerHeight += stlPadding[0] + stlPadding[2]; - } - for (var i = 0; i < pendingList.length; i++) { - var token = pendingList[i]; - var percentWidth = token.percentWidth; - token.width = parseInt(percentWidth, 10) / 100 * contentBlock.width; - } - return contentBlock; -} -function pushTokens(block, str, style, wrapInfo, styleName) { - var isEmptyStr = str === ''; - var tokenStyle = styleName && style.rich[styleName] || {}; - var lines = block.lines; - var font = tokenStyle.font || style.font; - var newLine = false; - var strLines; - var linesWidths; - if (wrapInfo) { - var tokenPadding = tokenStyle.padding; - var tokenPaddingH = tokenPadding ? tokenPadding[1] + tokenPadding[3] : 0; - if (tokenStyle.width != null && tokenStyle.width !== 'auto') { - var outerWidth_1 = parsePercent$1(tokenStyle.width, wrapInfo.width) + tokenPaddingH; - if (lines.length > 0) { - if (outerWidth_1 + wrapInfo.accumWidth > wrapInfo.width) { - strLines = str.split('\n'); - newLine = true; - } - } - wrapInfo.accumWidth = outerWidth_1; - } - else { - var res = wrapText(str, font, wrapInfo.width, wrapInfo.breakAll, wrapInfo.accumWidth); - wrapInfo.accumWidth = res.accumWidth + tokenPaddingH; - linesWidths = res.linesWidths; - strLines = res.lines; - } - } - else { - strLines = str.split('\n'); - } - for (var i = 0; i < strLines.length; i++) { - var text = strLines[i]; - var token = new RichTextToken(); - token.styleName = styleName; - token.text = text; - token.isLineHolder = !text && !isEmptyStr; - if (typeof tokenStyle.width === 'number') { - token.width = tokenStyle.width; - } - else { - token.width = linesWidths - ? linesWidths[i] - : getWidth(text, font); - } - if (!i && !newLine) { - var tokens = (lines[lines.length - 1] || (lines[0] = new RichTextLine())).tokens; - var tokensLen = tokens.length; - (tokensLen === 1 && tokens[0].isLineHolder) - ? (tokens[0] = token) - : ((text || !tokensLen || isEmptyStr) && tokens.push(token)); - } - else { - lines.push(new RichTextLine([token])); - } - } -} -function isAlphabeticLetter(ch) { - var code = ch.charCodeAt(0); - return code >= 0x20 && code <= 0x24F - || code >= 0x370 && code <= 0x10FF - || code >= 0x1200 && code <= 0x13FF - || code >= 0x1E00 && code <= 0x206F; -} -var breakCharMap = reduce(',&?/;] '.split(''), function (obj, ch) { - obj[ch] = true; - return obj; -}, {}); -function isWordBreakChar(ch) { - if (isAlphabeticLetter(ch)) { - if (breakCharMap[ch]) { - return true; - } - return false; - } - return true; -} -function wrapText(text, font, lineWidth, isBreakAll, lastAccumWidth) { - var lines = []; - var linesWidths = []; - var line = ''; - var currentWord = ''; - var currentWordWidth = 0; - var accumWidth = 0; - for (var i = 0; i < text.length; i++) { - var ch = text.charAt(i); - if (ch === '\n') { - if (currentWord) { - line += currentWord; - accumWidth += currentWordWidth; - } - lines.push(line); - linesWidths.push(accumWidth); - line = ''; - currentWord = ''; - currentWordWidth = 0; - accumWidth = 0; - continue; - } - var chWidth = getWidth(ch, font); - var inWord = isBreakAll ? false : !isWordBreakChar(ch); - if (!lines.length - ? lastAccumWidth + accumWidth + chWidth > lineWidth - : accumWidth + chWidth > lineWidth) { - if (!accumWidth) { - if (inWord) { - lines.push(currentWord); - linesWidths.push(currentWordWidth); - currentWord = ch; - currentWordWidth = chWidth; - } - else { - lines.push(ch); - linesWidths.push(chWidth); - } - } - else if (line || currentWord) { - if (inWord) { - if (!line) { - line = currentWord; - currentWord = ''; - currentWordWidth = 0; - accumWidth = currentWordWidth; - } - lines.push(line); - linesWidths.push(accumWidth - currentWordWidth); - currentWord += ch; - currentWordWidth += chWidth; - line = ''; - accumWidth = currentWordWidth; - } - else { - if (currentWord) { - line += currentWord; - currentWord = ''; - currentWordWidth = 0; - } - lines.push(line); - linesWidths.push(accumWidth); - line = ch; - accumWidth = chWidth; - } - } - continue; - } - accumWidth += chWidth; - if (inWord) { - currentWord += ch; - currentWordWidth += chWidth; - } - else { - if (currentWord) { - line += currentWord; - currentWord = ''; - currentWordWidth = 0; - } - line += ch; - } - } - if (!lines.length && !line) { - line = text; - currentWord = ''; - currentWordWidth = 0; - } - if (currentWord) { - line += currentWord; - } - if (line) { - lines.push(line); - linesWidths.push(accumWidth); - } - if (lines.length === 1) { - accumWidth += lastAccumWidth; - } - return { - accumWidth: accumWidth, - lines: lines, - linesWidths: linesWidths - }; -} - -var STYLE_MAGIC_KEY = '__zr_style_' + Math.round((Math.random() * 10)); -var DEFAULT_COMMON_STYLE = { - shadowBlur: 0, - shadowOffsetX: 0, - shadowOffsetY: 0, - shadowColor: '#000', - opacity: 1, - blend: 'source-over' -}; -var DEFAULT_COMMON_ANIMATION_PROPS = { - style: { - shadowBlur: true, - shadowOffsetX: true, - shadowOffsetY: true, - shadowColor: true, - opacity: true - } -}; -DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true; -var PRIMARY_STATES_KEYS = ['z', 'z2', 'invisible']; -var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ['invisible']; -var Displayable = (function (_super) { - __extends(Displayable, _super); - function Displayable(props) { - return _super.call(this, props) || this; - } - Displayable.prototype._init = function (props) { - var keysArr = keys(props); - for (var i = 0; i < keysArr.length; i++) { - var key = keysArr[i]; - if (key === 'style') { - this.useStyle(props[key]); - } - else { - _super.prototype.attrKV.call(this, key, props[key]); - } - } - if (!this.style) { - this.useStyle({}); - } - }; - Displayable.prototype.beforeBrush = function () { }; - Displayable.prototype.afterBrush = function () { }; - Displayable.prototype.innerBeforeBrush = function () { }; - Displayable.prototype.innerAfterBrush = function () { }; - Displayable.prototype.shouldBePainted = function (viewWidth, viewHeight, considerClipPath, considerAncestors) { - var m = this.transform; - if (this.ignore - || this.invisible - || this.style.opacity === 0 - || (this.culling - && isDisplayableCulled(this, viewWidth, viewHeight)) - || (m && !m[0] && !m[3])) { - return false; - } - if (considerClipPath && this.__clipPaths) { - for (var i = 0; i < this.__clipPaths.length; ++i) { - if (this.__clipPaths[i].isZeroArea()) { - return false; - } - } - } - if (considerAncestors && this.parent) { - var parent_1 = this.parent; - while (parent_1) { - if (parent_1.ignore) { - return false; - } - parent_1 = parent_1.parent; - } - } - return true; - }; - Displayable.prototype.contain = function (x, y) { - return this.rectContain(x, y); - }; - Displayable.prototype.traverse = function (cb, context) { - cb.call(context, this); - }; - Displayable.prototype.rectContain = function (x, y) { - var coord = this.transformCoordToLocal(x, y); - var rect = this.getBoundingRect(); - return rect.contain(coord[0], coord[1]); - }; - Displayable.prototype.getPaintRect = function () { - var rect = this._paintRect; - if (!this._paintRect || this.__dirty) { - var transform = this.transform; - var elRect = this.getBoundingRect(); - var style = this.style; - var shadowSize = style.shadowBlur || 0; - var shadowOffsetX = style.shadowOffsetX || 0; - var shadowOffsetY = style.shadowOffsetY || 0; - rect = this._paintRect || (this._paintRect = new BoundingRect(0, 0, 0, 0)); - if (transform) { - BoundingRect.applyTransform(rect, elRect, transform); - } - else { - rect.copy(elRect); - } - if (shadowSize || shadowOffsetX || shadowOffsetY) { - rect.width += shadowSize * 2 + Math.abs(shadowOffsetX); - rect.height += shadowSize * 2 + Math.abs(shadowOffsetY); - rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize); - rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize); - } - var tolerance = this.dirtyRectTolerance; - if (!rect.isZero()) { - rect.x = Math.floor(rect.x - tolerance); - rect.y = Math.floor(rect.y - tolerance); - rect.width = Math.ceil(rect.width + 1 + tolerance * 2); - rect.height = Math.ceil(rect.height + 1 + tolerance * 2); - } - } - return rect; - }; - Displayable.prototype.setPrevPaintRect = function (paintRect) { - if (paintRect) { - this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0); - this._prevPaintRect.copy(paintRect); - } - else { - this._prevPaintRect = null; - } - }; - Displayable.prototype.getPrevPaintRect = function () { - return this._prevPaintRect; - }; - Displayable.prototype.animateStyle = function (loop) { - return this.animate('style', loop); - }; - Displayable.prototype.updateDuringAnimation = function (targetKey) { - if (targetKey === 'style') { - this.dirtyStyle(); - } - else { - this.markRedraw(); - } - }; - Displayable.prototype.attrKV = function (key, value) { - if (key !== 'style') { - _super.prototype.attrKV.call(this, key, value); - } - else { - if (!this.style) { - this.useStyle(value); - } - else { - this.setStyle(value); - } - } - }; - Displayable.prototype.setStyle = function (keyOrObj, value) { - if (typeof keyOrObj === 'string') { - this.style[keyOrObj] = value; - } - else { - extend(this.style, keyOrObj); - } - this.dirtyStyle(); - return this; - }; - Displayable.prototype.dirtyStyle = function (notRedraw) { - if (!notRedraw) { - this.markRedraw(); - } - this.__dirty |= STYLE_CHANGED_BIT; - if (this._rect) { - this._rect = null; - } - }; - Displayable.prototype.dirty = function () { - this.dirtyStyle(); - }; - Displayable.prototype.styleChanged = function () { - return !!(this.__dirty & STYLE_CHANGED_BIT); - }; - Displayable.prototype.styleUpdated = function () { - this.__dirty &= -3; - }; - Displayable.prototype.createStyle = function (obj) { - return createObject(DEFAULT_COMMON_STYLE, obj); - }; - Displayable.prototype.useStyle = function (obj) { - if (!obj[STYLE_MAGIC_KEY]) { - obj = this.createStyle(obj); - } - if (this.__inHover) { - this.__hoverStyle = obj; - } - else { - this.style = obj; - } - this.dirtyStyle(); - }; - Displayable.prototype.isStyleObject = function (obj) { - return obj[STYLE_MAGIC_KEY]; - }; - Displayable.prototype._innerSaveToNormal = function (toState) { - _super.prototype._innerSaveToNormal.call(this, toState); - var normalState = this._normalState; - if (toState.style && !normalState.style) { - normalState.style = this._mergeStyle(this.createStyle(), this.style); - } - this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS); - }; - Displayable.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) { - _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg); - var needsRestoreToNormal = !(state && keepCurrentStates); - var targetStyle; - if (state && state.style) { - if (transition) { - if (keepCurrentStates) { - targetStyle = state.style; - } - else { - targetStyle = this._mergeStyle(this.createStyle(), normalState.style); - this._mergeStyle(targetStyle, state.style); - } - } - else { - targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style); - this._mergeStyle(targetStyle, state.style); - } - } - else if (needsRestoreToNormal) { - targetStyle = normalState.style; - } - if (targetStyle) { - if (transition) { - var sourceStyle = this.style; - this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle); - if (needsRestoreToNormal) { - var changedKeys = keys(sourceStyle); - for (var i = 0; i < changedKeys.length; i++) { - var key = changedKeys[i]; - if (key in targetStyle) { - targetStyle[key] = targetStyle[key]; - this.style[key] = sourceStyle[key]; - } - } - } - var targetKeys = keys(targetStyle); - for (var i = 0; i < targetKeys.length; i++) { - var key = targetKeys[i]; - this.style[key] = this.style[key]; - } - this._transitionState(stateName, { - style: targetStyle - }, animationCfg, this.getAnimationStyleProps()); - } - else { - this.useStyle(targetStyle); - } - } - var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS; - for (var i = 0; i < statesKeys.length; i++) { - var key = statesKeys[i]; - if (state && state[key] != null) { - this[key] = state[key]; - } - else if (needsRestoreToNormal) { - if (normalState[key] != null) { - this[key] = normalState[key]; - } - } - } - }; - Displayable.prototype._mergeStates = function (states) { - var mergedState = _super.prototype._mergeStates.call(this, states); - var mergedStyle; - for (var i = 0; i < states.length; i++) { - var state = states[i]; - if (state.style) { - mergedStyle = mergedStyle || {}; - this._mergeStyle(mergedStyle, state.style); - } - } - if (mergedStyle) { - mergedState.style = mergedStyle; - } - return mergedState; - }; - Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) { - extend(targetStyle, sourceStyle); - return targetStyle; - }; - Displayable.prototype.getAnimationStyleProps = function () { - return DEFAULT_COMMON_ANIMATION_PROPS; - }; - Displayable.initDefaultProps = (function () { - var dispProto = Displayable.prototype; - dispProto.type = 'displayable'; - dispProto.invisible = false; - dispProto.z = 0; - dispProto.z2 = 0; - dispProto.zlevel = 0; - dispProto.culling = false; - dispProto.cursor = 'pointer'; - dispProto.rectHover = false; - dispProto.incremental = false; - dispProto._rect = null; - dispProto.dirtyRectTolerance = 0; - dispProto.__dirty = REDRAW_BIT | STYLE_CHANGED_BIT; - })(); - return Displayable; -}(Element)); -var tmpRect = new BoundingRect(0, 0, 0, 0); -var viewRect = new BoundingRect(0, 0, 0, 0); -function isDisplayableCulled(el, width, height) { - tmpRect.copy(el.getBoundingRect()); - if (el.transform) { - tmpRect.applyTransform(el.transform); - } - viewRect.width = width; - viewRect.height = height; - return !tmpRect.intersect(viewRect); -} - -var mathMin$4 = Math.min; -var mathMax$4 = Math.max; -var mathSin$3 = Math.sin; -var mathCos$3 = Math.cos; -var PI2$6 = Math.PI * 2; -var start = create$1(); -var end = create$1(); -var extremity = create$1(); -function fromLine(x0, y0, x1, y1, min, max) { - min[0] = mathMin$4(x0, x1); - min[1] = mathMin$4(y0, y1); - max[0] = mathMax$4(x0, x1); - max[1] = mathMax$4(y0, y1); -} -var xDim = []; -var yDim = []; -function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) { - var cubicExtrema$1 = cubicExtrema; - var cubicAt$1 = cubicAt; - var n = cubicExtrema$1(x0, x1, x2, x3, xDim); - min[0] = Infinity; - min[1] = Infinity; - max[0] = -Infinity; - max[1] = -Infinity; - for (var i = 0; i < n; i++) { - var x = cubicAt$1(x0, x1, x2, x3, xDim[i]); - min[0] = mathMin$4(x, min[0]); - max[0] = mathMax$4(x, max[0]); - } - n = cubicExtrema$1(y0, y1, y2, y3, yDim); - for (var i = 0; i < n; i++) { - var y = cubicAt$1(y0, y1, y2, y3, yDim[i]); - min[1] = mathMin$4(y, min[1]); - max[1] = mathMax$4(y, max[1]); - } - min[0] = mathMin$4(x0, min[0]); - max[0] = mathMax$4(x0, max[0]); - min[0] = mathMin$4(x3, min[0]); - max[0] = mathMax$4(x3, max[0]); - min[1] = mathMin$4(y0, min[1]); - max[1] = mathMax$4(y0, max[1]); - min[1] = mathMin$4(y3, min[1]); - max[1] = mathMax$4(y3, max[1]); -} -function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) { - var quadraticExtremum$1 = quadraticExtremum; - var quadraticAt$1 = quadraticAt; - var tx = mathMax$4(mathMin$4(quadraticExtremum$1(x0, x1, x2), 1), 0); - var ty = mathMax$4(mathMin$4(quadraticExtremum$1(y0, y1, y2), 1), 0); - var x = quadraticAt$1(x0, x1, x2, tx); - var y = quadraticAt$1(y0, y1, y2, ty); - min[0] = mathMin$4(x0, x2, x); - min[1] = mathMin$4(y0, y2, y); - max[0] = mathMax$4(x0, x2, x); - max[1] = mathMax$4(y0, y2, y); -} -function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min, max) { - var vec2Min = min$1; - var vec2Max = max$1; - var diff = Math.abs(startAngle - endAngle); - if (diff % PI2$6 < 1e-4 && diff > 1e-4) { - min[0] = x - rx; - min[1] = y - ry; - max[0] = x + rx; - max[1] = y + ry; - return; - } - start[0] = mathCos$3(startAngle) * rx + x; - start[1] = mathSin$3(startAngle) * ry + y; - end[0] = mathCos$3(endAngle) * rx + x; - end[1] = mathSin$3(endAngle) * ry + y; - vec2Min(min, start, end); - vec2Max(max, start, end); - startAngle = startAngle % (PI2$6); - if (startAngle < 0) { - startAngle = startAngle + PI2$6; - } - endAngle = endAngle % (PI2$6); - if (endAngle < 0) { - endAngle = endAngle + PI2$6; - } - if (startAngle > endAngle && !anticlockwise) { - endAngle += PI2$6; - } - else if (startAngle < endAngle && anticlockwise) { - startAngle += PI2$6; - } - if (anticlockwise) { - var tmp = endAngle; - endAngle = startAngle; - startAngle = tmp; - } - for (var angle = 0; angle < endAngle; angle += Math.PI / 2) { - if (angle > startAngle) { - extremity[0] = mathCos$3(angle) * rx + x; - extremity[1] = mathSin$3(angle) * ry + y; - vec2Min(min, extremity, min); - vec2Max(max, extremity, max); - } - } -} - -var CMD$2 = { - M: 1, - L: 2, - C: 3, - Q: 4, - A: 5, - Z: 6, - R: 7 -}; -var tmpOutX = []; -var tmpOutY = []; -var min = []; -var max = []; -var min2 = []; -var max2 = []; -var mathMin$3 = Math.min; -var mathMax$3 = Math.max; -var mathCos$2 = Math.cos; -var mathSin$2 = Math.sin; -var mathAbs$1 = Math.abs; -var PI$4 = Math.PI; -var PI2$5 = PI$4 * 2; -var hasTypedArray = typeof Float32Array !== 'undefined'; -var tmpAngles = []; -function modPI2(radian) { - var n = Math.round(radian / PI$4 * 1e8) / 1e8; - return (n % 2) * PI$4; -} -function normalizeArcAngles(angles, anticlockwise) { - var newStartAngle = modPI2(angles[0]); - if (newStartAngle < 0) { - newStartAngle += PI2$5; - } - var delta = newStartAngle - angles[0]; - var newEndAngle = angles[1]; - newEndAngle += delta; - if (!anticlockwise && newEndAngle - newStartAngle >= PI2$5) { - newEndAngle = newStartAngle + PI2$5; - } - else if (anticlockwise && newStartAngle - newEndAngle >= PI2$5) { - newEndAngle = newStartAngle - PI2$5; - } - else if (!anticlockwise && newStartAngle > newEndAngle) { - newEndAngle = newStartAngle + (PI2$5 - modPI2(newStartAngle - newEndAngle)); - } - else if (anticlockwise && newStartAngle < newEndAngle) { - newEndAngle = newStartAngle - (PI2$5 - modPI2(newEndAngle - newStartAngle)); - } - angles[0] = newStartAngle; - angles[1] = newEndAngle; -} -var PathProxy = (function () { - function PathProxy(notSaveData) { - this.dpr = 1; - this._xi = 0; - this._yi = 0; - this._x0 = 0; - this._y0 = 0; - this._len = 0; - if (notSaveData) { - this._saveData = false; - } - if (this._saveData) { - this.data = []; - } - } - PathProxy.prototype.increaseVersion = function () { - this._version++; - }; - PathProxy.prototype.getVersion = function () { - return this._version; - }; - PathProxy.prototype.setScale = function (sx, sy, segmentIgnoreThreshold) { - segmentIgnoreThreshold = segmentIgnoreThreshold || 0; - if (segmentIgnoreThreshold > 0) { - this._ux = mathAbs$1(segmentIgnoreThreshold / devicePixelRatio / sx) || 0; - this._uy = mathAbs$1(segmentIgnoreThreshold / devicePixelRatio / sy) || 0; - } - }; - PathProxy.prototype.setDPR = function (dpr) { - this.dpr = dpr; - }; - PathProxy.prototype.setContext = function (ctx) { - this._ctx = ctx; - }; - PathProxy.prototype.getContext = function () { - return this._ctx; - }; - PathProxy.prototype.beginPath = function () { - this._ctx && this._ctx.beginPath(); - this.reset(); - return this; - }; - PathProxy.prototype.reset = function () { - if (this._saveData) { - this._len = 0; - } - if (this._pathSegLen) { - this._pathSegLen = null; - this._pathLen = 0; - } - this._version++; - }; - PathProxy.prototype.moveTo = function (x, y) { - this._drawPendingPt(); - this.addData(CMD$2.M, x, y); - this._ctx && this._ctx.moveTo(x, y); - this._x0 = x; - this._y0 = y; - this._xi = x; - this._yi = y; - return this; - }; - PathProxy.prototype.lineTo = function (x, y) { - var dx = mathAbs$1(x - this._xi); - var dy = mathAbs$1(y - this._yi); - var exceedUnit = dx > this._ux || dy > this._uy; - this.addData(CMD$2.L, x, y); - if (this._ctx && exceedUnit) { - this._ctx.lineTo(x, y); - } - if (exceedUnit) { - this._xi = x; - this._yi = y; - this._pendingPtDist = 0; - } - else { - var d2 = dx * dx + dy * dy; - if (d2 > this._pendingPtDist) { - this._pendingPtX = x; - this._pendingPtY = y; - this._pendingPtDist = d2; - } - } - return this; - }; - PathProxy.prototype.bezierCurveTo = function (x1, y1, x2, y2, x3, y3) { - this._drawPendingPt(); - this.addData(CMD$2.C, x1, y1, x2, y2, x3, y3); - if (this._ctx) { - this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3); - } - this._xi = x3; - this._yi = y3; - return this; - }; - PathProxy.prototype.quadraticCurveTo = function (x1, y1, x2, y2) { - this._drawPendingPt(); - this.addData(CMD$2.Q, x1, y1, x2, y2); - if (this._ctx) { - this._ctx.quadraticCurveTo(x1, y1, x2, y2); - } - this._xi = x2; - this._yi = y2; - return this; - }; - PathProxy.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) { - this._drawPendingPt(); - tmpAngles[0] = startAngle; - tmpAngles[1] = endAngle; - normalizeArcAngles(tmpAngles, anticlockwise); - startAngle = tmpAngles[0]; - endAngle = tmpAngles[1]; - var delta = endAngle - startAngle; - this.addData(CMD$2.A, cx, cy, r, r, startAngle, delta, 0, anticlockwise ? 0 : 1); - this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise); - this._xi = mathCos$2(endAngle) * r + cx; - this._yi = mathSin$2(endAngle) * r + cy; - return this; - }; - PathProxy.prototype.arcTo = function (x1, y1, x2, y2, radius) { - this._drawPendingPt(); - if (this._ctx) { - this._ctx.arcTo(x1, y1, x2, y2, radius); - } - return this; - }; - PathProxy.prototype.rect = function (x, y, w, h) { - this._drawPendingPt(); - this._ctx && this._ctx.rect(x, y, w, h); - this.addData(CMD$2.R, x, y, w, h); - return this; - }; - PathProxy.prototype.closePath = function () { - this._drawPendingPt(); - this.addData(CMD$2.Z); - var ctx = this._ctx; - var x0 = this._x0; - var y0 = this._y0; - if (ctx) { - ctx.closePath(); - } - this._xi = x0; - this._yi = y0; - return this; - }; - PathProxy.prototype.fill = function (ctx) { - ctx && ctx.fill(); - this.toStatic(); - }; - PathProxy.prototype.stroke = function (ctx) { - ctx && ctx.stroke(); - this.toStatic(); - }; - PathProxy.prototype.len = function () { - return this._len; - }; - PathProxy.prototype.setData = function (data) { - var len = data.length; - if (!(this.data && this.data.length === len) && hasTypedArray) { - this.data = new Float32Array(len); - } - for (var i = 0; i < len; i++) { - this.data[i] = data[i]; - } - this._len = len; - }; - PathProxy.prototype.appendPath = function (path) { - if (!(path instanceof Array)) { - path = [path]; - } - var len = path.length; - var appendSize = 0; - var offset = this._len; - for (var i = 0; i < len; i++) { - appendSize += path[i].len(); - } - if (hasTypedArray && (this.data instanceof Float32Array)) { - this.data = new Float32Array(offset + appendSize); - } - for (var i = 0; i < len; i++) { - var appendPathData = path[i].data; - for (var k = 0; k < appendPathData.length; k++) { - this.data[offset++] = appendPathData[k]; - } - } - this._len = offset; - }; - PathProxy.prototype.addData = function (cmd, a, b, c, d, e, f, g, h) { - if (!this._saveData) { - return; - } - var data = this.data; - if (this._len + arguments.length > data.length) { - this._expandData(); - data = this.data; - } - for (var i = 0; i < arguments.length; i++) { - data[this._len++] = arguments[i]; - } - }; - PathProxy.prototype._drawPendingPt = function () { - if (this._pendingPtDist > 0) { - this._ctx && this._ctx.lineTo(this._pendingPtX, this._pendingPtY); - this._pendingPtDist = 0; - } - }; - PathProxy.prototype._expandData = function () { - if (!(this.data instanceof Array)) { - var newData = []; - for (var i = 0; i < this._len; i++) { - newData[i] = this.data[i]; - } - this.data = newData; - } - }; - PathProxy.prototype.toStatic = function () { - if (!this._saveData) { - return; - } - this._drawPendingPt(); - var data = this.data; - if (data instanceof Array) { - data.length = this._len; - if (hasTypedArray && this._len > 11) { - this.data = new Float32Array(data); - } - } - }; - PathProxy.prototype.getBoundingRect = function () { - min[0] = min[1] = min2[0] = min2[1] = Number.MAX_VALUE; - max[0] = max[1] = max2[0] = max2[1] = -Number.MAX_VALUE; - var data = this.data; - var xi = 0; - var yi = 0; - var x0 = 0; - var y0 = 0; - var i; - for (i = 0; i < this._len;) { - var cmd = data[i++]; - var isFirst = i === 1; - if (isFirst) { - xi = data[i]; - yi = data[i + 1]; - x0 = xi; - y0 = yi; - } - switch (cmd) { - case CMD$2.M: - xi = x0 = data[i++]; - yi = y0 = data[i++]; - min2[0] = x0; - min2[1] = y0; - max2[0] = x0; - max2[1] = y0; - break; - case CMD$2.L: - fromLine(xi, yi, data[i], data[i + 1], min2, max2); - xi = data[i++]; - yi = data[i++]; - break; - case CMD$2.C: - fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2); - xi = data[i++]; - yi = data[i++]; - break; - case CMD$2.Q: - fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2); - xi = data[i++]; - yi = data[i++]; - break; - case CMD$2.A: - var cx = data[i++]; - var cy = data[i++]; - var rx = data[i++]; - var ry = data[i++]; - var startAngle = data[i++]; - var endAngle = data[i++] + startAngle; - i += 1; - var anticlockwise = !data[i++]; - if (isFirst) { - x0 = mathCos$2(startAngle) * rx + cx; - y0 = mathSin$2(startAngle) * ry + cy; - } - fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2); - xi = mathCos$2(endAngle) * rx + cx; - yi = mathSin$2(endAngle) * ry + cy; - break; - case CMD$2.R: - x0 = xi = data[i++]; - y0 = yi = data[i++]; - var width = data[i++]; - var height = data[i++]; - fromLine(x0, y0, x0 + width, y0 + height, min2, max2); - break; - case CMD$2.Z: - xi = x0; - yi = y0; - break; - } - min$1(min, min, min2); - max$1(max, max, max2); - } - if (i === 0) { - min[0] = min[1] = max[0] = max[1] = 0; - } - return new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]); - }; - PathProxy.prototype._calculateLength = function () { - var data = this.data; - var len = this._len; - var ux = this._ux; - var uy = this._uy; - var xi = 0; - var yi = 0; - var x0 = 0; - var y0 = 0; - if (!this._pathSegLen) { - this._pathSegLen = []; - } - var pathSegLen = this._pathSegLen; - var pathTotalLen = 0; - var segCount = 0; - for (var i = 0; i < len;) { - var cmd = data[i++]; - var isFirst = i === 1; - if (isFirst) { - xi = data[i]; - yi = data[i + 1]; - x0 = xi; - y0 = yi; - } - var l = -1; - switch (cmd) { - case CMD$2.M: - xi = x0 = data[i++]; - yi = y0 = data[i++]; - break; - case CMD$2.L: { - var x2 = data[i++]; - var y2 = data[i++]; - var dx = x2 - xi; - var dy = y2 - yi; - if (mathAbs$1(dx) > ux || mathAbs$1(dy) > uy || i === len - 1) { - l = Math.sqrt(dx * dx + dy * dy); - xi = x2; - yi = y2; - } - break; - } - case CMD$2.C: { - var x1 = data[i++]; - var y1 = data[i++]; - var x2 = data[i++]; - var y2 = data[i++]; - var x3 = data[i++]; - var y3 = data[i++]; - l = cubicLength(xi, yi, x1, y1, x2, y2, x3, y3, 10); - xi = x3; - yi = y3; - break; - } - case CMD$2.Q: { - var x1 = data[i++]; - var y1 = data[i++]; - var x2 = data[i++]; - var y2 = data[i++]; - l = quadraticLength(xi, yi, x1, y1, x2, y2, 10); - xi = x2; - yi = y2; - break; - } - case CMD$2.A: - var cx = data[i++]; - var cy = data[i++]; - var rx = data[i++]; - var ry = data[i++]; - var startAngle = data[i++]; - var delta = data[i++]; - var endAngle = delta + startAngle; - i += 1; - if (isFirst) { - x0 = mathCos$2(startAngle) * rx + cx; - y0 = mathSin$2(startAngle) * ry + cy; - } - l = mathMax$3(rx, ry) * mathMin$3(PI2$5, Math.abs(delta)); - xi = mathCos$2(endAngle) * rx + cx; - yi = mathSin$2(endAngle) * ry + cy; - break; - case CMD$2.R: { - x0 = xi = data[i++]; - y0 = yi = data[i++]; - var width = data[i++]; - var height = data[i++]; - l = width * 2 + height * 2; - break; - } - case CMD$2.Z: { - var dx = x0 - xi; - var dy = y0 - yi; - l = Math.sqrt(dx * dx + dy * dy); - xi = x0; - yi = y0; - break; - } - } - if (l >= 0) { - pathSegLen[segCount++] = l; - pathTotalLen += l; - } - } - this._pathLen = pathTotalLen; - return pathTotalLen; - }; - PathProxy.prototype.rebuildPath = function (ctx, percent) { - var d = this.data; - var ux = this._ux; - var uy = this._uy; - var len = this._len; - var x0; - var y0; - var xi; - var yi; - var x; - var y; - var drawPart = percent < 1; - var pathSegLen; - var pathTotalLen; - var accumLength = 0; - var segCount = 0; - var displayedLength; - var pendingPtDist = 0; - var pendingPtX; - var pendingPtY; - if (drawPart) { - if (!this._pathSegLen) { - this._calculateLength(); - } - pathSegLen = this._pathSegLen; - pathTotalLen = this._pathLen; - displayedLength = percent * pathTotalLen; - if (!displayedLength) { - return; - } - } - lo: for (var i = 0; i < len;) { - var cmd = d[i++]; - var isFirst = i === 1; - if (isFirst) { - xi = d[i]; - yi = d[i + 1]; - x0 = xi; - y0 = yi; - } - if (cmd !== CMD$2.L && pendingPtDist > 0) { - ctx.lineTo(pendingPtX, pendingPtY); - pendingPtDist = 0; - } - switch (cmd) { - case CMD$2.M: - x0 = xi = d[i++]; - y0 = yi = d[i++]; - ctx.moveTo(xi, yi); - break; - case CMD$2.L: { - x = d[i++]; - y = d[i++]; - var dx = mathAbs$1(x - xi); - var dy = mathAbs$1(y - yi); - if (dx > ux || dy > uy) { - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - var t = (displayedLength - accumLength) / l; - ctx.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t); - break lo; - } - accumLength += l; - } - ctx.lineTo(x, y); - xi = x; - yi = y; - pendingPtDist = 0; - } - else { - var d2 = dx * dx + dy * dy; - if (d2 > pendingPtDist) { - pendingPtX = x; - pendingPtY = y; - pendingPtDist = d2; - } - } - break; - } - case CMD$2.C: { - var x1 = d[i++]; - var y1 = d[i++]; - var x2 = d[i++]; - var y2 = d[i++]; - var x3 = d[i++]; - var y3 = d[i++]; - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - var t = (displayedLength - accumLength) / l; - cubicSubdivide(xi, x1, x2, x3, t, tmpOutX); - cubicSubdivide(yi, y1, y2, y3, t, tmpOutY); - ctx.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]); - break lo; - } - accumLength += l; - } - ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3); - xi = x3; - yi = y3; - break; - } - case CMD$2.Q: { - var x1 = d[i++]; - var y1 = d[i++]; - var x2 = d[i++]; - var y2 = d[i++]; - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - var t = (displayedLength - accumLength) / l; - quadraticSubdivide(xi, x1, x2, t, tmpOutX); - quadraticSubdivide(yi, y1, y2, t, tmpOutY); - ctx.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]); - break lo; - } - accumLength += l; - } - ctx.quadraticCurveTo(x1, y1, x2, y2); - xi = x2; - yi = y2; - break; - } - case CMD$2.A: - var cx = d[i++]; - var cy = d[i++]; - var rx = d[i++]; - var ry = d[i++]; - var startAngle = d[i++]; - var delta = d[i++]; - var psi = d[i++]; - var anticlockwise = !d[i++]; - var r = (rx > ry) ? rx : ry; - var isEllipse = mathAbs$1(rx - ry) > 1e-3; - var endAngle = startAngle + delta; - var breakBuild = false; - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - endAngle = startAngle + delta * (displayedLength - accumLength) / l; - breakBuild = true; - } - accumLength += l; - } - if (isEllipse && ctx.ellipse) { - ctx.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise); - } - else { - ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise); - } - if (breakBuild) { - break lo; - } - if (isFirst) { - x0 = mathCos$2(startAngle) * rx + cx; - y0 = mathSin$2(startAngle) * ry + cy; - } - xi = mathCos$2(endAngle) * rx + cx; - yi = mathSin$2(endAngle) * ry + cy; - break; - case CMD$2.R: - x0 = xi = d[i]; - y0 = yi = d[i + 1]; - x = d[i++]; - y = d[i++]; - var width = d[i++]; - var height = d[i++]; - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - var d_1 = displayedLength - accumLength; - ctx.moveTo(x, y); - ctx.lineTo(x + mathMin$3(d_1, width), y); - d_1 -= width; - if (d_1 > 0) { - ctx.lineTo(x + width, y + mathMin$3(d_1, height)); - } - d_1 -= height; - if (d_1 > 0) { - ctx.lineTo(x + mathMax$3(width - d_1, 0), y + height); - } - d_1 -= width; - if (d_1 > 0) { - ctx.lineTo(x, y + mathMax$3(height - d_1, 0)); - } - break lo; - } - accumLength += l; - } - ctx.rect(x, y, width, height); - break; - case CMD$2.Z: - if (drawPart) { - var l = pathSegLen[segCount++]; - if (accumLength + l > displayedLength) { - var t = (displayedLength - accumLength) / l; - ctx.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t); - break lo; - } - accumLength += l; - } - ctx.closePath(); - xi = x0; - yi = y0; - } - } - }; - PathProxy.prototype.clone = function () { - var newProxy = new PathProxy(); - var data = this.data; - newProxy.data = data.slice ? data.slice() - : Array.prototype.slice.call(data); - newProxy._len = this._len; - return newProxy; - }; - PathProxy.CMD = CMD$2; - PathProxy.initDefaultProps = (function () { - var proto = PathProxy.prototype; - proto._saveData = true; - proto._ux = 0; - proto._uy = 0; - proto._pendingPtDist = 0; - proto._version = 0; - })(); - return PathProxy; -}()); - -function containStroke$4(x0, y0, x1, y1, lineWidth, x, y) { - if (lineWidth === 0) { - return false; - } - var _l = lineWidth; - var _a = 0; - var _b = x0; - if ((y > y0 + _l && y > y1 + _l) - || (y < y0 - _l && y < y1 - _l) - || (x > x0 + _l && x > x1 + _l) - || (x < x0 - _l && x < x1 - _l)) { - return false; - } - if (x0 !== x1) { - _a = (y0 - y1) / (x0 - x1); - _b = (x0 * y1 - x1 * y0) / (x0 - x1); - } - else { - return Math.abs(x - x0) <= _l / 2; - } - var tmp = _a * x - y + _b; - var _s = tmp * tmp / (_a * _a + 1); - return _s <= _l / 2 * _l / 2; -} - -function containStroke$3(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) { - if (lineWidth === 0) { - return false; - } - var _l = lineWidth; - if ((y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l) - || (y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l) - || (x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l) - || (x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l)) { - return false; - } - var d = cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y); - return d <= _l / 2; -} - -function containStroke$2(x0, y0, x1, y1, x2, y2, lineWidth, x, y) { - if (lineWidth === 0) { - return false; - } - var _l = lineWidth; - if ((y > y0 + _l && y > y1 + _l && y > y2 + _l) - || (y < y0 - _l && y < y1 - _l && y < y2 - _l) - || (x > x0 + _l && x > x1 + _l && x > x2 + _l) - || (x < x0 - _l && x < x1 - _l && x < x2 - _l)) { - return false; - } - var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y); - return d <= _l / 2; -} - -var PI2$4 = Math.PI * 2; -function normalizeRadian(angle) { - angle %= PI2$4; - if (angle < 0) { - angle += PI2$4; - } - return angle; -} - -var PI2$3 = Math.PI * 2; -function containStroke$1(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) { - if (lineWidth === 0) { - return false; - } - var _l = lineWidth; - x -= cx; - y -= cy; - var d = Math.sqrt(x * x + y * y); - if ((d - _l > r) || (d + _l < r)) { - return false; - } - if (Math.abs(startAngle - endAngle) % PI2$3 < 1e-4) { - return true; - } - if (anticlockwise) { - var tmp = startAngle; - startAngle = normalizeRadian(endAngle); - endAngle = normalizeRadian(tmp); - } - else { - startAngle = normalizeRadian(startAngle); - endAngle = normalizeRadian(endAngle); - } - if (startAngle > endAngle) { - endAngle += PI2$3; - } - var angle = Math.atan2(y, x); - if (angle < 0) { - angle += PI2$3; - } - return (angle >= startAngle && angle <= endAngle) - || (angle + PI2$3 >= startAngle && angle + PI2$3 <= endAngle); -} - -function windingLine(x0, y0, x1, y1, x, y) { - if ((y > y0 && y > y1) || (y < y0 && y < y1)) { - return 0; - } - if (y1 === y0) { - return 0; - } - var t = (y - y0) / (y1 - y0); - var dir = y1 < y0 ? 1 : -1; - if (t === 1 || t === 0) { - dir = y1 < y0 ? 0.5 : -0.5; - } - var x_ = t * (x1 - x0) + x0; - return x_ === x ? Infinity : x_ > x ? dir : 0; -} - -var CMD$1 = PathProxy.CMD; -var PI2$2 = Math.PI * 2; -var EPSILON = 1e-4; -function isAroundEqual(a, b) { - return Math.abs(a - b) < EPSILON; -} -var roots = [-1, -1, -1]; -var extrema = [-1, -1]; -function swapExtrema() { - var tmp = extrema[0]; - extrema[0] = extrema[1]; - extrema[1] = tmp; -} -function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) { - if ((y > y0 && y > y1 && y > y2 && y > y3) - || (y < y0 && y < y1 && y < y2 && y < y3)) { - return 0; - } - var nRoots = cubicRootAt(y0, y1, y2, y3, y, roots); - if (nRoots === 0) { - return 0; - } - else { - var w = 0; - var nExtrema = -1; - var y0_ = void 0; - var y1_ = void 0; - for (var i = 0; i < nRoots; i++) { - var t = roots[i]; - var unit = (t === 0 || t === 1) ? 0.5 : 1; - var x_ = cubicAt(x0, x1, x2, x3, t); - if (x_ < x) { - continue; - } - if (nExtrema < 0) { - nExtrema = cubicExtrema(y0, y1, y2, y3, extrema); - if (extrema[1] < extrema[0] && nExtrema > 1) { - swapExtrema(); - } - y0_ = cubicAt(y0, y1, y2, y3, extrema[0]); - if (nExtrema > 1) { - y1_ = cubicAt(y0, y1, y2, y3, extrema[1]); - } - } - if (nExtrema === 2) { - if (t < extrema[0]) { - w += y0_ < y0 ? unit : -unit; - } - else if (t < extrema[1]) { - w += y1_ < y0_ ? unit : -unit; - } - else { - w += y3 < y1_ ? unit : -unit; - } - } - else { - if (t < extrema[0]) { - w += y0_ < y0 ? unit : -unit; - } - else { - w += y3 < y0_ ? unit : -unit; - } - } - } - return w; - } -} -function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) { - if ((y > y0 && y > y1 && y > y2) - || (y < y0 && y < y1 && y < y2)) { - return 0; - } - var nRoots = quadraticRootAt(y0, y1, y2, y, roots); - if (nRoots === 0) { - return 0; - } - else { - var t = quadraticExtremum(y0, y1, y2); - if (t >= 0 && t <= 1) { - var w = 0; - var y_ = quadraticAt(y0, y1, y2, t); - for (var i = 0; i < nRoots; i++) { - var unit = (roots[i] === 0 || roots[i] === 1) ? 0.5 : 1; - var x_ = quadraticAt(x0, x1, x2, roots[i]); - if (x_ < x) { - continue; - } - if (roots[i] < t) { - w += y_ < y0 ? unit : -unit; - } - else { - w += y2 < y_ ? unit : -unit; - } - } - return w; - } - else { - var unit = (roots[0] === 0 || roots[0] === 1) ? 0.5 : 1; - var x_ = quadraticAt(x0, x1, x2, roots[0]); - if (x_ < x) { - return 0; - } - return y2 < y0 ? unit : -unit; - } - } -} -function windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) { - y -= cy; - if (y > r || y < -r) { - return 0; - } - var tmp = Math.sqrt(r * r - y * y); - roots[0] = -tmp; - roots[1] = tmp; - var dTheta = Math.abs(startAngle - endAngle); - if (dTheta < 1e-4) { - return 0; - } - if (dTheta >= PI2$2 - 1e-4) { - startAngle = 0; - endAngle = PI2$2; - var dir = anticlockwise ? 1 : -1; - if (x >= roots[0] + cx && x <= roots[1] + cx) { - return dir; - } - else { - return 0; - } - } - if (startAngle > endAngle) { - var tmp_1 = startAngle; - startAngle = endAngle; - endAngle = tmp_1; - } - if (startAngle < 0) { - startAngle += PI2$2; - endAngle += PI2$2; - } - var w = 0; - for (var i = 0; i < 2; i++) { - var x_ = roots[i]; - if (x_ + cx > x) { - var angle = Math.atan2(y, x_); - var dir = anticlockwise ? 1 : -1; - if (angle < 0) { - angle = PI2$2 + angle; - } - if ((angle >= startAngle && angle <= endAngle) - || (angle + PI2$2 >= startAngle && angle + PI2$2 <= endAngle)) { - if (angle > Math.PI / 2 && angle < Math.PI * 1.5) { - dir = -dir; - } - w += dir; - } - } - } - return w; -} -function containPath(path, lineWidth, isStroke, x, y) { - var data = path.data; - var len = path.len(); - var w = 0; - var xi = 0; - var yi = 0; - var x0 = 0; - var y0 = 0; - var x1; - var y1; - for (var i = 0; i < len;) { - var cmd = data[i++]; - var isFirst = i === 1; - if (cmd === CMD$1.M && i > 1) { - if (!isStroke) { - w += windingLine(xi, yi, x0, y0, x, y); - } - } - if (isFirst) { - xi = data[i]; - yi = data[i + 1]; - x0 = xi; - y0 = yi; - } - switch (cmd) { - case CMD$1.M: - x0 = data[i++]; - y0 = data[i++]; - xi = x0; - yi = y0; - break; - case CMD$1.L: - if (isStroke) { - if (containStroke$4(xi, yi, data[i], data[i + 1], lineWidth, x, y)) { - return true; - } - } - else { - w += windingLine(xi, yi, data[i], data[i + 1], x, y) || 0; - } - xi = data[i++]; - yi = data[i++]; - break; - case CMD$1.C: - if (isStroke) { - if (containStroke$3(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) { - return true; - } - } - else { - w += windingCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], x, y) || 0; - } - xi = data[i++]; - yi = data[i++]; - break; - case CMD$1.Q: - if (isStroke) { - if (containStroke$2(xi, yi, data[i++], data[i++], data[i], data[i + 1], lineWidth, x, y)) { - return true; - } - } - else { - w += windingQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], x, y) || 0; - } - xi = data[i++]; - yi = data[i++]; - break; - case CMD$1.A: - var cx = data[i++]; - var cy = data[i++]; - var rx = data[i++]; - var ry = data[i++]; - var theta = data[i++]; - var dTheta = data[i++]; - i += 1; - var anticlockwise = !!(1 - data[i++]); - x1 = Math.cos(theta) * rx + cx; - y1 = Math.sin(theta) * ry + cy; - if (!isFirst) { - w += windingLine(xi, yi, x1, y1, x, y); - } - else { - x0 = x1; - y0 = y1; - } - var _x = (x - cx) * ry / rx + cx; - if (isStroke) { - if (containStroke$1(cx, cy, ry, theta, theta + dTheta, anticlockwise, lineWidth, _x, y)) { - return true; - } - } - else { - w += windingArc(cx, cy, ry, theta, theta + dTheta, anticlockwise, _x, y); - } - xi = Math.cos(theta + dTheta) * rx + cx; - yi = Math.sin(theta + dTheta) * ry + cy; - break; - case CMD$1.R: - x0 = xi = data[i++]; - y0 = yi = data[i++]; - var width = data[i++]; - var height = data[i++]; - x1 = x0 + width; - y1 = y0 + height; - if (isStroke) { - if (containStroke$4(x0, y0, x1, y0, lineWidth, x, y) - || containStroke$4(x1, y0, x1, y1, lineWidth, x, y) - || containStroke$4(x1, y1, x0, y1, lineWidth, x, y) - || containStroke$4(x0, y1, x0, y0, lineWidth, x, y)) { - return true; - } - } - else { - w += windingLine(x1, y0, x1, y1, x, y); - w += windingLine(x0, y1, x0, y0, x, y); - } - break; - case CMD$1.Z: - if (isStroke) { - if (containStroke$4(xi, yi, x0, y0, lineWidth, x, y)) { - return true; - } - } - else { - w += windingLine(xi, yi, x0, y0, x, y); - } - xi = x0; - yi = y0; - break; - } - } - if (!isStroke && !isAroundEqual(yi, y0)) { - w += windingLine(xi, yi, x0, y0, x, y) || 0; - } - return w !== 0; -} -function contain$1(pathProxy, x, y) { - return containPath(pathProxy, 0, false, x, y); -} -function containStroke(pathProxy, lineWidth, x, y) { - return containPath(pathProxy, lineWidth, true, x, y); -} - -var DEFAULT_PATH_STYLE = defaults({ - fill: '#000', - stroke: null, - strokePercent: 1, - fillOpacity: 1, - strokeOpacity: 1, - lineDashOffset: 0, - lineWidth: 1, - lineCap: 'butt', - miterLimit: 10, - strokeNoScale: false, - strokeFirst: false -}, DEFAULT_COMMON_STYLE); -var DEFAULT_PATH_ANIMATION_PROPS = { - style: defaults({ - fill: true, - stroke: true, - strokePercent: true, - fillOpacity: true, - strokeOpacity: true, - lineDashOffset: true, - lineWidth: true, - miterLimit: true - }, DEFAULT_COMMON_ANIMATION_PROPS.style) -}; -var pathCopyParams = TRANSFORMABLE_PROPS.concat(['invisible', - 'culling', 'z', 'z2', 'zlevel', 'parent' -]); -var Path = (function (_super) { - __extends(Path, _super); - function Path(opts) { - return _super.call(this, opts) || this; - } - Path.prototype.update = function () { - var _this = this; - _super.prototype.update.call(this); - var style = this.style; - if (style.decal) { - var decalEl = this._decalEl = this._decalEl || new Path(); - if (decalEl.buildPath === Path.prototype.buildPath) { - decalEl.buildPath = function (ctx) { - _this.buildPath(ctx, _this.shape); - }; - } - decalEl.silent = true; - var decalElStyle = decalEl.style; - for (var key in style) { - if (decalElStyle[key] !== style[key]) { - decalElStyle[key] = style[key]; - } - } - decalElStyle.fill = style.fill ? style.decal : null; - decalElStyle.decal = null; - decalElStyle.shadowColor = null; - style.strokeFirst && (decalElStyle.stroke = null); - for (var i = 0; i < pathCopyParams.length; ++i) { - decalEl[pathCopyParams[i]] = this[pathCopyParams[i]]; - } - decalEl.__dirty |= REDRAW_BIT; - } - else if (this._decalEl) { - this._decalEl = null; - } - }; - Path.prototype.getDecalElement = function () { - return this._decalEl; - }; - Path.prototype._init = function (props) { - var keysArr = keys(props); - this.shape = this.getDefaultShape(); - var defaultStyle = this.getDefaultStyle(); - if (defaultStyle) { - this.useStyle(defaultStyle); - } - for (var i = 0; i < keysArr.length; i++) { - var key = keysArr[i]; - var value = props[key]; - if (key === 'style') { - if (!this.style) { - this.useStyle(value); - } - else { - extend(this.style, value); - } - } - else if (key === 'shape') { - extend(this.shape, value); - } - else { - _super.prototype.attrKV.call(this, key, value); - } - } - if (!this.style) { - this.useStyle({}); - } - }; - Path.prototype.getDefaultStyle = function () { - return null; - }; - Path.prototype.getDefaultShape = function () { - return {}; - }; - Path.prototype.canBeInsideText = function () { - return this.hasFill(); - }; - Path.prototype.getInsideTextFill = function () { - var pathFill = this.style.fill; - if (pathFill !== 'none') { - if (isString(pathFill)) { - var fillLum = lum(pathFill, 0); - if (fillLum > 0.5) { - return DARK_LABEL_COLOR; - } - else if (fillLum > 0.2) { - return LIGHTER_LABEL_COLOR; - } - return LIGHT_LABEL_COLOR; - } - else if (pathFill) { - return LIGHT_LABEL_COLOR; - } - } - return DARK_LABEL_COLOR; - }; - Path.prototype.getInsideTextStroke = function (textFill) { - var pathFill = this.style.fill; - if (isString(pathFill)) { - var zr = this.__zr; - var isDarkMode = !!(zr && zr.isDarkMode()); - var isDarkLabel = lum(textFill, 0) < DARK_MODE_THRESHOLD; - if (isDarkMode === isDarkLabel) { - return pathFill; - } - } - }; - Path.prototype.buildPath = function (ctx, shapeCfg, inBatch) { }; - Path.prototype.pathUpdated = function () { - this.__dirty &= -5; - }; - Path.prototype.getUpdatedPathProxy = function (inBatch) { - !this.path && this.createPathProxy(); - this.path.beginPath(); - this.buildPath(this.path, this.shape, inBatch); - return this.path; - }; - Path.prototype.createPathProxy = function () { - this.path = new PathProxy(false); - }; - Path.prototype.hasStroke = function () { - var style = this.style; - var stroke = style.stroke; - return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0)); - }; - Path.prototype.hasFill = function () { - var style = this.style; - var fill = style.fill; - return fill != null && fill !== 'none'; - }; - Path.prototype.getBoundingRect = function () { - var rect = this._rect; - var style = this.style; - var needsUpdateRect = !rect; - if (needsUpdateRect) { - var firstInvoke = false; - if (!this.path) { - firstInvoke = true; - this.createPathProxy(); - } - var path = this.path; - if (firstInvoke || (this.__dirty & SHAPE_CHANGED_BIT)) { - path.beginPath(); - this.buildPath(path, this.shape, false); - this.pathUpdated(); - } - rect = path.getBoundingRect(); - } - this._rect = rect; - if (this.hasStroke() && this.path && this.path.len() > 0) { - var rectStroke = this._rectStroke || (this._rectStroke = rect.clone()); - if (this.__dirty || needsUpdateRect) { - rectStroke.copy(rect); - var lineScale = style.strokeNoScale ? this.getLineScale() : 1; - var w = style.lineWidth; - if (!this.hasFill()) { - var strokeContainThreshold = this.strokeContainThreshold; - w = Math.max(w, strokeContainThreshold == null ? 4 : strokeContainThreshold); - } - if (lineScale > 1e-10) { - rectStroke.width += w / lineScale; - rectStroke.height += w / lineScale; - rectStroke.x -= w / lineScale / 2; - rectStroke.y -= w / lineScale / 2; - } - } - return rectStroke; - } - return rect; - }; - Path.prototype.contain = function (x, y) { - var localPos = this.transformCoordToLocal(x, y); - var rect = this.getBoundingRect(); - var style = this.style; - x = localPos[0]; - y = localPos[1]; - if (rect.contain(x, y)) { - var pathProxy = this.path; - if (this.hasStroke()) { - var lineWidth = style.lineWidth; - var lineScale = style.strokeNoScale ? this.getLineScale() : 1; - if (lineScale > 1e-10) { - if (!this.hasFill()) { - lineWidth = Math.max(lineWidth, this.strokeContainThreshold); - } - if (containStroke(pathProxy, lineWidth / lineScale, x, y)) { - return true; - } - } - } - if (this.hasFill()) { - return contain$1(pathProxy, x, y); - } - } - return false; - }; - Path.prototype.dirtyShape = function () { - this.__dirty |= SHAPE_CHANGED_BIT; - if (this._rect) { - this._rect = null; - } - if (this._decalEl) { - this._decalEl.dirtyShape(); - } - this.markRedraw(); - }; - Path.prototype.dirty = function () { - this.dirtyStyle(); - this.dirtyShape(); - }; - Path.prototype.animateShape = function (loop) { - return this.animate('shape', loop); - }; - Path.prototype.updateDuringAnimation = function (targetKey) { - if (targetKey === 'style') { - this.dirtyStyle(); - } - else if (targetKey === 'shape') { - this.dirtyShape(); - } - else { - this.markRedraw(); - } - }; - Path.prototype.attrKV = function (key, value) { - if (key === 'shape') { - this.setShape(value); - } - else { - _super.prototype.attrKV.call(this, key, value); - } - }; - Path.prototype.setShape = function (keyOrObj, value) { - var shape = this.shape; - if (!shape) { - shape = this.shape = {}; - } - if (typeof keyOrObj === 'string') { - shape[keyOrObj] = value; - } - else { - extend(shape, keyOrObj); - } - this.dirtyShape(); - return this; - }; - Path.prototype.shapeChanged = function () { - return !!(this.__dirty & SHAPE_CHANGED_BIT); - }; - Path.prototype.createStyle = function (obj) { - return createObject(DEFAULT_PATH_STYLE, obj); - }; - Path.prototype._innerSaveToNormal = function (toState) { - _super.prototype._innerSaveToNormal.call(this, toState); - var normalState = this._normalState; - if (toState.shape && !normalState.shape) { - normalState.shape = extend({}, this.shape); - } - }; - Path.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) { - _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg); - var needsRestoreToNormal = !(state && keepCurrentStates); - var targetShape; - if (state && state.shape) { - if (transition) { - if (keepCurrentStates) { - targetShape = state.shape; - } - else { - targetShape = extend({}, normalState.shape); - extend(targetShape, state.shape); - } - } - else { - targetShape = extend({}, keepCurrentStates ? this.shape : normalState.shape); - extend(targetShape, state.shape); - } - } - else if (needsRestoreToNormal) { - targetShape = normalState.shape; - } - if (targetShape) { - if (transition) { - this.shape = extend({}, this.shape); - var targetShapePrimaryProps = {}; - var shapeKeys = keys(targetShape); - for (var i = 0; i < shapeKeys.length; i++) { - var key = shapeKeys[i]; - if (typeof targetShape[key] === 'object') { - this.shape[key] = targetShape[key]; - } - else { - targetShapePrimaryProps[key] = targetShape[key]; - } - } - this._transitionState(stateName, { - shape: targetShapePrimaryProps - }, animationCfg); - } - else { - this.shape = targetShape; - this.dirtyShape(); - } - } - }; - Path.prototype._mergeStates = function (states) { - var mergedState = _super.prototype._mergeStates.call(this, states); - var mergedShape; - for (var i = 0; i < states.length; i++) { - var state = states[i]; - if (state.shape) { - mergedShape = mergedShape || {}; - this._mergeStyle(mergedShape, state.shape); - } - } - if (mergedShape) { - mergedState.shape = mergedShape; - } - return mergedState; - }; - Path.prototype.getAnimationStyleProps = function () { - return DEFAULT_PATH_ANIMATION_PROPS; - }; - Path.prototype.isZeroArea = function () { - return false; - }; - Path.extend = function (defaultProps) { - var Sub = (function (_super) { - __extends(Sub, _super); - function Sub(opts) { - var _this = _super.call(this, opts) || this; - defaultProps.init && defaultProps.init.call(_this, opts); - return _this; - } - Sub.prototype.getDefaultStyle = function () { - return clone$2(defaultProps.style); - }; - Sub.prototype.getDefaultShape = function () { - return clone$2(defaultProps.shape); - }; - return Sub; - }(Path)); - for (var key in defaultProps) { - if (typeof defaultProps[key] === 'function') { - Sub.prototype[key] = defaultProps[key]; - } - } - return Sub; - }; - Path.initDefaultProps = (function () { - var pathProto = Path.prototype; - pathProto.type = 'path'; - pathProto.strokeContainThreshold = 5; - pathProto.segmentIgnoreThreshold = 0; - pathProto.subPixelOptimize = false; - pathProto.autoBatch = false; - pathProto.__dirty = REDRAW_BIT | STYLE_CHANGED_BIT | SHAPE_CHANGED_BIT; - })(); - return Path; -}(Displayable)); - -var DEFAULT_TSPAN_STYLE = defaults({ - strokeFirst: true, - font: DEFAULT_FONT, - x: 0, - y: 0, - textAlign: 'left', - textBaseline: 'top', - miterLimit: 2 -}, DEFAULT_PATH_STYLE); -var TSpan = (function (_super) { - __extends(TSpan, _super); - function TSpan() { - return _super !== null && _super.apply(this, arguments) || this; - } - TSpan.prototype.hasStroke = function () { - var style = this.style; - var stroke = style.stroke; - return stroke != null && stroke !== 'none' && style.lineWidth > 0; - }; - TSpan.prototype.hasFill = function () { - var style = this.style; - var fill = style.fill; - return fill != null && fill !== 'none'; - }; - TSpan.prototype.createStyle = function (obj) { - return createObject(DEFAULT_TSPAN_STYLE, obj); - }; - TSpan.prototype.setBoundingRect = function (rect) { - this._rect = rect; - }; - TSpan.prototype.getBoundingRect = function () { - var style = this.style; - if (!this._rect) { - var text = style.text; - text != null ? (text += '') : (text = ''); - var rect = getBoundingRect(text, style.font, style.textAlign, style.textBaseline); - rect.x += style.x || 0; - rect.y += style.y || 0; - if (this.hasStroke()) { - var w = style.lineWidth; - rect.x -= w / 2; - rect.y -= w / 2; - rect.width += w; - rect.height += w; - } - this._rect = rect; - } - return this._rect; - }; - TSpan.initDefaultProps = (function () { - var tspanProto = TSpan.prototype; - tspanProto.dirtyRectTolerance = 10; - })(); - return TSpan; -}(Displayable)); -TSpan.prototype.type = 'tspan'; - -var DEFAULT_IMAGE_STYLE = defaults({ - x: 0, - y: 0 -}, DEFAULT_COMMON_STYLE); -var DEFAULT_IMAGE_ANIMATION_PROPS = { - style: defaults({ - x: true, - y: true, - width: true, - height: true, - sx: true, - sy: true, - sWidth: true, - sHeight: true - }, DEFAULT_COMMON_ANIMATION_PROPS.style) -}; -function isImageLike(source) { - return !!(source - && typeof source !== 'string' - && source.width && source.height); -} -var ZRImage = (function (_super) { - __extends(ZRImage, _super); - function ZRImage() { - return _super !== null && _super.apply(this, arguments) || this; - } - ZRImage.prototype.createStyle = function (obj) { - return createObject(DEFAULT_IMAGE_STYLE, obj); - }; - ZRImage.prototype._getSize = function (dim) { - var style = this.style; - var size = style[dim]; - if (size != null) { - return size; - } - var imageSource = isImageLike(style.image) - ? style.image : this.__image; - if (!imageSource) { - return 0; - } - var otherDim = dim === 'width' ? 'height' : 'width'; - var otherDimSize = style[otherDim]; - if (otherDimSize == null) { - return imageSource[dim]; - } - else { - return imageSource[dim] / imageSource[otherDim] * otherDimSize; - } - }; - ZRImage.prototype.getWidth = function () { - return this._getSize('width'); - }; - ZRImage.prototype.getHeight = function () { - return this._getSize('height'); - }; - ZRImage.prototype.getAnimationStyleProps = function () { - return DEFAULT_IMAGE_ANIMATION_PROPS; - }; - ZRImage.prototype.getBoundingRect = function () { - var style = this.style; - if (!this._rect) { - this._rect = new BoundingRect(style.x || 0, style.y || 0, this.getWidth(), this.getHeight()); - } - return this._rect; - }; - return ZRImage; -}(Displayable)); -ZRImage.prototype.type = 'image'; - -function buildPath$2(ctx, shape) { - var x = shape.x; - var y = shape.y; - var width = shape.width; - var height = shape.height; - var r = shape.r; - var r1; - var r2; - var r3; - var r4; - if (width < 0) { - x = x + width; - width = -width; - } - if (height < 0) { - y = y + height; - height = -height; - } - if (typeof r === 'number') { - r1 = r2 = r3 = r4 = r; - } - else if (r instanceof Array) { - if (r.length === 1) { - r1 = r2 = r3 = r4 = r[0]; - } - else if (r.length === 2) { - r1 = r3 = r[0]; - r2 = r4 = r[1]; - } - else if (r.length === 3) { - r1 = r[0]; - r2 = r4 = r[1]; - r3 = r[2]; - } - else { - r1 = r[0]; - r2 = r[1]; - r3 = r[2]; - r4 = r[3]; - } - } - else { - r1 = r2 = r3 = r4 = 0; - } - var total; - if (r1 + r2 > width) { - total = r1 + r2; - r1 *= width / total; - r2 *= width / total; - } - if (r3 + r4 > width) { - total = r3 + r4; - r3 *= width / total; - r4 *= width / total; - } - if (r2 + r3 > height) { - total = r2 + r3; - r2 *= height / total; - r3 *= height / total; - } - if (r1 + r4 > height) { - total = r1 + r4; - r1 *= height / total; - r4 *= height / total; - } - ctx.moveTo(x + r1, y); - ctx.lineTo(x + width - r2, y); - r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0); - ctx.lineTo(x + width, y + height - r3); - r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2); - ctx.lineTo(x + r4, y + height); - r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI); - ctx.lineTo(x, y + r1); - r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5); -} - -var round = Math.round; -function subPixelOptimizeLine$1(outputShape, inputShape, style) { - if (!inputShape) { - return; - } - var x1 = inputShape.x1; - var x2 = inputShape.x2; - var y1 = inputShape.y1; - var y2 = inputShape.y2; - outputShape.x1 = x1; - outputShape.x2 = x2; - outputShape.y1 = y1; - outputShape.y2 = y2; - var lineWidth = style && style.lineWidth; - if (!lineWidth) { - return outputShape; - } - if (round(x1 * 2) === round(x2 * 2)) { - outputShape.x1 = outputShape.x2 = subPixelOptimize$1(x1, lineWidth, true); - } - if (round(y1 * 2) === round(y2 * 2)) { - outputShape.y1 = outputShape.y2 = subPixelOptimize$1(y1, lineWidth, true); - } - return outputShape; -} -function subPixelOptimizeRect$1(outputShape, inputShape, style) { - if (!inputShape) { - return; - } - var originX = inputShape.x; - var originY = inputShape.y; - var originWidth = inputShape.width; - var originHeight = inputShape.height; - outputShape.x = originX; - outputShape.y = originY; - outputShape.width = originWidth; - outputShape.height = originHeight; - var lineWidth = style && style.lineWidth; - if (!lineWidth) { - return outputShape; - } - outputShape.x = subPixelOptimize$1(originX, lineWidth, true); - outputShape.y = subPixelOptimize$1(originY, lineWidth, true); - outputShape.width = Math.max(subPixelOptimize$1(originX + originWidth, lineWidth, false) - outputShape.x, originWidth === 0 ? 0 : 1); - outputShape.height = Math.max(subPixelOptimize$1(originY + originHeight, lineWidth, false) - outputShape.y, originHeight === 0 ? 0 : 1); - return outputShape; -} -function subPixelOptimize$1(position, lineWidth, positiveOrNegative) { - if (!lineWidth) { - return position; - } - var doubledPosition = round(position * 2); - return (doubledPosition + round(lineWidth)) % 2 === 0 - ? doubledPosition / 2 - : (doubledPosition + (positiveOrNegative ? 1 : -1)) / 2; -} - -var RectShape = (function () { - function RectShape() { - this.x = 0; - this.y = 0; - this.width = 0; - this.height = 0; - } - return RectShape; -}()); -var subPixelOptimizeOutputShape$1 = {}; -var Rect = (function (_super) { - __extends(Rect, _super); - function Rect(opts) { - return _super.call(this, opts) || this; - } - Rect.prototype.getDefaultShape = function () { - return new RectShape(); - }; - Rect.prototype.buildPath = function (ctx, shape) { - var x; - var y; - var width; - var height; - if (this.subPixelOptimize) { - var optimizedShape = subPixelOptimizeRect$1(subPixelOptimizeOutputShape$1, shape, this.style); - x = optimizedShape.x; - y = optimizedShape.y; - width = optimizedShape.width; - height = optimizedShape.height; - optimizedShape.r = shape.r; - shape = optimizedShape; - } - else { - x = shape.x; - y = shape.y; - width = shape.width; - height = shape.height; - } - if (!shape.r) { - ctx.rect(x, y, width, height); - } - else { - buildPath$2(ctx, shape); - } - }; - Rect.prototype.isZeroArea = function () { - return !this.shape.width || !this.shape.height; - }; - return Rect; -}(Path)); -Rect.prototype.type = 'rect'; - -var DEFAULT_RICH_TEXT_COLOR = { - fill: "#000" -}; -var DEFAULT_STROKE_LINE_WIDTH = 2; -var DEFAULT_TEXT_ANIMATION_PROPS = { - style: defaults({ - fill: true, - stroke: true, - fillOpacity: true, - strokeOpacity: true, - lineWidth: true, - fontSize: true, - lineHeight: true, - width: true, - height: true, - textShadowColor: true, - textShadowBlur: true, - textShadowOffsetX: true, - textShadowOffsetY: true, - backgroundColor: true, - padding: true, - borderColor: true, - borderWidth: true, - borderRadius: true - }, DEFAULT_COMMON_ANIMATION_PROPS.style) -}; -var ZRText = function(_super) { - __extends(ZRText2, _super); - function ZRText2(opts) { - var _this = _super.call(this) || this; - _this.type = "text"; - _this._children = []; - _this._defaultStyle = DEFAULT_RICH_TEXT_COLOR; - _this.attr(opts); - return _this; - } - ZRText2.prototype.childrenRef = function() { - return this._children; - }; - ZRText2.prototype.update = function() { - _super.prototype.update.call(this); - if (this.styleChanged()) { - this._updateSubTexts(); - } - for (var i = 0; i < this._children.length; i++) { - var child = this._children[i]; - child.zlevel = this.zlevel; - child.z = this.z; - child.z2 = this.z2; - child.culling = this.culling; - child.cursor = this.cursor; - child.invisible = this.invisible; - } - }; - ZRText2.prototype.updateTransform = function() { - var innerTransformable = this.innerTransformable; - if (innerTransformable) { - innerTransformable.updateTransform(); - if (innerTransformable.transform) { - this.transform = innerTransformable.transform; - } - } else { - _super.prototype.updateTransform.call(this); - } - }; - ZRText2.prototype.getLocalTransform = function(m) { - var innerTransformable = this.innerTransformable; - return innerTransformable ? innerTransformable.getLocalTransform(m) : _super.prototype.getLocalTransform.call(this, m); - }; - ZRText2.prototype.getComputedTransform = function() { - if (this.__hostTarget) { - this.__hostTarget.getComputedTransform(); - this.__hostTarget.updateInnerText(true); - } - return _super.prototype.getComputedTransform.call(this); - }; - ZRText2.prototype._updateSubTexts = function() { - this._childCursor = 0; - normalizeTextStyle(this.style); - this.style.rich ? this._updateRichTexts() : this._updatePlainTexts(); - this._children.length = this._childCursor; - this.styleUpdated(); - }; - ZRText2.prototype.addSelfToZr = function(zr) { - _super.prototype.addSelfToZr.call(this, zr); - for (var i = 0; i < this._children.length; i++) { - this._children[i].__zr = zr; - } - }; - ZRText2.prototype.removeSelfFromZr = function(zr) { - _super.prototype.removeSelfFromZr.call(this, zr); - for (var i = 0; i < this._children.length; i++) { - this._children[i].__zr = null; - } - }; - ZRText2.prototype.getBoundingRect = function() { - if (this.styleChanged()) { - this._updateSubTexts(); - } - if (!this._rect) { - var tmpRect = new BoundingRect(0, 0, 0, 0); - var children = this._children; - var tmpMat = []; - var rect = null; - for (var i = 0; i < children.length; i++) { - var child = children[i]; - var childRect = child.getBoundingRect(); - var transform = child.getLocalTransform(tmpMat); - if (transform) { - tmpRect.copy(childRect); - tmpRect.applyTransform(transform); - rect = rect || tmpRect.clone(); - rect.union(tmpRect); - } else { - rect = rect || childRect.clone(); - rect.union(childRect); - } - } - this._rect = rect || tmpRect; - } - return this._rect; - }; - ZRText2.prototype.setDefaultTextStyle = function(defaultTextStyle) { - this._defaultStyle = defaultTextStyle || DEFAULT_RICH_TEXT_COLOR; - }; - ZRText2.prototype.setTextContent = function(textContent) { - }; - ZRText2.prototype._mergeStyle = function(targetStyle, sourceStyle) { - if (!sourceStyle) { - return targetStyle; - } - var sourceRich = sourceStyle.rich; - var targetRich = targetStyle.rich || sourceRich && {}; - extend(targetStyle, sourceStyle); - if (sourceRich && targetRich) { - this._mergeRich(targetRich, sourceRich); - targetStyle.rich = targetRich; - } else if (targetRich) { - targetStyle.rich = targetRich; - } - return targetStyle; - }; - ZRText2.prototype._mergeRich = function(targetRich, sourceRich) { - var richNames = keys(sourceRich); - for (var i = 0; i < richNames.length; i++) { - var richName = richNames[i]; - targetRich[richName] = targetRich[richName] || {}; - extend(targetRich[richName], sourceRich[richName]); - } - }; - ZRText2.prototype.getAnimationStyleProps = function() { - return DEFAULT_TEXT_ANIMATION_PROPS; - }; - ZRText2.prototype._getOrCreateChild = function(Ctor) { - var child = this._children[this._childCursor]; - if (!child || !(child instanceof Ctor)) { - child = new Ctor(); - } - this._children[this._childCursor++] = child; - child.__zr = this.__zr; - child.parent = this; - return child; - }; - ZRText2.prototype._updatePlainTexts = function() { - var style = this.style; - var textFont = style.font || DEFAULT_FONT; - var textPadding = style.padding; - var text = getStyleText(style); - var contentBlock = parsePlainText(text, style); - var needDrawBg = needDrawBackground(style); - var bgColorDrawn = !!style.backgroundColor; - var outerHeight = contentBlock.outerHeight; - var outerWidth = contentBlock.outerWidth; - var contentWidth = contentBlock.contentWidth; - var textLines = contentBlock.lines; - var lineHeight = contentBlock.lineHeight; - var defaultStyle = this._defaultStyle; - this.isTruncated = !!contentBlock.isTruncated; - var baseX = style.x || 0; - var baseY = style.y || 0; - var textAlign = style.align || defaultStyle.align || "left"; - var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign || "top"; - var textX = baseX; - var textY = adjustTextY(baseY, contentBlock.contentHeight, verticalAlign); - if (needDrawBg || textPadding) { - var boxX = adjustTextX(baseX, outerWidth, textAlign); - var boxY = adjustTextY(baseY, outerHeight, verticalAlign); - needDrawBg && this._renderBackground(style, style, boxX, boxY, outerWidth, outerHeight); - } - textY += lineHeight / 2; - if (textPadding) { - textX = getTextXForPadding(baseX, textAlign, textPadding); - if (verticalAlign === "top") { - textY += textPadding[0]; - } else if (verticalAlign === "bottom") { - textY -= textPadding[2]; - } - } - var defaultLineWidth = 0; - var useDefaultFill = false; - var textFill = getFill("fill" in style ? style.fill : (useDefaultFill = true, defaultStyle.fill)); - var textStroke = getStroke("stroke" in style ? style.stroke : !bgColorDrawn && (!defaultStyle.autoStroke || useDefaultFill) ? (defaultLineWidth = DEFAULT_STROKE_LINE_WIDTH, defaultStyle.stroke) : null); - var hasShadow = style.textShadowBlur > 0; - var fixedBoundingRect = style.width != null && (style.overflow === "truncate" || style.overflow === "break" || style.overflow === "breakAll"); - var calculatedLineHeight = contentBlock.calculatedLineHeight; - for (var i = 0; i < textLines.length; i++) { - var el = this._getOrCreateChild(TSpan); - var subElStyle = el.createStyle(); - el.useStyle(subElStyle); - subElStyle.text = textLines[i]; - subElStyle.x = textX; - subElStyle.y = textY; - { - subElStyle.textAlign = textAlign; - } - subElStyle.textBaseline = "middle"; - subElStyle.opacity = style.opacity; - subElStyle.strokeFirst = true; - if (hasShadow) { - subElStyle.shadowBlur = style.textShadowBlur || 0; - subElStyle.shadowColor = style.textShadowColor || "transparent"; - subElStyle.shadowOffsetX = style.textShadowOffsetX || 0; - subElStyle.shadowOffsetY = style.textShadowOffsetY || 0; - } - subElStyle.stroke = textStroke; - subElStyle.fill = textFill; - if (textStroke) { - subElStyle.lineWidth = style.lineWidth || defaultLineWidth; - subElStyle.lineDash = style.lineDash; - subElStyle.lineDashOffset = style.lineDashOffset || 0; - } - subElStyle.font = textFont; - setSeparateFont(subElStyle, style); - textY += lineHeight; - if (fixedBoundingRect) { - el.setBoundingRect(new BoundingRect(adjustTextX(subElStyle.x, contentWidth, subElStyle.textAlign), adjustTextY(subElStyle.y, calculatedLineHeight, subElStyle.textBaseline), contentWidth, calculatedLineHeight)); - } - } - }; - ZRText2.prototype._updateRichTexts = function() { - var style = this.style; - var text = getStyleText(style); - var contentBlock = parseRichText(text, style); - var contentWidth = contentBlock.width; - var outerWidth = contentBlock.outerWidth; - var outerHeight = contentBlock.outerHeight; - var textPadding = style.padding; - var baseX = style.x || 0; - var baseY = style.y || 0; - var defaultStyle = this._defaultStyle; - var textAlign = style.align || defaultStyle.align; - var verticalAlign = style.verticalAlign || defaultStyle.verticalAlign; - this.isTruncated = !!contentBlock.isTruncated; - var boxX = adjustTextX(baseX, outerWidth, textAlign); - var boxY = adjustTextY(baseY, outerHeight, verticalAlign); - var xLeft = boxX; - var lineTop = boxY; - if (textPadding) { - xLeft += textPadding[3]; - lineTop += textPadding[0]; - } - var xRight = xLeft + contentWidth; - if (needDrawBackground(style)) { - this._renderBackground(style, style, boxX, boxY, outerWidth, outerHeight); - } - var bgColorDrawn = !!style.backgroundColor; - for (var i = 0; i < contentBlock.lines.length; i++) { - var line = contentBlock.lines[i]; - var tokens = line.tokens; - var tokenCount = tokens.length; - var lineHeight = line.lineHeight; - var remainedWidth = line.width; - var leftIndex = 0; - var lineXLeft = xLeft; - var lineXRight = xRight; - var rightIndex = tokenCount - 1; - var token = void 0; - while (leftIndex < tokenCount && (token = tokens[leftIndex], !token.align || token.align === "left")) { - this._placeToken(token, style, lineHeight, lineTop, lineXLeft, "left", bgColorDrawn); - remainedWidth -= token.width; - lineXLeft += token.width; - leftIndex++; - } - while (rightIndex >= 0 && (token = tokens[rightIndex], token.align === "right")) { - this._placeToken(token, style, lineHeight, lineTop, lineXRight, "right", bgColorDrawn); - remainedWidth -= token.width; - lineXRight -= token.width; - rightIndex--; - } - lineXLeft += (contentWidth - (lineXLeft - xLeft) - (xRight - lineXRight) - remainedWidth) / 2; - while (leftIndex <= rightIndex) { - token = tokens[leftIndex]; - this._placeToken(token, style, lineHeight, lineTop, lineXLeft + token.width / 2, "center", bgColorDrawn); - lineXLeft += token.width; - leftIndex++; - } - lineTop += lineHeight; - } - }; - ZRText2.prototype._placeToken = function(token, style, lineHeight, lineTop, x, textAlign, parentBgColorDrawn) { - var tokenStyle = style.rich[token.styleName] || {}; - tokenStyle.text = token.text; - var verticalAlign = token.verticalAlign; - var y = lineTop + lineHeight / 2; - if (verticalAlign === "top") { - y = lineTop + token.height / 2; - } else if (verticalAlign === "bottom") { - y = lineTop + lineHeight - token.height / 2; - } - var needDrawBg = !token.isLineHolder && needDrawBackground(tokenStyle); - needDrawBg && this._renderBackground(tokenStyle, style, textAlign === "right" ? x - token.width : textAlign === "center" ? x - token.width / 2 : x, y - token.height / 2, token.width, token.height); - var bgColorDrawn = !!tokenStyle.backgroundColor; - var textPadding = token.textPadding; - if (textPadding) { - x = getTextXForPadding(x, textAlign, textPadding); - y -= token.height / 2 - textPadding[0] - token.innerHeight / 2; - } - var el = this._getOrCreateChild(TSpan); - var subElStyle = el.createStyle(); - el.useStyle(subElStyle); - var defaultStyle = this._defaultStyle; - var useDefaultFill = false; - var defaultLineWidth = 0; - var textFill = getFill("fill" in tokenStyle ? tokenStyle.fill : "fill" in style ? style.fill : (useDefaultFill = true, defaultStyle.fill)); - var textStroke = getStroke("stroke" in tokenStyle ? tokenStyle.stroke : "stroke" in style ? style.stroke : !bgColorDrawn && !parentBgColorDrawn && (!defaultStyle.autoStroke || useDefaultFill) ? (defaultLineWidth = DEFAULT_STROKE_LINE_WIDTH, defaultStyle.stroke) : null); - var hasShadow = tokenStyle.textShadowBlur > 0 || style.textShadowBlur > 0; - subElStyle.text = token.text; - subElStyle.x = x; - subElStyle.y = y; - if (hasShadow) { - subElStyle.shadowBlur = tokenStyle.textShadowBlur || style.textShadowBlur || 0; - subElStyle.shadowColor = tokenStyle.textShadowColor || style.textShadowColor || "transparent"; - subElStyle.shadowOffsetX = tokenStyle.textShadowOffsetX || style.textShadowOffsetX || 0; - subElStyle.shadowOffsetY = tokenStyle.textShadowOffsetY || style.textShadowOffsetY || 0; - } - subElStyle.textAlign = textAlign; - subElStyle.textBaseline = "middle"; - subElStyle.font = token.font || DEFAULT_FONT; - subElStyle.opacity = retrieve3(tokenStyle.opacity, style.opacity, 1); - setSeparateFont(subElStyle, tokenStyle); - if (textStroke) { - subElStyle.lineWidth = retrieve3(tokenStyle.lineWidth, style.lineWidth, defaultLineWidth); - subElStyle.lineDash = retrieve2(tokenStyle.lineDash, style.lineDash); - subElStyle.lineDashOffset = style.lineDashOffset || 0; - subElStyle.stroke = textStroke; - } - if (textFill) { - subElStyle.fill = textFill; - } - var textWidth = token.contentWidth; - var textHeight = token.contentHeight; - el.setBoundingRect(new BoundingRect(adjustTextX(subElStyle.x, textWidth, subElStyle.textAlign), adjustTextY(subElStyle.y, textHeight, subElStyle.textBaseline), textWidth, textHeight)); - }; - ZRText2.prototype._renderBackground = function(style, topStyle, x, y, width, height) { - var textBackgroundColor = style.backgroundColor; - var textBorderWidth = style.borderWidth; - var textBorderColor = style.borderColor; - var isImageBg = textBackgroundColor && textBackgroundColor.image; - var isPlainOrGradientBg = textBackgroundColor && !isImageBg; - var textBorderRadius = style.borderRadius; - var self = this; - var rectEl; - var imgEl; - if (isPlainOrGradientBg || style.lineHeight || textBorderWidth && textBorderColor) { - rectEl = this._getOrCreateChild(Rect); - rectEl.useStyle(rectEl.createStyle()); - rectEl.style.fill = null; - var rectShape = rectEl.shape; - rectShape.x = x; - rectShape.y = y; - rectShape.width = width; - rectShape.height = height; - rectShape.r = textBorderRadius; - rectEl.dirtyShape(); - } - if (isPlainOrGradientBg) { - var rectStyle = rectEl.style; - rectStyle.fill = textBackgroundColor || null; - rectStyle.fillOpacity = retrieve2(style.fillOpacity, 1); - } else if (isImageBg) { - imgEl = this._getOrCreateChild(ZRImage); - imgEl.onload = function() { - self.dirtyStyle(); - }; - var imgStyle = imgEl.style; - imgStyle.image = textBackgroundColor.image; - imgStyle.x = x; - imgStyle.y = y; - imgStyle.width = width; - imgStyle.height = height; - } - if (textBorderWidth && textBorderColor) { - var rectStyle = rectEl.style; - rectStyle.lineWidth = textBorderWidth; - rectStyle.stroke = textBorderColor; - rectStyle.strokeOpacity = retrieve2(style.strokeOpacity, 1); - rectStyle.lineDash = style.borderDash; - rectStyle.lineDashOffset = style.borderDashOffset || 0; - rectEl.strokeContainThreshold = 0; - if (rectEl.hasFill() && rectEl.hasStroke()) { - rectStyle.strokeFirst = true; - rectStyle.lineWidth *= 2; - } - } - var commonStyle = (rectEl || imgEl).style; - commonStyle.shadowBlur = style.shadowBlur || 0; - commonStyle.shadowColor = style.shadowColor || "transparent"; - commonStyle.shadowOffsetX = style.shadowOffsetX || 0; - commonStyle.shadowOffsetY = style.shadowOffsetY || 0; - commonStyle.opacity = retrieve3(style.opacity, topStyle.opacity, 1); - }; - ZRText2.makeFont = function(style) { - var font = ""; - if (hasSeparateFont(style)) { - font = [ - style.fontStyle, - style.fontWeight, - parseFontSize(style.fontSize), - style.fontFamily || "sans-serif" - ].join(" "); - } - return font && trim(font) || style.textFont || style.font; - }; - return ZRText2; -}(Displayable); -var VALID_TEXT_ALIGN = { left: true, right: 1, center: 1 }; -var VALID_TEXT_VERTICAL_ALIGN = { top: 1, bottom: 1, middle: 1 }; -var FONT_PARTS = ["fontStyle", "fontWeight", "fontSize", "fontFamily"]; -function parseFontSize(fontSize) { - if (typeof fontSize === "string" && (fontSize.indexOf("px") !== -1 || fontSize.indexOf("rem") !== -1 || fontSize.indexOf("em") !== -1)) { - return fontSize; - } else if (!isNaN(+fontSize)) { - return fontSize + "px"; - } else { - return DEFAULT_FONT_SIZE + "px"; - } -} -function setSeparateFont(targetStyle, sourceStyle) { - for (var i = 0; i < FONT_PARTS.length; i++) { - var fontProp = FONT_PARTS[i]; - var val = sourceStyle[fontProp]; - if (val != null) { - targetStyle[fontProp] = val; - } - } -} -function hasSeparateFont(style) { - return style.fontSize != null || style.fontFamily || style.fontWeight; -} -function normalizeTextStyle(style) { - normalizeStyle(style); - each$4(style.rich, normalizeStyle); - return style; -} -function normalizeStyle(style) { - if (style) { - style.font = ZRText.makeFont(style); - var textAlign = style.align; - textAlign === "middle" && (textAlign = "center"); - style.align = textAlign == null || VALID_TEXT_ALIGN[textAlign] ? textAlign : "left"; - var verticalAlign = style.verticalAlign; - verticalAlign === "center" && (verticalAlign = "middle"); - style.verticalAlign = verticalAlign == null || VALID_TEXT_VERTICAL_ALIGN[verticalAlign] ? verticalAlign : "top"; - var textPadding = style.padding; - if (textPadding) { - style.padding = normalizeCssArray$1(style.padding); - } - } -} -function getStroke(stroke, lineWidth) { - return stroke == null || lineWidth <= 0 || stroke === "transparent" || stroke === "none" ? null : stroke.image || stroke.colorStops ? "#000" : stroke; -} -function getFill(fill) { - return fill == null || fill === "none" ? null : fill.image || fill.colorStops ? "#000" : fill; -} -function getTextXForPadding(x, textAlign, textPadding) { - return textAlign === "right" ? x - textPadding[1] : textAlign === "center" ? x + textPadding[3] / 2 - textPadding[1] / 2 : x + textPadding[3]; -} -function getStyleText(style) { - var text = style.text; - text != null && (text += ""); - return text; -} -function needDrawBackground(style) { - return !!(style.backgroundColor || style.lineHeight || style.borderWidth && style.borderColor); -} - -var getECData = makeInner(); -var setCommonECData = function (seriesIndex, dataType, dataIdx, el) { - if (el) { - var ecData = getECData(el); - // Add data index and series index for indexing the data by element - // Useful in tooltip - ecData.dataIndex = dataIdx; - ecData.dataType = dataType; - ecData.seriesIndex = seriesIndex; - ecData.ssrType = 'chart'; - // TODO: not store dataIndex on children. - if (el.type === 'group') { - el.traverse(function (child) { - var childECData = getECData(child); - childECData.seriesIndex = seriesIndex; - childECData.dataIndex = dataIdx; - childECData.dataType = dataType; - childECData.ssrType = 'chart'; - }); - } - } -}; - -var _highlightNextDigit = 1; -var _highlightKeyMap = {}; -var getSavedStates = makeInner(); -var getComponentStates = makeInner(); -var HOVER_STATE_NORMAL = 0; -var HOVER_STATE_BLUR = 1; -var HOVER_STATE_EMPHASIS = 2; -var SPECIAL_STATES = ["emphasis", "blur", "select"]; -var DISPLAY_STATES = ["normal", "emphasis", "blur", "select"]; -var Z2_EMPHASIS_LIFT = 10; -var Z2_SELECT_LIFT = 9; -var HIGHLIGHT_ACTION_TYPE = "highlight"; -var DOWNPLAY_ACTION_TYPE = "downplay"; -var SELECT_ACTION_TYPE = "select"; -var UNSELECT_ACTION_TYPE = "unselect"; -var TOGGLE_SELECT_ACTION_TYPE = "toggleSelect"; -function hasFillOrStroke(fillOrStroke) { - return fillOrStroke != null && fillOrStroke !== "none"; -} -function doChangeHoverState(el, stateName, hoverStateEnum) { - if (el.onHoverStateChange && (el.hoverState || 0) !== hoverStateEnum) { - el.onHoverStateChange(stateName); - } - el.hoverState = hoverStateEnum; -} -function singleEnterEmphasis(el) { - doChangeHoverState(el, "emphasis", HOVER_STATE_EMPHASIS); -} -function singleLeaveEmphasis(el) { - if (el.hoverState === HOVER_STATE_EMPHASIS) { - doChangeHoverState(el, "normal", HOVER_STATE_NORMAL); - } -} -function singleEnterBlur(el) { - doChangeHoverState(el, "blur", HOVER_STATE_BLUR); -} -function singleLeaveBlur(el) { - if (el.hoverState === HOVER_STATE_BLUR) { - doChangeHoverState(el, "normal", HOVER_STATE_NORMAL); - } -} -function singleEnterSelect(el) { - el.selected = true; -} -function singleLeaveSelect(el) { - el.selected = false; -} -function updateElementState(el, updater, commonParam) { - updater(el, commonParam); -} -function traverseUpdateState(el, updater, commonParam) { - updateElementState(el, updater, commonParam); - el.isGroup && el.traverse(function(child) { - updateElementState(child, updater, commonParam); - }); -} -function setStatesFlag(el, stateName) { - switch (stateName) { - case "emphasis": - el.hoverState = HOVER_STATE_EMPHASIS; - break; - case "normal": - el.hoverState = HOVER_STATE_NORMAL; - break; - case "blur": - el.hoverState = HOVER_STATE_BLUR; - break; - case "select": - el.selected = true; - } -} -function getFromStateStyle(el, props, toStateName, defaultValue) { - var style = el.style; - var fromState = {}; - for (var i = 0; i < props.length; i++) { - var propName = props[i]; - var val = style[propName]; - fromState[propName] = val == null ? defaultValue && defaultValue[propName] : val; - } - for (var i = 0; i < el.animators.length; i++) { - var animator = el.animators[i]; - if (animator.__fromStateTransition && animator.__fromStateTransition.indexOf(toStateName) < 0 && animator.targetName === "style") { - animator.saveTo(fromState, props); - } - } - return fromState; -} -function createEmphasisDefaultState(el, stateName, targetStates, state) { - var hasSelect = targetStates && indexOf(targetStates, "select") >= 0; - var cloned = false; - if (el instanceof Path) { - var store = getSavedStates(el); - var fromFill = hasSelect ? store.selectFill || store.normalFill : store.normalFill; - var fromStroke = hasSelect ? store.selectStroke || store.normalStroke : store.normalStroke; - if (hasFillOrStroke(fromFill) || hasFillOrStroke(fromStroke)) { - state = state || {}; - var emphasisStyle = state.style || {}; - if (emphasisStyle.fill === "inherit") { - cloned = true; - state = extend({}, state); - emphasisStyle = extend({}, emphasisStyle); - emphasisStyle.fill = fromFill; - } else if (!hasFillOrStroke(emphasisStyle.fill) && hasFillOrStroke(fromFill)) { - cloned = true; - state = extend({}, state); - emphasisStyle = extend({}, emphasisStyle); - emphasisStyle.fill = liftColor(fromFill); - } else if (!hasFillOrStroke(emphasisStyle.stroke) && hasFillOrStroke(fromStroke)) { - if (!cloned) { - state = extend({}, state); - emphasisStyle = extend({}, emphasisStyle); - } - emphasisStyle.stroke = liftColor(fromStroke); - } - state.style = emphasisStyle; - } - } - if (state) { - if (state.z2 == null) { - if (!cloned) { - state = extend({}, state); - } - var z2EmphasisLift = el.z2EmphasisLift; - state.z2 = el.z2 + (z2EmphasisLift != null ? z2EmphasisLift : Z2_EMPHASIS_LIFT); - } - } - return state; -} -function createSelectDefaultState(el, stateName, state) { - if (state) { - if (state.z2 == null) { - state = extend({}, state); - var z2SelectLift = el.z2SelectLift; - state.z2 = el.z2 + (z2SelectLift != null ? z2SelectLift : Z2_SELECT_LIFT); - } - } - return state; -} -function createBlurDefaultState(el, stateName, state) { - var hasBlur = indexOf(el.currentStates, stateName) >= 0; - var currentOpacity = el.style.opacity; - var fromState = !hasBlur ? getFromStateStyle(el, ["opacity"], stateName, { - opacity: 1 - }) : null; - state = state || {}; - var blurStyle = state.style || {}; - if (blurStyle.opacity == null) { - state = extend({}, state); - blurStyle = extend({ - // Already being applied 'emphasis'. DON'T mul opacity multiple times. - opacity: hasBlur ? currentOpacity : fromState.opacity * 0.1 - }, blurStyle); - state.style = blurStyle; - } - return state; -} -function elementStateProxy(stateName, targetStates) { - var state = this.states[stateName]; - if (this.style) { - if (stateName === "emphasis") { - return createEmphasisDefaultState(this, stateName, targetStates, state); - } else if (stateName === "blur") { - return createBlurDefaultState(this, stateName, state); - } else if (stateName === "select") { - return createSelectDefaultState(this, stateName, state); - } - } - return state; -} -function setDefaultStateProxy(el) { - el.stateProxy = elementStateProxy; - var textContent = el.getTextContent(); - var textGuide = el.getTextGuideLine(); - if (textContent) { - textContent.stateProxy = elementStateProxy; - } - if (textGuide) { - textGuide.stateProxy = elementStateProxy; - } -} -function enterEmphasisWhenMouseOver(el, e) { - !shouldSilent(el, e) && !el.__highByOuter && traverseUpdateState(el, singleEnterEmphasis); -} -function leaveEmphasisWhenMouseOut(el, e) { - !shouldSilent(el, e) && !el.__highByOuter && traverseUpdateState(el, singleLeaveEmphasis); -} -function enterEmphasis(el, highlightDigit) { - el.__highByOuter |= 1 << (highlightDigit || 0); - traverseUpdateState(el, singleEnterEmphasis); -} -function leaveEmphasis(el, highlightDigit) { - !(el.__highByOuter &= ~(1 << (highlightDigit || 0))) && traverseUpdateState(el, singleLeaveEmphasis); -} -function enterBlur(el) { - traverseUpdateState(el, singleEnterBlur); -} -function leaveBlur(el) { - traverseUpdateState(el, singleLeaveBlur); -} -function enterSelect(el) { - traverseUpdateState(el, singleEnterSelect); -} -function leaveSelect(el) { - traverseUpdateState(el, singleLeaveSelect); -} -function shouldSilent(el, e) { - return el.__highDownSilentOnTouch && e.zrByTouch; -} -function allLeaveBlur(api) { - var model = api.getModel(); - var leaveBlurredSeries = []; - var allComponentViews = []; - model.eachComponent(function(componentType, componentModel) { - var componentStates = getComponentStates(componentModel); - var isSeries = componentType === "series"; - var view = isSeries ? api.getViewOfSeriesModel(componentModel) : api.getViewOfComponentModel(componentModel); - !isSeries && allComponentViews.push(view); - if (componentStates.isBlured) { - view.group.traverse(function(child) { - singleLeaveBlur(child); - }); - isSeries && leaveBlurredSeries.push(componentModel); - } - componentStates.isBlured = false; - }); - each$4(allComponentViews, function(view) { - if (view && view.toggleBlurSeries) { - view.toggleBlurSeries(leaveBlurredSeries, false, model); - } - }); -} -function blurSeries(targetSeriesIndex, focus, blurScope, api) { - var ecModel = api.getModel(); - blurScope = blurScope || "coordinateSystem"; - function leaveBlurOfIndices(data, dataIndices) { - for (var i = 0; i < dataIndices.length; i++) { - var itemEl = data.getItemGraphicEl(dataIndices[i]); - itemEl && leaveBlur(itemEl); - } - } - if (targetSeriesIndex == null) { - return; - } - if (!focus || focus === "none") { - return; - } - var targetSeriesModel = ecModel.getSeriesByIndex(targetSeriesIndex); - var targetCoordSys = targetSeriesModel.coordinateSystem; - if (targetCoordSys && targetCoordSys.master) { - targetCoordSys = targetCoordSys.master; - } - var blurredSeries = []; - ecModel.eachSeries(function(seriesModel) { - var sameSeries = targetSeriesModel === seriesModel; - var coordSys = seriesModel.coordinateSystem; - if (coordSys && coordSys.master) { - coordSys = coordSys.master; - } - var sameCoordSys = coordSys && targetCoordSys ? coordSys === targetCoordSys : sameSeries; - if (!// Not blur other series if blurScope series - (blurScope === "series" && !sameSeries || blurScope === "coordinateSystem" && !sameCoordSys || focus === "series" && sameSeries)) { - var view = api.getViewOfSeriesModel(seriesModel); - view.group.traverse(function(child) { - if (child.__highByOuter && sameSeries && focus === "self") { - return; - } - singleEnterBlur(child); - }); - if (isArrayLike(focus)) { - leaveBlurOfIndices(seriesModel.getData(), focus); - } else if (isObject$2(focus)) { - var dataTypes = keys(focus); - for (var d = 0; d < dataTypes.length; d++) { - leaveBlurOfIndices(seriesModel.getData(dataTypes[d]), focus[dataTypes[d]]); - } - } - blurredSeries.push(seriesModel); - getComponentStates(seriesModel).isBlured = true; - } - }); - ecModel.eachComponent(function(componentType, componentModel) { - if (componentType === "series") { - return; - } - var view = api.getViewOfComponentModel(componentModel); - if (view && view.toggleBlurSeries) { - view.toggleBlurSeries(blurredSeries, true, ecModel); - } - }); -} -function blurComponent(componentMainType, componentIndex, api) { - if (componentMainType == null || componentIndex == null) { - return; - } - var componentModel = api.getModel().getComponent(componentMainType, componentIndex); - if (!componentModel) { - return; - } - getComponentStates(componentModel).isBlured = true; - var view = api.getViewOfComponentModel(componentModel); - if (!view || !view.focusBlurEnabled) { - return; - } - view.group.traverse(function(child) { - singleEnterBlur(child); - }); -} -function blurSeriesFromHighlightPayload(seriesModel, payload, api) { - var seriesIndex = seriesModel.seriesIndex; - var data = seriesModel.getData(payload.dataType); - if (!data) { - return; - } - var dataIndex = queryDataIndex(data, payload); - dataIndex = (isArray(dataIndex) ? dataIndex[0] : dataIndex) || 0; - var el = data.getItemGraphicEl(dataIndex); - if (!el) { - var count = data.count(); - var current = 0; - while (!el && current < count) { - el = data.getItemGraphicEl(current++); - } - } - if (el) { - var ecData = getECData(el); - blurSeries(seriesIndex, ecData.focus, ecData.blurScope, api); - } else { - var focus_1 = seriesModel.get(["emphasis", "focus"]); - var blurScope = seriesModel.get(["emphasis", "blurScope"]); - if (focus_1 != null) { - blurSeries(seriesIndex, focus_1, blurScope, api); - } - } -} -function findComponentHighDownDispatchers(componentMainType, componentIndex, name, api) { - var ret = { - focusSelf: false, - dispatchers: null - }; - if (componentMainType == null || componentMainType === "series" || componentIndex == null || name == null) { - return ret; - } - var componentModel = api.getModel().getComponent(componentMainType, componentIndex); - if (!componentModel) { - return ret; - } - var view = api.getViewOfComponentModel(componentModel); - if (!view || !view.findHighDownDispatchers) { - return ret; - } - var dispatchers = view.findHighDownDispatchers(name); - var focusSelf; - for (var i = 0; i < dispatchers.length; i++) { - if (getECData(dispatchers[i]).focus === "self") { - focusSelf = true; - break; - } - } - return { - focusSelf, - dispatchers - }; -} -function handleGlobalMouseOverForHighDown(dispatcher, e, api) { - var ecData = getECData(dispatcher); - var _a = findComponentHighDownDispatchers(ecData.componentMainType, ecData.componentIndex, ecData.componentHighDownName, api), dispatchers = _a.dispatchers, focusSelf = _a.focusSelf; - if (dispatchers) { - if (focusSelf) { - blurComponent(ecData.componentMainType, ecData.componentIndex, api); - } - each$4(dispatchers, function(dispatcher2) { - return enterEmphasisWhenMouseOver(dispatcher2, e); - }); - } else { - blurSeries(ecData.seriesIndex, ecData.focus, ecData.blurScope, api); - if (ecData.focus === "self") { - blurComponent(ecData.componentMainType, ecData.componentIndex, api); - } - enterEmphasisWhenMouseOver(dispatcher, e); - } -} -function handleGlobalMouseOutForHighDown(dispatcher, e, api) { - allLeaveBlur(api); - var ecData = getECData(dispatcher); - var dispatchers = findComponentHighDownDispatchers(ecData.componentMainType, ecData.componentIndex, ecData.componentHighDownName, api).dispatchers; - if (dispatchers) { - each$4(dispatchers, function(dispatcher2) { - return leaveEmphasisWhenMouseOut(dispatcher2, e); - }); - } else { - leaveEmphasisWhenMouseOut(dispatcher, e); - } -} -function toggleSelectionFromPayload(seriesModel, payload, api) { - if (!isSelectChangePayload(payload)) { - return; - } - var dataType = payload.dataType; - var data = seriesModel.getData(dataType); - var dataIndex = queryDataIndex(data, payload); - if (!isArray(dataIndex)) { - dataIndex = [dataIndex]; - } - seriesModel[payload.type === TOGGLE_SELECT_ACTION_TYPE ? "toggleSelect" : payload.type === SELECT_ACTION_TYPE ? "select" : "unselect"](dataIndex, dataType); -} -function updateSeriesElementSelection(seriesModel) { - var allData = seriesModel.getAllData(); - each$4(allData, function(_a) { - var data = _a.data, type = _a.type; - data.eachItemGraphicEl(function(el, idx) { - seriesModel.isSelected(idx, type) ? enterSelect(el) : leaveSelect(el); - }); - }); -} -function getAllSelectedIndices(ecModel) { - var ret = []; - ecModel.eachSeries(function(seriesModel) { - var allData = seriesModel.getAllData(); - each$4(allData, function(_a) { - _a.data; var type = _a.type; - var dataIndices = seriesModel.getSelectedDataIndices(); - if (dataIndices.length > 0) { - var item = { - dataIndex: dataIndices, - seriesIndex: seriesModel.seriesIndex - }; - if (type != null) { - item.dataType = type; - } - ret.push(item); - } - }); - }); - return ret; -} -function enableHoverEmphasis(el, focus, blurScope) { - setAsHighDownDispatcher(el, true); - traverseUpdateState(el, setDefaultStateProxy); - enableHoverFocus(el, focus, blurScope); -} -function disableHoverEmphasis(el) { - setAsHighDownDispatcher(el, false); -} -function toggleHoverEmphasis(el, focus, blurScope, isDisabled) { - isDisabled ? disableHoverEmphasis(el) : enableHoverEmphasis(el, focus, blurScope); -} -function enableHoverFocus(el, focus, blurScope) { - var ecData = getECData(el); - if (focus != null) { - ecData.focus = focus; - ecData.blurScope = blurScope; - } else if (ecData.focus) { - ecData.focus = null; - } -} -var OTHER_STATES = ["emphasis", "blur", "select"]; -var defaultStyleGetterMap = { - itemStyle: "getItemStyle", - lineStyle: "getLineStyle", - areaStyle: "getAreaStyle" -}; -function setStatesStylesFromModel(el, itemModel, styleType, getter) { - styleType = styleType || "itemStyle"; - for (var i = 0; i < OTHER_STATES.length; i++) { - var stateName = OTHER_STATES[i]; - var model = itemModel.getModel([stateName, styleType]); - var state = el.ensureState(stateName); - state.style = model[defaultStyleGetterMap[styleType]](); - } -} -function setAsHighDownDispatcher(el, asDispatcher) { - var disable = asDispatcher === false; - var extendedEl = el; - if (el.highDownSilentOnTouch) { - extendedEl.__highDownSilentOnTouch = el.highDownSilentOnTouch; - } - if (!disable || extendedEl.__highDownDispatcher) { - extendedEl.__highByOuter = extendedEl.__highByOuter || 0; - extendedEl.__highDownDispatcher = !disable; - } -} -function isHighDownDispatcher(el) { - return !!(el && el.__highDownDispatcher); -} -function getHighlightDigit(highlightKey) { - var highlightDigit = _highlightKeyMap[highlightKey]; - if (highlightDigit == null && _highlightNextDigit <= 32) { - highlightDigit = _highlightKeyMap[highlightKey] = _highlightNextDigit++; - } - return highlightDigit; -} -function isSelectChangePayload(payload) { - var payloadType = payload.type; - return payloadType === SELECT_ACTION_TYPE || payloadType === UNSELECT_ACTION_TYPE || payloadType === TOGGLE_SELECT_ACTION_TYPE; -} -function isHighDownPayload(payload) { - var payloadType = payload.type; - return payloadType === HIGHLIGHT_ACTION_TYPE || payloadType === DOWNPLAY_ACTION_TYPE; -} -function savePathStates(el) { - var store = getSavedStates(el); - store.normalFill = el.style.fill; - store.normalStroke = el.style.stroke; - var selectState = el.states.select || {}; - store.selectFill = selectState.style && selectState.style.fill || null; - store.selectStroke = selectState.style && selectState.style.stroke || null; -} - -var CMD = PathProxy.CMD; -var points = [[], [], []]; -var mathSqrt$2 = Math.sqrt; -var mathAtan2 = Math.atan2; -function transformPath(path, m) { - if (!m) { - return; - } - var data = path.data; - var len = path.len(); - var cmd; - var nPoint; - var i; - var j; - var k; - var p; - var M = CMD.M; - var C = CMD.C; - var L = CMD.L; - var R = CMD.R; - var A = CMD.A; - var Q = CMD.Q; - for (i = 0, j = 0; i < len;) { - cmd = data[i++]; - j = i; - nPoint = 0; - switch (cmd) { - case M: - nPoint = 1; - break; - case L: - nPoint = 1; - break; - case C: - nPoint = 3; - break; - case Q: - nPoint = 2; - break; - case A: - var x = m[4]; - var y = m[5]; - var sx = mathSqrt$2(m[0] * m[0] + m[1] * m[1]); - var sy = mathSqrt$2(m[2] * m[2] + m[3] * m[3]); - var angle = mathAtan2(-m[1] / sy, m[0] / sx); - data[i] *= sx; - data[i++] += x; - data[i] *= sy; - data[i++] += y; - data[i++] *= sx; - data[i++] *= sy; - data[i++] += angle; - data[i++] += angle; - i += 2; - j = i; - break; - case R: - p[0] = data[i++]; - p[1] = data[i++]; - applyTransform$1(p, p, m); - data[j++] = p[0]; - data[j++] = p[1]; - p[0] += data[i++]; - p[1] += data[i++]; - applyTransform$1(p, p, m); - data[j++] = p[0]; - data[j++] = p[1]; - } - for (k = 0; k < nPoint; k++) { - var p_1 = points[k]; - p_1[0] = data[i++]; - p_1[1] = data[i++]; - applyTransform$1(p_1, p_1, m); - data[j++] = p_1[0]; - data[j++] = p_1[1]; - } - } - path.increaseVersion(); -} - -var mathSqrt$1 = Math.sqrt; -var mathSin$1 = Math.sin; -var mathCos$1 = Math.cos; -var PI$3 = Math.PI; -function vMag(v) { - return Math.sqrt(v[0] * v[0] + v[1] * v[1]); -} -function vRatio(u, v) { - return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v)); -} -function vAngle(u, v) { - return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) - * Math.acos(vRatio(u, v)); -} -function processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) { - var psi = psiDeg * (PI$3 / 180.0); - var xp = mathCos$1(psi) * (x1 - x2) / 2.0 - + mathSin$1(psi) * (y1 - y2) / 2.0; - var yp = -1 * mathSin$1(psi) * (x1 - x2) / 2.0 - + mathCos$1(psi) * (y1 - y2) / 2.0; - var lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry); - if (lambda > 1) { - rx *= mathSqrt$1(lambda); - ry *= mathSqrt$1(lambda); - } - var f = (fa === fs ? -1 : 1) - * mathSqrt$1((((rx * rx) * (ry * ry)) - - ((rx * rx) * (yp * yp)) - - ((ry * ry) * (xp * xp))) / ((rx * rx) * (yp * yp) - + (ry * ry) * (xp * xp))) || 0; - var cxp = f * rx * yp / ry; - var cyp = f * -ry * xp / rx; - var cx = (x1 + x2) / 2.0 - + mathCos$1(psi) * cxp - - mathSin$1(psi) * cyp; - var cy = (y1 + y2) / 2.0 - + mathSin$1(psi) * cxp - + mathCos$1(psi) * cyp; - var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]); - var u = [(xp - cxp) / rx, (yp - cyp) / ry]; - var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry]; - var dTheta = vAngle(u, v); - if (vRatio(u, v) <= -1) { - dTheta = PI$3; - } - if (vRatio(u, v) >= 1) { - dTheta = 0; - } - if (dTheta < 0) { - var n = Math.round(dTheta / PI$3 * 1e6) / 1e6; - dTheta = PI$3 * 2 + (n % 2) * PI$3; - } - path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs); -} -var commandReg = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/ig; -var numberReg = /-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g; -function createPathProxyFromString(data) { - var path = new PathProxy(); - if (!data) { - return path; - } - var cpx = 0; - var cpy = 0; - var subpathX = cpx; - var subpathY = cpy; - var prevCmd; - var CMD = PathProxy.CMD; - var cmdList = data.match(commandReg); - if (!cmdList) { - return path; - } - for (var l = 0; l < cmdList.length; l++) { - var cmdText = cmdList[l]; - var cmdStr = cmdText.charAt(0); - var cmd = void 0; - var p = cmdText.match(numberReg) || []; - var pLen = p.length; - for (var i = 0; i < pLen; i++) { - p[i] = parseFloat(p[i]); - } - var off = 0; - while (off < pLen) { - var ctlPtx = void 0; - var ctlPty = void 0; - var rx = void 0; - var ry = void 0; - var psi = void 0; - var fa = void 0; - var fs = void 0; - var x1 = cpx; - var y1 = cpy; - var len = void 0; - var pathData = void 0; - switch (cmdStr) { - case 'l': - cpx += p[off++]; - cpy += p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'L': - cpx = p[off++]; - cpy = p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'm': - cpx += p[off++]; - cpy += p[off++]; - cmd = CMD.M; - path.addData(cmd, cpx, cpy); - subpathX = cpx; - subpathY = cpy; - cmdStr = 'l'; - break; - case 'M': - cpx = p[off++]; - cpy = p[off++]; - cmd = CMD.M; - path.addData(cmd, cpx, cpy); - subpathX = cpx; - subpathY = cpy; - cmdStr = 'L'; - break; - case 'h': - cpx += p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'H': - cpx = p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'v': - cpy += p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'V': - cpy = p[off++]; - cmd = CMD.L; - path.addData(cmd, cpx, cpy); - break; - case 'C': - cmd = CMD.C; - path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]); - cpx = p[off - 2]; - cpy = p[off - 1]; - break; - case 'c': - cmd = CMD.C; - path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy); - cpx += p[off - 2]; - cpy += p[off - 1]; - break; - case 'S': - ctlPtx = cpx; - ctlPty = cpy; - len = path.len(); - pathData = path.data; - if (prevCmd === CMD.C) { - ctlPtx += cpx - pathData[len - 4]; - ctlPty += cpy - pathData[len - 3]; - } - cmd = CMD.C; - x1 = p[off++]; - y1 = p[off++]; - cpx = p[off++]; - cpy = p[off++]; - path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy); - break; - case 's': - ctlPtx = cpx; - ctlPty = cpy; - len = path.len(); - pathData = path.data; - if (prevCmd === CMD.C) { - ctlPtx += cpx - pathData[len - 4]; - ctlPty += cpy - pathData[len - 3]; - } - cmd = CMD.C; - x1 = cpx + p[off++]; - y1 = cpy + p[off++]; - cpx += p[off++]; - cpy += p[off++]; - path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy); - break; - case 'Q': - x1 = p[off++]; - y1 = p[off++]; - cpx = p[off++]; - cpy = p[off++]; - cmd = CMD.Q; - path.addData(cmd, x1, y1, cpx, cpy); - break; - case 'q': - x1 = p[off++] + cpx; - y1 = p[off++] + cpy; - cpx += p[off++]; - cpy += p[off++]; - cmd = CMD.Q; - path.addData(cmd, x1, y1, cpx, cpy); - break; - case 'T': - ctlPtx = cpx; - ctlPty = cpy; - len = path.len(); - pathData = path.data; - if (prevCmd === CMD.Q) { - ctlPtx += cpx - pathData[len - 4]; - ctlPty += cpy - pathData[len - 3]; - } - cpx = p[off++]; - cpy = p[off++]; - cmd = CMD.Q; - path.addData(cmd, ctlPtx, ctlPty, cpx, cpy); - break; - case 't': - ctlPtx = cpx; - ctlPty = cpy; - len = path.len(); - pathData = path.data; - if (prevCmd === CMD.Q) { - ctlPtx += cpx - pathData[len - 4]; - ctlPty += cpy - pathData[len - 3]; - } - cpx += p[off++]; - cpy += p[off++]; - cmd = CMD.Q; - path.addData(cmd, ctlPtx, ctlPty, cpx, cpy); - break; - case 'A': - rx = p[off++]; - ry = p[off++]; - psi = p[off++]; - fa = p[off++]; - fs = p[off++]; - x1 = cpx, y1 = cpy; - cpx = p[off++]; - cpy = p[off++]; - cmd = CMD.A; - processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path); - break; - case 'a': - rx = p[off++]; - ry = p[off++]; - psi = p[off++]; - fa = p[off++]; - fs = p[off++]; - x1 = cpx, y1 = cpy; - cpx += p[off++]; - cpy += p[off++]; - cmd = CMD.A; - processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path); - break; - } - } - if (cmdStr === 'z' || cmdStr === 'Z') { - cmd = CMD.Z; - path.addData(cmd); - cpx = subpathX; - cpy = subpathY; - } - prevCmd = cmd; - } - path.toStatic(); - return path; -} -var SVGPath = (function (_super) { - __extends(SVGPath, _super); - function SVGPath() { - return _super !== null && _super.apply(this, arguments) || this; - } - SVGPath.prototype.applyTransform = function (m) { }; - return SVGPath; -}(Path)); -function isPathProxy(path) { - return path.setData != null; -} -function createPathOptions(str, opts) { - var pathProxy = createPathProxyFromString(str); - var innerOpts = extend({}, opts); - innerOpts.buildPath = function (path) { - if (isPathProxy(path)) { - path.setData(pathProxy.data); - var ctx = path.getContext(); - if (ctx) { - path.rebuildPath(ctx, 1); - } - } - else { - var ctx = path; - pathProxy.rebuildPath(ctx, 1); - } - }; - innerOpts.applyTransform = function (m) { - transformPath(pathProxy, m); - this.dirtyShape(); - }; - return innerOpts; -} -function createFromString(str, opts) { - return new SVGPath(createPathOptions(str, opts)); -} -function extendFromString(str, defaultOpts) { - var innerOpts = createPathOptions(str, defaultOpts); - var Sub = (function (_super) { - __extends(Sub, _super); - function Sub(opts) { - var _this = _super.call(this, opts) || this; - _this.applyTransform = innerOpts.applyTransform; - _this.buildPath = innerOpts.buildPath; - return _this; - } - return Sub; - }(SVGPath)); - return Sub; -} -function mergePath$1(pathEls, opts) { - var pathList = []; - var len = pathEls.length; - for (var i = 0; i < len; i++) { - var pathEl = pathEls[i]; - pathList.push(pathEl.getUpdatedPathProxy(true)); - } - var pathBundle = new Path(opts); - pathBundle.createPathProxy(); - pathBundle.buildPath = function (path) { - if (isPathProxy(path)) { - path.appendPath(pathList); - var ctx = path.getContext(); - if (ctx) { - path.rebuildPath(ctx, 1); - } - } - }; - return pathBundle; -} - -var CircleShape = (function () { - function CircleShape() { - this.cx = 0; - this.cy = 0; - this.r = 0; - } - return CircleShape; -}()); -var Circle = (function (_super) { - __extends(Circle, _super); - function Circle(opts) { - return _super.call(this, opts) || this; - } - Circle.prototype.getDefaultShape = function () { - return new CircleShape(); - }; - Circle.prototype.buildPath = function (ctx, shape) { - ctx.moveTo(shape.cx + shape.r, shape.cy); - ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2); - }; - return Circle; -}(Path)); -Circle.prototype.type = 'circle'; - -var EllipseShape = (function () { - function EllipseShape() { - this.cx = 0; - this.cy = 0; - this.rx = 0; - this.ry = 0; - } - return EllipseShape; -}()); -var Ellipse = (function (_super) { - __extends(Ellipse, _super); - function Ellipse(opts) { - return _super.call(this, opts) || this; - } - Ellipse.prototype.getDefaultShape = function () { - return new EllipseShape(); - }; - Ellipse.prototype.buildPath = function (ctx, shape) { - var k = 0.5522848; - var x = shape.cx; - var y = shape.cy; - var a = shape.rx; - var b = shape.ry; - var ox = a * k; - var oy = b * k; - ctx.moveTo(x - a, y); - ctx.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b); - ctx.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y); - ctx.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b); - ctx.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y); - ctx.closePath(); - }; - return Ellipse; -}(Path)); -Ellipse.prototype.type = 'ellipse'; - -var PI$2 = Math.PI; -var PI2$1 = PI$2 * 2; -var mathSin = Math.sin; -var mathCos = Math.cos; -var mathACos = Math.acos; -var mathATan2 = Math.atan2; -var mathAbs = Math.abs; -var mathSqrt = Math.sqrt; -var mathMax$2 = Math.max; -var mathMin$2 = Math.min; -var e = 1e-4; -function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { - var dx10 = x1 - x0; - var dy10 = y1 - y0; - var dx32 = x3 - x2; - var dy32 = y3 - y2; - var t = dy32 * dx10 - dx32 * dy10; - if (t * t < e) { - return; - } - t = (dx32 * (y0 - y2) - dy32 * (x0 - x2)) / t; - return [x0 + t * dx10, y0 + t * dy10]; -} -function computeCornerTangents(x0, y0, x1, y1, radius, cr, clockwise) { - var x01 = x0 - x1; - var y01 = y0 - y1; - var lo = (clockwise ? cr : -cr) / mathSqrt(x01 * x01 + y01 * y01); - var ox = lo * y01; - var oy = -lo * x01; - var x11 = x0 + ox; - var y11 = y0 + oy; - var x10 = x1 + ox; - var y10 = y1 + oy; - var x00 = (x11 + x10) / 2; - var y00 = (y11 + y10) / 2; - var dx = x10 - x11; - var dy = y10 - y11; - var d2 = dx * dx + dy * dy; - var r = radius - cr; - var s = x11 * y10 - x10 * y11; - var d = (dy < 0 ? -1 : 1) * mathSqrt(mathMax$2(0, r * r * d2 - s * s)); - var cx0 = (s * dy - dx * d) / d2; - var cy0 = (-s * dx - dy * d) / d2; - var cx1 = (s * dy + dx * d) / d2; - var cy1 = (-s * dx + dy * d) / d2; - var dx0 = cx0 - x00; - var dy0 = cy0 - y00; - var dx1 = cx1 - x00; - var dy1 = cy1 - y00; - if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) { - cx0 = cx1; - cy0 = cy1; - } - return { - cx: cx0, - cy: cy0, - x0: -ox, - y0: -oy, - x1: cx0 * (radius / r - 1), - y1: cy0 * (radius / r - 1) - }; -} -function normalizeCornerRadius(cr) { - var arr; - if (isArray(cr)) { - var len = cr.length; - if (!len) { - return cr; - } - if (len === 1) { - arr = [cr[0], cr[0], 0, 0]; - } - else if (len === 2) { - arr = [cr[0], cr[0], cr[1], cr[1]]; - } - else if (len === 3) { - arr = cr.concat(cr[2]); - } - else { - arr = cr; - } - } - else { - arr = [cr, cr, cr, cr]; - } - return arr; -} -function buildPath$1(ctx, shape) { - var _a; - var radius = mathMax$2(shape.r, 0); - var innerRadius = mathMax$2(shape.r0 || 0, 0); - var hasRadius = radius > 0; - var hasInnerRadius = innerRadius > 0; - if (!hasRadius && !hasInnerRadius) { - return; - } - if (!hasRadius) { - radius = innerRadius; - innerRadius = 0; - } - if (innerRadius > radius) { - var tmp = radius; - radius = innerRadius; - innerRadius = tmp; - } - var startAngle = shape.startAngle, endAngle = shape.endAngle; - if (isNaN(startAngle) || isNaN(endAngle)) { - return; - } - var cx = shape.cx, cy = shape.cy; - var clockwise = !!shape.clockwise; - var arc = mathAbs(endAngle - startAngle); - var mod = arc > PI2$1 && arc % PI2$1; - mod > e && (arc = mod); - if (!(radius > e)) { - ctx.moveTo(cx, cy); - } - else if (arc > PI2$1 - e) { - ctx.moveTo(cx + radius * mathCos(startAngle), cy + radius * mathSin(startAngle)); - ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise); - if (innerRadius > e) { - ctx.moveTo(cx + innerRadius * mathCos(endAngle), cy + innerRadius * mathSin(endAngle)); - ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise); - } - } - else { - var icrStart = void 0; - var icrEnd = void 0; - var ocrStart = void 0; - var ocrEnd = void 0; - var ocrs = void 0; - var ocre = void 0; - var icrs = void 0; - var icre = void 0; - var ocrMax = void 0; - var icrMax = void 0; - var limitedOcrMax = void 0; - var limitedIcrMax = void 0; - var xre = void 0; - var yre = void 0; - var xirs = void 0; - var yirs = void 0; - var xrs = radius * mathCos(startAngle); - var yrs = radius * mathSin(startAngle); - var xire = innerRadius * mathCos(endAngle); - var yire = innerRadius * mathSin(endAngle); - var hasArc = arc > e; - if (hasArc) { - var cornerRadius = shape.cornerRadius; - if (cornerRadius) { - _a = normalizeCornerRadius(cornerRadius), icrStart = _a[0], icrEnd = _a[1], ocrStart = _a[2], ocrEnd = _a[3]; - } - var halfRd = mathAbs(radius - innerRadius) / 2; - ocrs = mathMin$2(halfRd, ocrStart); - ocre = mathMin$2(halfRd, ocrEnd); - icrs = mathMin$2(halfRd, icrStart); - icre = mathMin$2(halfRd, icrEnd); - limitedOcrMax = ocrMax = mathMax$2(ocrs, ocre); - limitedIcrMax = icrMax = mathMax$2(icrs, icre); - if (ocrMax > e || icrMax > e) { - xre = radius * mathCos(endAngle); - yre = radius * mathSin(endAngle); - xirs = innerRadius * mathCos(startAngle); - yirs = innerRadius * mathSin(startAngle); - if (arc < PI$2) { - var it_1 = intersect(xrs, yrs, xirs, yirs, xre, yre, xire, yire); - if (it_1) { - var x0 = xrs - it_1[0]; - var y0 = yrs - it_1[1]; - var x1 = xre - it_1[0]; - var y1 = yre - it_1[1]; - var a = 1 / mathSin(mathACos((x0 * x1 + y0 * y1) / (mathSqrt(x0 * x0 + y0 * y0) * mathSqrt(x1 * x1 + y1 * y1))) / 2); - var b = mathSqrt(it_1[0] * it_1[0] + it_1[1] * it_1[1]); - limitedOcrMax = mathMin$2(ocrMax, (radius - b) / (a + 1)); - limitedIcrMax = mathMin$2(icrMax, (innerRadius - b) / (a - 1)); - } - } - } - } - if (!hasArc) { - ctx.moveTo(cx + xrs, cy + yrs); - } - else if (limitedOcrMax > e) { - var crStart = mathMin$2(ocrStart, limitedOcrMax); - var crEnd = mathMin$2(ocrEnd, limitedOcrMax); - var ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, radius, crStart, clockwise); - var ct1 = computeCornerTangents(xre, yre, xire, yire, radius, crEnd, clockwise); - ctx.moveTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0); - if (limitedOcrMax < ocrMax && crStart === crEnd) { - ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedOcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise); - } - else { - crStart > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crStart, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise); - ctx.arc(cx, cy, radius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), !clockwise); - crEnd > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crEnd, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise); - } - } - else { - ctx.moveTo(cx + xrs, cy + yrs); - ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise); - } - if (!(innerRadius > e) || !hasArc) { - ctx.lineTo(cx + xire, cy + yire); - } - else if (limitedIcrMax > e) { - var crStart = mathMin$2(icrStart, limitedIcrMax); - var crEnd = mathMin$2(icrEnd, limitedIcrMax); - var ct0 = computeCornerTangents(xire, yire, xre, yre, innerRadius, -crEnd, clockwise); - var ct1 = computeCornerTangents(xrs, yrs, xirs, yirs, innerRadius, -crStart, clockwise); - ctx.lineTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0); - if (limitedIcrMax < icrMax && crStart === crEnd) { - ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedIcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise); - } - else { - crEnd > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crEnd, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise); - ctx.arc(cx, cy, innerRadius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), clockwise); - crStart > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crStart, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise); - } - } - else { - ctx.lineTo(cx + xire, cy + yire); - ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise); - } - } - ctx.closePath(); -} - -var SectorShape = (function () { - function SectorShape() { - this.cx = 0; - this.cy = 0; - this.r0 = 0; - this.r = 0; - this.startAngle = 0; - this.endAngle = Math.PI * 2; - this.clockwise = true; - this.cornerRadius = 0; - } - return SectorShape; -}()); -var Sector = (function (_super) { - __extends(Sector, _super); - function Sector(opts) { - return _super.call(this, opts) || this; - } - Sector.prototype.getDefaultShape = function () { - return new SectorShape(); - }; - Sector.prototype.buildPath = function (ctx, shape) { - buildPath$1(ctx, shape); - }; - Sector.prototype.isZeroArea = function () { - return this.shape.startAngle === this.shape.endAngle - || this.shape.r === this.shape.r0; - }; - return Sector; -}(Path)); -Sector.prototype.type = 'sector'; - -var RingShape = (function () { - function RingShape() { - this.cx = 0; - this.cy = 0; - this.r = 0; - this.r0 = 0; - } - return RingShape; -}()); -var Ring = (function (_super) { - __extends(Ring, _super); - function Ring(opts) { - return _super.call(this, opts) || this; - } - Ring.prototype.getDefaultShape = function () { - return new RingShape(); - }; - Ring.prototype.buildPath = function (ctx, shape) { - var x = shape.cx; - var y = shape.cy; - var PI2 = Math.PI * 2; - ctx.moveTo(x + shape.r, y); - ctx.arc(x, y, shape.r, 0, PI2, false); - ctx.moveTo(x + shape.r0, y); - ctx.arc(x, y, shape.r0, 0, PI2, true); - }; - return Ring; -}(Path)); -Ring.prototype.type = 'ring'; - -function smoothBezier(points, smooth, isLoop, constraint) { - var cps = []; - var v = []; - var v1 = []; - var v2 = []; - var prevPoint; - var nextPoint; - var min; - var max; - if (constraint) { - min = [Infinity, Infinity]; - max = [-Infinity, -Infinity]; - for (var i = 0, len = points.length; i < len; i++) { - min$1(min, min, points[i]); - max$1(max, max, points[i]); - } - min$1(min, min, constraint[0]); - max$1(max, max, constraint[1]); - } - for (var i = 0, len = points.length; i < len; i++) { - var point = points[i]; - if (isLoop) { - prevPoint = points[i ? i - 1 : len - 1]; - nextPoint = points[(i + 1) % len]; - } - else { - if (i === 0 || i === len - 1) { - cps.push(clone$1(points[i])); - continue; - } - else { - prevPoint = points[i - 1]; - nextPoint = points[i + 1]; - } - } - sub(v, nextPoint, prevPoint); - scale$2(v, v, smooth); - var d0 = distance(point, prevPoint); - var d1 = distance(point, nextPoint); - var sum = d0 + d1; - if (sum !== 0) { - d0 /= sum; - d1 /= sum; - } - scale$2(v1, v, -d0); - scale$2(v2, v, d1); - var cp0 = add([], point, v1); - var cp1 = add([], point, v2); - if (constraint) { - max$1(cp0, cp0, min); - min$1(cp0, cp0, max); - max$1(cp1, cp1, min); - min$1(cp1, cp1, max); - } - cps.push(cp0); - cps.push(cp1); - } - if (isLoop) { - cps.push(cps.shift()); - } - return cps; -} - -function buildPath(ctx, shape, closePath) { - var smooth = shape.smooth; - var points = shape.points; - if (points && points.length >= 2) { - if (smooth) { - var controlPoints = smoothBezier(points, smooth, closePath, shape.smoothConstraint); - ctx.moveTo(points[0][0], points[0][1]); - var len = points.length; - for (var i = 0; i < (closePath ? len : len - 1); i++) { - var cp1 = controlPoints[i * 2]; - var cp2 = controlPoints[i * 2 + 1]; - var p = points[(i + 1) % len]; - ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]); - } - } - else { - ctx.moveTo(points[0][0], points[0][1]); - for (var i = 1, l = points.length; i < l; i++) { - ctx.lineTo(points[i][0], points[i][1]); - } - } - closePath && ctx.closePath(); - } -} - -var PolygonShape = (function () { - function PolygonShape() { - this.points = null; - this.smooth = 0; - this.smoothConstraint = null; - } - return PolygonShape; -}()); -var Polygon = (function (_super) { - __extends(Polygon, _super); - function Polygon(opts) { - return _super.call(this, opts) || this; - } - Polygon.prototype.getDefaultShape = function () { - return new PolygonShape(); - }; - Polygon.prototype.buildPath = function (ctx, shape) { - buildPath(ctx, shape, true); - }; - return Polygon; -}(Path)); -Polygon.prototype.type = 'polygon'; - -var PolylineShape = (function () { - function PolylineShape() { - this.points = null; - this.percent = 1; - this.smooth = 0; - this.smoothConstraint = null; - } - return PolylineShape; -}()); -var Polyline = (function (_super) { - __extends(Polyline, _super); - function Polyline(opts) { - return _super.call(this, opts) || this; - } - Polyline.prototype.getDefaultStyle = function () { - return { - stroke: '#000', - fill: null - }; - }; - Polyline.prototype.getDefaultShape = function () { - return new PolylineShape(); - }; - Polyline.prototype.buildPath = function (ctx, shape) { - buildPath(ctx, shape, false); - }; - return Polyline; -}(Path)); -Polyline.prototype.type = 'polyline'; - -var subPixelOptimizeOutputShape = {}; -var LineShape = (function () { - function LineShape() { - this.x1 = 0; - this.y1 = 0; - this.x2 = 0; - this.y2 = 0; - this.percent = 1; - } - return LineShape; -}()); -var Line = (function (_super) { - __extends(Line, _super); - function Line(opts) { - return _super.call(this, opts) || this; - } - Line.prototype.getDefaultStyle = function () { - return { - stroke: '#000', - fill: null - }; - }; - Line.prototype.getDefaultShape = function () { - return new LineShape(); - }; - Line.prototype.buildPath = function (ctx, shape) { - var x1; - var y1; - var x2; - var y2; - if (this.subPixelOptimize) { - var optimizedShape = subPixelOptimizeLine$1(subPixelOptimizeOutputShape, shape, this.style); - x1 = optimizedShape.x1; - y1 = optimizedShape.y1; - x2 = optimizedShape.x2; - y2 = optimizedShape.y2; - } - else { - x1 = shape.x1; - y1 = shape.y1; - x2 = shape.x2; - y2 = shape.y2; - } - var percent = shape.percent; - if (percent === 0) { - return; - } - ctx.moveTo(x1, y1); - if (percent < 1) { - x2 = x1 * (1 - percent) + x2 * percent; - y2 = y1 * (1 - percent) + y2 * percent; - } - ctx.lineTo(x2, y2); - }; - Line.prototype.pointAt = function (p) { - var shape = this.shape; - return [ - shape.x1 * (1 - p) + shape.x2 * p, - shape.y1 * (1 - p) + shape.y2 * p - ]; - }; - return Line; -}(Path)); -Line.prototype.type = 'line'; - -var out = []; -var BezierCurveShape = (function () { - function BezierCurveShape() { - this.x1 = 0; - this.y1 = 0; - this.x2 = 0; - this.y2 = 0; - this.cpx1 = 0; - this.cpy1 = 0; - this.percent = 1; - } - return BezierCurveShape; -}()); -function someVectorAt(shape, t, isTangent) { - var cpx2 = shape.cpx2; - var cpy2 = shape.cpy2; - if (cpx2 != null || cpy2 != null) { - return [ - (isTangent ? cubicDerivativeAt : cubicAt)(shape.x1, shape.cpx1, shape.cpx2, shape.x2, t), - (isTangent ? cubicDerivativeAt : cubicAt)(shape.y1, shape.cpy1, shape.cpy2, shape.y2, t) - ]; - } - else { - return [ - (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.x1, shape.cpx1, shape.x2, t), - (isTangent ? quadraticDerivativeAt : quadraticAt)(shape.y1, shape.cpy1, shape.y2, t) - ]; - } -} -var BezierCurve = (function (_super) { - __extends(BezierCurve, _super); - function BezierCurve(opts) { - return _super.call(this, opts) || this; - } - BezierCurve.prototype.getDefaultStyle = function () { - return { - stroke: '#000', - fill: null - }; - }; - BezierCurve.prototype.getDefaultShape = function () { - return new BezierCurveShape(); - }; - BezierCurve.prototype.buildPath = function (ctx, shape) { - var x1 = shape.x1; - var y1 = shape.y1; - var x2 = shape.x2; - var y2 = shape.y2; - var cpx1 = shape.cpx1; - var cpy1 = shape.cpy1; - var cpx2 = shape.cpx2; - var cpy2 = shape.cpy2; - var percent = shape.percent; - if (percent === 0) { - return; - } - ctx.moveTo(x1, y1); - if (cpx2 == null || cpy2 == null) { - if (percent < 1) { - quadraticSubdivide(x1, cpx1, x2, percent, out); - cpx1 = out[1]; - x2 = out[2]; - quadraticSubdivide(y1, cpy1, y2, percent, out); - cpy1 = out[1]; - y2 = out[2]; - } - ctx.quadraticCurveTo(cpx1, cpy1, x2, y2); - } - else { - if (percent < 1) { - cubicSubdivide(x1, cpx1, cpx2, x2, percent, out); - cpx1 = out[1]; - cpx2 = out[2]; - x2 = out[3]; - cubicSubdivide(y1, cpy1, cpy2, y2, percent, out); - cpy1 = out[1]; - cpy2 = out[2]; - y2 = out[3]; - } - ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2); - } - }; - BezierCurve.prototype.pointAt = function (t) { - return someVectorAt(this.shape, t, false); - }; - BezierCurve.prototype.tangentAt = function (t) { - var p = someVectorAt(this.shape, t, true); - return normalize$1(p, p); - }; - return BezierCurve; -}(Path)); -BezierCurve.prototype.type = 'bezier-curve'; - -var ArcShape = (function () { - function ArcShape() { - this.cx = 0; - this.cy = 0; - this.r = 0; - this.startAngle = 0; - this.endAngle = Math.PI * 2; - this.clockwise = true; - } - return ArcShape; -}()); -var Arc = (function (_super) { - __extends(Arc, _super); - function Arc(opts) { - return _super.call(this, opts) || this; - } - Arc.prototype.getDefaultStyle = function () { - return { - stroke: '#000', - fill: null - }; - }; - Arc.prototype.getDefaultShape = function () { - return new ArcShape(); - }; - Arc.prototype.buildPath = function (ctx, shape) { - var x = shape.cx; - var y = shape.cy; - var r = Math.max(shape.r, 0); - var startAngle = shape.startAngle; - var endAngle = shape.endAngle; - var clockwise = shape.clockwise; - var unitX = Math.cos(startAngle); - var unitY = Math.sin(startAngle); - ctx.moveTo(unitX * r + x, unitY * r + y); - ctx.arc(x, y, r, startAngle, endAngle, !clockwise); - }; - return Arc; -}(Path)); -Arc.prototype.type = 'arc'; - -var CompoundPath = (function (_super) { - __extends(CompoundPath, _super); - function CompoundPath() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = 'compound'; - return _this; - } - CompoundPath.prototype._updatePathDirty = function () { - var paths = this.shape.paths; - var dirtyPath = this.shapeChanged(); - for (var i = 0; i < paths.length; i++) { - dirtyPath = dirtyPath || paths[i].shapeChanged(); - } - if (dirtyPath) { - this.dirtyShape(); - } - }; - CompoundPath.prototype.beforeBrush = function () { - this._updatePathDirty(); - var paths = this.shape.paths || []; - var scale = this.getGlobalScale(); - for (var i = 0; i < paths.length; i++) { - if (!paths[i].path) { - paths[i].createPathProxy(); - } - paths[i].path.setScale(scale[0], scale[1], paths[i].segmentIgnoreThreshold); - } - }; - CompoundPath.prototype.buildPath = function (ctx, shape) { - var paths = shape.paths || []; - for (var i = 0; i < paths.length; i++) { - paths[i].buildPath(ctx, paths[i].shape, true); - } - }; - CompoundPath.prototype.afterBrush = function () { - var paths = this.shape.paths || []; - for (var i = 0; i < paths.length; i++) { - paths[i].pathUpdated(); - } - }; - CompoundPath.prototype.getBoundingRect = function () { - this._updatePathDirty.call(this); - return Path.prototype.getBoundingRect.call(this); - }; - return CompoundPath; -}(Path)); - -var Gradient = (function () { - function Gradient(colorStops) { - this.colorStops = colorStops || []; - } - Gradient.prototype.addColorStop = function (offset, color) { - this.colorStops.push({ - offset: offset, - color: color - }); - }; - return Gradient; -}()); - -var LinearGradient = (function (_super) { - __extends(LinearGradient, _super); - function LinearGradient(x, y, x2, y2, colorStops, globalCoord) { - var _this = _super.call(this, colorStops) || this; - _this.x = x == null ? 0 : x; - _this.y = y == null ? 0 : y; - _this.x2 = x2 == null ? 1 : x2; - _this.y2 = y2 == null ? 0 : y2; - _this.type = 'linear'; - _this.global = globalCoord || false; - return _this; - } - return LinearGradient; -}(Gradient)); - -var RadialGradient = (function (_super) { - __extends(RadialGradient, _super); - function RadialGradient(x, y, r, colorStops, globalCoord) { - var _this = _super.call(this, colorStops) || this; - _this.x = x == null ? 0.5 : x; - _this.y = y == null ? 0.5 : y; - _this.r = r == null ? 0.5 : r; - _this.type = 'radial'; - _this.global = globalCoord || false; - return _this; - } - return RadialGradient; -}(Gradient)); - -var extent = [0, 0]; -var extent2 = [0, 0]; -var minTv = new Point(); -var maxTv = new Point(); -var OrientedBoundingRect = (function () { - function OrientedBoundingRect(rect, transform) { - this._corners = []; - this._axes = []; - this._origin = [0, 0]; - for (var i = 0; i < 4; i++) { - this._corners[i] = new Point(); - } - for (var i = 0; i < 2; i++) { - this._axes[i] = new Point(); - } - if (rect) { - this.fromBoundingRect(rect, transform); - } - } - OrientedBoundingRect.prototype.fromBoundingRect = function (rect, transform) { - var corners = this._corners; - var axes = this._axes; - var x = rect.x; - var y = rect.y; - var x2 = x + rect.width; - var y2 = y + rect.height; - corners[0].set(x, y); - corners[1].set(x2, y); - corners[2].set(x2, y2); - corners[3].set(x, y2); - if (transform) { - for (var i = 0; i < 4; i++) { - corners[i].transform(transform); - } - } - Point.sub(axes[0], corners[1], corners[0]); - Point.sub(axes[1], corners[3], corners[0]); - axes[0].normalize(); - axes[1].normalize(); - for (var i = 0; i < 2; i++) { - this._origin[i] = axes[i].dot(corners[0]); - } - }; - OrientedBoundingRect.prototype.intersect = function (other, mtv) { - var overlapped = true; - var noMtv = !mtv; - minTv.set(Infinity, Infinity); - maxTv.set(0, 0); - if (!this._intersectCheckOneSide(this, other, minTv, maxTv, noMtv, 1)) { - overlapped = false; - if (noMtv) { - return overlapped; - } - } - if (!this._intersectCheckOneSide(other, this, minTv, maxTv, noMtv, -1)) { - overlapped = false; - if (noMtv) { - return overlapped; - } - } - if (!noMtv) { - Point.copy(mtv, overlapped ? minTv : maxTv); - } - return overlapped; - }; - OrientedBoundingRect.prototype._intersectCheckOneSide = function (self, other, minTv, maxTv, noMtv, inverse) { - var overlapped = true; - for (var i = 0; i < 2; i++) { - var axis = this._axes[i]; - this._getProjMinMaxOnAxis(i, self._corners, extent); - this._getProjMinMaxOnAxis(i, other._corners, extent2); - if (extent[1] < extent2[0] || extent[0] > extent2[1]) { - overlapped = false; - if (noMtv) { - return overlapped; - } - var dist0 = Math.abs(extent2[0] - extent[1]); - var dist1 = Math.abs(extent[0] - extent2[1]); - if (Math.min(dist0, dist1) > maxTv.len()) { - if (dist0 < dist1) { - Point.scale(maxTv, axis, -dist0 * inverse); - } - else { - Point.scale(maxTv, axis, dist1 * inverse); - } - } - } - else if (minTv) { - var dist0 = Math.abs(extent2[0] - extent[1]); - var dist1 = Math.abs(extent[0] - extent2[1]); - if (Math.min(dist0, dist1) < minTv.len()) { - if (dist0 < dist1) { - Point.scale(minTv, axis, dist0 * inverse); - } - else { - Point.scale(minTv, axis, -dist1 * inverse); - } - } - } - } - return overlapped; - }; - OrientedBoundingRect.prototype._getProjMinMaxOnAxis = function (dim, corners, out) { - var axis = this._axes[dim]; - var origin = this._origin; - var proj = corners[0].dot(axis) + origin[dim]; - var min = proj; - var max = proj; - for (var i = 1; i < corners.length; i++) { - var proj_1 = corners[i].dot(axis) + origin[dim]; - min = Math.min(proj_1, min); - max = Math.max(proj_1, max); - } - out[0] = min; - out[1] = max; - }; - return OrientedBoundingRect; -}()); - -var m = []; -var IncrementalDisplayable = (function (_super) { - __extends(IncrementalDisplayable, _super); - function IncrementalDisplayable() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.notClear = true; - _this.incremental = true; - _this._displayables = []; - _this._temporaryDisplayables = []; - _this._cursor = 0; - return _this; - } - IncrementalDisplayable.prototype.traverse = function (cb, context) { - cb.call(context, this); - }; - IncrementalDisplayable.prototype.useStyle = function () { - this.style = {}; - }; - IncrementalDisplayable.prototype.getCursor = function () { - return this._cursor; - }; - IncrementalDisplayable.prototype.innerAfterBrush = function () { - this._cursor = this._displayables.length; - }; - IncrementalDisplayable.prototype.clearDisplaybles = function () { - this._displayables = []; - this._temporaryDisplayables = []; - this._cursor = 0; - this.markRedraw(); - this.notClear = false; - }; - IncrementalDisplayable.prototype.clearTemporalDisplayables = function () { - this._temporaryDisplayables = []; - }; - IncrementalDisplayable.prototype.addDisplayable = function (displayable, notPersistent) { - if (notPersistent) { - this._temporaryDisplayables.push(displayable); - } - else { - this._displayables.push(displayable); - } - this.markRedraw(); - }; - IncrementalDisplayable.prototype.addDisplayables = function (displayables, notPersistent) { - notPersistent = notPersistent || false; - for (var i = 0; i < displayables.length; i++) { - this.addDisplayable(displayables[i], notPersistent); - } - }; - IncrementalDisplayable.prototype.getDisplayables = function () { - return this._displayables; - }; - IncrementalDisplayable.prototype.getTemporalDisplayables = function () { - return this._temporaryDisplayables; - }; - IncrementalDisplayable.prototype.eachPendingDisplayable = function (cb) { - for (var i = this._cursor; i < this._displayables.length; i++) { - cb && cb(this._displayables[i]); - } - for (var i = 0; i < this._temporaryDisplayables.length; i++) { - cb && cb(this._temporaryDisplayables[i]); - } - }; - IncrementalDisplayable.prototype.update = function () { - this.updateTransform(); - for (var i = this._cursor; i < this._displayables.length; i++) { - var displayable = this._displayables[i]; - displayable.parent = this; - displayable.update(); - displayable.parent = null; - } - for (var i = 0; i < this._temporaryDisplayables.length; i++) { - var displayable = this._temporaryDisplayables[i]; - displayable.parent = this; - displayable.update(); - displayable.parent = null; - } - }; - IncrementalDisplayable.prototype.getBoundingRect = function () { - if (!this._rect) { - var rect = new BoundingRect(Infinity, Infinity, -Infinity, -Infinity); - for (var i = 0; i < this._displayables.length; i++) { - var displayable = this._displayables[i]; - var childRect = displayable.getBoundingRect().clone(); - if (displayable.needLocalTransform()) { - childRect.applyTransform(displayable.getLocalTransform(m)); - } - rect.union(childRect); - } - this._rect = rect; - } - return this._rect; - }; - IncrementalDisplayable.prototype.contain = function (x, y) { - var localPos = this.transformCoordToLocal(x, y); - var rect = this.getBoundingRect(); - if (rect.contain(localPos[0], localPos[1])) { - for (var i = 0; i < this._displayables.length; i++) { - var displayable = this._displayables[i]; - if (displayable.contain(x, y)) { - return true; - } - } - } - return false; - }; - return IncrementalDisplayable; -}(Displayable)); - -// Stored properties for further transition. -var transitionStore = makeInner(); -/** - * Return null if animation is disabled. - */ -function getAnimationConfig(animationType, animatableModel, dataIndex, -// Extra opts can override the option in animatable model. -extraOpts, -// TODO It's only for pictorial bar now. -extraDelayParams) { - var animationPayload; - // Check if there is global animation configuration from dataZoom/resize can override the config in option. - // If animation is enabled. Will use this animation config in payload. - // If animation is disabled. Just ignore it. - if (animatableModel && animatableModel.ecModel) { - var updatePayload = animatableModel.ecModel.getUpdatePayload(); - animationPayload = updatePayload && updatePayload.animation; - } - var animationEnabled = animatableModel && animatableModel.isAnimationEnabled(); - var isUpdate = animationType === 'update'; - if (animationEnabled) { - var duration = void 0; - var easing = void 0; - var delay = void 0; - if (extraOpts) { - duration = retrieve2(extraOpts.duration, 200); - easing = retrieve2(extraOpts.easing, 'cubicOut'); - delay = 0; - } else { - duration = animatableModel.getShallow(isUpdate ? 'animationDurationUpdate' : 'animationDuration'); - easing = animatableModel.getShallow(isUpdate ? 'animationEasingUpdate' : 'animationEasing'); - delay = animatableModel.getShallow(isUpdate ? 'animationDelayUpdate' : 'animationDelay'); - } - // animation from payload has highest priority. - if (animationPayload) { - animationPayload.duration != null && (duration = animationPayload.duration); - animationPayload.easing != null && (easing = animationPayload.easing); - animationPayload.delay != null && (delay = animationPayload.delay); - } - if (isFunction(delay)) { - delay = delay(dataIndex, extraDelayParams); - } - if (isFunction(duration)) { - duration = duration(dataIndex); - } - var config = { - duration: duration || 0, - delay: delay, - easing: easing - }; - return config; - } else { - return null; - } -} -function animateOrSetProps(animationType, el, props, animatableModel, dataIndex, cb, during) { - var isFrom = false; - var removeOpt; - if (isFunction(dataIndex)) { - during = cb; - cb = dataIndex; - dataIndex = null; - } else if (isObject$2(dataIndex)) { - cb = dataIndex.cb; - during = dataIndex.during; - isFrom = dataIndex.isFrom; - removeOpt = dataIndex.removeOpt; - dataIndex = dataIndex.dataIndex; - } - var isRemove = animationType === 'leave'; - if (!isRemove) { - // Must stop the remove animation. - el.stopAnimation('leave'); - } - var animationConfig = getAnimationConfig(animationType, animatableModel, dataIndex, isRemove ? removeOpt || {} : null, animatableModel && animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null); - if (animationConfig && animationConfig.duration > 0) { - var duration = animationConfig.duration; - var animationDelay = animationConfig.delay; - var animationEasing = animationConfig.easing; - var animateConfig = { - duration: duration, - delay: animationDelay || 0, - easing: animationEasing, - done: cb, - force: !!cb || !!during, - // Set to final state in update/init animation. - // So the post processing based on the path shape can be done correctly. - setToFinal: !isRemove, - scope: animationType, - during: during - }; - isFrom ? el.animateFrom(props, animateConfig) : el.animateTo(props, animateConfig); - } else { - el.stopAnimation(); - // If `isFrom`, the props is the "from" props. - !isFrom && el.attr(props); - // Call during at least once. - during && during(1); - cb && cb(); - } -} -/** - * Update graphic element properties with or without animation according to the - * configuration in series. - * - * Caution: this method will stop previous animation. - * So do not use this method to one element twice before - * animation starts, unless you know what you are doing. - * @example - * graphic.updateProps(el, { - * position: [100, 100] - * }, seriesModel, dataIndex, function () { console.log('Animation done!'); }); - * // Or - * graphic.updateProps(el, { - * position: [100, 100] - * }, seriesModel, function () { console.log('Animation done!'); }); - */ -function updateProps$1(el, props, -// TODO: TYPE AnimatableModel -animatableModel, dataIndex, cb, during) { - animateOrSetProps('update', el, props, animatableModel, dataIndex, cb, during); -} -/** - * Init graphic element properties with or without animation according to the - * configuration in series. - * - * Caution: this method will stop previous animation. - * So do not use this method to one element twice before - * animation starts, unless you know what you are doing. - */ -function initProps(el, props, animatableModel, dataIndex, cb, during) { - animateOrSetProps('enter', el, props, animatableModel, dataIndex, cb, during); -} -/** - * If element is removed. - * It can determine if element is having remove animation. - */ -function isElementRemoved(el) { - if (!el.__zr) { - return true; - } - for (var i = 0; i < el.animators.length; i++) { - var animator = el.animators[i]; - if (animator.scope === 'leave') { - return true; - } - } - return false; -} -/** - * Remove graphic element - */ -function removeElement(el, props, animatableModel, dataIndex, cb, during) { - // Don't do remove animation twice. - if (isElementRemoved(el)) { - return; - } - animateOrSetProps('leave', el, props, animatableModel, dataIndex, cb, during); -} -function fadeOutDisplayable(el, animatableModel, dataIndex, done) { - el.removeTextContent(); - el.removeTextGuideLine(); - removeElement(el, { - style: { - opacity: 0 - } - }, animatableModel, dataIndex, done); -} -function removeElementWithFadeOut(el, animatableModel, dataIndex) { - function doRemove() { - el.parent && el.parent.remove(el); - } - // Hide label and labelLine first - // TODO Also use fade out animation? - if (!el.isGroup) { - fadeOutDisplayable(el, animatableModel, dataIndex, doRemove); - } else { - el.traverse(function (disp) { - if (!disp.isGroup) { - // Can invoke doRemove multiple times. - fadeOutDisplayable(disp, animatableModel, dataIndex, doRemove); - } - }); - } -} -/** - * Save old style for style transition in universalTransition module. - * It's used when element will be reused in each render. - * For chart like map, heatmap, which will always create new element. - * We don't need to save this because universalTransition can get old style from the old element - */ -function saveOldStyle(el) { - transitionStore(el).oldStyle = el.style; -} - -var mathMax$1 = Math.max; -var mathMin$1 = Math.min; -var _customShapeMap = {}; -/** - * Extend shape with parameters - */ -function extendShape(opts) { - return Path.extend(opts); -} -var extendPathFromString = extendFromString; -/** - * Extend path - */ -function extendPath(pathData, opts) { - return extendPathFromString(pathData, opts); -} -/** - * Register a user defined shape. - * The shape class can be fetched by `getShapeClass` - * This method will overwrite the registered shapes, including - * the registered built-in shapes, if using the same `name`. - * The shape can be used in `custom series` and - * `graphic component` by declaring `{type: name}`. - * - * @param name - * @param ShapeClass Can be generated by `extendShape`. - */ -function registerShape(name, ShapeClass) { - _customShapeMap[name] = ShapeClass; -} -/** - * Find shape class registered by `registerShape`. Usually used in - * fetching user defined shape. - * - * [Caution]: - * (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared - * to use user registered shapes. - * Because the built-in shape (see `getBuiltInShape`) will be registered by - * `registerShape` by default. That enables users to get both built-in - * shapes as well as the shapes belonging to themsleves. But users can overwrite - * the built-in shapes by using names like 'circle', 'rect' via calling - * `registerShape`. So the echarts inner featrues should not fetch shapes from here - * in case that it is overwritten by users, except that some features, like - * `custom series`, `graphic component`, do it deliberately. - * - * (2) In the features like `custom series`, `graphic component`, the user input - * `{tpye: 'xxx'}` does not only specify shapes but also specify other graphic - * elements like `'group'`, `'text'`, `'image'` or event `'path'`. Those names - * are reserved names, that is, if some user registers a shape named `'image'`, - * the shape will not be used. If we intending to add some more reserved names - * in feature, that might bring break changes (disable some existing user shape - * names). But that case probably rarely happens. So we don't make more mechanism - * to resolve this issue here. - * - * @param name - * @return The shape class. If not found, return nothing. - */ -function getShapeClass(name) { - if (_customShapeMap.hasOwnProperty(name)) { - return _customShapeMap[name]; - } -} -/** - * Create a path element from path data string - * @param pathData - * @param opts - * @param rect - * @param layout 'center' or 'cover' default to be cover - */ -function makePath(pathData, opts, rect, layout) { - var path = createFromString(pathData, opts); - if (rect) { - if (layout === 'center') { - rect = centerGraphic(rect, path.getBoundingRect()); - } - resizePath(path, rect); - } - return path; -} -/** - * Create a image element from image url - * @param imageUrl image url - * @param opts options - * @param rect constrain rect - * @param layout 'center' or 'cover'. Default to be 'cover' - */ -function makeImage(imageUrl, rect, layout) { - var zrImg = new ZRImage({ - style: { - image: imageUrl, - x: rect.x, - y: rect.y, - width: rect.width, - height: rect.height - }, - onload: function (img) { - if (layout === 'center') { - var boundingRect = { - width: img.width, - height: img.height - }; - zrImg.setStyle(centerGraphic(rect, boundingRect)); - } - } - }); - return zrImg; -} -/** - * Get position of centered element in bounding box. - * - * @param rect element local bounding box - * @param boundingRect constraint bounding box - * @return element position containing x, y, width, and height - */ -function centerGraphic(rect, boundingRect) { - // Set rect to center, keep width / height ratio. - var aspect = boundingRect.width / boundingRect.height; - var width = rect.height * aspect; - var height; - if (width <= rect.width) { - height = rect.height; - } else { - width = rect.width; - height = width / aspect; - } - var cx = rect.x + rect.width / 2; - var cy = rect.y + rect.height / 2; - return { - x: cx - width / 2, - y: cy - height / 2, - width: width, - height: height - }; -} -var mergePath = mergePath$1; -/** - * Resize a path to fit the rect - * @param path - * @param rect - */ -function resizePath(path, rect) { - if (!path.applyTransform) { - return; - } - var pathRect = path.getBoundingRect(); - var m = pathRect.calculateTransform(rect); - path.applyTransform(m); -} -/** - * Sub pixel optimize line for canvas - */ -function subPixelOptimizeLine(shape, lineWidth) { - subPixelOptimizeLine$1(shape, shape, { - lineWidth: lineWidth - }); - return shape; -} -/** - * Sub pixel optimize rect for canvas - */ -function subPixelOptimizeRect(param) { - subPixelOptimizeRect$1(param.shape, param.shape, param.style); - return param; -} -/** - * Sub pixel optimize for canvas - * - * @param position Coordinate, such as x, y - * @param lineWidth Should be nonnegative integer. - * @param positiveOrNegative Default false (negative). - * @return Optimized position. - */ -var subPixelOptimize = subPixelOptimize$1; -/** - * Get transform matrix of target (param target), - * in coordinate of its ancestor (param ancestor) - * - * @param target - * @param [ancestor] - */ -function getTransform(target, ancestor) { - var mat = identity([]); - while (target && target !== ancestor) { - mul(mat, target.getLocalTransform(), mat); - target = target.parent; - } - return mat; -} -/** - * Apply transform to an vertex. - * @param target [x, y] - * @param transform Can be: - * + Transform matrix: like [1, 0, 0, 1, 0, 0] - * + {position, rotation, scale}, the same as `zrender/Transformable`. - * @param invert Whether use invert matrix. - * @return [x, y] - */ -function applyTransform(target, transform, invert$1) { - if (transform && !isArrayLike(transform)) { - transform = Transformable.getLocalTransform(transform); - } - if (invert$1) { - transform = invert([], transform); - } - return applyTransform$1([], target, transform); -} -/** - * @param direction 'left' 'right' 'top' 'bottom' - * @param transform Transform matrix: like [1, 0, 0, 1, 0, 0] - * @param invert Whether use invert matrix. - * @return Transformed direction. 'left' 'right' 'top' 'bottom' - */ -function transformDirection(direction, transform, invert) { - // Pick a base, ensure that transform result will not be (0, 0). - var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]); - var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]); - var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0]; - vertex = applyTransform(vertex, transform, invert); - return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top'; -} -function isNotGroup(el) { - return !el.isGroup; -} -function isPath(el) { - return el.shape != null; -} -/** - * Apply group transition animation from g1 to g2. - * If no animatableModel, no animation. - */ -function groupTransition(g1, g2, animatableModel) { - if (!g1 || !g2) { - return; - } - function getElMap(g) { - var elMap = {}; - g.traverse(function (el) { - if (isNotGroup(el) && el.anid) { - elMap[el.anid] = el; - } - }); - return elMap; - } - function getAnimatableProps(el) { - var obj = { - x: el.x, - y: el.y, - rotation: el.rotation - }; - if (isPath(el)) { - obj.shape = extend({}, el.shape); - } - return obj; - } - var elMap1 = getElMap(g1); - g2.traverse(function (el) { - if (isNotGroup(el) && el.anid) { - var oldEl = elMap1[el.anid]; - if (oldEl) { - var newProp = getAnimatableProps(el); - el.attr(getAnimatableProps(oldEl)); - updateProps$1(el, newProp, animatableModel, getECData(el).dataIndex); - } - } - }); -} -function clipPointsByRect(points, rect) { - // FIXME: This way might be incorrect when graphic clipped by a corner - // and when element has a border. - return map$1(points, function (point) { - var x = point[0]; - x = mathMax$1(x, rect.x); - x = mathMin$1(x, rect.x + rect.width); - var y = point[1]; - y = mathMax$1(y, rect.y); - y = mathMin$1(y, rect.y + rect.height); - return [x, y]; - }); -} -/** - * Return a new clipped rect. If rect size are negative, return undefined. - */ -function clipRectByRect(targetRect, rect) { - var x = mathMax$1(targetRect.x, rect.x); - var x2 = mathMin$1(targetRect.x + targetRect.width, rect.x + rect.width); - var y = mathMax$1(targetRect.y, rect.y); - var y2 = mathMin$1(targetRect.y + targetRect.height, rect.y + rect.height); - // If the total rect is cliped, nothing, including the border, - // should be painted. So return undefined. - if (x2 >= x && y2 >= y) { - return { - x: x, - y: y, - width: x2 - x, - height: y2 - y - }; - } -} -function createIcon(iconStr, -// Support 'image://' or 'path://' or direct svg path. -opt, rect) { - var innerOpts = extend({ - rectHover: true - }, opt); - var style = innerOpts.style = { - strokeNoScale: true - }; - rect = rect || { - x: -1, - y: -1, - width: 2, - height: 2 - }; - if (iconStr) { - return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), defaults(style, rect), new ZRImage(innerOpts)) : makePath(iconStr.replace('path://', ''), innerOpts, rect, 'center'); - } -} -/** - * Return `true` if the given line (line `a`) and the given polygon - * are intersect. - * Note that we do not count colinear as intersect here because no - * requirement for that. We could do that if required in future. - */ -function linePolygonIntersect(a1x, a1y, a2x, a2y, points) { - for (var i = 0, p2 = points[points.length - 1]; i < points.length; i++) { - var p = points[i]; - if (lineLineIntersect(a1x, a1y, a2x, a2y, p[0], p[1], p2[0], p2[1])) { - return true; - } - p2 = p; - } -} -/** - * Return `true` if the given two lines (line `a` and line `b`) - * are intersect. - * Note that we do not count colinear as intersect here because no - * requirement for that. We could do that if required in future. - */ -function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) { - // let `vec_m` to be `vec_a2 - vec_a1` and `vec_n` to be `vec_b2 - vec_b1`. - var mx = a2x - a1x; - var my = a2y - a1y; - var nx = b2x - b1x; - var ny = b2y - b1y; - // `vec_m` and `vec_n` are parallel iff - // existing `k` such that `vec_m = k · vec_n`, equivalent to `vec_m X vec_n = 0`. - var nmCrossProduct = crossProduct2d(nx, ny, mx, my); - if (nearZero(nmCrossProduct)) { - return false; - } - // `vec_m` and `vec_n` are intersect iff - // existing `p` and `q` in [0, 1] such that `vec_a1 + p * vec_m = vec_b1 + q * vec_n`, - // such that `q = ((vec_a1 - vec_b1) X vec_m) / (vec_n X vec_m)` - // and `p = ((vec_a1 - vec_b1) X vec_n) / (vec_n X vec_m)`. - var b1a1x = a1x - b1x; - var b1a1y = a1y - b1y; - var q = crossProduct2d(b1a1x, b1a1y, mx, my) / nmCrossProduct; - if (q < 0 || q > 1) { - return false; - } - var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct; - if (p < 0 || p > 1) { - return false; - } - return true; -} -/** - * Cross product of 2-dimension vector. - */ -function crossProduct2d(x1, y1, x2, y2) { - return x1 * y2 - x2 * y1; -} -function nearZero(val) { - return val <= 1e-6 && val >= -1e-6; -} -function setTooltipConfig(opt) { - var itemTooltipOption = opt.itemTooltipOption; - var componentModel = opt.componentModel; - var itemName = opt.itemName; - var itemTooltipOptionObj = isString(itemTooltipOption) ? { - formatter: itemTooltipOption - } : itemTooltipOption; - var mainType = componentModel.mainType; - var componentIndex = componentModel.componentIndex; - var formatterParams = { - componentType: mainType, - name: itemName, - $vars: ['name'] - }; - formatterParams[mainType + 'Index'] = componentIndex; - var formatterParamsExtra = opt.formatterParamsExtra; - if (formatterParamsExtra) { - each$4(keys(formatterParamsExtra), function (key) { - if (!hasOwn(formatterParams, key)) { - formatterParams[key] = formatterParamsExtra[key]; - formatterParams.$vars.push(key); - } - }); - } - var ecData = getECData(opt.el); - ecData.componentMainType = mainType; - ecData.componentIndex = componentIndex; - ecData.tooltipConfig = { - name: itemName, - option: defaults({ - content: itemName, - encodeHTMLContent: true, - formatterParams: formatterParams - }, itemTooltipOptionObj) - }; -} -function traverseElement(el, cb) { - var stopped; - // TODO - // Polyfill for fixing zrender group traverse don't visit it's root issue. - if (el.isGroup) { - stopped = cb(el); - } - if (!stopped) { - el.traverse(cb); - } -} -function traverseElements(els, cb) { - if (els) { - if (isArray(els)) { - for (var i = 0; i < els.length; i++) { - traverseElement(els[i], cb); - } - } else { - traverseElement(els, cb); - } - } -} -// Register built-in shapes. These shapes might be overwritten -// by users, although we do not recommend that. -registerShape('circle', Circle); -registerShape('ellipse', Ellipse); -registerShape('sector', Sector); -registerShape('ring', Ring); -registerShape('polygon', Polygon); -registerShape('polyline', Polyline); -registerShape('rect', Rect); -registerShape('line', Line); -registerShape('bezierCurve', BezierCurve); -registerShape('arc', Arc); - -const graphic = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({ - __proto__: null, - Arc, - BezierCurve, - BoundingRect, - Circle, - CompoundPath, - Ellipse, - Group: Group$2, - Image: ZRImage, - IncrementalDisplayable, - Line, - LinearGradient, - OrientedBoundingRect, - Path, - Point, - Polygon, - Polyline, - RadialGradient, - Rect, - Ring, - Sector, - Text: ZRText, - applyTransform, - clipPointsByRect, - clipRectByRect, - createIcon, - extendPath, - extendShape, - getShapeClass, - getTransform, - groupTransition, - initProps, - isElementRemoved, - lineLineIntersect, - linePolygonIntersect, - makeImage, - makePath, - mergePath, - registerShape, - removeElement, - removeElementWithFadeOut, - resizePath, - setTooltipConfig, - subPixelOptimize, - subPixelOptimizeLine, - subPixelOptimizeRect, - transformDirection, - traverseElements, - updateProps: updateProps$1 -}, Symbol.toStringTag, { value: 'Module' })); - -var EMPTY_OBJ = {}; -function setLabelText(label, labelTexts) { - for (var i = 0; i < SPECIAL_STATES.length; i++) { - var stateName = SPECIAL_STATES[i]; - var text = labelTexts[stateName]; - var state = label.ensureState(stateName); - state.style = state.style || {}; - state.style.text = text; - } - var oldStates = label.currentStates.slice(); - label.clearStates(true); - label.setStyle({ - text: labelTexts.normal - }); - label.useStates(oldStates, true); -} -function getLabelText(opt, stateModels, interpolatedValue) { - var labelFetcher = opt.labelFetcher; - var labelDataIndex = opt.labelDataIndex; - var labelDimIndex = opt.labelDimIndex; - var normalModel = stateModels.normal; - var baseText; - if (labelFetcher) { - baseText = labelFetcher.getFormattedLabel(labelDataIndex, "normal", null, labelDimIndex, normalModel && normalModel.get("formatter"), interpolatedValue != null ? { - interpolatedValue - } : null); - } - if (baseText == null) { - baseText = isFunction(opt.defaultText) ? opt.defaultText(labelDataIndex, opt, interpolatedValue) : opt.defaultText; - } - var statesText = { - normal: baseText - }; - for (var i = 0; i < SPECIAL_STATES.length; i++) { - var stateName = SPECIAL_STATES[i]; - var stateModel = stateModels[stateName]; - statesText[stateName] = retrieve2(labelFetcher ? labelFetcher.getFormattedLabel(labelDataIndex, stateName, null, labelDimIndex, stateModel && stateModel.get("formatter")) : null, baseText); - } - return statesText; -} -function setLabelStyle(targetEl, labelStatesModels, opt, stateSpecified) { - opt = opt || EMPTY_OBJ; - var isSetOnText = targetEl instanceof ZRText; - var needsCreateText = false; - for (var i = 0; i < DISPLAY_STATES.length; i++) { - var stateModel = labelStatesModels[DISPLAY_STATES[i]]; - if (stateModel && stateModel.getShallow("show")) { - needsCreateText = true; - break; - } - } - var textContent = isSetOnText ? targetEl : targetEl.getTextContent(); - if (needsCreateText) { - if (!isSetOnText) { - if (!textContent) { - textContent = new ZRText(); - targetEl.setTextContent(textContent); - } - if (targetEl.stateProxy) { - textContent.stateProxy = targetEl.stateProxy; - } - } - var labelStatesTexts = getLabelText(opt, labelStatesModels); - var normalModel = labelStatesModels.normal; - var showNormal = !!normalModel.getShallow("show"); - var normalStyle = createTextStyle(normalModel, stateSpecified && stateSpecified.normal, opt, false, !isSetOnText); - normalStyle.text = labelStatesTexts.normal; - if (!isSetOnText) { - targetEl.setTextConfig(createTextConfig(normalModel, opt, false)); - } - for (var i = 0; i < SPECIAL_STATES.length; i++) { - var stateName = SPECIAL_STATES[i]; - var stateModel = labelStatesModels[stateName]; - if (stateModel) { - var stateObj = textContent.ensureState(stateName); - var stateShow = !!retrieve2(stateModel.getShallow("show"), showNormal); - if (stateShow !== showNormal) { - stateObj.ignore = !stateShow; - } - stateObj.style = createTextStyle(stateModel, stateSpecified && stateSpecified[stateName], opt, true, !isSetOnText); - stateObj.style.text = labelStatesTexts[stateName]; - if (!isSetOnText) { - var targetElEmphasisState = targetEl.ensureState(stateName); - targetElEmphasisState.textConfig = createTextConfig(stateModel, opt, true); - } - } - } - textContent.silent = !!normalModel.getShallow("silent"); - if (textContent.style.x != null) { - normalStyle.x = textContent.style.x; - } - if (textContent.style.y != null) { - normalStyle.y = textContent.style.y; - } - textContent.ignore = !showNormal; - textContent.useStyle(normalStyle); - textContent.dirty(); - if (opt.enableTextSetter) { - labelInner(textContent).setLabelText = function(interpolatedValue) { - var labelStatesTexts2 = getLabelText(opt, labelStatesModels, interpolatedValue); - setLabelText(textContent, labelStatesTexts2); - }; - } - } else if (textContent) { - textContent.ignore = true; - } - targetEl.dirty(); -} -function getLabelStatesModels(itemModel, labelName) { - labelName = labelName || "label"; - var statesModels = { - normal: itemModel.getModel(labelName) - }; - for (var i = 0; i < SPECIAL_STATES.length; i++) { - var stateName = SPECIAL_STATES[i]; - statesModels[stateName] = itemModel.getModel([stateName, labelName]); - } - return statesModels; -} -function createTextStyle(textStyleModel, specifiedTextStyle, opt, isNotNormal, isAttached) { - var textStyle = {}; - setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached); - specifiedTextStyle && extend(textStyle, specifiedTextStyle); - return textStyle; -} -function createTextConfig(textStyleModel, opt, isNotNormal) { - opt = opt || {}; - var textConfig = {}; - var labelPosition; - var labelRotate = textStyleModel.getShallow("rotate"); - var labelDistance = retrieve2(textStyleModel.getShallow("distance"), isNotNormal ? null : 5); - var labelOffset = textStyleModel.getShallow("offset"); - labelPosition = textStyleModel.getShallow("position") || (isNotNormal ? null : "inside"); - labelPosition === "outside" && (labelPosition = opt.defaultOutsidePosition || "top"); - if (labelPosition != null) { - textConfig.position = labelPosition; - } - if (labelOffset != null) { - textConfig.offset = labelOffset; - } - if (labelRotate != null) { - labelRotate *= Math.PI / 180; - textConfig.rotation = labelRotate; - } - if (labelDistance != null) { - textConfig.distance = labelDistance; - } - textConfig.outsideFill = textStyleModel.get("color") === "inherit" ? opt.inheritColor || null : "auto"; - return textConfig; -} -function setTextStyleCommon(textStyle, textStyleModel, opt, isNotNormal, isAttached) { - opt = opt || EMPTY_OBJ; - var ecModel = textStyleModel.ecModel; - var globalTextStyle = ecModel && ecModel.option.textStyle; - var richItemNames = getRichItemNames(textStyleModel); - var richResult; - if (richItemNames) { - richResult = {}; - for (var name_1 in richItemNames) { - if (richItemNames.hasOwnProperty(name_1)) { - var richTextStyle = textStyleModel.getModel(["rich", name_1]); - setTokenTextStyle(richResult[name_1] = {}, richTextStyle, globalTextStyle, opt, isNotNormal, isAttached, false, true); - } - } - } - if (richResult) { - textStyle.rich = richResult; - } - var overflow = textStyleModel.get("overflow"); - if (overflow) { - textStyle.overflow = overflow; - } - var margin = textStyleModel.get("minMargin"); - if (margin != null) { - textStyle.margin = margin; - } - setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, true, false); -} -function getRichItemNames(textStyleModel) { - var richItemNameMap; - while (textStyleModel && textStyleModel !== textStyleModel.ecModel) { - var rich = (textStyleModel.option || EMPTY_OBJ).rich; - if (rich) { - richItemNameMap = richItemNameMap || {}; - var richKeys = keys(rich); - for (var i = 0; i < richKeys.length; i++) { - var richKey = richKeys[i]; - richItemNameMap[richKey] = 1; - } - } - textStyleModel = textStyleModel.parentModel; - } - return richItemNameMap; -} -var TEXT_PROPS_WITH_GLOBAL = ["fontStyle", "fontWeight", "fontSize", "fontFamily", "textShadowColor", "textShadowBlur", "textShadowOffsetX", "textShadowOffsetY"]; -var TEXT_PROPS_SELF = ["align", "lineHeight", "width", "height", "tag", "verticalAlign", "ellipsis"]; -var TEXT_PROPS_BOX = ["padding", "borderWidth", "borderRadius", "borderDashOffset", "backgroundColor", "borderColor", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]; -function setTokenTextStyle(textStyle, textStyleModel, globalTextStyle, opt, isNotNormal, isAttached, isBlock, inRich) { - globalTextStyle = !isNotNormal && globalTextStyle || EMPTY_OBJ; - var inheritColor = opt && opt.inheritColor; - var fillColor = textStyleModel.getShallow("color"); - var strokeColor = textStyleModel.getShallow("textBorderColor"); - var opacity = retrieve2(textStyleModel.getShallow("opacity"), globalTextStyle.opacity); - if (fillColor === "inherit" || fillColor === "auto") { - if (inheritColor) { - fillColor = inheritColor; - } else { - fillColor = null; - } - } - if (strokeColor === "inherit" || strokeColor === "auto") { - if (inheritColor) { - strokeColor = inheritColor; - } else { - strokeColor = null; - } - } - if (!isAttached) { - fillColor = fillColor || globalTextStyle.color; - strokeColor = strokeColor || globalTextStyle.textBorderColor; - } - if (fillColor != null) { - textStyle.fill = fillColor; - } - if (strokeColor != null) { - textStyle.stroke = strokeColor; - } - var textBorderWidth = retrieve2(textStyleModel.getShallow("textBorderWidth"), globalTextStyle.textBorderWidth); - if (textBorderWidth != null) { - textStyle.lineWidth = textBorderWidth; - } - var textBorderType = retrieve2(textStyleModel.getShallow("textBorderType"), globalTextStyle.textBorderType); - if (textBorderType != null) { - textStyle.lineDash = textBorderType; - } - var textBorderDashOffset = retrieve2(textStyleModel.getShallow("textBorderDashOffset"), globalTextStyle.textBorderDashOffset); - if (textBorderDashOffset != null) { - textStyle.lineDashOffset = textBorderDashOffset; - } - if (!isNotNormal && opacity == null && !inRich) { - opacity = opt && opt.defaultOpacity; - } - if (opacity != null) { - textStyle.opacity = opacity; - } - if (!isNotNormal && !isAttached) { - if (textStyle.fill == null && opt.inheritColor) { - textStyle.fill = opt.inheritColor; - } - } - for (var i = 0; i < TEXT_PROPS_WITH_GLOBAL.length; i++) { - var key = TEXT_PROPS_WITH_GLOBAL[i]; - var val = retrieve2(textStyleModel.getShallow(key), globalTextStyle[key]); - if (val != null) { - textStyle[key] = val; - } - } - for (var i = 0; i < TEXT_PROPS_SELF.length; i++) { - var key = TEXT_PROPS_SELF[i]; - var val = textStyleModel.getShallow(key); - if (val != null) { - textStyle[key] = val; - } - } - if (textStyle.verticalAlign == null) { - var baseline = textStyleModel.getShallow("baseline"); - if (baseline != null) { - textStyle.verticalAlign = baseline; - } - } - if (!isBlock || !opt.disableBox) { - for (var i = 0; i < TEXT_PROPS_BOX.length; i++) { - var key = TEXT_PROPS_BOX[i]; - var val = textStyleModel.getShallow(key); - if (val != null) { - textStyle[key] = val; - } - } - var borderType = textStyleModel.getShallow("borderType"); - if (borderType != null) { - textStyle.borderDash = borderType; - } - if ((textStyle.backgroundColor === "auto" || textStyle.backgroundColor === "inherit") && inheritColor) { - textStyle.backgroundColor = inheritColor; - } - if ((textStyle.borderColor === "auto" || textStyle.borderColor === "inherit") && inheritColor) { - textStyle.borderColor = inheritColor; - } - } -} -function getFont(opt, ecModel) { - var gTextStyleModel = ecModel && ecModel.getModel("textStyle"); - return trim([ - // FIXME in node-canvas fontWeight is before fontStyle - opt.fontStyle || gTextStyleModel && gTextStyleModel.getShallow("fontStyle") || "", - opt.fontWeight || gTextStyleModel && gTextStyleModel.getShallow("fontWeight") || "", - (opt.fontSize || gTextStyleModel && gTextStyleModel.getShallow("fontSize") || 12) + "px", - opt.fontFamily || gTextStyleModel && gTextStyleModel.getShallow("fontFamily") || "sans-serif" - ].join(" ")); -} -var labelInner = makeInner(); - -var PATH_COLOR = ['textStyle', 'color']; -var textStyleParams = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'padding', 'lineHeight', 'rich', 'width', 'height', 'overflow']; -// TODO Performance improvement? -var tmpText = new ZRText(); -var TextStyleMixin = /** @class */function () { - function TextStyleMixin() {} - /** - * Get color property or get color from option.textStyle.color - */ - // TODO Callback - TextStyleMixin.prototype.getTextColor = function (isEmphasis) { - var ecModel = this.ecModel; - return this.getShallow('color') || (!isEmphasis && ecModel ? ecModel.get(PATH_COLOR) : null); - }; - /** - * Create font string from fontStyle, fontWeight, fontSize, fontFamily - * @return {string} - */ - TextStyleMixin.prototype.getFont = function () { - return getFont({ - fontStyle: this.getShallow('fontStyle'), - fontWeight: this.getShallow('fontWeight'), - fontSize: this.getShallow('fontSize'), - fontFamily: this.getShallow('fontFamily') - }, this.ecModel); - }; - TextStyleMixin.prototype.getTextRect = function (text) { - var style = { - text: text, - verticalAlign: this.getShallow('verticalAlign') || this.getShallow('baseline') - }; - for (var i = 0; i < textStyleParams.length; i++) { - style[textStyleParams[i]] = this.getShallow(textStyleParams[i]); - } - tmpText.useStyle(style); - tmpText.update(); - return tmpText.getBoundingRect(); - }; - return TextStyleMixin; -}(); - -var LINE_STYLE_KEY_MAP = [['lineWidth', 'width'], ['stroke', 'color'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'type'], ['lineDashOffset', 'dashOffset'], ['lineCap', 'cap'], ['lineJoin', 'join'], ['miterLimit'] -// Option decal is in `DecalObject` but style.decal is in `PatternObject`. -// So do not transfer decal directly. -]; -var getLineStyle = makeStyleMapper(LINE_STYLE_KEY_MAP); -var LineStyleMixin = /** @class */function () { - function LineStyleMixin() {} - LineStyleMixin.prototype.getLineStyle = function (excludes) { - return getLineStyle(this, excludes); - }; - return LineStyleMixin; -}(); - -var ITEM_STYLE_KEY_MAP = [['fill', 'color'], ['stroke', 'borderColor'], ['lineWidth', 'borderWidth'], ['opacity'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['shadowColor'], ['lineDash', 'borderType'], ['lineDashOffset', 'borderDashOffset'], ['lineCap', 'borderCap'], ['lineJoin', 'borderJoin'], ['miterLimit', 'borderMiterLimit'] -// Option decal is in `DecalObject` but style.decal is in `PatternObject`. -// So do not transfer decal directly. -]; -var getItemStyle = makeStyleMapper(ITEM_STYLE_KEY_MAP); -var ItemStyleMixin = /** @class */function () { - function ItemStyleMixin() {} - ItemStyleMixin.prototype.getItemStyle = function (excludes, includes) { - return getItemStyle(this, excludes, includes); - }; - return ItemStyleMixin; -}(); - -var Model = /** @class */function () { - function Model(option, parentModel, ecModel) { - this.parentModel = parentModel; - this.ecModel = ecModel; - this.option = option; - // Simple optimization - // if (this.init) { - // if (arguments.length <= 4) { - // this.init(option, parentModel, ecModel, extraOpt); - // } - // else { - // this.init.apply(this, arguments); - // } - // } - } - Model.prototype.init = function (option, parentModel, ecModel) { - }; - /** - * Merge the input option to me. - */ - Model.prototype.mergeOption = function (option, ecModel) { - merge(this.option, option, true); - }; - // `path` can be 'a.b.c', so the return value type have to be `ModelOption` - // TODO: TYPE strict key check? - // get(path: string | string[], ignoreParent?: boolean): ModelOption; - Model.prototype.get = function (path, ignoreParent) { - if (path == null) { - return this.option; - } - return this._doGet(this.parsePath(path), !ignoreParent && this.parentModel); - }; - Model.prototype.getShallow = function (key, ignoreParent) { - var option = this.option; - var val = option == null ? option : option[key]; - if (val == null && !ignoreParent) { - var parentModel = this.parentModel; - if (parentModel) { - // FIXME:TS do not know how to make it works - val = parentModel.getShallow(key); - } - } - return val; - }; - // `path` can be 'a.b.c', so the return value type have to be `Model` - // getModel(path: string | string[], parentModel?: Model): Model; - // TODO 'a.b.c' is deprecated - Model.prototype.getModel = function (path, parentModel) { - var hasPath = path != null; - var pathFinal = hasPath ? this.parsePath(path) : null; - var obj = hasPath ? this._doGet(pathFinal) : this.option; - parentModel = parentModel || this.parentModel && this.parentModel.getModel(this.resolveParentPath(pathFinal)); - return new Model(obj, parentModel, this.ecModel); - }; - /** - * If model has option - */ - Model.prototype.isEmpty = function () { - return this.option == null; - }; - Model.prototype.restoreData = function () {}; - // Pending - Model.prototype.clone = function () { - var Ctor = this.constructor; - return new Ctor(clone$2(this.option)); - }; - // setReadOnly(properties): void { - // clazzUtil.setReadOnly(this, properties); - // } - // If path is null/undefined, return null/undefined. - Model.prototype.parsePath = function (path) { - if (typeof path === 'string') { - return path.split('.'); - } - return path; - }; - // Resolve path for parent. Perhaps useful when parent use a different property. - // Default to be a identity resolver. - // Can be modified to a different resolver. - Model.prototype.resolveParentPath = function (path) { - return path; - }; - // FIXME:TS check whether put this method here - Model.prototype.isAnimationEnabled = function () { - if (!env.node && this.option) { - if (this.option.animation != null) { - return !!this.option.animation; - } else if (this.parentModel) { - return this.parentModel.isAnimationEnabled(); - } - } - }; - Model.prototype._doGet = function (pathArr, parentModel) { - var obj = this.option; - if (!pathArr) { - return obj; - } - for (var i = 0; i < pathArr.length; i++) { - // Ignore empty - if (!pathArr[i]) { - continue; - } - // obj could be number/string/... (like 0) - obj = obj && typeof obj === 'object' ? obj[pathArr[i]] : null; - if (obj == null) { - break; - } - } - if (obj == null && parentModel) { - obj = parentModel._doGet(this.resolveParentPath(pathArr), parentModel.parentModel); - } - return obj; - }; - return Model; -}(); -// Enable Model.extend. -enableClassExtend(Model); -enableClassCheck(Model); -mixin(Model, LineStyleMixin); -mixin(Model, ItemStyleMixin); -mixin(Model, AreaStyleMixin); -mixin(Model, TextStyleMixin); - -var base = Math.round(Math.random() * 10); -function getUID(type) { - return [type || "", base++].join("_"); -} -function enableSubTypeDefaulter(target) { - var subTypeDefaulters = {}; - target.registerSubTypeDefaulter = function(componentType, defaulter) { - var componentTypeInfo = parseClassType(componentType); - subTypeDefaulters[componentTypeInfo.main] = defaulter; - }; - target.determineSubType = function(componentType, option) { - var type = option.type; - if (!type) { - var componentTypeMain = parseClassType(componentType).main; - if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) { - type = subTypeDefaulters[componentTypeMain](option); - } - } - return type; - }; -} -function enableTopologicalTravel(entity, dependencyGetter) { - entity.topologicalTravel = function(targetNameList, fullNameList, callback, context) { - if (!targetNameList.length) { - return; - } - var result = makeDepndencyGraph(fullNameList); - var graph = result.graph; - var noEntryList = result.noEntryList; - var targetNameSet = {}; - each$4(targetNameList, function(name) { - targetNameSet[name] = true; - }); - while (noEntryList.length) { - var currComponentType = noEntryList.pop(); - var currVertex = graph[currComponentType]; - var isInTargetNameSet = !!targetNameSet[currComponentType]; - if (isInTargetNameSet) { - callback.call(context, currComponentType, currVertex.originalDeps.slice()); - delete targetNameSet[currComponentType]; - } - each$4(currVertex.successor, isInTargetNameSet ? removeEdgeAndAdd : removeEdge); - } - each$4(targetNameSet, function() { - var errMsg = ""; - throw new Error(errMsg); - }); - function removeEdge(succComponentType) { - graph[succComponentType].entryCount--; - if (graph[succComponentType].entryCount === 0) { - noEntryList.push(succComponentType); - } - } - function removeEdgeAndAdd(succComponentType) { - targetNameSet[succComponentType] = true; - removeEdge(succComponentType); - } - }; - function makeDepndencyGraph(fullNameList) { - var graph = {}; - var noEntryList = []; - each$4(fullNameList, function(name) { - var thisItem = createDependencyGraphItem(graph, name); - var originalDeps = thisItem.originalDeps = dependencyGetter(name); - var availableDeps = getAvailableDependencies(originalDeps, fullNameList); - thisItem.entryCount = availableDeps.length; - if (thisItem.entryCount === 0) { - noEntryList.push(name); - } - each$4(availableDeps, function(dependentName) { - if (indexOf(thisItem.predecessor, dependentName) < 0) { - thisItem.predecessor.push(dependentName); - } - var thatItem = createDependencyGraphItem(graph, dependentName); - if (indexOf(thatItem.successor, dependentName) < 0) { - thatItem.successor.push(name); - } - }); - }); - return { - graph, - noEntryList - }; - } - function createDependencyGraphItem(graph, name) { - if (!graph[name]) { - graph[name] = { - predecessor: [], - successor: [] - }; - } - return graph[name]; - } - function getAvailableDependencies(originalDeps, fullNameList) { - var availableDeps = []; - each$4(originalDeps, function(dep) { - indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep); - }); - return availableDeps; - } -} -function inheritDefaultOption(superOption, subOption) { - return merge(merge({}, superOption, true), subOption, true); -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -/** - * Language: English. - */ -const langEN = { - time: { - month: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], - monthAbbr: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], - dayOfWeek: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], - dayOfWeekAbbr: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] - }, - legend: { - selector: { - all: 'All', - inverse: 'Inv' - } - }, - toolbox: { - brush: { - title: { - rect: 'Box Select', - polygon: 'Lasso Select', - lineX: 'Horizontally Select', - lineY: 'Vertically Select', - keep: 'Keep Selections', - clear: 'Clear Selections' - } - }, - dataView: { - title: 'Data View', - lang: ['Data View', 'Close', 'Refresh'] - }, - dataZoom: { - title: { - zoom: 'Zoom', - back: 'Zoom Reset' - } - }, - magicType: { - title: { - line: 'Switch to Line Chart', - bar: 'Switch to Bar Chart', - stack: 'Stack', - tiled: 'Tile' - } - }, - restore: { - title: 'Restore' - }, - saveAsImage: { - title: 'Save as Image', - lang: ['Right Click to Save Image'] - } - }, - series: { - typeNames: { - pie: 'Pie chart', - bar: 'Bar chart', - line: 'Line chart', - scatter: 'Scatter plot', - effectScatter: 'Ripple scatter plot', - radar: 'Radar chart', - tree: 'Tree', - treemap: 'Treemap', - boxplot: 'Boxplot', - candlestick: 'Candlestick', - k: 'K line chart', - heatmap: 'Heat map', - map: 'Map', - parallel: 'Parallel coordinate map', - lines: 'Line graph', - graph: 'Relationship graph', - sankey: 'Sankey diagram', - funnel: 'Funnel chart', - gauge: 'Gauge', - pictorialBar: 'Pictorial bar', - themeRiver: 'Theme River Map', - sunburst: 'Sunburst', - custom: 'Custom chart', - chart: 'Chart' - } - }, - aria: { - general: { - withTitle: 'This is a chart about "{title}"', - withoutTitle: 'This is a chart' - }, - series: { - single: { - prefix: '', - withName: ' with type {seriesType} named {seriesName}.', - withoutName: ' with type {seriesType}.' - }, - multiple: { - prefix: '. It consists of {seriesCount} series count.', - withName: ' The {seriesId} series is a {seriesType} representing {seriesName}.', - withoutName: ' The {seriesId} series is a {seriesType}.', - separator: { - middle: '', - end: '' - } - } - }, - data: { - allData: 'The data is as follows: ', - partialData: 'The first {displayCnt} items are: ', - withName: 'the data for {name} is {value}', - withoutName: '{value}', - separator: { - middle: ', ', - end: '. ' - } - } - } -}; - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -const langZH = { - time: { - month: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'], - monthAbbr: ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'], - dayOfWeek: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'], - dayOfWeekAbbr: ['日', '一', '二', '三', '四', '五', '六'] - }, - legend: { - selector: { - all: '全选', - inverse: '反选' - } - }, - toolbox: { - brush: { - title: { - rect: '矩形选择', - polygon: '圈选', - lineX: '横向选择', - lineY: '纵向选择', - keep: '保持选择', - clear: '清除选择' - } - }, - dataView: { - title: '数据视图', - lang: ['数据视图', '关闭', '刷新'] - }, - dataZoom: { - title: { - zoom: '区域缩放', - back: '区域缩放还原' - } - }, - magicType: { - title: { - line: '切换为折线图', - bar: '切换为柱状图', - stack: '切换为堆叠', - tiled: '切换为平铺' - } - }, - restore: { - title: '还原' - }, - saveAsImage: { - title: '保存为图片', - lang: ['右键另存为图片'] - } - }, - series: { - typeNames: { - pie: '饼图', - bar: '柱状图', - line: '折线图', - scatter: '散点图', - effectScatter: '涟漪散点图', - radar: '雷达图', - tree: '树图', - treemap: '矩形树图', - boxplot: '箱型图', - candlestick: 'K线图', - k: 'K线图', - heatmap: '热力图', - map: '地图', - parallel: '平行坐标图', - lines: '线图', - graph: '关系图', - sankey: '桑基图', - funnel: '漏斗图', - gauge: '仪表盘图', - pictorialBar: '象形柱图', - themeRiver: '主题河流图', - sunburst: '旭日图', - custom: '自定义图表', - chart: '图表' - } - }, - aria: { - general: { - withTitle: '这是一个关于“{title}”的图表。', - withoutTitle: '这是一个图表，' - }, - series: { - single: { - prefix: '', - withName: '图表类型是{seriesType}，表示{seriesName}。', - withoutName: '图表类型是{seriesType}。' - }, - multiple: { - prefix: '它由{seriesCount}个图表系列组成。', - withName: '第{seriesId}个系列是一个表示{seriesName}的{seriesType}，', - withoutName: '第{seriesId}个系列是一个{seriesType}，', - separator: { - middle: '；', - end: '。' - } - } - }, - data: { - allData: '其数据是——', - partialData: '其中，前{displayCnt}项是——', - withName: '{name}的数据是{value}', - withoutName: '{value}', - separator: { - middle: '，', - end: '' - } - } - } -}; - -var LOCALE_ZH = 'ZH'; -var LOCALE_EN = 'EN'; -var DEFAULT_LOCALE = LOCALE_EN; -var localeStorage = {}; -var localeModels = {}; -var SYSTEM_LANG = !env.domSupported ? DEFAULT_LOCALE : function () { - var langStr = (/* eslint-disable-next-line */ - document.documentElement.lang || navigator.language || navigator.browserLanguage || DEFAULT_LOCALE).toUpperCase(); - return langStr.indexOf(LOCALE_ZH) > -1 ? LOCALE_ZH : DEFAULT_LOCALE; -}(); -function registerLocale(locale, localeObj) { - locale = locale.toUpperCase(); - localeModels[locale] = new Model(localeObj); - localeStorage[locale] = localeObj; -} -// export function getLocale(locale: string) { -// return localeStorage[locale]; -// } -function createLocaleObject(locale) { - if (isString(locale)) { - var localeObj = localeStorage[locale.toUpperCase()] || {}; - if (locale === LOCALE_ZH || locale === LOCALE_EN) { - return clone$2(localeObj); - } else { - return merge(clone$2(localeObj), clone$2(localeStorage[DEFAULT_LOCALE]), false); - } - } else { - return merge(clone$2(locale), clone$2(localeStorage[DEFAULT_LOCALE]), false); - } -} -function getLocaleModel(lang) { - return localeModels[lang]; -} -function getDefaultLocaleModel() { - return localeModels[DEFAULT_LOCALE]; -} -// Default locale -registerLocale(LOCALE_EN, langEN); -registerLocale(LOCALE_ZH, langZH); - -var ONE_SECOND = 1000; -var ONE_MINUTE = ONE_SECOND * 60; -var ONE_HOUR = ONE_MINUTE * 60; -var ONE_DAY = ONE_HOUR * 24; -var ONE_YEAR = ONE_DAY * 365; -var defaultLeveledFormatter = { - year: '{yyyy}', - month: '{MMM}', - day: '{d}', - hour: '{HH}:{mm}', - minute: '{HH}:{mm}', - second: '{HH}:{mm}:{ss}', - millisecond: '{HH}:{mm}:{ss} {SSS}', - none: '{yyyy}-{MM}-{dd} {HH}:{mm}:{ss} {SSS}' -}; -var fullDayFormatter = '{yyyy}-{MM}-{dd}'; -var fullLeveledFormatter = { - year: '{yyyy}', - month: '{yyyy}-{MM}', - day: fullDayFormatter, - hour: fullDayFormatter + ' ' + defaultLeveledFormatter.hour, - minute: fullDayFormatter + ' ' + defaultLeveledFormatter.minute, - second: fullDayFormatter + ' ' + defaultLeveledFormatter.second, - millisecond: defaultLeveledFormatter.none -}; -var primaryTimeUnits = ['year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond']; -var timeUnits = ['year', 'half-year', 'quarter', 'month', 'week', 'half-week', 'day', 'half-day', 'quarter-day', 'hour', 'minute', 'second', 'millisecond']; -function pad(str, len) { - str += ''; - return '0000'.substr(0, len - str.length) + str; -} -function getPrimaryTimeUnit(timeUnit) { - switch (timeUnit) { - case 'half-year': - case 'quarter': - return 'month'; - case 'week': - case 'half-week': - return 'day'; - case 'half-day': - case 'quarter-day': - return 'hour'; - default: - // year, minutes, second, milliseconds - return timeUnit; - } -} -function isPrimaryTimeUnit(timeUnit) { - return timeUnit === getPrimaryTimeUnit(timeUnit); -} -function getDefaultFormatPrecisionOfInterval(timeUnit) { - switch (timeUnit) { - case 'year': - case 'month': - return 'day'; - case 'millisecond': - return 'millisecond'; - default: - // Also for day, hour, minute, second - return 'second'; - } -} -function format( -// Note: The result based on `isUTC` are totally different, which can not be just simply -// substituted by the result without `isUTC`. So we make the param `isUTC` mandatory. -time, template, isUTC, lang) { - var date = parseDate(time); - var y = date[fullYearGetterName(isUTC)](); - var M = date[monthGetterName(isUTC)]() + 1; - var q = Math.floor((M - 1) / 3) + 1; - var d = date[dateGetterName(isUTC)](); - var e = date['get' + (isUTC ? 'UTC' : '') + 'Day'](); - var H = date[hoursGetterName(isUTC)](); - var h = (H - 1) % 12 + 1; - var m = date[minutesGetterName(isUTC)](); - var s = date[secondsGetterName(isUTC)](); - var S = date[millisecondsGetterName(isUTC)](); - var a = H >= 12 ? 'pm' : 'am'; - var A = a.toUpperCase(); - var localeModel = lang instanceof Model ? lang : getLocaleModel(lang || SYSTEM_LANG) || getDefaultLocaleModel(); - var timeModel = localeModel.getModel('time'); - var month = timeModel.get('month'); - var monthAbbr = timeModel.get('monthAbbr'); - var dayOfWeek = timeModel.get('dayOfWeek'); - var dayOfWeekAbbr = timeModel.get('dayOfWeekAbbr'); - return (template || '').replace(/{a}/g, a + '').replace(/{A}/g, A + '').replace(/{yyyy}/g, y + '').replace(/{yy}/g, pad(y % 100 + '', 2)).replace(/{Q}/g, q + '').replace(/{MMMM}/g, month[M - 1]).replace(/{MMM}/g, monthAbbr[M - 1]).replace(/{MM}/g, pad(M, 2)).replace(/{M}/g, M + '').replace(/{dd}/g, pad(d, 2)).replace(/{d}/g, d + '').replace(/{eeee}/g, dayOfWeek[e]).replace(/{ee}/g, dayOfWeekAbbr[e]).replace(/{e}/g, e + '').replace(/{HH}/g, pad(H, 2)).replace(/{H}/g, H + '').replace(/{hh}/g, pad(h + '', 2)).replace(/{h}/g, h + '').replace(/{mm}/g, pad(m, 2)).replace(/{m}/g, m + '').replace(/{ss}/g, pad(s, 2)).replace(/{s}/g, s + '').replace(/{SSS}/g, pad(S, 3)).replace(/{S}/g, S + ''); -} -function leveledFormat(tick, idx, formatter, lang, isUTC) { - var template = null; - if (isString(formatter)) { - // Single formatter for all units at all levels - template = formatter; - } else if (isFunction(formatter)) { - // Callback formatter - template = formatter(tick.value, idx, { - level: tick.level - }); - } else { - var defaults$1 = extend({}, defaultLeveledFormatter); - if (tick.level > 0) { - for (var i = 0; i < primaryTimeUnits.length; ++i) { - defaults$1[primaryTimeUnits[i]] = "{primary|" + defaults$1[primaryTimeUnits[i]] + "}"; - } - } - var mergedFormatter = formatter ? formatter.inherit === false ? formatter // Use formatter with bigger units - : defaults(formatter, defaults$1) : defaults$1; - var unit = getUnitFromValue(tick.value, isUTC); - if (mergedFormatter[unit]) { - template = mergedFormatter[unit]; - } else if (mergedFormatter.inherit) { - // Unit formatter is not defined and should inherit from bigger units - var targetId = timeUnits.indexOf(unit); - for (var i = targetId - 1; i >= 0; --i) { - if (mergedFormatter[unit]) { - template = mergedFormatter[unit]; - break; - } - } - template = template || defaults$1.none; - } - if (isArray(template)) { - var levelId = tick.level == null ? 0 : tick.level >= 0 ? tick.level : template.length + tick.level; - levelId = Math.min(levelId, template.length - 1); - template = template[levelId]; - } - } - return format(new Date(tick.value), template, isUTC, lang); -} -function getUnitFromValue(value, isUTC) { - var date = parseDate(value); - var M = date[monthGetterName(isUTC)]() + 1; - var d = date[dateGetterName(isUTC)](); - var h = date[hoursGetterName(isUTC)](); - var m = date[minutesGetterName(isUTC)](); - var s = date[secondsGetterName(isUTC)](); - var S = date[millisecondsGetterName(isUTC)](); - var isSecond = S === 0; - var isMinute = isSecond && s === 0; - var isHour = isMinute && m === 0; - var isDay = isHour && h === 0; - var isMonth = isDay && d === 1; - var isYear = isMonth && M === 1; - if (isYear) { - return 'year'; - } else if (isMonth) { - return 'month'; - } else if (isDay) { - return 'day'; - } else if (isHour) { - return 'hour'; - } else if (isMinute) { - return 'minute'; - } else if (isSecond) { - return 'second'; - } else { - return 'millisecond'; - } -} -function getUnitValue(value, unit, isUTC) { - var date = isNumber(value) ? parseDate(value) : value; - unit = unit || getUnitFromValue(value, isUTC); - switch (unit) { - case 'year': - return date[fullYearGetterName(isUTC)](); - case 'half-year': - return date[monthGetterName(isUTC)]() >= 6 ? 1 : 0; - case 'quarter': - return Math.floor((date[monthGetterName(isUTC)]() + 1) / 4); - case 'month': - return date[monthGetterName(isUTC)](); - case 'day': - return date[dateGetterName(isUTC)](); - case 'half-day': - return date[hoursGetterName(isUTC)]() / 24; - case 'hour': - return date[hoursGetterName(isUTC)](); - case 'minute': - return date[minutesGetterName(isUTC)](); - case 'second': - return date[secondsGetterName(isUTC)](); - case 'millisecond': - return date[millisecondsGetterName(isUTC)](); - } -} -function fullYearGetterName(isUTC) { - return isUTC ? 'getUTCFullYear' : 'getFullYear'; -} -function monthGetterName(isUTC) { - return isUTC ? 'getUTCMonth' : 'getMonth'; -} -function dateGetterName(isUTC) { - return isUTC ? 'getUTCDate' : 'getDate'; -} -function hoursGetterName(isUTC) { - return isUTC ? 'getUTCHours' : 'getHours'; -} -function minutesGetterName(isUTC) { - return isUTC ? 'getUTCMinutes' : 'getMinutes'; -} -function secondsGetterName(isUTC) { - return isUTC ? 'getUTCSeconds' : 'getSeconds'; -} -function millisecondsGetterName(isUTC) { - return isUTC ? 'getUTCMilliseconds' : 'getMilliseconds'; -} -function fullYearSetterName(isUTC) { - return isUTC ? 'setUTCFullYear' : 'setFullYear'; -} -function monthSetterName(isUTC) { - return isUTC ? 'setUTCMonth' : 'setMonth'; -} -function dateSetterName(isUTC) { - return isUTC ? 'setUTCDate' : 'setDate'; -} -function hoursSetterName(isUTC) { - return isUTC ? 'setUTCHours' : 'setHours'; -} -function minutesSetterName(isUTC) { - return isUTC ? 'setUTCMinutes' : 'setMinutes'; -} -function secondsSetterName(isUTC) { - return isUTC ? 'setUTCSeconds' : 'setSeconds'; -} -function millisecondsSetterName(isUTC) { - return isUTC ? 'setUTCMilliseconds' : 'setMilliseconds'; -} - -function addCommas(x) { - if (!isNumeric(x)) { - return isString(x) ? x : "-"; - } - var parts = (x + "").split("."); - return parts[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, "$1,") + (parts.length > 1 ? "." + parts[1] : ""); -} -function toCamelCase(str, upperCaseFirst) { - str = (str || "").toLowerCase().replace(/-(.)/g, function(match, group1) { - return group1.toUpperCase(); - }); - if (upperCaseFirst && str) { - str = str.charAt(0).toUpperCase() + str.slice(1); - } - return str; -} -var normalizeCssArray = normalizeCssArray$1; -function makeValueReadable(value, valueType, useUTC) { - var USER_READABLE_DEFUALT_TIME_PATTERN = "{yyyy}-{MM}-{dd} {HH}:{mm}:{ss}"; - function stringToUserReadable(str) { - return str && trim(str) ? str : "-"; - } - function isNumberUserReadable(num) { - return !!(num != null && !isNaN(num) && isFinite(num)); - } - var isTypeTime = valueType === "time"; - var isValueDate = value instanceof Date; - if (isTypeTime || isValueDate) { - var date = isTypeTime ? parseDate(value) : value; - if (!isNaN(+date)) { - return format(date, USER_READABLE_DEFUALT_TIME_PATTERN, useUTC); - } else if (isValueDate) { - return "-"; - } - } - if (valueType === "ordinal") { - return isStringSafe(value) ? stringToUserReadable(value) : isNumber(value) ? isNumberUserReadable(value) ? value + "" : "-" : "-"; - } - var numericResult = numericToNumber(value); - return isNumberUserReadable(numericResult) ? addCommas(numericResult) : isStringSafe(value) ? stringToUserReadable(value) : typeof value === "boolean" ? value + "" : "-"; -} -var TPL_VAR_ALIAS = ["a", "b", "c", "d", "e", "f", "g"]; -var wrapVar = function(varName, seriesIdx) { - return "{" + varName + (seriesIdx == null ? "" : seriesIdx) + "}"; -}; -function formatTpl(tpl, paramsList, encode) { - if (!isArray(paramsList)) { - paramsList = [paramsList]; - } - var seriesLen = paramsList.length; - if (!seriesLen) { - return ""; - } - var $vars = paramsList[0].$vars || []; - for (var i = 0; i < $vars.length; i++) { - var alias = TPL_VAR_ALIAS[i]; - tpl = tpl.replace(wrapVar(alias), wrapVar(alias, 0)); - } - for (var seriesIdx = 0; seriesIdx < seriesLen; seriesIdx++) { - for (var k = 0; k < $vars.length; k++) { - var val = paramsList[seriesIdx][$vars[k]]; - tpl = tpl.replace(wrapVar(TPL_VAR_ALIAS[k], seriesIdx), encode ? encodeHTML(val) : val); - } - } - return tpl; -} -function getTooltipMarker(inOpt, extraCssText) { - var opt = isString(inOpt) ? { - color: inOpt, - extraCssText - } : inOpt || {}; - var color = opt.color; - var type = opt.type; - extraCssText = opt.extraCssText; - var renderMode = opt.renderMode || "html"; - if (!color) { - return ""; - } - if (renderMode === "html") { - return type === "subItem" ? '' : ''; - } else { - var markerId = opt.markerId || "markerX"; - return { - renderMode, - content: "{" + markerId + "|} ", - style: type === "subItem" ? { - width: 4, - height: 4, - borderRadius: 2, - backgroundColor: color - } : { - width: 10, - height: 10, - borderRadius: 5, - backgroundColor: color - } - }; - } -} -function convertToColorString(color, defaultColor) { - defaultColor = defaultColor || "transparent"; - return isString(color) ? color : isObject$2(color) ? color.colorStops && (color.colorStops[0] || {}).color || defaultColor : defaultColor; -} -function windowOpen(link, target) { - if (target === "_blank" || target === "blank") { - var blank = window.open(); - blank.opener = null; - blank.location.href = link; - } else { - window.open(link, target); - } -} - -var each$3 = each$4; -/** - * @public - */ -var LOCATION_PARAMS = ['left', 'right', 'top', 'bottom', 'width', 'height']; -/** - * @public - */ -var HV_NAMES = [['width', 'left', 'right'], ['height', 'top', 'bottom']]; -function boxLayout(orient, group, gap, maxWidth, maxHeight) { - var x = 0; - var y = 0; - if (maxWidth == null) { - maxWidth = Infinity; - } - if (maxHeight == null) { - maxHeight = Infinity; - } - var currentLineMaxSize = 0; - group.eachChild(function (child, idx) { - var rect = child.getBoundingRect(); - var nextChild = group.childAt(idx + 1); - var nextChildRect = nextChild && nextChild.getBoundingRect(); - var nextX; - var nextY; - if (orient === 'horizontal') { - var moveX = rect.width + (nextChildRect ? -nextChildRect.x + rect.x : 0); - nextX = x + moveX; - // Wrap when width exceeds maxWidth or meet a `newline` group - // FIXME compare before adding gap? - if (nextX > maxWidth || child.newline) { - x = 0; - nextX = moveX; - y += currentLineMaxSize + gap; - currentLineMaxSize = rect.height; - } else { - // FIXME: consider rect.y is not `0`? - currentLineMaxSize = Math.max(currentLineMaxSize, rect.height); - } - } else { - var moveY = rect.height + (nextChildRect ? -nextChildRect.y + rect.y : 0); - nextY = y + moveY; - // Wrap when width exceeds maxHeight or meet a `newline` group - if (nextY > maxHeight || child.newline) { - x += currentLineMaxSize + gap; - y = 0; - nextY = moveY; - currentLineMaxSize = rect.width; - } else { - currentLineMaxSize = Math.max(currentLineMaxSize, rect.width); - } - } - if (child.newline) { - return; - } - child.x = x; - child.y = y; - child.markRedraw(); - orient === 'horizontal' ? x = nextX + gap : y = nextY + gap; - }); -} -/** - * VBox or HBox layouting - * @param {string} orient - * @param {module:zrender/graphic/Group} group - * @param {number} gap - * @param {number} [width=Infinity] - * @param {number} [height=Infinity] - */ -var box = boxLayout; -/** - * VBox layouting - * @param {module:zrender/graphic/Group} group - * @param {number} gap - * @param {number} [width=Infinity] - * @param {number} [height=Infinity] - */ -curry$1(boxLayout, 'vertical'); -/** - * HBox layouting - * @param {module:zrender/graphic/Group} group - * @param {number} gap - * @param {number} [width=Infinity] - * @param {number} [height=Infinity] - */ -curry$1(boxLayout, 'horizontal'); -/** - * Parse position info. - */ -function getLayoutRect(positionInfo, containerRect, margin) { - margin = normalizeCssArray(margin || 0); - var containerWidth = containerRect.width; - var containerHeight = containerRect.height; - var left = parsePercent(positionInfo.left, containerWidth); - var top = parsePercent(positionInfo.top, containerHeight); - var right = parsePercent(positionInfo.right, containerWidth); - var bottom = parsePercent(positionInfo.bottom, containerHeight); - var width = parsePercent(positionInfo.width, containerWidth); - var height = parsePercent(positionInfo.height, containerHeight); - var verticalMargin = margin[2] + margin[0]; - var horizontalMargin = margin[1] + margin[3]; - var aspect = positionInfo.aspect; - // If width is not specified, calculate width from left and right - if (isNaN(width)) { - width = containerWidth - right - horizontalMargin - left; - } - if (isNaN(height)) { - height = containerHeight - bottom - verticalMargin - top; - } - if (aspect != null) { - // If width and height are not given - // 1. Graph should not exceeds the container - // 2. Aspect must be keeped - // 3. Graph should take the space as more as possible - // FIXME - // Margin is not considered, because there is no case that both - // using margin and aspect so far. - if (isNaN(width) && isNaN(height)) { - if (aspect > containerWidth / containerHeight) { - width = containerWidth * 0.8; - } else { - height = containerHeight * 0.8; - } - } - // Calculate width or height with given aspect - if (isNaN(width)) { - width = aspect * height; - } - if (isNaN(height)) { - height = width / aspect; - } - } - // If left is not specified, calculate left from right and width - if (isNaN(left)) { - left = containerWidth - right - width - horizontalMargin; - } - if (isNaN(top)) { - top = containerHeight - bottom - height - verticalMargin; - } - // Align left and top - switch (positionInfo.left || positionInfo.right) { - case 'center': - left = containerWidth / 2 - width / 2 - margin[3]; - break; - case 'right': - left = containerWidth - width - horizontalMargin; - break; - } - switch (positionInfo.top || positionInfo.bottom) { - case 'middle': - case 'center': - top = containerHeight / 2 - height / 2 - margin[0]; - break; - case 'bottom': - top = containerHeight - height - verticalMargin; - break; - } - // If something is wrong and left, top, width, height are calculated as NaN - left = left || 0; - top = top || 0; - if (isNaN(width)) { - // Width may be NaN if only one value is given except width - width = containerWidth - horizontalMargin - left - (right || 0); - } - if (isNaN(height)) { - // Height may be NaN if only one value is given except height - height = containerHeight - verticalMargin - top - (bottom || 0); - } - var rect = new BoundingRect(left + margin[3], top + margin[0], width, height); - rect.margin = margin; - return rect; -} -function fetchLayoutMode(ins) { - var layoutMode = ins.layoutMode || ins.constructor.layoutMode; - return isObject$2(layoutMode) ? layoutMode : layoutMode ? { - type: layoutMode - } : null; -} -/** - * Consider Case: - * When default option has {left: 0, width: 100}, and we set {right: 0} - * through setOption or media query, using normal zrUtil.merge will cause - * {right: 0} does not take effect. - * - * @example - * ComponentModel.extend({ - * init: function () { - * ... - * let inputPositionParams = layout.getLayoutParams(option); - * this.mergeOption(inputPositionParams); - * }, - * mergeOption: function (newOption) { - * newOption && zrUtil.merge(thisOption, newOption, true); - * layout.mergeLayoutParam(thisOption, newOption); - * } - * }); - * - * @param targetOption - * @param newOption - * @param opt - */ -function mergeLayoutParam(targetOption, newOption, opt) { - var ignoreSize = opt && opt.ignoreSize; - !isArray(ignoreSize) && (ignoreSize = [ignoreSize, ignoreSize]); - var hResult = merge(HV_NAMES[0], 0); - var vResult = merge(HV_NAMES[1], 1); - copy(HV_NAMES[0], targetOption, hResult); - copy(HV_NAMES[1], targetOption, vResult); - function merge(names, hvIdx) { - var newParams = {}; - var newValueCount = 0; - var merged = {}; - var mergedValueCount = 0; - var enoughParamNumber = 2; - each$3(names, function (name) { - merged[name] = targetOption[name]; - }); - each$3(names, function (name) { - // Consider case: newOption.width is null, which is - // set by user for removing width setting. - hasProp(newOption, name) && (newParams[name] = merged[name] = newOption[name]); - hasValue(newParams, name) && newValueCount++; - hasValue(merged, name) && mergedValueCount++; - }); - if (ignoreSize[hvIdx]) { - // Only one of left/right is premitted to exist. - if (hasValue(newOption, names[1])) { - merged[names[2]] = null; - } else if (hasValue(newOption, names[2])) { - merged[names[1]] = null; - } - return merged; - } - // Case: newOption: {width: ..., right: ...}, - // or targetOption: {right: ...} and newOption: {width: ...}, - // There is no conflict when merged only has params count - // little than enoughParamNumber. - if (mergedValueCount === enoughParamNumber || !newValueCount) { - return merged; - } - // Case: newOption: {width: ..., right: ...}, - // Than we can make sure user only want those two, and ignore - // all origin params in targetOption. - else if (newValueCount >= enoughParamNumber) { - return newParams; - } else { - // Chose another param from targetOption by priority. - for (var i = 0; i < names.length; i++) { - var name_1 = names[i]; - if (!hasProp(newParams, name_1) && hasProp(targetOption, name_1)) { - newParams[name_1] = targetOption[name_1]; - break; - } - } - return newParams; - } - } - function hasProp(obj, name) { - return obj.hasOwnProperty(name); - } - function hasValue(obj, name) { - return obj[name] != null && obj[name] !== 'auto'; - } - function copy(names, target, source) { - each$3(names, function (name) { - target[name] = source[name]; - }); - } -} -/** - * Retrieve 'left', 'right', 'top', 'bottom', 'width', 'height' from object. - */ -function getLayoutParams(source) { - return copyLayoutParams({}, source); -} -/** - * Retrieve 'left', 'right', 'top', 'bottom', 'width', 'height' from object. - * @param {Object} source - * @return {Object} Result contains those props. - */ -function copyLayoutParams(target, source) { - source && target && each$3(LOCATION_PARAMS, function (name) { - source.hasOwnProperty(name) && (target[name] = source[name]); - }); - return target; -} - -var inner$9 = makeInner(); -var ComponentModel = /** @class */function (_super) { - __extends(ComponentModel, _super); - function ComponentModel(option, parentModel, ecModel) { - var _this = _super.call(this, option, parentModel, ecModel) || this; - _this.uid = getUID('ec_cpt_model'); - return _this; - } - ComponentModel.prototype.init = function (option, parentModel, ecModel) { - this.mergeDefaultAndTheme(option, ecModel); - }; - ComponentModel.prototype.mergeDefaultAndTheme = function (option, ecModel) { - var layoutMode = fetchLayoutMode(this); - var inputPositionParams = layoutMode ? getLayoutParams(option) : {}; - var themeModel = ecModel.getTheme(); - merge(option, themeModel.get(this.mainType)); - merge(option, this.getDefaultOption()); - if (layoutMode) { - mergeLayoutParam(option, inputPositionParams, layoutMode); - } - }; - ComponentModel.prototype.mergeOption = function (option, ecModel) { - merge(this.option, option, true); - var layoutMode = fetchLayoutMode(this); - if (layoutMode) { - mergeLayoutParam(this.option, option, layoutMode); - } - }; - /** - * Called immediately after `init` or `mergeOption` of this instance called. - */ - ComponentModel.prototype.optionUpdated = function (newCptOption, isInit) {}; - /** - * [How to declare defaultOption]: - * - * (A) If using class declaration in typescript (since echarts 5): - * ```ts - * import {ComponentOption} from '../model/option.js'; - * export interface XxxOption extends ComponentOption { - * aaa: number - * } - * export class XxxModel extends Component { - * static type = 'xxx'; - * static defaultOption: XxxOption = { - * aaa: 123 - * } - * } - * Component.registerClass(XxxModel); - * ``` - * ```ts - * import {inheritDefaultOption} from '../util/component.js'; - * import {XxxModel, XxxOption} from './XxxModel.js'; - * export interface XxxSubOption extends XxxOption { - * bbb: number - * } - * class XxxSubModel extends XxxModel { - * static defaultOption: XxxSubOption = inheritDefaultOption(XxxModel.defaultOption, { - * bbb: 456 - * }) - * fn() { - * let opt = this.getDefaultOption(); - * // opt is {aaa: 123, bbb: 456} - * } - * } - * ``` - * - * (B) If using class extend (previous approach in echarts 3 & 4): - * ```js - * let XxxComponent = Component.extend({ - * defaultOption: { - * xx: 123 - * } - * }) - * ``` - * ```js - * let XxxSubComponent = XxxComponent.extend({ - * defaultOption: { - * yy: 456 - * }, - * fn: function () { - * let opt = this.getDefaultOption(); - * // opt is {xx: 123, yy: 456} - * } - * }) - * ``` - */ - ComponentModel.prototype.getDefaultOption = function () { - var ctor = this.constructor; - // If using class declaration, it is different to travel super class - // in legacy env and auto merge defaultOption. So if using class - // declaration, defaultOption should be merged manually. - if (!isExtendedClass(ctor)) { - // When using ts class, defaultOption must be declared as static. - return ctor.defaultOption; - } - // FIXME: remove this approach? - var fields = inner$9(this); - if (!fields.defaultOption) { - var optList = []; - var clz = ctor; - while (clz) { - var opt = clz.prototype.defaultOption; - opt && optList.push(opt); - clz = clz.superClass; - } - var defaultOption = {}; - for (var i = optList.length - 1; i >= 0; i--) { - defaultOption = merge(defaultOption, optList[i], true); - } - fields.defaultOption = defaultOption; - } - return fields.defaultOption; - }; - /** - * Notice: always force to input param `useDefault` in case that forget to consider it. - * The same behavior as `modelUtil.parseFinder`. - * - * @param useDefault In many cases like series refer axis and axis refer grid, - * If axis index / axis id not specified, use the first target as default. - * In other cases like dataZoom refer axis, if not specified, measn no refer. - */ - ComponentModel.prototype.getReferringComponents = function (mainType, opt) { - var indexKey = mainType + 'Index'; - var idKey = mainType + 'Id'; - return queryReferringComponents(this.ecModel, mainType, { - index: this.get(indexKey, true), - id: this.get(idKey, true) - }, opt); - }; - ComponentModel.prototype.getBoxLayoutParams = function () { - // Consider itself having box layout configs. - var boxLayoutModel = this; - return { - left: boxLayoutModel.get('left'), - top: boxLayoutModel.get('top'), - right: boxLayoutModel.get('right'), - bottom: boxLayoutModel.get('bottom'), - width: boxLayoutModel.get('width'), - height: boxLayoutModel.get('height') - }; - }; - /** - * Get key for zlevel. - * If developers don't configure zlevel. We will assign zlevel to series based on the key. - * For example, lines with trail effect and progressive series will in an individual zlevel. - */ - ComponentModel.prototype.getZLevelKey = function () { - return ''; - }; - ComponentModel.prototype.setZLevel = function (zlevel) { - this.option.zlevel = zlevel; - }; - ComponentModel.protoInitialize = function () { - var proto = ComponentModel.prototype; - proto.type = 'component'; - proto.id = ''; - proto.name = ''; - proto.mainType = ''; - proto.subType = ''; - proto.componentIndex = 0; - }(); - return ComponentModel; -}(Model); -mountExtend(ComponentModel, Model); -enableClassManagement(ComponentModel); -enableSubTypeDefaulter(ComponentModel); -enableTopologicalTravel(ComponentModel, getDependencies); -function getDependencies(componentType) { - var deps = []; - each$4(ComponentModel.getClassesByMainType(componentType), function (clz) { - deps = deps.concat(clz.dependencies || clz.prototype.dependencies || []); - }); - // Ensure main type. - deps = map$1(deps, function (type) { - return parseClassType(type).main; - }); - // Hack dataset for convenience. - if (componentType !== 'dataset' && indexOf(deps, 'dataset') <= 0) { - deps.unshift('dataset'); - } - return deps; -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -var platform = ''; -// Navigator not exists in node -if (typeof navigator !== 'undefined') { - /* global navigator */ - platform = navigator.platform || ''; -} -var decalColor = 'rgba(0, 0, 0, 0.2)'; -const globalDefault = { - darkMode: 'auto', - // backgroundColor: 'rgba(0,0,0,0)', - colorBy: 'series', - color: ['#5470c6', '#91cc75', '#fac858', '#ee6666', '#73c0de', '#3ba272', '#fc8452', '#9a60b4', '#ea7ccc'], - gradientColor: ['#f6efa6', '#d88273', '#bf444c'], - aria: { - decal: { - decals: [{ - color: decalColor, - dashArrayX: [1, 0], - dashArrayY: [2, 5], - symbolSize: 1, - rotation: Math.PI / 6 - }, { - color: decalColor, - symbol: 'circle', - dashArrayX: [[8, 8], [0, 8, 8, 0]], - dashArrayY: [6, 0], - symbolSize: 0.8 - }, { - color: decalColor, - dashArrayX: [1, 0], - dashArrayY: [4, 3], - rotation: -Math.PI / 4 - }, { - color: decalColor, - dashArrayX: [[6, 6], [0, 6, 6, 0]], - dashArrayY: [6, 0] - }, { - color: decalColor, - dashArrayX: [[1, 0], [1, 6]], - dashArrayY: [1, 0, 6, 0], - rotation: Math.PI / 4 - }, { - color: decalColor, - symbol: 'triangle', - dashArrayX: [[9, 9], [0, 9, 9, 0]], - dashArrayY: [7, 2], - symbolSize: 0.75 - }] - } - }, - // If xAxis and yAxis declared, grid is created by default. - // grid: {}, - textStyle: { - // color: '#000', - // decoration: 'none', - // PENDING - fontFamily: platform.match(/^Win/) ? 'Microsoft YaHei' : 'sans-serif', - // fontFamily: 'Arial, Verdana, sans-serif', - fontSize: 12, - fontStyle: 'normal', - fontWeight: 'normal' - }, - // http://blogs.adobe.com/webplatform/2014/02/24/using-blend-modes-in-html-canvas/ - // https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation - // Default is source-over - blendMode: null, - stateAnimation: { - duration: 300, - easing: 'cubicOut' - }, - animation: 'auto', - animationDuration: 1000, - animationDurationUpdate: 500, - animationEasing: 'cubicInOut', - animationEasingUpdate: 'cubicInOut', - animationThreshold: 2000, - // Configuration for progressive/incremental rendering - progressiveThreshold: 3000, - progressive: 400, - // Threshold of if use single hover layer to optimize. - // It is recommended that `hoverLayerThreshold` is equivalent to or less than - // `progressiveThreshold`, otherwise hover will cause restart of progressive, - // which is unexpected. - // see example . - hoverLayerThreshold: 3000, - // See: module:echarts/scale/Time - useUTC: false -}; - -var VISUAL_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'itemGroupId', 'itemChildGroupId', 'seriesName']); -var SOURCE_FORMAT_ORIGINAL = 'original'; -var SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows'; -var SOURCE_FORMAT_OBJECT_ROWS = 'objectRows'; -var SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns'; -var SOURCE_FORMAT_TYPED_ARRAY = 'typedArray'; -var SOURCE_FORMAT_UNKNOWN = 'unknown'; -var SERIES_LAYOUT_BY_COLUMN = 'column'; -var SERIES_LAYOUT_BY_ROW = 'row'; - -// The result of `guessOrdinal`. -var BE_ORDINAL = { - Must: 1, - Might: 2, - Not: 3 // Other cases -}; -var innerGlobalModel = makeInner(); -/** - * MUST be called before mergeOption of all series. - */ -function resetSourceDefaulter(ecModel) { - // `datasetMap` is used to make default encode. - innerGlobalModel(ecModel).datasetMap = createHashMap(); -} -/** - * [The strategy of the arrengment of data dimensions for dataset]: - * "value way": all axes are non-category axes. So series one by one take - * several (the number is coordSysDims.length) dimensions from dataset. - * The result of data arrengment of data dimensions like: - * | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y | - * "category way": at least one axis is category axis. So the the first data - * dimension is always mapped to the first category axis and shared by - * all of the series. The other data dimensions are taken by series like - * "value way" does. - * The result of data arrengment of data dimensions like: - * | ser_shared_x | ser0_y | ser1_y | ser2_y | - * - * @return encode Never be `null/undefined`. - */ -function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) { - var encode = {}; - var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); - // Currently only make default when using dataset, util more reqirements occur. - if (!datasetModel || !coordDimensions) { - return encode; - } - var encodeItemName = []; - var encodeSeriesName = []; - var ecModel = seriesModel.ecModel; - var datasetMap = innerGlobalModel(ecModel).datasetMap; - var key = datasetModel.uid + '_' + source.seriesLayoutBy; - var baseCategoryDimIndex; - var categoryWayValueDimStart; - coordDimensions = coordDimensions.slice(); - each$4(coordDimensions, function (coordDimInfoLoose, coordDimIdx) { - var coordDimInfo = isObject$2(coordDimInfoLoose) ? coordDimInfoLoose : coordDimensions[coordDimIdx] = { - name: coordDimInfoLoose - }; - if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) { - baseCategoryDimIndex = coordDimIdx; - categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimInfo); - } - encode[coordDimInfo.name] = []; - }); - var datasetRecord = datasetMap.get(key) || datasetMap.set(key, { - categoryWayDim: categoryWayValueDimStart, - valueWayDim: 0 - }); - // TODO - // Auto detect first time axis and do arrangement. - each$4(coordDimensions, function (coordDimInfo, coordDimIdx) { - var coordDimName = coordDimInfo.name; - var count = getDataDimCountOnCoordDim(coordDimInfo); - // In value way. - if (baseCategoryDimIndex == null) { - var start = datasetRecord.valueWayDim; - pushDim(encode[coordDimName], start, count); - pushDim(encodeSeriesName, start, count); - datasetRecord.valueWayDim += count; - // ??? TODO give a better default series name rule? - // especially when encode x y specified. - // consider: when multiple series share one dimension - // category axis, series name should better use - // the other dimension name. On the other hand, use - // both dimensions name. - } - // In category way, the first category axis. - else if (baseCategoryDimIndex === coordDimIdx) { - pushDim(encode[coordDimName], 0, count); - pushDim(encodeItemName, 0, count); - } - // In category way, the other axis. - else { - var start = datasetRecord.categoryWayDim; - pushDim(encode[coordDimName], start, count); - pushDim(encodeSeriesName, start, count); - datasetRecord.categoryWayDim += count; - } - }); - function pushDim(dimIdxArr, idxFrom, idxCount) { - for (var i = 0; i < idxCount; i++) { - dimIdxArr.push(idxFrom + i); - } - } - function getDataDimCountOnCoordDim(coordDimInfo) { - var dimsDef = coordDimInfo.dimsDef; - return dimsDef ? dimsDef.length : 1; - } - encodeItemName.length && (encode.itemName = encodeItemName); - encodeSeriesName.length && (encode.seriesName = encodeSeriesName); - return encode; -} -/** - * Work for data like [{name: ..., value: ...}, ...]. - * - * @return encode Never be `null/undefined`. - */ -function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) { - var encode = {}; - var datasetModel = querySeriesUpstreamDatasetModel(seriesModel); - // Currently only make default when using dataset, util more reqirements occur. - if (!datasetModel) { - return encode; - } - var sourceFormat = source.sourceFormat; - var dimensionsDefine = source.dimensionsDefine; - var potentialNameDimIndex; - if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) { - each$4(dimensionsDefine, function (dim, idx) { - if ((isObject$2(dim) ? dim.name : dim) === 'name') { - potentialNameDimIndex = idx; - } - }); - } - var idxResult = function () { - var idxRes0 = {}; - var idxRes1 = {}; - var guessRecords = []; - // 5 is an experience value. - for (var i = 0, len = Math.min(5, dimCount); i < len; i++) { - var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i); - guessRecords.push(guessResult); - var isPureNumber = guessResult === BE_ORDINAL.Not; - // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim, - // and then find a name dim with the priority: - // "BE_ORDINAL.Might|BE_ORDINAL.Must" > "other dim" > "the value dim itself". - if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) { - idxRes0.v = i; - } - if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) { - idxRes0.n = i; - } - if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) { - return idxRes0; - } - // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not), - // find the first BE_ORDINAL.Might as the value dim, - // and then find a name dim with the priority: - // "other dim" > "the value dim itself". - // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be - // treated as number. - if (!isPureNumber) { - if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) { - idxRes1.v = i; - } - if (idxRes1.n == null || idxRes1.n === idxRes1.v) { - idxRes1.n = i; - } - } - } - function fulfilled(idxResult) { - return idxResult.v != null && idxResult.n != null; - } - return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null; - }(); - if (idxResult) { - encode.value = [idxResult.v]; - // `potentialNameDimIndex` has highest priority. - var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n; - // By default, label uses itemName in charts. - // So we don't set encodeLabel here. - encode.itemName = [nameDimIndex]; - encode.seriesName = [nameDimIndex]; - } - return encode; -} -/** - * @return If return null/undefined, indicate that should not use datasetModel. - */ -function querySeriesUpstreamDatasetModel(seriesModel) { - // Caution: consider the scenario: - // A dataset is declared and a series is not expected to use the dataset, - // and at the beginning `setOption({series: { noData })` (just prepare other - // option but no data), then `setOption({series: {data: [...]}); In this case, - // the user should set an empty array to avoid that dataset is used by default. - var thisData = seriesModel.get('data', true); - if (!thisData) { - return queryReferringComponents(seriesModel.ecModel, 'dataset', { - index: seriesModel.get('datasetIndex', true), - id: seriesModel.get('datasetId', true) - }, SINGLE_REFERRING).models[0]; - } -} -/** - * @return Always return an array event empty. - */ -function queryDatasetUpstreamDatasetModels(datasetModel) { - // Only these attributes declared, we by default reference to `datasetIndex: 0`. - // Otherwise, no reference. - if (!datasetModel.get('transform', true) && !datasetModel.get('fromTransformResult', true)) { - return []; - } - return queryReferringComponents(datasetModel.ecModel, 'dataset', { - index: datasetModel.get('fromDatasetIndex', true), - id: datasetModel.get('fromDatasetId', true) - }, SINGLE_REFERRING).models; -} -/** - * The rule should not be complex, otherwise user might not - * be able to known where the data is wrong. - * The code is ugly, but how to make it neat? - */ -function guessOrdinal(source, dimIndex) { - return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex); -} -// dimIndex may be overflow source data. -// return {BE_ORDINAL} -function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) { - var result; - // Experience value. - var maxLoop = 5; - if (isTypedArray(data)) { - return BE_ORDINAL.Not; - } - // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine - // always exists in source. - var dimName; - var dimType; - if (dimensionsDefine) { - var dimDefItem = dimensionsDefine[dimIndex]; - if (isObject$2(dimDefItem)) { - dimName = dimDefItem.name; - dimType = dimDefItem.type; - } else if (isString(dimDefItem)) { - dimName = dimDefItem; - } - } - if (dimType != null) { - return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not; - } - if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) { - var dataArrayRows = data; - if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) { - var sample = dataArrayRows[dimIndex]; - for (var i = 0; i < (sample || []).length && i < maxLoop; i++) { - if ((result = detectValue(sample[startIndex + i])) != null) { - return result; - } - } - } else { - for (var i = 0; i < dataArrayRows.length && i < maxLoop; i++) { - var row = dataArrayRows[startIndex + i]; - if (row && (result = detectValue(row[dimIndex])) != null) { - return result; - } - } - } - } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) { - var dataObjectRows = data; - if (!dimName) { - return BE_ORDINAL.Not; - } - for (var i = 0; i < dataObjectRows.length && i < maxLoop; i++) { - var item = dataObjectRows[i]; - if (item && (result = detectValue(item[dimName])) != null) { - return result; - } - } - } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) { - var dataKeyedColumns = data; - if (!dimName) { - return BE_ORDINAL.Not; - } - var sample = dataKeyedColumns[dimName]; - if (!sample || isTypedArray(sample)) { - return BE_ORDINAL.Not; - } - for (var i = 0; i < sample.length && i < maxLoop; i++) { - if ((result = detectValue(sample[i])) != null) { - return result; - } - } - } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) { - var dataOriginal = data; - for (var i = 0; i < dataOriginal.length && i < maxLoop; i++) { - var item = dataOriginal[i]; - var val = getDataItemValue(item); - if (!isArray(val)) { - return BE_ORDINAL.Not; - } - if ((result = detectValue(val[dimIndex])) != null) { - return result; - } - } - } - function detectValue(val) { - var beStr = isString(val); - // Consider usage convenience, '1', '2' will be treated as "number". - // `Number('')` (or any whitespace) is `0`. - if (val != null && Number.isFinite(Number(val)) && val !== '') { - return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not; - } else if (beStr && val !== '-') { - return BE_ORDINAL.Must; - } - } - return BE_ORDINAL.Not; -} - -var internalOptionCreatorMap = createHashMap(); -function concatInternalOptions(ecModel, mainType, newCmptOptionList) { - var internalOptionCreator = internalOptionCreatorMap.get(mainType); - if (!internalOptionCreator) { - return newCmptOptionList; - } - var internalOptions = internalOptionCreator(ecModel); - if (!internalOptions) { - return newCmptOptionList; - } - return newCmptOptionList.concat(internalOptions); -} - -var innerColor = makeInner(); -makeInner(); -var PaletteMixin = /** @class */function () { - function PaletteMixin() {} - PaletteMixin.prototype.getColorFromPalette = function (name, scope, requestNum) { - var defaultPalette = normalizeToArray(this.get('color', true)); - var layeredPalette = this.get('colorLayer', true); - return getFromPalette(this, innerColor, defaultPalette, layeredPalette, name, scope, requestNum); - }; - PaletteMixin.prototype.clearColorPalette = function () { - clearPalette(this, innerColor); - }; - return PaletteMixin; -}(); -function getNearestPalette(palettes, requestColorNum) { - var paletteNum = palettes.length; - // TODO palettes must be in order - for (var i = 0; i < paletteNum; i++) { - if (palettes[i].length > requestColorNum) { - return palettes[i]; - } - } - return palettes[paletteNum - 1]; -} -/** - * @param name MUST NOT be null/undefined. Otherwise call this function - * twise with the same parameters will get different result. - * @param scope default this. - * @return Can be null/undefined - */ -function getFromPalette(that, inner, defaultPalette, layeredPalette, name, scope, requestNum) { - scope = scope || that; - var scopeFields = inner(scope); - var paletteIdx = scopeFields.paletteIdx || 0; - var paletteNameMap = scopeFields.paletteNameMap = scopeFields.paletteNameMap || {}; - // Use `hasOwnProperty` to avoid conflict with Object.prototype. - if (paletteNameMap.hasOwnProperty(name)) { - return paletteNameMap[name]; - } - var palette = requestNum == null || !layeredPalette ? defaultPalette : getNearestPalette(layeredPalette, requestNum); - // In case can't find in layered color palette. - palette = palette || defaultPalette; - if (!palette || !palette.length) { - return; - } - var pickedPaletteItem = palette[paletteIdx]; - if (name) { - paletteNameMap[name] = pickedPaletteItem; - } - scopeFields.paletteIdx = (paletteIdx + 1) % palette.length; - return pickedPaletteItem; -} -function clearPalette(that, inner) { - inner(that).paletteIdx = 0; - inner(that).paletteNameMap = {}; -} - -var reCreateSeriesIndices; -var assertSeriesInitialized; -var initBase; -var OPTION_INNER_KEY = "\0_ec_inner"; -var OPTION_INNER_VALUE = 1; -var GlobalModel = ( - /** @class */ - function(_super) { - __extends(GlobalModel2, _super); - function GlobalModel2() { - return _super !== null && _super.apply(this, arguments) || this; - } - GlobalModel2.prototype.init = function(option, parentModel, ecModel, theme, locale, optionManager) { - theme = theme || {}; - this.option = null; - this._theme = new Model(theme); - this._locale = new Model(locale); - this._optionManager = optionManager; - }; - GlobalModel2.prototype.setOption = function(option, opts, optionPreprocessorFuncs) { - var innerOpt = normalizeSetOptionInput(opts); - this._optionManager.setOption(option, optionPreprocessorFuncs, innerOpt); - this._resetOption(null, innerOpt); - }; - GlobalModel2.prototype.resetOption = function(type, opt) { - return this._resetOption(type, normalizeSetOptionInput(opt)); - }; - GlobalModel2.prototype._resetOption = function(type, opt) { - var optionChanged = false; - var optionManager = this._optionManager; - if (!type || type === "recreate") { - var baseOption = optionManager.mountOption(type === "recreate"); - if (!this.option || type === "recreate") { - initBase(this, baseOption); - } else { - this.restoreData(); - this._mergeOption(baseOption, opt); - } - optionChanged = true; - } - if (type === "timeline" || type === "media") { - this.restoreData(); - } - if (!type || type === "recreate" || type === "timeline") { - var timelineOption = optionManager.getTimelineOption(this); - if (timelineOption) { - optionChanged = true; - this._mergeOption(timelineOption, opt); - } - } - if (!type || type === "recreate" || type === "media") { - var mediaOptions = optionManager.getMediaOption(this); - if (mediaOptions.length) { - each$4(mediaOptions, function(mediaOption) { - optionChanged = true; - this._mergeOption(mediaOption, opt); - }, this); - } - } - return optionChanged; - }; - GlobalModel2.prototype.mergeOption = function(option) { - this._mergeOption(option, null); - }; - GlobalModel2.prototype._mergeOption = function(newOption, opt) { - var option = this.option; - var componentsMap = this._componentsMap; - var componentsCount = this._componentsCount; - var newCmptTypes = []; - var newCmptTypeMap = createHashMap(); - var replaceMergeMainTypeMap = opt && opt.replaceMergeMainTypeMap; - resetSourceDefaulter(this); - each$4(newOption, function(componentOption, mainType) { - if (componentOption == null) { - return; - } - if (!ComponentModel.hasClass(mainType)) { - option[mainType] = option[mainType] == null ? clone$2(componentOption) : merge(option[mainType], componentOption, true); - } else if (mainType) { - newCmptTypes.push(mainType); - newCmptTypeMap.set(mainType, true); - } - }); - if (replaceMergeMainTypeMap) { - replaceMergeMainTypeMap.each(function(val, mainTypeInReplaceMerge) { - if (ComponentModel.hasClass(mainTypeInReplaceMerge) && !newCmptTypeMap.get(mainTypeInReplaceMerge)) { - newCmptTypes.push(mainTypeInReplaceMerge); - newCmptTypeMap.set(mainTypeInReplaceMerge, true); - } - }); - } - ComponentModel.topologicalTravel(newCmptTypes, ComponentModel.getAllClassMainTypes(), visitComponent, this); - function visitComponent(mainType) { - var newCmptOptionList = concatInternalOptions(this, mainType, normalizeToArray(newOption[mainType])); - var oldCmptList = componentsMap.get(mainType); - var mergeMode = ( - // `!oldCmptList` means init. See the comment in `mappingToExists` - !oldCmptList ? "replaceAll" : replaceMergeMainTypeMap && replaceMergeMainTypeMap.get(mainType) ? "replaceMerge" : "normalMerge" - ); - var mappingResult = mappingToExists(oldCmptList, newCmptOptionList, mergeMode); - setComponentTypeToKeyInfo(mappingResult, mainType, ComponentModel); - option[mainType] = null; - componentsMap.set(mainType, null); - componentsCount.set(mainType, 0); - var optionsByMainType = []; - var cmptsByMainType = []; - var cmptsCountByMainType = 0; - var tooltipExists; - each$4(mappingResult, function(resultItem, index) { - var componentModel = resultItem.existing; - var newCmptOption = resultItem.newOption; - if (!newCmptOption) { - if (componentModel) { - componentModel.mergeOption({}, this); - componentModel.optionUpdated({}, false); - } - } else { - var isSeriesType = mainType === "series"; - var ComponentModelClass = ComponentModel.getClass( - mainType, - resultItem.keyInfo.subType, - !isSeriesType - // Give a more detailed warn later if series don't exists - ); - if (!ComponentModelClass) { - return; - } - if (mainType === "tooltip") { - if (tooltipExists) { - return; - } - tooltipExists = true; - } - if (componentModel && componentModel.constructor === ComponentModelClass) { - componentModel.name = resultItem.keyInfo.name; - componentModel.mergeOption(newCmptOption, this); - componentModel.optionUpdated(newCmptOption, false); - } else { - var extraOpt = extend({ - componentIndex: index - }, resultItem.keyInfo); - componentModel = new ComponentModelClass(newCmptOption, this, this, extraOpt); - extend(componentModel, extraOpt); - if (resultItem.brandNew) { - componentModel.__requireNewView = true; - } - componentModel.init(newCmptOption, this, this); - componentModel.optionUpdated(null, true); - } - } - if (componentModel) { - optionsByMainType.push(componentModel.option); - cmptsByMainType.push(componentModel); - cmptsCountByMainType++; - } else { - optionsByMainType.push(void 0); - cmptsByMainType.push(void 0); - } - }, this); - option[mainType] = optionsByMainType; - componentsMap.set(mainType, cmptsByMainType); - componentsCount.set(mainType, cmptsCountByMainType); - if (mainType === "series") { - reCreateSeriesIndices(this); - } - } - if (!this._seriesIndices) { - reCreateSeriesIndices(this); - } - }; - GlobalModel2.prototype.getOption = function() { - var option = clone$2(this.option); - each$4(option, function(optInMainType, mainType) { - if (ComponentModel.hasClass(mainType)) { - var opts = normalizeToArray(optInMainType); - var realLen = opts.length; - var metNonInner = false; - for (var i = realLen - 1; i >= 0; i--) { - if (opts[i] && !isComponentIdInternal(opts[i])) { - metNonInner = true; - } else { - opts[i] = null; - !metNonInner && realLen--; - } - } - opts.length = realLen; - option[mainType] = opts; - } - }); - delete option[OPTION_INNER_KEY]; - return option; - }; - GlobalModel2.prototype.getTheme = function() { - return this._theme; - }; - GlobalModel2.prototype.getLocaleModel = function() { - return this._locale; - }; - GlobalModel2.prototype.setUpdatePayload = function(payload) { - this._payload = payload; - }; - GlobalModel2.prototype.getUpdatePayload = function() { - return this._payload; - }; - GlobalModel2.prototype.getComponent = function(mainType, idx) { - var list = this._componentsMap.get(mainType); - if (list) { - var cmpt = list[idx || 0]; - if (cmpt) { - return cmpt; - } else if (idx == null) { - for (var i = 0; i < list.length; i++) { - if (list[i]) { - return list[i]; - } - } - } - } - }; - GlobalModel2.prototype.queryComponents = function(condition) { - var mainType = condition.mainType; - if (!mainType) { - return []; - } - var index = condition.index; - var id = condition.id; - var name = condition.name; - var cmpts = this._componentsMap.get(mainType); - if (!cmpts || !cmpts.length) { - return []; - } - var result; - if (index != null) { - result = []; - each$4(normalizeToArray(index), function(idx) { - cmpts[idx] && result.push(cmpts[idx]); - }); - } else if (id != null) { - result = queryByIdOrName("id", id, cmpts); - } else if (name != null) { - result = queryByIdOrName("name", name, cmpts); - } else { - result = filter(cmpts, function(cmpt) { - return !!cmpt; - }); - } - return filterBySubType(result, condition); - }; - GlobalModel2.prototype.findComponents = function(condition) { - var query = condition.query; - var mainType = condition.mainType; - var queryCond = getQueryCond(query); - var result = queryCond ? this.queryComponents(queryCond) : filter(this._componentsMap.get(mainType), function(cmpt) { - return !!cmpt; - }); - return doFilter(filterBySubType(result, condition)); - function getQueryCond(q) { - var indexAttr = mainType + "Index"; - var idAttr = mainType + "Id"; - var nameAttr = mainType + "Name"; - return q && (q[indexAttr] != null || q[idAttr] != null || q[nameAttr] != null) ? { - mainType, - // subType will be filtered finally. - index: q[indexAttr], - id: q[idAttr], - name: q[nameAttr] - } : null; - } - function doFilter(res) { - return condition.filter ? filter(res, condition.filter) : res; - } - }; - GlobalModel2.prototype.eachComponent = function(mainType, cb, context) { - var componentsMap = this._componentsMap; - if (isFunction(mainType)) { - var ctxForAll_1 = cb; - var cbForAll_1 = mainType; - componentsMap.each(function(cmpts2, componentType) { - for (var i2 = 0; cmpts2 && i2 < cmpts2.length; i2++) { - var cmpt2 = cmpts2[i2]; - cmpt2 && cbForAll_1.call(ctxForAll_1, componentType, cmpt2, cmpt2.componentIndex); - } - }); - } else { - var cmpts = isString(mainType) ? componentsMap.get(mainType) : isObject$2(mainType) ? this.findComponents(mainType) : null; - for (var i = 0; cmpts && i < cmpts.length; i++) { - var cmpt = cmpts[i]; - cmpt && cb.call(context, cmpt, cmpt.componentIndex); - } - } - }; - GlobalModel2.prototype.getSeriesByName = function(name) { - var nameStr = convertOptionIdName(name, null); - return filter(this._componentsMap.get("series"), function(oneSeries) { - return !!oneSeries && nameStr != null && oneSeries.name === nameStr; - }); - }; - GlobalModel2.prototype.getSeriesByIndex = function(seriesIndex) { - return this._componentsMap.get("series")[seriesIndex]; - }; - GlobalModel2.prototype.getSeriesByType = function(subType) { - return filter(this._componentsMap.get("series"), function(oneSeries) { - return !!oneSeries && oneSeries.subType === subType; - }); - }; - GlobalModel2.prototype.getSeries = function() { - return filter(this._componentsMap.get("series"), function(oneSeries) { - return !!oneSeries; - }); - }; - GlobalModel2.prototype.getSeriesCount = function() { - return this._componentsCount.get("series"); - }; - GlobalModel2.prototype.eachSeries = function(cb, context) { - assertSeriesInitialized(this); - each$4(this._seriesIndices, function(rawSeriesIndex) { - var series = this._componentsMap.get("series")[rawSeriesIndex]; - cb.call(context, series, rawSeriesIndex); - }, this); - }; - GlobalModel2.prototype.eachRawSeries = function(cb, context) { - each$4(this._componentsMap.get("series"), function(series) { - series && cb.call(context, series, series.componentIndex); - }); - }; - GlobalModel2.prototype.eachSeriesByType = function(subType, cb, context) { - assertSeriesInitialized(this); - each$4(this._seriesIndices, function(rawSeriesIndex) { - var series = this._componentsMap.get("series")[rawSeriesIndex]; - if (series.subType === subType) { - cb.call(context, series, rawSeriesIndex); - } - }, this); - }; - GlobalModel2.prototype.eachRawSeriesByType = function(subType, cb, context) { - return each$4(this.getSeriesByType(subType), cb, context); - }; - GlobalModel2.prototype.isSeriesFiltered = function(seriesModel) { - assertSeriesInitialized(this); - return this._seriesIndicesMap.get(seriesModel.componentIndex) == null; - }; - GlobalModel2.prototype.getCurrentSeriesIndices = function() { - return (this._seriesIndices || []).slice(); - }; - GlobalModel2.prototype.filterSeries = function(cb, context) { - assertSeriesInitialized(this); - var newSeriesIndices = []; - each$4(this._seriesIndices, function(seriesRawIdx) { - var series = this._componentsMap.get("series")[seriesRawIdx]; - cb.call(context, series, seriesRawIdx) && newSeriesIndices.push(seriesRawIdx); - }, this); - this._seriesIndices = newSeriesIndices; - this._seriesIndicesMap = createHashMap(newSeriesIndices); - }; - GlobalModel2.prototype.restoreData = function(payload) { - reCreateSeriesIndices(this); - var componentsMap = this._componentsMap; - var componentTypes = []; - componentsMap.each(function(components, componentType) { - if (ComponentModel.hasClass(componentType)) { - componentTypes.push(componentType); - } - }); - ComponentModel.topologicalTravel(componentTypes, ComponentModel.getAllClassMainTypes(), function(componentType) { - each$4(componentsMap.get(componentType), function(component) { - if (component && (componentType !== "series" || !isNotTargetSeries(component, payload))) { - component.restoreData(); - } - }); - }); - }; - GlobalModel2.internalField = function() { - reCreateSeriesIndices = function(ecModel) { - var seriesIndices = ecModel._seriesIndices = []; - each$4(ecModel._componentsMap.get("series"), function(series) { - series && seriesIndices.push(series.componentIndex); - }); - ecModel._seriesIndicesMap = createHashMap(seriesIndices); - }; - assertSeriesInitialized = function(ecModel) { - }; - initBase = function(ecModel, baseOption) { - ecModel.option = {}; - ecModel.option[OPTION_INNER_KEY] = OPTION_INNER_VALUE; - ecModel._componentsMap = createHashMap({ - series: [] - }); - ecModel._componentsCount = createHashMap(); - var airaOption = baseOption.aria; - if (isObject$2(airaOption) && airaOption.enabled == null) { - airaOption.enabled = true; - } - mergeTheme(baseOption, ecModel._theme.option); - merge(baseOption, globalDefault, false); - ecModel._mergeOption(baseOption, null); - }; - }(); - return GlobalModel2; - }(Model) -); -function isNotTargetSeries(seriesModel, payload) { - if (payload) { - var index = payload.seriesIndex; - var id = payload.seriesId; - var name_1 = payload.seriesName; - return index != null && seriesModel.componentIndex !== index || id != null && seriesModel.id !== id || name_1 != null && seriesModel.name !== name_1; - } -} -function mergeTheme(option, theme) { - var notMergeColorLayer = option.color && !option.colorLayer; - each$4(theme, function(themeItem, name) { - if (name === "colorLayer" && notMergeColorLayer) { - return; - } - if (!ComponentModel.hasClass(name)) { - if (typeof themeItem === "object") { - option[name] = !option[name] ? clone$2(themeItem) : merge(option[name], themeItem, false); - } else { - if (option[name] == null) { - option[name] = themeItem; - } - } - } - }); -} -function queryByIdOrName(attr, idOrName, cmpts) { - if (isArray(idOrName)) { - var keyMap_1 = createHashMap(); - each$4(idOrName, function(idOrNameItem) { - if (idOrNameItem != null) { - var idName = convertOptionIdName(idOrNameItem, null); - idName != null && keyMap_1.set(idOrNameItem, true); - } - }); - return filter(cmpts, function(cmpt) { - return cmpt && keyMap_1.get(cmpt[attr]); - }); - } else { - var idName_1 = convertOptionIdName(idOrName, null); - return filter(cmpts, function(cmpt) { - return cmpt && idName_1 != null && cmpt[attr] === idName_1; - }); - } -} -function filterBySubType(components, condition) { - return condition.hasOwnProperty("subType") ? filter(components, function(cmpt) { - return cmpt && cmpt.subType === condition.subType; - }) : components; -} -function normalizeSetOptionInput(opts) { - var replaceMergeMainTypeMap = createHashMap(); - opts && each$4(normalizeToArray(opts.replaceMerge), function(mainType) { - replaceMergeMainTypeMap.set(mainType, true); - }); - return { - replaceMergeMainTypeMap - }; -} -mixin(GlobalModel, PaletteMixin); - -var availableMethods = ['getDom', 'getZr', 'getWidth', 'getHeight', 'getDevicePixelRatio', 'dispatchAction', 'isSSR', 'isDisposed', 'on', 'off', 'getDataURL', 'getConnectedDataURL', -// 'getModel', -'getOption', -// 'getViewOfComponentModel', -// 'getViewOfSeriesModel', -'getId', 'updateLabelLayout']; -var ExtensionAPI = /** @class */function () { - function ExtensionAPI(ecInstance) { - each$4(availableMethods, function (methodName) { - this[methodName] = bind$1(ecInstance[methodName], ecInstance); - }, this); - } - return ExtensionAPI; -}(); - -var coordinateSystemCreators = {}; -var CoordinateSystemManager = /** @class */function () { - function CoordinateSystemManager() { - this._coordinateSystems = []; - } - CoordinateSystemManager.prototype.create = function (ecModel, api) { - var coordinateSystems = []; - each$4(coordinateSystemCreators, function (creator, type) { - var list = creator.create(ecModel, api); - coordinateSystems = coordinateSystems.concat(list || []); - }); - this._coordinateSystems = coordinateSystems; - }; - CoordinateSystemManager.prototype.update = function (ecModel, api) { - each$4(this._coordinateSystems, function (coordSys) { - coordSys.update && coordSys.update(ecModel, api); - }); - }; - CoordinateSystemManager.prototype.getCoordinateSystems = function () { - return this._coordinateSystems.slice(); - }; - CoordinateSystemManager.register = function (type, creator) { - coordinateSystemCreators[type] = creator; - }; - CoordinateSystemManager.get = function (type) { - return coordinateSystemCreators[type]; - }; - return CoordinateSystemManager; -}(); - -var QUERY_REG = /^(min|max)?(.+)$/; -var OptionManager = ( - /** @class */ - function() { - function OptionManager2(api) { - this._timelineOptions = []; - this._mediaList = []; - this._currentMediaIndices = []; - this._api = api; - } - OptionManager2.prototype.setOption = function(rawOption, optionPreprocessorFuncs, opt) { - if (rawOption) { - each$4(normalizeToArray(rawOption.series), function(series) { - series && series.data && isTypedArray(series.data) && setAsPrimitive(series.data); - }); - each$4(normalizeToArray(rawOption.dataset), function(dataset) { - dataset && dataset.source && isTypedArray(dataset.source) && setAsPrimitive(dataset.source); - }); - } - rawOption = clone$2(rawOption); - var optionBackup = this._optionBackup; - var newParsedOption = parseRawOption(rawOption, optionPreprocessorFuncs, !optionBackup); - this._newBaseOption = newParsedOption.baseOption; - if (optionBackup) { - if (newParsedOption.timelineOptions.length) { - optionBackup.timelineOptions = newParsedOption.timelineOptions; - } - if (newParsedOption.mediaList.length) { - optionBackup.mediaList = newParsedOption.mediaList; - } - if (newParsedOption.mediaDefault) { - optionBackup.mediaDefault = newParsedOption.mediaDefault; - } - } else { - this._optionBackup = newParsedOption; - } - }; - OptionManager2.prototype.mountOption = function(isRecreate) { - var optionBackup = this._optionBackup; - this._timelineOptions = optionBackup.timelineOptions; - this._mediaList = optionBackup.mediaList; - this._mediaDefault = optionBackup.mediaDefault; - this._currentMediaIndices = []; - return clone$2(isRecreate ? optionBackup.baseOption : this._newBaseOption); - }; - OptionManager2.prototype.getTimelineOption = function(ecModel) { - var option; - var timelineOptions = this._timelineOptions; - if (timelineOptions.length) { - var timelineModel = ecModel.getComponent("timeline"); - if (timelineModel) { - option = clone$2( - // FIXME:TS as TimelineModel or quivlant interface - timelineOptions[timelineModel.getCurrentIndex()] - ); - } - } - return option; - }; - OptionManager2.prototype.getMediaOption = function(ecModel) { - var ecWidth = this._api.getWidth(); - var ecHeight = this._api.getHeight(); - var mediaList = this._mediaList; - var mediaDefault = this._mediaDefault; - var indices = []; - var result = []; - if (!mediaList.length && !mediaDefault) { - return result; - } - for (var i = 0, len = mediaList.length; i < len; i++) { - if (applyMediaQuery(mediaList[i].query, ecWidth, ecHeight)) { - indices.push(i); - } - } - if (!indices.length && mediaDefault) { - indices = [-1]; - } - if (indices.length && !indicesEquals(indices, this._currentMediaIndices)) { - result = map$1(indices, function(index) { - return clone$2(index === -1 ? mediaDefault.option : mediaList[index].option); - }); - } - this._currentMediaIndices = indices; - return result; - }; - return OptionManager2; - }() -); -function parseRawOption(rawOption, optionPreprocessorFuncs, isNew) { - var mediaList = []; - var mediaDefault; - var baseOption; - var declaredBaseOption = rawOption.baseOption; - var timelineOnRoot = rawOption.timeline; - var timelineOptionsOnRoot = rawOption.options; - var mediaOnRoot = rawOption.media; - var hasMedia = !!rawOption.media; - var hasTimeline = !!(timelineOptionsOnRoot || timelineOnRoot || declaredBaseOption && declaredBaseOption.timeline); - if (declaredBaseOption) { - baseOption = declaredBaseOption; - if (!baseOption.timeline) { - baseOption.timeline = timelineOnRoot; - } - } else { - if (hasTimeline || hasMedia) { - rawOption.options = rawOption.media = null; - } - baseOption = rawOption; - } - if (hasMedia) { - if (isArray(mediaOnRoot)) { - each$4(mediaOnRoot, function(singleMedia) { - if (singleMedia && singleMedia.option) { - if (singleMedia.query) { - mediaList.push(singleMedia); - } else if (!mediaDefault) { - mediaDefault = singleMedia; - } - } - }); - } - } - doPreprocess(baseOption); - each$4(timelineOptionsOnRoot, function(option) { - return doPreprocess(option); - }); - each$4(mediaList, function(media) { - return doPreprocess(media.option); - }); - function doPreprocess(option) { - each$4(optionPreprocessorFuncs, function(preProcess) { - preProcess(option, isNew); - }); - } - return { - baseOption, - timelineOptions: timelineOptionsOnRoot || [], - mediaDefault, - mediaList - }; -} -function applyMediaQuery(query, ecWidth, ecHeight) { - var realMap = { - width: ecWidth, - height: ecHeight, - aspectratio: ecWidth / ecHeight - // lower case for convenience. - }; - var applicable = true; - each$4(query, function(value, attr) { - var matched = attr.match(QUERY_REG); - if (!matched || !matched[1] || !matched[2]) { - return; - } - var operator = matched[1]; - var realAttr = matched[2].toLowerCase(); - if (!compare(realMap[realAttr], value, operator)) { - applicable = false; - } - }); - return applicable; -} -function compare(real, expect, operator) { - if (operator === "min") { - return real >= expect; - } else if (operator === "max") { - return real <= expect; - } else { - return real === expect; - } -} -function indicesEquals(indices1, indices2) { - return indices1.join(",") === indices2.join(","); -} - -var each$2 = each$4; -var isObject$1 = isObject$2; -var POSSIBLE_STYLES = ["areaStyle", "lineStyle", "nodeStyle", "linkStyle", "chordStyle", "label", "labelLine"]; -function compatEC2ItemStyle(opt) { - var itemStyleOpt = opt && opt.itemStyle; - if (!itemStyleOpt) { - return; - } - for (var i = 0, len = POSSIBLE_STYLES.length; i < len; i++) { - var styleName = POSSIBLE_STYLES[i]; - var normalItemStyleOpt = itemStyleOpt.normal; - var emphasisItemStyleOpt = itemStyleOpt.emphasis; - if (normalItemStyleOpt && normalItemStyleOpt[styleName]) { - opt[styleName] = opt[styleName] || {}; - if (!opt[styleName].normal) { - opt[styleName].normal = normalItemStyleOpt[styleName]; - } else { - merge(opt[styleName].normal, normalItemStyleOpt[styleName]); - } - normalItemStyleOpt[styleName] = null; - } - if (emphasisItemStyleOpt && emphasisItemStyleOpt[styleName]) { - opt[styleName] = opt[styleName] || {}; - if (!opt[styleName].emphasis) { - opt[styleName].emphasis = emphasisItemStyleOpt[styleName]; - } else { - merge(opt[styleName].emphasis, emphasisItemStyleOpt[styleName]); - } - emphasisItemStyleOpt[styleName] = null; - } - } -} -function convertNormalEmphasis(opt, optType, useExtend) { - if (opt && opt[optType] && (opt[optType].normal || opt[optType].emphasis)) { - var normalOpt = opt[optType].normal; - var emphasisOpt = opt[optType].emphasis; - if (normalOpt) { - if (useExtend) { - opt[optType].normal = opt[optType].emphasis = null; - defaults(opt[optType], normalOpt); - } else { - opt[optType] = normalOpt; - } - } - if (emphasisOpt) { - opt.emphasis = opt.emphasis || {}; - opt.emphasis[optType] = emphasisOpt; - if (emphasisOpt.focus) { - opt.emphasis.focus = emphasisOpt.focus; - } - if (emphasisOpt.blurScope) { - opt.emphasis.blurScope = emphasisOpt.blurScope; - } - } - } -} -function removeEC3NormalStatus(opt) { - convertNormalEmphasis(opt, "itemStyle"); - convertNormalEmphasis(opt, "lineStyle"); - convertNormalEmphasis(opt, "areaStyle"); - convertNormalEmphasis(opt, "label"); - convertNormalEmphasis(opt, "labelLine"); - convertNormalEmphasis(opt, "upperLabel"); - convertNormalEmphasis(opt, "edgeLabel"); -} -function compatTextStyle(opt, propName) { - var labelOptSingle = isObject$1(opt) && opt[propName]; - var textStyle = isObject$1(labelOptSingle) && labelOptSingle.textStyle; - if (textStyle) { - for (var i = 0, len = TEXT_STYLE_OPTIONS.length; i < len; i++) { - var textPropName = TEXT_STYLE_OPTIONS[i]; - if (textStyle.hasOwnProperty(textPropName)) { - labelOptSingle[textPropName] = textStyle[textPropName]; - } - } - } -} -function compatEC3CommonStyles(opt) { - if (opt) { - removeEC3NormalStatus(opt); - compatTextStyle(opt, "label"); - opt.emphasis && compatTextStyle(opt.emphasis, "label"); - } -} -function processSeries(seriesOpt) { - if (!isObject$1(seriesOpt)) { - return; - } - compatEC2ItemStyle(seriesOpt); - removeEC3NormalStatus(seriesOpt); - compatTextStyle(seriesOpt, "label"); - compatTextStyle(seriesOpt, "upperLabel"); - compatTextStyle(seriesOpt, "edgeLabel"); - if (seriesOpt.emphasis) { - compatTextStyle(seriesOpt.emphasis, "label"); - compatTextStyle(seriesOpt.emphasis, "upperLabel"); - compatTextStyle(seriesOpt.emphasis, "edgeLabel"); - } - var markPoint = seriesOpt.markPoint; - if (markPoint) { - compatEC2ItemStyle(markPoint); - compatEC3CommonStyles(markPoint); - } - var markLine = seriesOpt.markLine; - if (markLine) { - compatEC2ItemStyle(markLine); - compatEC3CommonStyles(markLine); - } - var markArea = seriesOpt.markArea; - if (markArea) { - compatEC3CommonStyles(markArea); - } - var data = seriesOpt.data; - if (seriesOpt.type === "graph") { - data = data || seriesOpt.nodes; - var edgeData = seriesOpt.links || seriesOpt.edges; - if (edgeData && !isTypedArray(edgeData)) { - for (var i = 0; i < edgeData.length; i++) { - compatEC3CommonStyles(edgeData[i]); - } - } - each$4(seriesOpt.categories, function(opt) { - removeEC3NormalStatus(opt); - }); - } - if (data && !isTypedArray(data)) { - for (var i = 0; i < data.length; i++) { - compatEC3CommonStyles(data[i]); - } - } - markPoint = seriesOpt.markPoint; - if (markPoint && markPoint.data) { - var mpData = markPoint.data; - for (var i = 0; i < mpData.length; i++) { - compatEC3CommonStyles(mpData[i]); - } - } - markLine = seriesOpt.markLine; - if (markLine && markLine.data) { - var mlData = markLine.data; - for (var i = 0; i < mlData.length; i++) { - if (isArray(mlData[i])) { - compatEC3CommonStyles(mlData[i][0]); - compatEC3CommonStyles(mlData[i][1]); - } else { - compatEC3CommonStyles(mlData[i]); - } - } - } - if (seriesOpt.type === "gauge") { - compatTextStyle(seriesOpt, "axisLabel"); - compatTextStyle(seriesOpt, "title"); - compatTextStyle(seriesOpt, "detail"); - } else if (seriesOpt.type === "treemap") { - convertNormalEmphasis(seriesOpt.breadcrumb, "itemStyle"); - each$4(seriesOpt.levels, function(opt) { - removeEC3NormalStatus(opt); - }); - } else if (seriesOpt.type === "tree") { - removeEC3NormalStatus(seriesOpt.leaves); - } -} -function toArr(o) { - return isArray(o) ? o : o ? [o] : []; -} -function toObj(o) { - return (isArray(o) ? o[0] : o) || {}; -} -function globalCompatStyle(option, isTheme) { - each$2(toArr(option.series), function(seriesOpt) { - isObject$1(seriesOpt) && processSeries(seriesOpt); - }); - var axes = ["xAxis", "yAxis", "radiusAxis", "angleAxis", "singleAxis", "parallelAxis", "radar"]; - isTheme && axes.push("valueAxis", "categoryAxis", "logAxis", "timeAxis"); - each$2(axes, function(axisName) { - each$2(toArr(option[axisName]), function(axisOpt) { - if (axisOpt) { - compatTextStyle(axisOpt, "axisLabel"); - compatTextStyle(axisOpt.axisPointer, "label"); - } - }); - }); - each$2(toArr(option.parallel), function(parallelOpt) { - var parallelAxisDefault = parallelOpt && parallelOpt.parallelAxisDefault; - compatTextStyle(parallelAxisDefault, "axisLabel"); - compatTextStyle(parallelAxisDefault && parallelAxisDefault.axisPointer, "label"); - }); - each$2(toArr(option.calendar), function(calendarOpt) { - convertNormalEmphasis(calendarOpt, "itemStyle"); - compatTextStyle(calendarOpt, "dayLabel"); - compatTextStyle(calendarOpt, "monthLabel"); - compatTextStyle(calendarOpt, "yearLabel"); - }); - each$2(toArr(option.radar), function(radarOpt) { - compatTextStyle(radarOpt, "name"); - if (radarOpt.name && radarOpt.axisName == null) { - radarOpt.axisName = radarOpt.name; - delete radarOpt.name; - } - if (radarOpt.nameGap != null && radarOpt.axisNameGap == null) { - radarOpt.axisNameGap = radarOpt.nameGap; - delete radarOpt.nameGap; - } - }); - each$2(toArr(option.geo), function(geoOpt) { - if (isObject$1(geoOpt)) { - compatEC3CommonStyles(geoOpt); - each$2(toArr(geoOpt.regions), function(regionObj) { - compatEC3CommonStyles(regionObj); - }); - } - }); - each$2(toArr(option.timeline), function(timelineOpt) { - compatEC3CommonStyles(timelineOpt); - convertNormalEmphasis(timelineOpt, "label"); - convertNormalEmphasis(timelineOpt, "itemStyle"); - convertNormalEmphasis(timelineOpt, "controlStyle", true); - var data = timelineOpt.data; - isArray(data) && each$4(data, function(item) { - if (isObject$2(item)) { - convertNormalEmphasis(item, "label"); - convertNormalEmphasis(item, "itemStyle"); - } - }); - }); - each$2(toArr(option.toolbox), function(toolboxOpt) { - convertNormalEmphasis(toolboxOpt, "iconStyle"); - each$2(toolboxOpt.feature, function(featureOpt) { - convertNormalEmphasis(featureOpt, "iconStyle"); - }); - }); - compatTextStyle(toObj(option.axisPointer), "label"); - compatTextStyle(toObj(option.tooltip).axisPointer, "label"); -} - -function get(opt, path) { - var pathArr = path.split(","); - var obj = opt; - for (var i = 0; i < pathArr.length; i++) { - obj = obj && obj[pathArr[i]]; - if (obj == null) { - break; - } - } - return obj; -} -function set(opt, path, val, overwrite) { - var pathArr = path.split(","); - var obj = opt; - var key; - var i = 0; - for (; i < pathArr.length - 1; i++) { - key = pathArr[i]; - if (obj[key] == null) { - obj[key] = {}; - } - obj = obj[key]; - } - if (obj[pathArr[i]] == null) { - obj[pathArr[i]] = val; - } -} -function compatLayoutProperties(option) { - option && each$4(LAYOUT_PROPERTIES, function(prop) { - if (prop[0] in option && !(prop[1] in option)) { - option[prop[1]] = option[prop[0]]; - } - }); -} -var LAYOUT_PROPERTIES = [["x", "left"], ["y", "top"], ["x2", "right"], ["y2", "bottom"]]; -var COMPATITABLE_COMPONENTS = ["grid", "geo", "parallel", "legend", "toolbox", "title", "visualMap", "dataZoom", "timeline"]; -var BAR_ITEM_STYLE_MAP = [["borderRadius", "barBorderRadius"], ["borderColor", "barBorderColor"], ["borderWidth", "barBorderWidth"]]; -function compatBarItemStyle(option) { - var itemStyle = option && option.itemStyle; - if (itemStyle) { - for (var i = 0; i < BAR_ITEM_STYLE_MAP.length; i++) { - var oldName = BAR_ITEM_STYLE_MAP[i][1]; - var newName = BAR_ITEM_STYLE_MAP[i][0]; - if (itemStyle[oldName] != null) { - itemStyle[newName] = itemStyle[oldName]; - } - } - } -} -function compatPieLabel(option) { - if (!option) { - return; - } - if (option.alignTo === "edge" && option.margin != null && option.edgeDistance == null) { - option.edgeDistance = option.margin; - } -} -function compatSunburstState(option) { - if (!option) { - return; - } - if (option.downplay && !option.blur) { - option.blur = option.downplay; - } -} -function compatGraphFocus(option) { - if (!option) { - return; - } - if (option.focusNodeAdjacency != null) { - option.emphasis = option.emphasis || {}; - if (option.emphasis.focus == null) { - option.emphasis.focus = "adjacency"; - } - } -} -function traverseTree(data, cb) { - if (data) { - for (var i = 0; i < data.length; i++) { - cb(data[i]); - data[i] && traverseTree(data[i].children, cb); - } - } -} -function globalBackwardCompat(option, isTheme) { - globalCompatStyle(option, isTheme); - option.series = normalizeToArray(option.series); - each$4(option.series, function(seriesOpt) { - if (!isObject$2(seriesOpt)) { - return; - } - var seriesType = seriesOpt.type; - if (seriesType === "line") { - if (seriesOpt.clipOverflow != null) { - seriesOpt.clip = seriesOpt.clipOverflow; - } - } else if (seriesType === "pie" || seriesType === "gauge") { - if (seriesOpt.clockWise != null) { - seriesOpt.clockwise = seriesOpt.clockWise; - } - compatPieLabel(seriesOpt.label); - var data = seriesOpt.data; - if (data && !isTypedArray(data)) { - for (var i = 0; i < data.length; i++) { - compatPieLabel(data[i]); - } - } - if (seriesOpt.hoverOffset != null) { - seriesOpt.emphasis = seriesOpt.emphasis || {}; - if (seriesOpt.emphasis.scaleSize = null) { - seriesOpt.emphasis.scaleSize = seriesOpt.hoverOffset; - } - } - } else if (seriesType === "gauge") { - var pointerColor = get(seriesOpt, "pointer.color"); - pointerColor != null && set(seriesOpt, "itemStyle.color", pointerColor); - } else if (seriesType === "bar") { - compatBarItemStyle(seriesOpt); - compatBarItemStyle(seriesOpt.backgroundStyle); - compatBarItemStyle(seriesOpt.emphasis); - var data = seriesOpt.data; - if (data && !isTypedArray(data)) { - for (var i = 0; i < data.length; i++) { - if (typeof data[i] === "object") { - compatBarItemStyle(data[i]); - compatBarItemStyle(data[i] && data[i].emphasis); - } - } - } - } else if (seriesType === "sunburst") { - var highlightPolicy = seriesOpt.highlightPolicy; - if (highlightPolicy) { - seriesOpt.emphasis = seriesOpt.emphasis || {}; - if (!seriesOpt.emphasis.focus) { - seriesOpt.emphasis.focus = highlightPolicy; - } - } - compatSunburstState(seriesOpt); - traverseTree(seriesOpt.data, compatSunburstState); - } else if (seriesType === "graph" || seriesType === "sankey") { - compatGraphFocus(seriesOpt); - } else if (seriesType === "map") { - if (seriesOpt.mapType && !seriesOpt.map) { - seriesOpt.map = seriesOpt.mapType; - } - if (seriesOpt.mapLocation) { - defaults(seriesOpt, seriesOpt.mapLocation); - } - } - if (seriesOpt.hoverAnimation != null) { - seriesOpt.emphasis = seriesOpt.emphasis || {}; - if (seriesOpt.emphasis && seriesOpt.emphasis.scale == null) { - seriesOpt.emphasis.scale = seriesOpt.hoverAnimation; - } - } - compatLayoutProperties(seriesOpt); - }); - if (option.dataRange) { - option.visualMap = option.dataRange; - } - each$4(COMPATITABLE_COMPONENTS, function(componentName) { - var options = option[componentName]; - if (options) { - if (!isArray(options)) { - options = [options]; - } - each$4(options, function(option2) { - compatLayoutProperties(option2); - }); - } - }); -} - -// (1) [Caution]: the logic is correct based on the premises: -// data processing stage is blocked in stream. -// See -// (2) Only register once when import repeatedly. -// Should be executed after series is filtered and before stack calculation. -function dataStack(ecModel) { - var stackInfoMap = createHashMap(); - ecModel.eachSeries(function (seriesModel) { - var stack = seriesModel.get('stack'); - // Compatible: when `stack` is set as '', do not stack. - if (stack) { - var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []); - var data = seriesModel.getData(); - var stackInfo = { - // Used for calculate axis extent automatically. - // TODO: Type getCalculationInfo return more specific type? - stackResultDimension: data.getCalculationInfo('stackResultDimension'), - stackedOverDimension: data.getCalculationInfo('stackedOverDimension'), - stackedDimension: data.getCalculationInfo('stackedDimension'), - stackedByDimension: data.getCalculationInfo('stackedByDimension'), - isStackedByIndex: data.getCalculationInfo('isStackedByIndex'), - data: data, - seriesModel: seriesModel - }; - // If stacked on axis that do not support data stack. - if (!stackInfo.stackedDimension || !(stackInfo.isStackedByIndex || stackInfo.stackedByDimension)) { - return; - } - stackInfoList.length && data.setCalculationInfo('stackedOnSeries', stackInfoList[stackInfoList.length - 1].seriesModel); - stackInfoList.push(stackInfo); - } - }); - stackInfoMap.each(calculateStack); -} -function calculateStack(stackInfoList) { - each$4(stackInfoList, function (targetStackInfo, idxInStack) { - var resultVal = []; - var resultNaN = [NaN, NaN]; - var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension]; - var targetData = targetStackInfo.data; - var isStackedByIndex = targetStackInfo.isStackedByIndex; - var stackStrategy = targetStackInfo.seriesModel.get('stackStrategy') || 'samesign'; - // Should not write on raw data, because stack series model list changes - // depending on legend selection. - targetData.modify(dims, function (v0, v1, dataIndex) { - var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex); - // Consider `connectNulls` of line area, if value is NaN, stackedOver - // should also be NaN, to draw a appropriate belt area. - if (isNaN(sum)) { - return resultNaN; - } - var byValue; - var stackedDataRawIndex; - if (isStackedByIndex) { - stackedDataRawIndex = targetData.getRawIndex(dataIndex); - } else { - byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex); - } - // If stackOver is NaN, chart view will render point on value start. - var stackedOver = NaN; - for (var j = idxInStack - 1; j >= 0; j--) { - var stackInfo = stackInfoList[j]; - // Has been optimized by inverted indices on `stackedByDimension`. - if (!isStackedByIndex) { - stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue); - } - if (stackedDataRawIndex >= 0) { - var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex); - // Considering positive stack, negative stack and empty data - if (stackStrategy === 'all' // single stack group - || stackStrategy === 'positive' && val > 0 || stackStrategy === 'negative' && val < 0 || stackStrategy === 'samesign' && sum >= 0 && val > 0 // All positive stack - || stackStrategy === 'samesign' && sum <= 0 && val < 0 // All negative stack - ) { - // The sum has to be very small to be affected by the - // floating arithmetic problem. An incorrect result will probably - // cause axis min/max to be filtered incorrectly. - sum = addSafe(sum, val); - stackedOver = val; - break; - } - } - } - resultVal[0] = sum; - resultVal[1] = stackedOver; - return resultVal; - }); - }); -} - -var SourceImpl = ( - /** @class */ - /* @__PURE__ */ function() { - function SourceImpl2(fields) { - this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []); - this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN; - this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN; - this.startIndex = fields.startIndex || 0; - this.dimensionsDetectedCount = fields.dimensionsDetectedCount; - this.metaRawOption = fields.metaRawOption; - var dimensionsDefine = this.dimensionsDefine = fields.dimensionsDefine; - if (dimensionsDefine) { - for (var i = 0; i < dimensionsDefine.length; i++) { - var dim = dimensionsDefine[i]; - if (dim.type == null) { - if (guessOrdinal(this, i) === BE_ORDINAL.Must) { - dim.type = "ordinal"; - } - } - } - } - } - return SourceImpl2; - }() -); -function isSourceInstance(val) { - return val instanceof SourceImpl; -} -function createSource(sourceData, thisMetaRawOption, sourceFormat) { - sourceFormat = sourceFormat || detectSourceFormat(sourceData); - var seriesLayoutBy = thisMetaRawOption.seriesLayoutBy; - var determined = determineSourceDimensions(sourceData, sourceFormat, seriesLayoutBy, thisMetaRawOption.sourceHeader, thisMetaRawOption.dimensions); - var source = new SourceImpl({ - data: sourceData, - sourceFormat, - seriesLayoutBy, - dimensionsDefine: determined.dimensionsDefine, - startIndex: determined.startIndex, - dimensionsDetectedCount: determined.dimensionsDetectedCount, - metaRawOption: clone$2(thisMetaRawOption) - }); - return source; -} -function createSourceFromSeriesDataOption(data) { - return new SourceImpl({ - data, - sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL - }); -} -function cloneSourceShallow(source) { - return new SourceImpl({ - data: source.data, - sourceFormat: source.sourceFormat, - seriesLayoutBy: source.seriesLayoutBy, - dimensionsDefine: clone$2(source.dimensionsDefine), - startIndex: source.startIndex, - dimensionsDetectedCount: source.dimensionsDetectedCount - }); -} -function detectSourceFormat(data) { - var sourceFormat = SOURCE_FORMAT_UNKNOWN; - if (isTypedArray(data)) { - sourceFormat = SOURCE_FORMAT_TYPED_ARRAY; - } else if (isArray(data)) { - if (data.length === 0) { - sourceFormat = SOURCE_FORMAT_ARRAY_ROWS; - } - for (var i = 0, len = data.length; i < len; i++) { - var item = data[i]; - if (item == null) { - continue; - } else if (isArray(item) || isTypedArray(item)) { - sourceFormat = SOURCE_FORMAT_ARRAY_ROWS; - break; - } else if (isObject$2(item)) { - sourceFormat = SOURCE_FORMAT_OBJECT_ROWS; - break; - } - } - } else if (isObject$2(data)) { - for (var key in data) { - if (hasOwn(data, key) && isArrayLike(data[key])) { - sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS; - break; - } - } - } - return sourceFormat; -} -function determineSourceDimensions(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) { - var dimensionsDetectedCount; - var startIndex; - if (!data) { - return { - dimensionsDefine: normalizeDimensionsOption(dimensionsDefine), - startIndex, - dimensionsDetectedCount - }; - } - if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) { - var dataArrayRows = data; - if (sourceHeader === "auto" || sourceHeader == null) { - arrayRowsTravelFirst(function(val) { - if (val != null && val !== "-") { - if (isString(val)) { - startIndex == null && (startIndex = 1); - } else { - startIndex = 0; - } - } - }, seriesLayoutBy, dataArrayRows, 10); - } else { - startIndex = isNumber(sourceHeader) ? sourceHeader : sourceHeader ? 1 : 0; - } - if (!dimensionsDefine && startIndex === 1) { - dimensionsDefine = []; - arrayRowsTravelFirst(function(val, index) { - dimensionsDefine[index] = val != null ? val + "" : ""; - }, seriesLayoutBy, dataArrayRows, Infinity); - } - dimensionsDetectedCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? dataArrayRows.length : dataArrayRows[0] ? dataArrayRows[0].length : null; - } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) { - if (!dimensionsDefine) { - dimensionsDefine = objectRowsCollectDimensions(data); - } - } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) { - if (!dimensionsDefine) { - dimensionsDefine = []; - each$4(data, function(colArr, key) { - dimensionsDefine.push(key); - }); - } - } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) { - var value0 = getDataItemValue(data[0]); - dimensionsDetectedCount = isArray(value0) && value0.length || 1; - } else ; - return { - startIndex, - dimensionsDefine: normalizeDimensionsOption(dimensionsDefine), - dimensionsDetectedCount - }; -} -function objectRowsCollectDimensions(data) { - var firstIndex = 0; - var obj; - while (firstIndex < data.length && !(obj = data[firstIndex++])) { - } - if (obj) { - return keys(obj); - } -} -function normalizeDimensionsOption(dimensionsDefine) { - if (!dimensionsDefine) { - return; - } - var nameMap = createHashMap(); - return map$1(dimensionsDefine, function(rawItem, index) { - rawItem = isObject$2(rawItem) ? rawItem : { - name: rawItem - }; - var item = { - name: rawItem.name, - displayName: rawItem.displayName, - type: rawItem.type - }; - if (item.name == null) { - return item; - } - item.name += ""; - if (item.displayName == null) { - item.displayName = item.name; - } - var exist = nameMap.get(item.name); - if (!exist) { - nameMap.set(item.name, { - count: 1 - }); - } else { - item.name += "-" + exist.count++; - } - return item; - }); -} -function arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) { - if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) { - for (var i = 0; i < data.length && i < maxLoop; i++) { - cb(data[i] ? data[i][0] : null, i); - } - } else { - var value0 = data[0] || []; - for (var i = 0; i < value0.length && i < maxLoop; i++) { - cb(value0[i], i); - } - } -} -function shouldRetrieveDataByName(source) { - var sourceFormat = source.sourceFormat; - return sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS; -} - -var _a, _b, _c; -var providerMethods; -var mountMethods; -var DefaultDataProvider = ( - /** @class */ - function() { - function DefaultDataProvider2(sourceParam, dimSize) { - var source = !isSourceInstance(sourceParam) ? createSourceFromSeriesDataOption(sourceParam) : sourceParam; - this._source = source; - var data = this._data = source.data; - if (source.sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) { - this._offset = 0; - this._dimSize = dimSize; - this._data = data; - } - mountMethods(this, data, source); - } - DefaultDataProvider2.prototype.getSource = function() { - return this._source; - }; - DefaultDataProvider2.prototype.count = function() { - return 0; - }; - DefaultDataProvider2.prototype.getItem = function(idx, out) { - return; - }; - DefaultDataProvider2.prototype.appendData = function(newData) { - }; - DefaultDataProvider2.prototype.clean = function() { - }; - DefaultDataProvider2.protoInitialize = function() { - var proto = DefaultDataProvider2.prototype; - proto.pure = false; - proto.persistent = true; - }(); - DefaultDataProvider2.internalField = function() { - var _a2; - mountMethods = function(provider, data, source) { - var sourceFormat = source.sourceFormat; - var seriesLayoutBy = source.seriesLayoutBy; - var startIndex = source.startIndex; - var dimsDef = source.dimensionsDefine; - var methods = providerMethods[getMethodMapKey(sourceFormat, seriesLayoutBy)]; - extend(provider, methods); - if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) { - provider.getItem = getItemForTypedArray; - provider.count = countForTypedArray; - provider.fillStorage = fillStorageForTypedArray; - } else { - var rawItemGetter = getRawSourceItemGetter(sourceFormat, seriesLayoutBy); - provider.getItem = bind$1(rawItemGetter, null, data, startIndex, dimsDef); - var rawCounter = getRawSourceDataCounter(sourceFormat, seriesLayoutBy); - provider.count = bind$1(rawCounter, null, data, startIndex, dimsDef); - } - }; - var getItemForTypedArray = function(idx, out) { - idx = idx - this._offset; - out = out || []; - var data = this._data; - var dimSize = this._dimSize; - var offset = dimSize * idx; - for (var i = 0; i < dimSize; i++) { - out[i] = data[offset + i]; - } - return out; - }; - var fillStorageForTypedArray = function(start, end, storage, extent) { - var data = this._data; - var dimSize = this._dimSize; - for (var dim = 0; dim < dimSize; dim++) { - var dimExtent = extent[dim]; - var min = dimExtent[0] == null ? Infinity : dimExtent[0]; - var max = dimExtent[1] == null ? -Infinity : dimExtent[1]; - var count = end - start; - var arr = storage[dim]; - for (var i = 0; i < count; i++) { - var val = data[i * dimSize + dim]; - arr[start + i] = val; - val < min && (min = val); - val > max && (max = val); - } - dimExtent[0] = min; - dimExtent[1] = max; - } - }; - var countForTypedArray = function() { - return this._data ? this._data.length / this._dimSize : 0; - }; - providerMethods = (_a2 = {}, _a2[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_COLUMN] = { - pure: true, - appendData: appendDataSimply - }, _a2[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_ROW] = { - pure: true, - appendData: function() { - throw new Error('Do not support appendData when set seriesLayoutBy: "row".'); - } - }, _a2[SOURCE_FORMAT_OBJECT_ROWS] = { - pure: true, - appendData: appendDataSimply - }, _a2[SOURCE_FORMAT_KEYED_COLUMNS] = { - pure: true, - appendData: function(newData) { - var data = this._data; - each$4(newData, function(newCol, key) { - var oldCol = data[key] || (data[key] = []); - for (var i = 0; i < (newCol || []).length; i++) { - oldCol.push(newCol[i]); - } - }); - } - }, _a2[SOURCE_FORMAT_ORIGINAL] = { - appendData: appendDataSimply - }, _a2[SOURCE_FORMAT_TYPED_ARRAY] = { - persistent: false, - pure: true, - appendData: function(newData) { - this._data = newData; - }, - // Clean self if data is already used. - clean: function() { - this._offset += this.count(); - this._data = null; - } - }, _a2); - function appendDataSimply(newData) { - for (var i = 0; i < newData.length; i++) { - this._data.push(newData[i]); - } - } - }(); - return DefaultDataProvider2; - }() -); -var getItemSimply = function(rawData, startIndex, dimsDef, idx) { - return rawData[idx]; -}; -var rawSourceItemGetterMap = (_a = {}, _a[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_COLUMN] = function(rawData, startIndex, dimsDef, idx) { - return rawData[idx + startIndex]; -}, _a[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_ROW] = function(rawData, startIndex, dimsDef, idx, out) { - idx += startIndex; - var item = out || []; - var data = rawData; - for (var i = 0; i < data.length; i++) { - var row = data[i]; - item[i] = row ? row[idx] : null; - } - return item; -}, _a[SOURCE_FORMAT_OBJECT_ROWS] = getItemSimply, _a[SOURCE_FORMAT_KEYED_COLUMNS] = function(rawData, startIndex, dimsDef, idx, out) { - var item = out || []; - for (var i = 0; i < dimsDef.length; i++) { - var dimName = dimsDef[i].name; - var col = rawData[dimName]; - item[i] = col ? col[idx] : null; - } - return item; -}, _a[SOURCE_FORMAT_ORIGINAL] = getItemSimply, _a); -function getRawSourceItemGetter(sourceFormat, seriesLayoutBy) { - var method = rawSourceItemGetterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)]; - return method; -} -var countSimply = function(rawData, startIndex, dimsDef) { - return rawData.length; -}; -var rawSourceDataCounterMap = (_b = {}, _b[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_COLUMN] = function(rawData, startIndex, dimsDef) { - return Math.max(0, rawData.length - startIndex); -}, _b[SOURCE_FORMAT_ARRAY_ROWS + "_" + SERIES_LAYOUT_BY_ROW] = function(rawData, startIndex, dimsDef) { - var row = rawData[0]; - return row ? Math.max(0, row.length - startIndex) : 0; -}, _b[SOURCE_FORMAT_OBJECT_ROWS] = countSimply, _b[SOURCE_FORMAT_KEYED_COLUMNS] = function(rawData, startIndex, dimsDef) { - var dimName = dimsDef[0].name; - var col = rawData[dimName]; - return col ? col.length : 0; -}, _b[SOURCE_FORMAT_ORIGINAL] = countSimply, _b); -function getRawSourceDataCounter(sourceFormat, seriesLayoutBy) { - var method = rawSourceDataCounterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)]; - return method; -} -var getRawValueSimply = function(dataItem, dimIndex, property) { - return dataItem[dimIndex]; -}; -var rawSourceValueGetterMap = (_c = {}, _c[SOURCE_FORMAT_ARRAY_ROWS] = getRawValueSimply, _c[SOURCE_FORMAT_OBJECT_ROWS] = function(dataItem, dimIndex, property) { - return dataItem[property]; -}, _c[SOURCE_FORMAT_KEYED_COLUMNS] = getRawValueSimply, _c[SOURCE_FORMAT_ORIGINAL] = function(dataItem, dimIndex, property) { - var value = getDataItemValue(dataItem); - return !(value instanceof Array) ? value : value[dimIndex]; -}, _c[SOURCE_FORMAT_TYPED_ARRAY] = getRawValueSimply, _c); -function getRawSourceValueGetter(sourceFormat) { - var method = rawSourceValueGetterMap[sourceFormat]; - return method; -} -function getMethodMapKey(sourceFormat, seriesLayoutBy) { - return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + "_" + seriesLayoutBy : sourceFormat; -} -function retrieveRawValue(data, dataIndex, dim) { - if (!data) { - return; - } - var dataItem = data.getRawDataItem(dataIndex); - if (dataItem == null) { - return; - } - var store = data.getStore(); - var sourceFormat = store.getSource().sourceFormat; - if (dim != null) { - var dimIndex = data.getDimensionIndex(dim); - var property = store.getDimensionProperty(dimIndex); - return getRawSourceValueGetter(sourceFormat)(dataItem, dimIndex, property); - } else { - var result = dataItem; - if (sourceFormat === SOURCE_FORMAT_ORIGINAL) { - result = getDataItemValue(dataItem); - } - return result; - } -} - -var DIMENSION_LABEL_REG = /\{@(.+?)\}/g; -var DataFormatMixin = ( - /** @class */ - function() { - function DataFormatMixin2() { - } - DataFormatMixin2.prototype.getDataParams = function(dataIndex, dataType) { - var data = this.getData(dataType); - var rawValue = this.getRawValue(dataIndex, dataType); - var rawDataIndex = data.getRawIndex(dataIndex); - var name = data.getName(dataIndex); - var itemOpt = data.getRawDataItem(dataIndex); - var style = data.getItemVisual(dataIndex, "style"); - var color = style && style[data.getItemVisual(dataIndex, "drawType") || "fill"]; - var borderColor = style && style.stroke; - var mainType = this.mainType; - var isSeries = mainType === "series"; - var userOutput = data.userOutput && data.userOutput.get(); - return { - componentType: mainType, - componentSubType: this.subType, - componentIndex: this.componentIndex, - seriesType: isSeries ? this.subType : null, - seriesIndex: this.seriesIndex, - seriesId: isSeries ? this.id : null, - seriesName: isSeries ? this.name : null, - name, - dataIndex: rawDataIndex, - data: itemOpt, - dataType, - value: rawValue, - color, - borderColor, - dimensionNames: userOutput ? userOutput.fullDimensions : null, - encode: userOutput ? userOutput.encode : null, - // Param name list for mapping `a`, `b`, `c`, `d`, `e` - $vars: ["seriesName", "name", "value"] - }; - }; - DataFormatMixin2.prototype.getFormattedLabel = function(dataIndex, status, dataType, labelDimIndex, formatter, extendParams) { - status = status || "normal"; - var data = this.getData(dataType); - var params = this.getDataParams(dataIndex, dataType); - if (extendParams) { - params.value = extendParams.interpolatedValue; - } - if (labelDimIndex != null && isArray(params.value)) { - params.value = params.value[labelDimIndex]; - } - if (!formatter) { - var itemModel = data.getItemModel(dataIndex); - formatter = itemModel.get(status === "normal" ? ["label", "formatter"] : [status, "label", "formatter"]); - } - if (isFunction(formatter)) { - params.status = status; - params.dimensionIndex = labelDimIndex; - return formatter(params); - } else if (isString(formatter)) { - var str = formatTpl(formatter, params); - return str.replace(DIMENSION_LABEL_REG, function(origin, dimStr) { - var len = dimStr.length; - var dimLoose = dimStr; - if (dimLoose.charAt(0) === "[" && dimLoose.charAt(len - 1) === "]") { - dimLoose = +dimLoose.slice(1, len - 1); - } - var val = retrieveRawValue(data, dataIndex, dimLoose); - if (extendParams && isArray(extendParams.interpolatedValue)) { - var dimIndex = data.getDimensionIndex(dimLoose); - if (dimIndex >= 0) { - val = extendParams.interpolatedValue[dimIndex]; - } - } - return val != null ? val + "" : ""; - }); - } - }; - DataFormatMixin2.prototype.getRawValue = function(idx, dataType) { - return retrieveRawValue(this.getData(dataType), idx); - }; - DataFormatMixin2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) { - return; - }; - return DataFormatMixin2; - }() -); -function normalizeTooltipFormatResult(result) { - var markupText; - var markupFragment; - if (isObject$2(result)) { - if (result.type) { - markupFragment = result; - } - } else { - markupText = result; - } - return { - text: markupText, - // markers: markers || markersExisting, - frag: markupFragment - }; -} - -function createTask(define) { - return new Task(define); -} -var Task = ( - /** @class */ - function() { - function Task2(define) { - define = define || {}; - this._reset = define.reset; - this._plan = define.plan; - this._count = define.count; - this._onDirty = define.onDirty; - this._dirty = true; - } - Task2.prototype.perform = function(performArgs) { - var upTask = this._upstream; - var skip = performArgs && performArgs.skip; - if (this._dirty && upTask) { - var context = this.context; - context.data = context.outputData = upTask.context.outputData; - } - if (this.__pipeline) { - this.__pipeline.currentTask = this; - } - var planResult; - if (this._plan && !skip) { - planResult = this._plan(this.context); - } - var lastModBy = normalizeModBy(this._modBy); - var lastModDataCount = this._modDataCount || 0; - var modBy = normalizeModBy(performArgs && performArgs.modBy); - var modDataCount = performArgs && performArgs.modDataCount || 0; - if (lastModBy !== modBy || lastModDataCount !== modDataCount) { - planResult = "reset"; - } - function normalizeModBy(val) { - !(val >= 1) && (val = 1); - return val; - } - var forceFirstProgress; - if (this._dirty || planResult === "reset") { - this._dirty = false; - forceFirstProgress = this._doReset(skip); - } - this._modBy = modBy; - this._modDataCount = modDataCount; - var step = performArgs && performArgs.step; - if (upTask) { - this._dueEnd = upTask._outputDueEnd; - } else { - this._dueEnd = this._count ? this._count(this.context) : Infinity; - } - if (this._progress) { - var start = this._dueIndex; - var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd); - if (!skip && (forceFirstProgress || start < end)) { - var progress = this._progress; - if (isArray(progress)) { - for (var i = 0; i < progress.length; i++) { - this._doProgress(progress[i], start, end, modBy, modDataCount); - } - } else { - this._doProgress(progress, start, end, modBy, modDataCount); - } - } - this._dueIndex = end; - var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end; - this._outputDueEnd = outputDueEnd; - } else { - this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd; - } - return this.unfinished(); - }; - Task2.prototype.dirty = function() { - this._dirty = true; - this._onDirty && this._onDirty(this.context); - }; - Task2.prototype._doProgress = function(progress, start, end, modBy, modDataCount) { - iterator.reset(start, end, modBy, modDataCount); - this._callingProgress = progress; - this._callingProgress({ - start, - end, - count: end - start, - next: iterator.next - }, this.context); - }; - Task2.prototype._doReset = function(skip) { - this._dueIndex = this._outputDueEnd = this._dueEnd = 0; - this._settedOutputEnd = null; - var progress; - var forceFirstProgress; - if (!skip && this._reset) { - progress = this._reset(this.context); - if (progress && progress.progress) { - forceFirstProgress = progress.forceFirstProgress; - progress = progress.progress; - } - if (isArray(progress) && !progress.length) { - progress = null; - } - } - this._progress = progress; - this._modBy = this._modDataCount = null; - var downstream = this._downstream; - downstream && downstream.dirty(); - return forceFirstProgress; - }; - Task2.prototype.unfinished = function() { - return this._progress && this._dueIndex < this._dueEnd; - }; - Task2.prototype.pipe = function(downTask) { - if (this._downstream !== downTask || this._dirty) { - this._downstream = downTask; - downTask._upstream = this; - downTask.dirty(); - } - }; - Task2.prototype.dispose = function() { - if (this._disposed) { - return; - } - this._upstream && (this._upstream._downstream = null); - this._downstream && (this._downstream._upstream = null); - this._dirty = false; - this._disposed = true; - }; - Task2.prototype.getUpstream = function() { - return this._upstream; - }; - Task2.prototype.getDownstream = function() { - return this._downstream; - }; - Task2.prototype.setOutputEnd = function(end) { - this._outputDueEnd = this._settedOutputEnd = end; - }; - return Task2; - }() -); -var iterator = /* @__PURE__ */ function() { - var end; - var current; - var modBy; - var modDataCount; - var winCount; - var it = { - reset: function(s, e, sStep, sCount) { - current = s; - end = e; - modBy = sStep; - modDataCount = sCount; - winCount = Math.ceil(modDataCount / modBy); - it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext; - } - }; - return it; - function sequentialNext() { - return current < end ? current++ : null; - } - function modNext() { - var dataIndex = current % winCount * modBy + Math.ceil(current / winCount); - var result = current >= end ? null : dataIndex < modDataCount ? dataIndex : current; - current++; - return result; - } -}(); - -function parseDataValue(value, opt) { - var dimType = opt && opt.type; - if (dimType === "ordinal") { - return value; - } - if (dimType === "time" && !isNumber(value) && value != null && value !== "-") { - value = +parseDate(value); - } - return value == null || value === "" ? NaN : Number(value); -} -createHashMap({ - "number": function(val) { - return parseFloat(val); - }, - "time": function(val) { - return +parseDate(val); - }, - "trim": function(val) { - return isString(val) ? trim(val) : val; - } -}); -var SortOrderComparator = ( - /** @class */ - function() { - function SortOrderComparator2(order, incomparable) { - var isDesc = order === "desc"; - this._resultLT = isDesc ? 1 : -1; - if (incomparable == null) { - incomparable = isDesc ? "min" : "max"; - } - this._incomparable = incomparable === "min" ? -Infinity : Infinity; - } - SortOrderComparator2.prototype.evaluate = function(lval, rval) { - var lvalFloat = isNumber(lval) ? lval : numericToNumber(lval); - var rvalFloat = isNumber(rval) ? rval : numericToNumber(rval); - var lvalNotNumeric = isNaN(lvalFloat); - var rvalNotNumeric = isNaN(rvalFloat); - if (lvalNotNumeric) { - lvalFloat = this._incomparable; - } - if (rvalNotNumeric) { - rvalFloat = this._incomparable; - } - if (lvalNotNumeric && rvalNotNumeric) { - var lvalIsStr = isString(lval); - var rvalIsStr = isString(rval); - if (lvalIsStr) { - lvalFloat = rvalIsStr ? lval : 0; - } - if (rvalIsStr) { - rvalFloat = lvalIsStr ? rval : 0; - } - } - return lvalFloat < rvalFloat ? this._resultLT : lvalFloat > rvalFloat ? -this._resultLT : 0; - }; - return SortOrderComparator2; - }() -); - -var ExternalSource = ( - /** @class */ - function() { - function ExternalSource2() { - } - ExternalSource2.prototype.getRawData = function() { - throw new Error("not supported"); - }; - ExternalSource2.prototype.getRawDataItem = function(dataIndex) { - throw new Error("not supported"); - }; - ExternalSource2.prototype.cloneRawData = function() { - return; - }; - ExternalSource2.prototype.getDimensionInfo = function(dim) { - return; - }; - ExternalSource2.prototype.cloneAllDimensionInfo = function() { - return; - }; - ExternalSource2.prototype.count = function() { - return; - }; - ExternalSource2.prototype.retrieveValue = function(dataIndex, dimIndex) { - return; - }; - ExternalSource2.prototype.retrieveValueFromItem = function(dataItem, dimIndex) { - return; - }; - ExternalSource2.prototype.convertValue = function(rawVal, dimInfo) { - return parseDataValue(rawVal, dimInfo); - }; - return ExternalSource2; - }() -); -function createExternalSource(internalSource, externalTransform) { - var extSource = new ExternalSource(); - var data = internalSource.data; - var sourceFormat = extSource.sourceFormat = internalSource.sourceFormat; - var sourceHeaderCount = internalSource.startIndex; - var errMsg = ""; - if (internalSource.seriesLayoutBy !== SERIES_LAYOUT_BY_COLUMN) { - throwError(errMsg); - } - var dimensions = []; - var dimsByName = {}; - var dimsDef = internalSource.dimensionsDefine; - if (dimsDef) { - each$4(dimsDef, function(dimDef, idx) { - var name = dimDef.name; - var dimDefExt = { - index: idx, - name, - displayName: dimDef.displayName - }; - dimensions.push(dimDefExt); - if (name != null) { - var errMsg_1 = ""; - if (hasOwn(dimsByName, name)) { - throwError(errMsg_1); - } - dimsByName[name] = dimDefExt; - } - }); - } else { - for (var i = 0; i < internalSource.dimensionsDetectedCount || 0; i++) { - dimensions.push({ - index: i - }); - } - } - var rawItemGetter = getRawSourceItemGetter(sourceFormat, SERIES_LAYOUT_BY_COLUMN); - if (externalTransform.__isBuiltIn) { - extSource.getRawDataItem = function(dataIndex) { - return rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex); - }; - extSource.getRawData = bind$1(getRawData, null, internalSource); - } - extSource.cloneRawData = bind$1(cloneRawData, null, internalSource); - var rawCounter = getRawSourceDataCounter(sourceFormat, SERIES_LAYOUT_BY_COLUMN); - extSource.count = bind$1(rawCounter, null, data, sourceHeaderCount, dimensions); - var rawValueGetter = getRawSourceValueGetter(sourceFormat); - extSource.retrieveValue = function(dataIndex, dimIndex) { - var rawItem = rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex); - return retrieveValueFromItem(rawItem, dimIndex); - }; - var retrieveValueFromItem = extSource.retrieveValueFromItem = function(dataItem, dimIndex) { - if (dataItem == null) { - return; - } - var dimDef = dimensions[dimIndex]; - if (dimDef) { - return rawValueGetter(dataItem, dimIndex, dimDef.name); - } - }; - extSource.getDimensionInfo = bind$1(getDimensionInfo, null, dimensions, dimsByName); - extSource.cloneAllDimensionInfo = bind$1(cloneAllDimensionInfo, null, dimensions); - return extSource; -} -function getRawData(upstream) { - var sourceFormat = upstream.sourceFormat; - if (!isSupportedSourceFormat(sourceFormat)) { - var errMsg = ""; - throwError(errMsg); - } - return upstream.data; -} -function cloneRawData(upstream) { - var sourceFormat = upstream.sourceFormat; - var data = upstream.data; - if (!isSupportedSourceFormat(sourceFormat)) { - var errMsg = ""; - throwError(errMsg); - } - if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) { - var result = []; - for (var i = 0, len = data.length; i < len; i++) { - result.push(data[i].slice()); - } - return result; - } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) { - var result = []; - for (var i = 0, len = data.length; i < len; i++) { - result.push(extend({}, data[i])); - } - return result; - } -} -function getDimensionInfo(dimensions, dimsByName, dim) { - if (dim == null) { - return; - } - if (isNumber(dim) || !isNaN(dim) && !hasOwn(dimsByName, dim)) { - return dimensions[dim]; - } else if (hasOwn(dimsByName, dim)) { - return dimsByName[dim]; - } -} -function cloneAllDimensionInfo(dimensions) { - return clone$2(dimensions); -} -var externalTransformMap = createHashMap(); -function registerExternalTransform(externalTransform) { - externalTransform = clone$2(externalTransform); - var type = externalTransform.type; - var errMsg = ""; - if (!type) { - throwError(errMsg); - } - var typeParsed = type.split(":"); - if (typeParsed.length !== 2) { - throwError(errMsg); - } - var isBuiltIn = false; - if (typeParsed[0] === "echarts") { - type = typeParsed[1]; - isBuiltIn = true; - } - externalTransform.__isBuiltIn = isBuiltIn; - externalTransformMap.set(type, externalTransform); -} -function applyDataTransform(rawTransOption, sourceList, infoForPrint) { - var pipedTransOption = normalizeToArray(rawTransOption); - var pipeLen = pipedTransOption.length; - var errMsg = ""; - if (!pipeLen) { - throwError(errMsg); - } - for (var i = 0, len = pipeLen; i < len; i++) { - var transOption = pipedTransOption[i]; - sourceList = applySingleDataTransform(transOption, sourceList); - if (i !== len - 1) { - sourceList.length = Math.max(sourceList.length, 1); - } - } - return sourceList; -} -function applySingleDataTransform(transOption, upSourceList, infoForPrint, pipeIndex) { - var errMsg = ""; - if (!upSourceList.length) { - throwError(errMsg); - } - if (!isObject$2(transOption)) { - throwError(errMsg); - } - var transType = transOption.type; - var externalTransform = externalTransformMap.get(transType); - if (!externalTransform) { - throwError(errMsg); - } - var extUpSourceList = map$1(upSourceList, function(upSource) { - return createExternalSource(upSource, externalTransform); - }); - var resultList = normalizeToArray(externalTransform.transform({ - upstream: extUpSourceList[0], - upstreamList: extUpSourceList, - config: clone$2(transOption.config) - })); - return map$1(resultList, function(result, resultIndex) { - var errMsg2 = ""; - if (!isObject$2(result)) { - throwError(errMsg2); - } - if (!result.data) { - throwError(errMsg2); - } - var sourceFormat = detectSourceFormat(result.data); - if (!isSupportedSourceFormat(sourceFormat)) { - throwError(errMsg2); - } - var resultMetaRawOption; - var firstUpSource = upSourceList[0]; - if (firstUpSource && resultIndex === 0 && !result.dimensions) { - var startIndex = firstUpSource.startIndex; - if (startIndex) { - result.data = firstUpSource.data.slice(0, startIndex).concat(result.data); - } - resultMetaRawOption = { - seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN, - sourceHeader: startIndex, - dimensions: firstUpSource.metaRawOption.dimensions - }; - } else { - resultMetaRawOption = { - seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN, - sourceHeader: 0, - dimensions: result.dimensions - }; - } - return createSource(result.data, resultMetaRawOption, null); - }); -} -function isSupportedSourceFormat(sourceFormat) { - return sourceFormat === SOURCE_FORMAT_ARRAY_ROWS || sourceFormat === SOURCE_FORMAT_OBJECT_ROWS; -} - -var UNDEFINED = "undefined"; -var CtorUint32Array = typeof Uint32Array === UNDEFINED ? Array : Uint32Array; -var CtorUint16Array = typeof Uint16Array === UNDEFINED ? Array : Uint16Array; -var CtorInt32Array$1 = typeof Int32Array === UNDEFINED ? Array : Int32Array; -var CtorFloat64Array = typeof Float64Array === UNDEFINED ? Array : Float64Array; -var dataCtors = { - "float": CtorFloat64Array, - "int": CtorInt32Array$1, - // Ordinal data type can be string or int - "ordinal": Array, - "number": Array, - "time": CtorFloat64Array -}; -var defaultDimValueGetters; -function getIndicesCtor(rawCount) { - return rawCount > 65535 ? CtorUint32Array : CtorUint16Array; -} -function getInitialExtent() { - return [Infinity, -Infinity]; -} -function cloneChunk(originalChunk) { - var Ctor = originalChunk.constructor; - return Ctor === Array ? originalChunk.slice() : new Ctor(originalChunk); -} -function prepareStore(store, dimIdx, dimType, end, append) { - var DataCtor = dataCtors[dimType || "float"]; - if (append) { - var oldStore = store[dimIdx]; - var oldLen = oldStore && oldStore.length; - if (!(oldLen === end)) { - var newStore = new DataCtor(end); - for (var j = 0; j < oldLen; j++) { - newStore[j] = oldStore[j]; - } - store[dimIdx] = newStore; - } - } else { - store[dimIdx] = new DataCtor(end); - } -} -var DataStore = ( - /** @class */ - function() { - function DataStore2() { - this._chunks = []; - this._rawExtent = []; - this._extent = []; - this._count = 0; - this._rawCount = 0; - this._calcDimNameToIdx = createHashMap(); - } - DataStore2.prototype.initData = function(provider, inputDimensions, dimValueGetter) { - this._provider = provider; - this._chunks = []; - this._indices = null; - this.getRawIndex = this._getRawIdxIdentity; - var source = provider.getSource(); - var defaultGetter = this.defaultDimValueGetter = defaultDimValueGetters[source.sourceFormat]; - this._dimValueGetter = dimValueGetter || defaultGetter; - this._rawExtent = []; - shouldRetrieveDataByName(source); - this._dimensions = map$1(inputDimensions, function(dim) { - return { - // Only pick these two props. Not leak other properties like orderMeta. - type: dim.type, - property: dim.property - }; - }); - this._initDataFromProvider(0, provider.count()); - }; - DataStore2.prototype.getProvider = function() { - return this._provider; - }; - DataStore2.prototype.getSource = function() { - return this._provider.getSource(); - }; - DataStore2.prototype.ensureCalculationDimension = function(dimName, type) { - var calcDimNameToIdx = this._calcDimNameToIdx; - var dimensions = this._dimensions; - var calcDimIdx = calcDimNameToIdx.get(dimName); - if (calcDimIdx != null) { - if (dimensions[calcDimIdx].type === type) { - return calcDimIdx; - } - } else { - calcDimIdx = dimensions.length; - } - dimensions[calcDimIdx] = { - type - }; - calcDimNameToIdx.set(dimName, calcDimIdx); - this._chunks[calcDimIdx] = new dataCtors[type || "float"](this._rawCount); - this._rawExtent[calcDimIdx] = getInitialExtent(); - return calcDimIdx; - }; - DataStore2.prototype.collectOrdinalMeta = function(dimIdx, ordinalMeta) { - var chunk = this._chunks[dimIdx]; - var dim = this._dimensions[dimIdx]; - var rawExtents = this._rawExtent; - var offset = dim.ordinalOffset || 0; - var len = chunk.length; - if (offset === 0) { - rawExtents[dimIdx] = getInitialExtent(); - } - var dimRawExtent = rawExtents[dimIdx]; - for (var i = offset; i < len; i++) { - var val = chunk[i] = ordinalMeta.parseAndCollect(chunk[i]); - if (!isNaN(val)) { - dimRawExtent[0] = Math.min(val, dimRawExtent[0]); - dimRawExtent[1] = Math.max(val, dimRawExtent[1]); - } - } - dim.ordinalMeta = ordinalMeta; - dim.ordinalOffset = len; - dim.type = "ordinal"; - }; - DataStore2.prototype.getOrdinalMeta = function(dimIdx) { - var dimInfo = this._dimensions[dimIdx]; - var ordinalMeta = dimInfo.ordinalMeta; - return ordinalMeta; - }; - DataStore2.prototype.getDimensionProperty = function(dimIndex) { - var item = this._dimensions[dimIndex]; - return item && item.property; - }; - DataStore2.prototype.appendData = function(data) { - var provider = this._provider; - var start = this.count(); - provider.appendData(data); - var end = provider.count(); - if (!provider.persistent) { - end += start; - } - if (start < end) { - this._initDataFromProvider(start, end, true); - } - return [start, end]; - }; - DataStore2.prototype.appendValues = function(values, minFillLen) { - var chunks = this._chunks; - var dimensions = this._dimensions; - var dimLen = dimensions.length; - var rawExtent = this._rawExtent; - var start = this.count(); - var end = start + Math.max(values.length, minFillLen || 0); - for (var i = 0; i < dimLen; i++) { - var dim = dimensions[i]; - prepareStore(chunks, i, dim.type, end, true); - } - var emptyDataItem = []; - for (var idx = start; idx < end; idx++) { - var sourceIdx = idx - start; - for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) { - var dim = dimensions[dimIdx]; - var val = defaultDimValueGetters.arrayRows.call(this, values[sourceIdx] || emptyDataItem, dim.property, sourceIdx, dimIdx); - chunks[dimIdx][idx] = val; - var dimRawExtent = rawExtent[dimIdx]; - val < dimRawExtent[0] && (dimRawExtent[0] = val); - val > dimRawExtent[1] && (dimRawExtent[1] = val); - } - } - this._rawCount = this._count = end; - return { - start, - end - }; - }; - DataStore2.prototype._initDataFromProvider = function(start, end, append) { - var provider = this._provider; - var chunks = this._chunks; - var dimensions = this._dimensions; - var dimLen = dimensions.length; - var rawExtent = this._rawExtent; - var dimNames = map$1(dimensions, function(dim2) { - return dim2.property; - }); - for (var i = 0; i < dimLen; i++) { - var dim = dimensions[i]; - if (!rawExtent[i]) { - rawExtent[i] = getInitialExtent(); - } - prepareStore(chunks, i, dim.type, end, append); - } - if (provider.fillStorage) { - provider.fillStorage(start, end, chunks, rawExtent); - } else { - var dataItem = []; - for (var idx = start; idx < end; idx++) { - dataItem = provider.getItem(idx, dataItem); - for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) { - var dimStorage = chunks[dimIdx]; - var val = this._dimValueGetter(dataItem, dimNames[dimIdx], idx, dimIdx); - dimStorage[idx] = val; - var dimRawExtent = rawExtent[dimIdx]; - val < dimRawExtent[0] && (dimRawExtent[0] = val); - val > dimRawExtent[1] && (dimRawExtent[1] = val); - } - } - } - if (!provider.persistent && provider.clean) { - provider.clean(); - } - this._rawCount = this._count = end; - this._extent = []; - }; - DataStore2.prototype.count = function() { - return this._count; - }; - DataStore2.prototype.get = function(dim, idx) { - if (!(idx >= 0 && idx < this._count)) { - return NaN; - } - var dimStore = this._chunks[dim]; - return dimStore ? dimStore[this.getRawIndex(idx)] : NaN; - }; - DataStore2.prototype.getValues = function(dimensions, idx) { - var values = []; - var dimArr = []; - if (idx == null) { - idx = dimensions; - dimensions = []; - for (var i = 0; i < this._dimensions.length; i++) { - dimArr.push(i); - } - } else { - dimArr = dimensions; - } - for (var i = 0, len = dimArr.length; i < len; i++) { - values.push(this.get(dimArr[i], idx)); - } - return values; - }; - DataStore2.prototype.getByRawIndex = function(dim, rawIdx) { - if (!(rawIdx >= 0 && rawIdx < this._rawCount)) { - return NaN; - } - var dimStore = this._chunks[dim]; - return dimStore ? dimStore[rawIdx] : NaN; - }; - DataStore2.prototype.getSum = function(dim) { - var dimData = this._chunks[dim]; - var sum = 0; - if (dimData) { - for (var i = 0, len = this.count(); i < len; i++) { - var value = this.get(dim, i); - if (!isNaN(value)) { - sum += value; - } - } - } - return sum; - }; - DataStore2.prototype.getMedian = function(dim) { - var dimDataArray = []; - this.each([dim], function(val) { - if (!isNaN(val)) { - dimDataArray.push(val); - } - }); - var sortedDimDataArray = dimDataArray.sort(function(a, b) { - return a - b; - }); - var len = this.count(); - return len === 0 ? 0 : len % 2 === 1 ? sortedDimDataArray[(len - 1) / 2] : (sortedDimDataArray[len / 2] + sortedDimDataArray[len / 2 - 1]) / 2; - }; - DataStore2.prototype.indexOfRawIndex = function(rawIndex) { - if (rawIndex >= this._rawCount || rawIndex < 0) { - return -1; - } - if (!this._indices) { - return rawIndex; - } - var indices = this._indices; - var rawDataIndex = indices[rawIndex]; - if (rawDataIndex != null && rawDataIndex < this._count && rawDataIndex === rawIndex) { - return rawIndex; - } - var left = 0; - var right = this._count - 1; - while (left <= right) { - var mid = (left + right) / 2 | 0; - if (indices[mid] < rawIndex) { - left = mid + 1; - } else if (indices[mid] > rawIndex) { - right = mid - 1; - } else { - return mid; - } - } - return -1; - }; - DataStore2.prototype.indicesOfNearest = function(dim, value, maxDistance) { - var chunks = this._chunks; - var dimData = chunks[dim]; - var nearestIndices = []; - if (!dimData) { - return nearestIndices; - } - if (maxDistance == null) { - maxDistance = Infinity; - } - var minDist = Infinity; - var minDiff = -1; - var nearestIndicesLen = 0; - for (var i = 0, len = this.count(); i < len; i++) { - var dataIndex = this.getRawIndex(i); - var diff = value - dimData[dataIndex]; - var dist = Math.abs(diff); - if (dist <= maxDistance) { - if (dist < minDist || dist === minDist && diff >= 0 && minDiff < 0) { - minDist = dist; - minDiff = diff; - nearestIndicesLen = 0; - } - if (diff === minDiff) { - nearestIndices[nearestIndicesLen++] = i; - } - } - } - nearestIndices.length = nearestIndicesLen; - return nearestIndices; - }; - DataStore2.prototype.getIndices = function() { - var newIndices; - var indices = this._indices; - if (indices) { - var Ctor = indices.constructor; - var thisCount = this._count; - if (Ctor === Array) { - newIndices = new Ctor(thisCount); - for (var i = 0; i < thisCount; i++) { - newIndices[i] = indices[i]; - } - } else { - newIndices = new Ctor(indices.buffer, 0, thisCount); - } - } else { - var Ctor = getIndicesCtor(this._rawCount); - newIndices = new Ctor(this.count()); - for (var i = 0; i < newIndices.length; i++) { - newIndices[i] = i; - } - } - return newIndices; - }; - DataStore2.prototype.filter = function(dims, cb) { - if (!this._count) { - return this; - } - var newStore = this.clone(); - var count = newStore.count(); - var Ctor = getIndicesCtor(newStore._rawCount); - var newIndices = new Ctor(count); - var value = []; - var dimSize = dims.length; - var offset = 0; - var dim0 = dims[0]; - var chunks = newStore._chunks; - for (var i = 0; i < count; i++) { - var keep = void 0; - var rawIdx = newStore.getRawIndex(i); - if (dimSize === 0) { - keep = cb(i); - } else if (dimSize === 1) { - var val = chunks[dim0][rawIdx]; - keep = cb(val, i); - } else { - var k = 0; - for (; k < dimSize; k++) { - value[k] = chunks[dims[k]][rawIdx]; - } - value[k] = i; - keep = cb.apply(null, value); - } - if (keep) { - newIndices[offset++] = rawIdx; - } - } - if (offset < count) { - newStore._indices = newIndices; - } - newStore._count = offset; - newStore._extent = []; - newStore._updateGetRawIdx(); - return newStore; - }; - DataStore2.prototype.selectRange = function(range) { - var newStore = this.clone(); - var len = newStore._count; - if (!len) { - return this; - } - var dims = keys(range); - var dimSize = dims.length; - if (!dimSize) { - return this; - } - var originalCount = newStore.count(); - var Ctor = getIndicesCtor(newStore._rawCount); - var newIndices = new Ctor(originalCount); - var offset = 0; - var dim0 = dims[0]; - var min = range[dim0][0]; - var max = range[dim0][1]; - var storeArr = newStore._chunks; - var quickFinished = false; - if (!newStore._indices) { - var idx = 0; - if (dimSize === 1) { - var dimStorage = storeArr[dims[0]]; - for (var i = 0; i < len; i++) { - var val = dimStorage[i]; - if (val >= min && val <= max || isNaN(val)) { - newIndices[offset++] = idx; - } - idx++; - } - quickFinished = true; - } else if (dimSize === 2) { - var dimStorage = storeArr[dims[0]]; - var dimStorage2 = storeArr[dims[1]]; - var min2 = range[dims[1]][0]; - var max2 = range[dims[1]][1]; - for (var i = 0; i < len; i++) { - var val = dimStorage[i]; - var val2 = dimStorage2[i]; - if ((val >= min && val <= max || isNaN(val)) && (val2 >= min2 && val2 <= max2 || isNaN(val2))) { - newIndices[offset++] = idx; - } - idx++; - } - quickFinished = true; - } - } - if (!quickFinished) { - if (dimSize === 1) { - for (var i = 0; i < originalCount; i++) { - var rawIndex = newStore.getRawIndex(i); - var val = storeArr[dims[0]][rawIndex]; - if (val >= min && val <= max || isNaN(val)) { - newIndices[offset++] = rawIndex; - } - } - } else { - for (var i = 0; i < originalCount; i++) { - var keep = true; - var rawIndex = newStore.getRawIndex(i); - for (var k = 0; k < dimSize; k++) { - var dimk = dims[k]; - var val = storeArr[dimk][rawIndex]; - if (val < range[dimk][0] || val > range[dimk][1]) { - keep = false; - } - } - if (keep) { - newIndices[offset++] = newStore.getRawIndex(i); - } - } - } - } - if (offset < originalCount) { - newStore._indices = newIndices; - } - newStore._count = offset; - newStore._extent = []; - newStore._updateGetRawIdx(); - return newStore; - }; - DataStore2.prototype.map = function(dims, cb) { - var target = this.clone(dims); - this._updateDims(target, dims, cb); - return target; - }; - DataStore2.prototype.modify = function(dims, cb) { - this._updateDims(this, dims, cb); - }; - DataStore2.prototype._updateDims = function(target, dims, cb) { - var targetChunks = target._chunks; - var tmpRetValue = []; - var dimSize = dims.length; - var dataCount = target.count(); - var values = []; - var rawExtent = target._rawExtent; - for (var i = 0; i < dims.length; i++) { - rawExtent[dims[i]] = getInitialExtent(); - } - for (var dataIndex = 0; dataIndex < dataCount; dataIndex++) { - var rawIndex = target.getRawIndex(dataIndex); - for (var k = 0; k < dimSize; k++) { - values[k] = targetChunks[dims[k]][rawIndex]; - } - values[dimSize] = dataIndex; - var retValue = cb && cb.apply(null, values); - if (retValue != null) { - if (typeof retValue !== "object") { - tmpRetValue[0] = retValue; - retValue = tmpRetValue; - } - for (var i = 0; i < retValue.length; i++) { - var dim = dims[i]; - var val = retValue[i]; - var rawExtentOnDim = rawExtent[dim]; - var dimStore = targetChunks[dim]; - if (dimStore) { - dimStore[rawIndex] = val; - } - if (val < rawExtentOnDim[0]) { - rawExtentOnDim[0] = val; - } - if (val > rawExtentOnDim[1]) { - rawExtentOnDim[1] = val; - } - } - } - } - }; - DataStore2.prototype.lttbDownSample = function(valueDimension, rate) { - var target = this.clone([valueDimension], true); - var targetStorage = target._chunks; - var dimStore = targetStorage[valueDimension]; - var len = this.count(); - var sampledIndex = 0; - var frameSize = Math.floor(1 / rate); - var currentRawIndex = this.getRawIndex(0); - var maxArea; - var area; - var nextRawIndex; - var newIndices = new (getIndicesCtor(this._rawCount))(Math.min((Math.ceil(len / frameSize) + 2) * 2, len)); - newIndices[sampledIndex++] = currentRawIndex; - for (var i = 1; i < len - 1; i += frameSize) { - var nextFrameStart = Math.min(i + frameSize, len - 1); - var nextFrameEnd = Math.min(i + frameSize * 2, len); - var avgX = (nextFrameEnd + nextFrameStart) / 2; - var avgY = 0; - for (var idx = nextFrameStart; idx < nextFrameEnd; idx++) { - var rawIndex = this.getRawIndex(idx); - var y = dimStore[rawIndex]; - if (isNaN(y)) { - continue; - } - avgY += y; - } - avgY /= nextFrameEnd - nextFrameStart; - var frameStart = i; - var frameEnd = Math.min(i + frameSize, len); - var pointAX = i - 1; - var pointAY = dimStore[currentRawIndex]; - maxArea = -1; - nextRawIndex = frameStart; - var firstNaNIndex = -1; - var countNaN = 0; - for (var idx = frameStart; idx < frameEnd; idx++) { - var rawIndex = this.getRawIndex(idx); - var y = dimStore[rawIndex]; - if (isNaN(y)) { - countNaN++; - if (firstNaNIndex < 0) { - firstNaNIndex = rawIndex; - } - continue; - } - area = Math.abs((pointAX - avgX) * (y - pointAY) - (pointAX - idx) * (avgY - pointAY)); - if (area > maxArea) { - maxArea = area; - nextRawIndex = rawIndex; - } - } - if (countNaN > 0 && countNaN < frameEnd - frameStart) { - newIndices[sampledIndex++] = Math.min(firstNaNIndex, nextRawIndex); - nextRawIndex = Math.max(firstNaNIndex, nextRawIndex); - } - newIndices[sampledIndex++] = nextRawIndex; - currentRawIndex = nextRawIndex; - } - newIndices[sampledIndex++] = this.getRawIndex(len - 1); - target._count = sampledIndex; - target._indices = newIndices; - target.getRawIndex = this._getRawIdx; - return target; - }; - DataStore2.prototype.minmaxDownSample = function(valueDimension, rate) { - var target = this.clone([valueDimension], true); - var targetStorage = target._chunks; - var frameSize = Math.floor(1 / rate); - var dimStore = targetStorage[valueDimension]; - var len = this.count(); - var newIndices = new (getIndicesCtor(this._rawCount))(Math.ceil(len / frameSize) * 2); - var offset = 0; - for (var i = 0; i < len; i += frameSize) { - var minIndex = i; - var minValue = dimStore[this.getRawIndex(minIndex)]; - var maxIndex = i; - var maxValue = dimStore[this.getRawIndex(maxIndex)]; - var thisFrameSize = frameSize; - if (i + frameSize > len) { - thisFrameSize = len - i; - } - for (var k = 0; k < thisFrameSize; k++) { - var rawIndex = this.getRawIndex(i + k); - var value = dimStore[rawIndex]; - if (value < minValue) { - minValue = value; - minIndex = i + k; - } - if (value > maxValue) { - maxValue = value; - maxIndex = i + k; - } - } - var rawMinIndex = this.getRawIndex(minIndex); - var rawMaxIndex = this.getRawIndex(maxIndex); - if (minIndex < maxIndex) { - newIndices[offset++] = rawMinIndex; - newIndices[offset++] = rawMaxIndex; - } else { - newIndices[offset++] = rawMaxIndex; - newIndices[offset++] = rawMinIndex; - } - } - target._count = offset; - target._indices = newIndices; - target._updateGetRawIdx(); - return target; - }; - DataStore2.prototype.downSample = function(dimension, rate, sampleValue, sampleIndex) { - var target = this.clone([dimension], true); - var targetStorage = target._chunks; - var frameValues = []; - var frameSize = Math.floor(1 / rate); - var dimStore = targetStorage[dimension]; - var len = this.count(); - var rawExtentOnDim = target._rawExtent[dimension] = getInitialExtent(); - var newIndices = new (getIndicesCtor(this._rawCount))(Math.ceil(len / frameSize)); - var offset = 0; - for (var i = 0; i < len; i += frameSize) { - if (frameSize > len - i) { - frameSize = len - i; - frameValues.length = frameSize; - } - for (var k = 0; k < frameSize; k++) { - var dataIdx = this.getRawIndex(i + k); - frameValues[k] = dimStore[dataIdx]; - } - var value = sampleValue(frameValues); - var sampleFrameIdx = this.getRawIndex(Math.min(i + sampleIndex(frameValues, value) || 0, len - 1)); - dimStore[sampleFrameIdx] = value; - if (value < rawExtentOnDim[0]) { - rawExtentOnDim[0] = value; - } - if (value > rawExtentOnDim[1]) { - rawExtentOnDim[1] = value; - } - newIndices[offset++] = sampleFrameIdx; - } - target._count = offset; - target._indices = newIndices; - target._updateGetRawIdx(); - return target; - }; - DataStore2.prototype.each = function(dims, cb) { - if (!this._count) { - return; - } - var dimSize = dims.length; - var chunks = this._chunks; - for (var i = 0, len = this.count(); i < len; i++) { - var rawIdx = this.getRawIndex(i); - switch (dimSize) { - case 0: - cb(i); - break; - case 1: - cb(chunks[dims[0]][rawIdx], i); - break; - case 2: - cb(chunks[dims[0]][rawIdx], chunks[dims[1]][rawIdx], i); - break; - default: - var k = 0; - var value = []; - for (; k < dimSize; k++) { - value[k] = chunks[dims[k]][rawIdx]; - } - value[k] = i; - cb.apply(null, value); - } - } - }; - DataStore2.prototype.getDataExtent = function(dim) { - var dimData = this._chunks[dim]; - var initialExtent = getInitialExtent(); - if (!dimData) { - return initialExtent; - } - var currEnd = this.count(); - var useRaw = !this._indices; - var dimExtent; - if (useRaw) { - return this._rawExtent[dim].slice(); - } - dimExtent = this._extent[dim]; - if (dimExtent) { - return dimExtent.slice(); - } - dimExtent = initialExtent; - var min = dimExtent[0]; - var max = dimExtent[1]; - for (var i = 0; i < currEnd; i++) { - var rawIdx = this.getRawIndex(i); - var value = dimData[rawIdx]; - value < min && (min = value); - value > max && (max = value); - } - dimExtent = [min, max]; - this._extent[dim] = dimExtent; - return dimExtent; - }; - DataStore2.prototype.getRawDataItem = function(idx) { - var rawIdx = this.getRawIndex(idx); - if (!this._provider.persistent) { - var val = []; - var chunks = this._chunks; - for (var i = 0; i < chunks.length; i++) { - val.push(chunks[i][rawIdx]); - } - return val; - } else { - return this._provider.getItem(rawIdx); - } - }; - DataStore2.prototype.clone = function(clonedDims, ignoreIndices) { - var target = new DataStore2(); - var chunks = this._chunks; - var clonedDimsMap = clonedDims && reduce(clonedDims, function(obj, dimIdx) { - obj[dimIdx] = true; - return obj; - }, {}); - if (clonedDimsMap) { - for (var i = 0; i < chunks.length; i++) { - target._chunks[i] = !clonedDimsMap[i] ? chunks[i] : cloneChunk(chunks[i]); - } - } else { - target._chunks = chunks; - } - this._copyCommonProps(target); - if (!ignoreIndices) { - target._indices = this._cloneIndices(); - } - target._updateGetRawIdx(); - return target; - }; - DataStore2.prototype._copyCommonProps = function(target) { - target._count = this._count; - target._rawCount = this._rawCount; - target._provider = this._provider; - target._dimensions = this._dimensions; - target._extent = clone$2(this._extent); - target._rawExtent = clone$2(this._rawExtent); - }; - DataStore2.prototype._cloneIndices = function() { - if (this._indices) { - var Ctor = this._indices.constructor; - var indices = void 0; - if (Ctor === Array) { - var thisCount = this._indices.length; - indices = new Ctor(thisCount); - for (var i = 0; i < thisCount; i++) { - indices[i] = this._indices[i]; - } - } else { - indices = new Ctor(this._indices); - } - return indices; - } - return null; - }; - DataStore2.prototype._getRawIdxIdentity = function(idx) { - return idx; - }; - DataStore2.prototype._getRawIdx = function(idx) { - if (idx < this._count && idx >= 0) { - return this._indices[idx]; - } - return -1; - }; - DataStore2.prototype._updateGetRawIdx = function() { - this.getRawIndex = this._indices ? this._getRawIdx : this._getRawIdxIdentity; - }; - DataStore2.internalField = function() { - function getDimValueSimply(dataItem, property, dataIndex, dimIndex) { - return parseDataValue(dataItem[dimIndex], this._dimensions[dimIndex]); - } - defaultDimValueGetters = { - arrayRows: getDimValueSimply, - objectRows: function(dataItem, property, dataIndex, dimIndex) { - return parseDataValue(dataItem[property], this._dimensions[dimIndex]); - }, - keyedColumns: getDimValueSimply, - original: function(dataItem, property, dataIndex, dimIndex) { - var value = dataItem && (dataItem.value == null ? dataItem : dataItem.value); - return parseDataValue(value instanceof Array ? value[dimIndex] : value, this._dimensions[dimIndex]); - }, - typedArray: function(dataItem, property, dataIndex, dimIndex) { - return dataItem[dimIndex]; - } - }; - }(); - return DataStore2; - }() -); - -var SourceManager = ( - /** @class */ - function() { - function SourceManager2(sourceHost) { - this._sourceList = []; - this._storeList = []; - this._upstreamSignList = []; - this._versionSignBase = 0; - this._dirty = true; - this._sourceHost = sourceHost; - } - SourceManager2.prototype.dirty = function() { - this._setLocalSource([], []); - this._storeList = []; - this._dirty = true; - }; - SourceManager2.prototype._setLocalSource = function(sourceList, upstreamSignList) { - this._sourceList = sourceList; - this._upstreamSignList = upstreamSignList; - this._versionSignBase++; - if (this._versionSignBase > 9e10) { - this._versionSignBase = 0; - } - }; - SourceManager2.prototype._getVersionSign = function() { - return this._sourceHost.uid + "_" + this._versionSignBase; - }; - SourceManager2.prototype.prepareSource = function() { - if (this._isDirty()) { - this._createSource(); - this._dirty = false; - } - }; - SourceManager2.prototype._createSource = function() { - this._setLocalSource([], []); - var sourceHost = this._sourceHost; - var upSourceMgrList = this._getUpstreamSourceManagers(); - var hasUpstream = !!upSourceMgrList.length; - var resultSourceList; - var upstreamSignList; - if (isSeries(sourceHost)) { - var seriesModel = sourceHost; - var data = void 0; - var sourceFormat = void 0; - var upSource = void 0; - if (hasUpstream) { - var upSourceMgr = upSourceMgrList[0]; - upSourceMgr.prepareSource(); - upSource = upSourceMgr.getSource(); - data = upSource.data; - sourceFormat = upSource.sourceFormat; - upstreamSignList = [upSourceMgr._getVersionSign()]; - } else { - data = seriesModel.get("data", true); - sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL; - upstreamSignList = []; - } - var newMetaRawOption = this._getSourceMetaRawOption() || {}; - var upMetaRawOption = upSource && upSource.metaRawOption || {}; - var seriesLayoutBy = retrieve2(newMetaRawOption.seriesLayoutBy, upMetaRawOption.seriesLayoutBy) || null; - var sourceHeader = retrieve2(newMetaRawOption.sourceHeader, upMetaRawOption.sourceHeader); - var dimensions = retrieve2(newMetaRawOption.dimensions, upMetaRawOption.dimensions); - var needsCreateSource = seriesLayoutBy !== upMetaRawOption.seriesLayoutBy || !!sourceHeader !== !!upMetaRawOption.sourceHeader || dimensions; - resultSourceList = needsCreateSource ? [createSource(data, { - seriesLayoutBy, - sourceHeader, - dimensions - }, sourceFormat)] : []; - } else { - var datasetModel = sourceHost; - if (hasUpstream) { - var result = this._applyTransform(upSourceMgrList); - resultSourceList = result.sourceList; - upstreamSignList = result.upstreamSignList; - } else { - var sourceData = datasetModel.get("source", true); - resultSourceList = [createSource(sourceData, this._getSourceMetaRawOption(), null)]; - upstreamSignList = []; - } - } - this._setLocalSource(resultSourceList, upstreamSignList); - }; - SourceManager2.prototype._applyTransform = function(upMgrList) { - var datasetModel = this._sourceHost; - var transformOption = datasetModel.get("transform", true); - var fromTransformResult = datasetModel.get("fromTransformResult", true); - if (fromTransformResult != null) { - var errMsg = ""; - if (upMgrList.length !== 1) { - doThrow(errMsg); - } - } - var sourceList; - var upSourceList = []; - var upstreamSignList = []; - each$4(upMgrList, function(upMgr) { - upMgr.prepareSource(); - var upSource = upMgr.getSource(fromTransformResult || 0); - var errMsg2 = ""; - if (fromTransformResult != null && !upSource) { - doThrow(errMsg2); - } - upSourceList.push(upSource); - upstreamSignList.push(upMgr._getVersionSign()); - }); - if (transformOption) { - sourceList = applyDataTransform(transformOption, upSourceList, { - datasetIndex: datasetModel.componentIndex - }); - } else if (fromTransformResult != null) { - sourceList = [cloneSourceShallow(upSourceList[0])]; - } - return { - sourceList, - upstreamSignList - }; - }; - SourceManager2.prototype._isDirty = function() { - if (this._dirty) { - return true; - } - var upSourceMgrList = this._getUpstreamSourceManagers(); - for (var i = 0; i < upSourceMgrList.length; i++) { - var upSrcMgr = upSourceMgrList[i]; - if ( - // Consider the case that there is ancestor diry, call it recursively. - // The performance is probably not an issue because usually the chain is not long. - upSrcMgr._isDirty() || this._upstreamSignList[i] !== upSrcMgr._getVersionSign() - ) { - return true; - } - } - }; - SourceManager2.prototype.getSource = function(sourceIndex) { - sourceIndex = sourceIndex || 0; - var source = this._sourceList[sourceIndex]; - if (!source) { - var upSourceMgrList = this._getUpstreamSourceManagers(); - return upSourceMgrList[0] && upSourceMgrList[0].getSource(sourceIndex); - } - return source; - }; - SourceManager2.prototype.getSharedDataStore = function(seriesDimRequest) { - var schema = seriesDimRequest.makeStoreSchema(); - return this._innerGetDataStore(schema.dimensions, seriesDimRequest.source, schema.hash); - }; - SourceManager2.prototype._innerGetDataStore = function(storeDims, seriesSource, sourceReadKey) { - var sourceIndex = 0; - var storeList = this._storeList; - var cachedStoreMap = storeList[sourceIndex]; - if (!cachedStoreMap) { - cachedStoreMap = storeList[sourceIndex] = {}; - } - var cachedStore = cachedStoreMap[sourceReadKey]; - if (!cachedStore) { - var upSourceMgr = this._getUpstreamSourceManagers()[0]; - if (isSeries(this._sourceHost) && upSourceMgr) { - cachedStore = upSourceMgr._innerGetDataStore(storeDims, seriesSource, sourceReadKey); - } else { - cachedStore = new DataStore(); - cachedStore.initData(new DefaultDataProvider(seriesSource, storeDims.length), storeDims); - } - cachedStoreMap[sourceReadKey] = cachedStore; - } - return cachedStore; - }; - SourceManager2.prototype._getUpstreamSourceManagers = function() { - var sourceHost = this._sourceHost; - if (isSeries(sourceHost)) { - var datasetModel = querySeriesUpstreamDatasetModel(sourceHost); - return !datasetModel ? [] : [datasetModel.getSourceManager()]; - } else { - return map$1(queryDatasetUpstreamDatasetModels(sourceHost), function(datasetModel2) { - return datasetModel2.getSourceManager(); - }); - } - }; - SourceManager2.prototype._getSourceMetaRawOption = function() { - var sourceHost = this._sourceHost; - var seriesLayoutBy; - var sourceHeader; - var dimensions; - if (isSeries(sourceHost)) { - seriesLayoutBy = sourceHost.get("seriesLayoutBy", true); - sourceHeader = sourceHost.get("sourceHeader", true); - dimensions = sourceHost.get("dimensions", true); - } else if (!this._getUpstreamSourceManagers().length) { - var model = sourceHost; - seriesLayoutBy = model.get("seriesLayoutBy", true); - sourceHeader = model.get("sourceHeader", true); - dimensions = model.get("dimensions", true); - } - return { - seriesLayoutBy, - sourceHeader, - dimensions - }; - }; - return SourceManager2; - }() -); -function isSeries(sourceHost) { - return sourceHost.mainType === "series"; -} -function doThrow(errMsg) { - throw new Error(errMsg); -} - -var TOOLTIP_LINE_HEIGHT_CSS = "line-height:1"; -function getTooltipLineHeight(textStyle) { - var lineHeight = textStyle.lineHeight; - if (lineHeight == null) { - return TOOLTIP_LINE_HEIGHT_CSS; - } else { - return "line-height:" + encodeHTML(lineHeight + "") + "px"; - } -} -function getTooltipTextStyle(textStyle, renderMode) { - var nameFontColor = textStyle.color || "#6e7079"; - var nameFontSize = textStyle.fontSize || 12; - var nameFontWeight = textStyle.fontWeight || "400"; - var valueFontColor = textStyle.color || "#464646"; - var valueFontSize = textStyle.fontSize || 14; - var valueFontWeight = textStyle.fontWeight || "900"; - if (renderMode === "html") { - return { - // eslint-disable-next-line max-len - nameStyle: "font-size:" + encodeHTML(nameFontSize + "") + "px;color:" + encodeHTML(nameFontColor) + ";font-weight:" + encodeHTML(nameFontWeight + ""), - // eslint-disable-next-line max-len - valueStyle: "font-size:" + encodeHTML(valueFontSize + "") + "px;color:" + encodeHTML(valueFontColor) + ";font-weight:" + encodeHTML(valueFontWeight + "") - }; - } else { - return { - nameStyle: { - fontSize: nameFontSize, - fill: nameFontColor, - fontWeight: nameFontWeight - }, - valueStyle: { - fontSize: valueFontSize, - fill: valueFontColor, - fontWeight: valueFontWeight - } - }; - } -} -var HTML_GAPS = [0, 10, 20, 30]; -var RICH_TEXT_GAPS = ["", "\n", "\n\n", "\n\n\n"]; -function createTooltipMarkup(type, option) { - option.type = type; - return option; -} -function isSectionFragment(frag) { - return frag.type === "section"; -} -function getBuilder(frag) { - return isSectionFragment(frag) ? buildSection : buildNameValue; -} -function getBlockGapLevel(frag) { - if (isSectionFragment(frag)) { - var gapLevel_1 = 0; - var subBlockLen = frag.blocks.length; - var hasInnerGap_1 = subBlockLen > 1 || subBlockLen > 0 && !frag.noHeader; - each$4(frag.blocks, function(subBlock) { - var subGapLevel = getBlockGapLevel(subBlock); - if (subGapLevel >= gapLevel_1) { - gapLevel_1 = subGapLevel + +(hasInnerGap_1 && // 0 always can not be readable gap level. - (!subGapLevel || isSectionFragment(subBlock) && !subBlock.noHeader)); - } - }); - return gapLevel_1; - } - return 0; -} -function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) { - var noHeader = fragment.noHeader; - var gaps = getGap(getBlockGapLevel(fragment)); - var subMarkupTextList = []; - var subBlocks = fragment.blocks || []; - assert(!subBlocks || isArray(subBlocks)); - subBlocks = subBlocks || []; - var orderMode = ctx.orderMode; - if (fragment.sortBlocks && orderMode) { - subBlocks = subBlocks.slice(); - var orderMap = { - valueAsc: "asc", - valueDesc: "desc" - }; - if (hasOwn(orderMap, orderMode)) { - var comparator_1 = new SortOrderComparator(orderMap[orderMode], null); - subBlocks.sort(function(a, b) { - return comparator_1.evaluate(a.sortParam, b.sortParam); - }); - } else if (orderMode === "seriesDesc") { - subBlocks.reverse(); - } - } - each$4(subBlocks, function(subBlock, idx) { - var valueFormatter = fragment.valueFormatter; - var subMarkupText2 = getBuilder(subBlock)( - // Inherit valueFormatter - valueFormatter ? extend(extend({}, ctx), { - valueFormatter - }) : ctx, - subBlock, - idx > 0 ? gaps.html : 0, - toolTipTextStyle - ); - subMarkupText2 != null && subMarkupTextList.push(subMarkupText2); - }); - var subMarkupText = ctx.renderMode === "richText" ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(toolTipTextStyle, subMarkupTextList.join(""), noHeader ? topMarginForOuterGap : gaps.html); - if (noHeader) { - return subMarkupText; - } - var displayableHeader = makeValueReadable(fragment.header, "ordinal", ctx.useUTC); - var nameStyle = getTooltipTextStyle(toolTipTextStyle, ctx.renderMode).nameStyle; - var tooltipLineHeight = getTooltipLineHeight(toolTipTextStyle); - if (ctx.renderMode === "richText") { - return wrapInlineNameRichText(ctx, displayableHeader, nameStyle) + gaps.richText + subMarkupText; - } else { - return wrapBlockHTML(toolTipTextStyle, '
' + encodeHTML(displayableHeader) + "
" + subMarkupText, topMarginForOuterGap); - } -} -function buildNameValue(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) { - var renderMode = ctx.renderMode; - var noName = fragment.noName; - var noValue = fragment.noValue; - var noMarker = !fragment.markerType; - var name = fragment.name; - var useUTC = ctx.useUTC; - var valueFormatter = fragment.valueFormatter || ctx.valueFormatter || function(value) { - value = isArray(value) ? value : [value]; - return map$1(value, function(val, idx) { - return makeValueReadable(val, isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption, useUTC); - }); - }; - if (noName && noValue) { - return; - } - var markerStr = noMarker ? "" : ctx.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || "#333", renderMode); - var readableName = noName ? "" : makeValueReadable(name, "ordinal", useUTC); - var valueTypeOption = fragment.valueType; - var readableValueList = noValue ? [] : valueFormatter(fragment.value, fragment.dataIndex); - var valueAlignRight = !noMarker || !noName; - var valueCloseToMarker = !noMarker && noName; - var _a = getTooltipTextStyle(toolTipTextStyle, renderMode), nameStyle = _a.nameStyle, valueStyle = _a.valueStyle; - return renderMode === "richText" ? (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameRichText(ctx, readableName, nameStyle)) + (noValue ? "" : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML(toolTipTextStyle, (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? "" : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap); -} -function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) { - if (!fragment) { - return; - } - var builder = getBuilder(fragment); - var ctx = { - useUTC, - renderMode, - orderMode, - markupStyleCreator, - valueFormatter: fragment.valueFormatter - }; - return builder(ctx, fragment, 0, toolTipTextStyle); -} -function getGap(gapLevel) { - return { - html: HTML_GAPS[gapLevel], - richText: RICH_TEXT_GAPS[gapLevel] - }; -} -function wrapBlockHTML(textStyle, encodedContent, topGap) { - var clearfix = '
'; - var marginCSS = "margin: " + topGap + "px 0 0"; - var tooltipLineHeight = getTooltipLineHeight(textStyle); - return '
' + encodedContent + clearfix + "
"; -} -function wrapInlineNameHTML(name, leftHasMarker, style) { - var marginCss = leftHasMarker ? "margin-left:2px" : ""; - return '' + encodeHTML(name) + ""; -} -function wrapInlineValueHTML(valueList, alignRight, valueCloseToMarker, style) { - var paddingStr = valueCloseToMarker ? "10px" : "20px"; - var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : ""; - valueList = isArray(valueList) ? valueList : [valueList]; - return '' + map$1(valueList, function(value) { - return encodeHTML(value); - }).join("  ") + ""; -} -function wrapInlineNameRichText(ctx, name, style) { - return ctx.markupStyleCreator.wrapRichTextStyle(name, style); -} -function wrapInlineValueRichText(ctx, values, alignRight, valueCloseToMarker, style) { - var styles = [style]; - var paddingLeft = valueCloseToMarker ? 10 : 20; - alignRight && styles.push({ - padding: [0, 0, 0, paddingLeft], - align: "right" - }); - return ctx.markupStyleCreator.wrapRichTextStyle(isArray(values) ? values.join(" ") : values, styles); -} -function retrieveVisualColorForTooltipMarker(series, dataIndex) { - var style = series.getData().getItemVisual(dataIndex, "style"); - var color = style[series.visualDrawType]; - return convertToColorString(color); -} -function getPaddingFromTooltipModel(model, renderMode) { - var padding = model.get("padding"); - return padding != null ? padding : renderMode === "richText" ? [8, 10] : 10; -} -var TooltipMarkupStyleCreator = ( - /** @class */ - function() { - function TooltipMarkupStyleCreator2() { - this.richTextStyles = {}; - this._nextStyleNameId = getRandomIdBase(); - } - TooltipMarkupStyleCreator2.prototype._generateStyleName = function() { - return "__EC_aUTo_" + this._nextStyleNameId++; - }; - TooltipMarkupStyleCreator2.prototype.makeTooltipMarker = function(markerType, colorStr, renderMode) { - var markerId = renderMode === "richText" ? this._generateStyleName() : null; - var marker = getTooltipMarker({ - color: colorStr, - type: markerType, - renderMode, - markerId - }); - if (isString(marker)) { - return marker; - } else { - this.richTextStyles[markerId] = marker.style; - return marker.content; - } - }; - TooltipMarkupStyleCreator2.prototype.wrapRichTextStyle = function(text, styles) { - var finalStl = {}; - if (isArray(styles)) { - each$4(styles, function(stl) { - return extend(finalStl, stl); - }); - } else { - extend(finalStl, styles); - } - var styleName = this._generateStyleName(); - this.richTextStyles[styleName] = finalStl; - return "{" + styleName + "|" + text + "}"; - }; - return TooltipMarkupStyleCreator2; - }() -); - -function defaultSeriesFormatTooltip(opt) { - var series = opt.series; - var dataIndex = opt.dataIndex; - var multipleSeries = opt.multipleSeries; - var data = series.getData(); - var tooltipDims = data.mapDimensionsAll('defaultedTooltip'); - var tooltipDimLen = tooltipDims.length; - var value = series.getRawValue(dataIndex); - var isValueArr = isArray(value); - var markerColor = retrieveVisualColorForTooltipMarker(series, dataIndex); - // Complicated rule for pretty tooltip. - var inlineValue; - var inlineValueType; - var subBlocks; - var sortParam; - if (tooltipDimLen > 1 || isValueArr && !tooltipDimLen) { - var formatArrResult = formatTooltipArrayValue(value, series, dataIndex, tooltipDims, markerColor); - inlineValue = formatArrResult.inlineValues; - inlineValueType = formatArrResult.inlineValueTypes; - subBlocks = formatArrResult.blocks; - // Only support tooltip sort by the first inline value. It's enough in most cases. - sortParam = formatArrResult.inlineValues[0]; - } else if (tooltipDimLen) { - var dimInfo = data.getDimensionInfo(tooltipDims[0]); - sortParam = inlineValue = retrieveRawValue(data, dataIndex, tooltipDims[0]); - inlineValueType = dimInfo.type; - } else { - sortParam = inlineValue = isValueArr ? value[0] : value; - } - // Do not show generated series name. It might not be readable. - var seriesNameSpecified = isNameSpecified(series); - var seriesName = seriesNameSpecified && series.name || ''; - var itemName = data.getName(dataIndex); - var inlineName = multipleSeries ? seriesName : itemName; - return createTooltipMarkup('section', { - header: seriesName, - // When series name is not specified, do not show a header line with only '-'. - // This case always happens in tooltip.trigger: 'item'. - noHeader: multipleSeries || !seriesNameSpecified, - sortParam: sortParam, - blocks: [createTooltipMarkup('nameValue', { - markerType: 'item', - markerColor: markerColor, - // Do not mix display seriesName and itemName in one tooltip, - // which might confuses users. - name: inlineName, - // name dimension might be auto assigned, where the name might - // be not readable. So we check trim here. - noName: !trim(inlineName), - value: inlineValue, - valueType: inlineValueType, - dataIndex: dataIndex - })].concat(subBlocks || []) - }); -} -function formatTooltipArrayValue(value, series, dataIndex, tooltipDims, colorStr) { - // check: category-no-encode-has-axis-data in dataset.html - var data = series.getData(); - var isValueMultipleLine = reduce(value, function (isValueMultipleLine, val, idx) { - var dimItem = data.getDimensionInfo(idx); - return isValueMultipleLine = isValueMultipleLine || dimItem && dimItem.tooltip !== false && dimItem.displayName != null; - }, false); - var inlineValues = []; - var inlineValueTypes = []; - var blocks = []; - tooltipDims.length ? each$4(tooltipDims, function (dim) { - setEachItem(retrieveRawValue(data, dataIndex, dim), dim); - }) - // By default, all dims is used on tooltip. - : each$4(value, setEachItem); - function setEachItem(val, dim) { - var dimInfo = data.getDimensionInfo(dim); - // If `dimInfo.tooltip` is not set, show tooltip. - if (!dimInfo || dimInfo.otherDims.tooltip === false) { - return; - } - if (isValueMultipleLine) { - blocks.push(createTooltipMarkup('nameValue', { - markerType: 'subItem', - markerColor: colorStr, - name: dimInfo.displayName, - value: val, - valueType: dimInfo.type - })); - } else { - inlineValues.push(val); - inlineValueTypes.push(dimInfo.type); - } - } - return { - inlineValues: inlineValues, - inlineValueTypes: inlineValueTypes, - blocks: blocks - }; -} - -var inner$8 = makeInner(); -function getSelectionKey(data, dataIndex) { - return data.getName(dataIndex) || data.getId(dataIndex); -} -var SERIES_UNIVERSAL_TRANSITION_PROP = "__universalTransitionEnabled"; -var SeriesModel = ( - /** @class */ - function(_super) { - __extends(SeriesModel2, _super); - function SeriesModel2() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this._selectedDataIndicesMap = {}; - return _this; - } - SeriesModel2.prototype.init = function(option, parentModel, ecModel) { - this.seriesIndex = this.componentIndex; - this.dataTask = createTask({ - count: dataTaskCount, - reset: dataTaskReset - }); - this.dataTask.context = { - model: this - }; - this.mergeDefaultAndTheme(option, ecModel); - var sourceManager = inner$8(this).sourceManager = new SourceManager(this); - sourceManager.prepareSource(); - var data = this.getInitialData(option, ecModel); - wrapData(data, this); - this.dataTask.context.data = data; - inner$8(this).dataBeforeProcessed = data; - autoSeriesName(this); - this._initSelectedMapFromData(data); - }; - SeriesModel2.prototype.mergeDefaultAndTheme = function(option, ecModel) { - var layoutMode = fetchLayoutMode(this); - var inputPositionParams = layoutMode ? getLayoutParams(option) : {}; - var themeSubType = this.subType; - if (ComponentModel.hasClass(themeSubType)) { - themeSubType += "Series"; - } - merge(option, ecModel.getTheme().get(this.subType)); - merge(option, this.getDefaultOption()); - defaultEmphasis(option, "label", ["show"]); - this.fillDataTextStyle(option.data); - if (layoutMode) { - mergeLayoutParam(option, inputPositionParams, layoutMode); - } - }; - SeriesModel2.prototype.mergeOption = function(newSeriesOption, ecModel) { - newSeriesOption = merge(this.option, newSeriesOption, true); - this.fillDataTextStyle(newSeriesOption.data); - var layoutMode = fetchLayoutMode(this); - if (layoutMode) { - mergeLayoutParam(this.option, newSeriesOption, layoutMode); - } - var sourceManager = inner$8(this).sourceManager; - sourceManager.dirty(); - sourceManager.prepareSource(); - var data = this.getInitialData(newSeriesOption, ecModel); - wrapData(data, this); - this.dataTask.dirty(); - this.dataTask.context.data = data; - inner$8(this).dataBeforeProcessed = data; - autoSeriesName(this); - this._initSelectedMapFromData(data); - }; - SeriesModel2.prototype.fillDataTextStyle = function(data) { - if (data && !isTypedArray(data)) { - var props = ["show"]; - for (var i = 0; i < data.length; i++) { - if (data[i] && data[i].label) { - defaultEmphasis(data[i], "label", props); - } - } - } - }; - SeriesModel2.prototype.getInitialData = function(option, ecModel) { - return; - }; - SeriesModel2.prototype.appendData = function(params) { - var data = this.getRawData(); - data.appendData(params.data); - }; - SeriesModel2.prototype.getData = function(dataType) { - var task = getCurrentTask(this); - if (task) { - var data = task.context.data; - return dataType == null || !data.getLinkedData ? data : data.getLinkedData(dataType); - } else { - return inner$8(this).data; - } - }; - SeriesModel2.prototype.getAllData = function() { - var mainData = this.getData(); - return mainData && mainData.getLinkedDataAll ? mainData.getLinkedDataAll() : [{ - data: mainData - }]; - }; - SeriesModel2.prototype.setData = function(data) { - var task = getCurrentTask(this); - if (task) { - var context = task.context; - context.outputData = data; - if (task !== this.dataTask) { - context.data = data; - } - } - inner$8(this).data = data; - }; - SeriesModel2.prototype.getEncode = function() { - var encode = this.get("encode", true); - if (encode) { - return createHashMap(encode); - } - }; - SeriesModel2.prototype.getSourceManager = function() { - return inner$8(this).sourceManager; - }; - SeriesModel2.prototype.getSource = function() { - return this.getSourceManager().getSource(); - }; - SeriesModel2.prototype.getRawData = function() { - return inner$8(this).dataBeforeProcessed; - }; - SeriesModel2.prototype.getColorBy = function() { - var colorBy = this.get("colorBy"); - return colorBy || "series"; - }; - SeriesModel2.prototype.isColorBySeries = function() { - return this.getColorBy() === "series"; - }; - SeriesModel2.prototype.getBaseAxis = function() { - var coordSys = this.coordinateSystem; - return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis(); - }; - SeriesModel2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) { - return defaultSeriesFormatTooltip({ - series: this, - dataIndex, - multipleSeries - }); - }; - SeriesModel2.prototype.isAnimationEnabled = function() { - var ecModel = this.ecModel; - if (env.node && !(ecModel && ecModel.ssr)) { - return false; - } - var animationEnabled = this.getShallow("animation"); - if (animationEnabled) { - if (this.getData().count() > this.getShallow("animationThreshold")) { - animationEnabled = false; - } - } - return !!animationEnabled; - }; - SeriesModel2.prototype.restoreData = function() { - this.dataTask.dirty(); - }; - SeriesModel2.prototype.getColorFromPalette = function(name, scope, requestColorNum) { - var ecModel = this.ecModel; - var color = PaletteMixin.prototype.getColorFromPalette.call(this, name, scope, requestColorNum); - if (!color) { - color = ecModel.getColorFromPalette(name, scope, requestColorNum); - } - return color; - }; - SeriesModel2.prototype.coordDimToDataDim = function(coordDim) { - return this.getRawData().mapDimensionsAll(coordDim); - }; - SeriesModel2.prototype.getProgressive = function() { - return this.get("progressive"); - }; - SeriesModel2.prototype.getProgressiveThreshold = function() { - return this.get("progressiveThreshold"); - }; - SeriesModel2.prototype.select = function(innerDataIndices, dataType) { - this._innerSelect(this.getData(dataType), innerDataIndices); - }; - SeriesModel2.prototype.unselect = function(innerDataIndices, dataType) { - var selectedMap = this.option.selectedMap; - if (!selectedMap) { - return; - } - var selectedMode = this.option.selectedMode; - var data = this.getData(dataType); - if (selectedMode === "series" || selectedMap === "all") { - this.option.selectedMap = {}; - this._selectedDataIndicesMap = {}; - return; - } - for (var i = 0; i < innerDataIndices.length; i++) { - var dataIndex = innerDataIndices[i]; - var nameOrId = getSelectionKey(data, dataIndex); - selectedMap[nameOrId] = false; - this._selectedDataIndicesMap[nameOrId] = -1; - } - }; - SeriesModel2.prototype.toggleSelect = function(innerDataIndices, dataType) { - var tmpArr = []; - for (var i = 0; i < innerDataIndices.length; i++) { - tmpArr[0] = innerDataIndices[i]; - this.isSelected(innerDataIndices[i], dataType) ? this.unselect(tmpArr, dataType) : this.select(tmpArr, dataType); - } - }; - SeriesModel2.prototype.getSelectedDataIndices = function() { - if (this.option.selectedMap === "all") { - return [].slice.call(this.getData().getIndices()); - } - var selectedDataIndicesMap = this._selectedDataIndicesMap; - var nameOrIds = keys(selectedDataIndicesMap); - var dataIndices = []; - for (var i = 0; i < nameOrIds.length; i++) { - var dataIndex = selectedDataIndicesMap[nameOrIds[i]]; - if (dataIndex >= 0) { - dataIndices.push(dataIndex); - } - } - return dataIndices; - }; - SeriesModel2.prototype.isSelected = function(dataIndex, dataType) { - var selectedMap = this.option.selectedMap; - if (!selectedMap) { - return false; - } - var data = this.getData(dataType); - return (selectedMap === "all" || selectedMap[getSelectionKey(data, dataIndex)]) && !data.getItemModel(dataIndex).get(["select", "disabled"]); - }; - SeriesModel2.prototype.isUniversalTransitionEnabled = function() { - if (this[SERIES_UNIVERSAL_TRANSITION_PROP]) { - return true; - } - var universalTransitionOpt = this.option.universalTransition; - if (!universalTransitionOpt) { - return false; - } - if (universalTransitionOpt === true) { - return true; - } - return universalTransitionOpt && universalTransitionOpt.enabled; - }; - SeriesModel2.prototype._innerSelect = function(data, innerDataIndices) { - var _a, _b; - var option = this.option; - var selectedMode = option.selectedMode; - var len = innerDataIndices.length; - if (!selectedMode || !len) { - return; - } - if (selectedMode === "series") { - option.selectedMap = "all"; - } else if (selectedMode === "multiple") { - if (!isObject$2(option.selectedMap)) { - option.selectedMap = {}; - } - var selectedMap = option.selectedMap; - for (var i = 0; i < len; i++) { - var dataIndex = innerDataIndices[i]; - var nameOrId = getSelectionKey(data, dataIndex); - selectedMap[nameOrId] = true; - this._selectedDataIndicesMap[nameOrId] = data.getRawIndex(dataIndex); - } - } else if (selectedMode === "single" || selectedMode === true) { - var lastDataIndex = innerDataIndices[len - 1]; - var nameOrId = getSelectionKey(data, lastDataIndex); - option.selectedMap = (_a = {}, _a[nameOrId] = true, _a); - this._selectedDataIndicesMap = (_b = {}, _b[nameOrId] = data.getRawIndex(lastDataIndex), _b); - } - }; - SeriesModel2.prototype._initSelectedMapFromData = function(data) { - if (this.option.selectedMap) { - return; - } - var dataIndices = []; - if (data.hasItemOption) { - data.each(function(idx) { - var rawItem = data.getRawDataItem(idx); - if (rawItem && rawItem.selected) { - dataIndices.push(idx); - } - }); - } - if (dataIndices.length > 0) { - this._innerSelect(data, dataIndices); - } - }; - SeriesModel2.registerClass = function(clz) { - return ComponentModel.registerClass(clz); - }; - SeriesModel2.protoInitialize = function() { - var proto = SeriesModel2.prototype; - proto.type = "series.__base__"; - proto.seriesIndex = 0; - proto.ignoreStyleOnData = false; - proto.hasSymbolVisual = false; - proto.defaultSymbol = "circle"; - proto.visualStyleAccessPath = "itemStyle"; - proto.visualDrawType = "fill"; - }(); - return SeriesModel2; - }(ComponentModel) -); -mixin(SeriesModel, DataFormatMixin); -mixin(SeriesModel, PaletteMixin); -mountExtend(SeriesModel, ComponentModel); -function autoSeriesName(seriesModel) { - var name = seriesModel.name; - if (!isNameSpecified(seriesModel)) { - seriesModel.name = getSeriesAutoName(seriesModel) || name; - } -} -function getSeriesAutoName(seriesModel) { - var data = seriesModel.getRawData(); - var dataDims = data.mapDimensionsAll("seriesName"); - var nameArr = []; - each$4(dataDims, function(dataDim) { - var dimInfo = data.getDimensionInfo(dataDim); - dimInfo.displayName && nameArr.push(dimInfo.displayName); - }); - return nameArr.join(" "); -} -function dataTaskCount(context) { - return context.model.getRawData().count(); -} -function dataTaskReset(context) { - var seriesModel = context.model; - seriesModel.setData(seriesModel.getRawData().cloneShallow()); - return dataTaskProgress; -} -function dataTaskProgress(param, context) { - if (context.outputData && param.end > context.outputData.count()) { - context.model.getRawData().cloneShallow(context.outputData); - } -} -function wrapData(data, seriesModel) { - each$4(concatArray(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS), function(methodName) { - data.wrapMethod(methodName, curry$1(onDataChange, seriesModel)); - }); -} -function onDataChange(seriesModel, newList) { - var task = getCurrentTask(seriesModel); - if (task) { - task.setOutputEnd((newList || this).count()); - } - return newList; -} -function getCurrentTask(seriesModel) { - var scheduler = (seriesModel.ecModel || {}).scheduler; - var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid); - if (pipeline) { - var task = pipeline.currentTask; - if (task) { - var agentStubMap = task.agentStubMap; - if (agentStubMap) { - task = agentStubMap.get(seriesModel.uid); - } - } - return task; - } -} - -var ComponentView = /** @class */function () { - function ComponentView() { - this.group = new Group$2(); - this.uid = getUID('viewComponent'); - } - ComponentView.prototype.init = function (ecModel, api) {}; - ComponentView.prototype.render = function (model, ecModel, api, payload) {}; - ComponentView.prototype.dispose = function (ecModel, api) {}; - ComponentView.prototype.updateView = function (model, ecModel, api, payload) { - // Do nothing; - }; - ComponentView.prototype.updateLayout = function (model, ecModel, api, payload) { - // Do nothing; - }; - ComponentView.prototype.updateVisual = function (model, ecModel, api, payload) { - // Do nothing; - }; - /** - * Hook for toggle blur target series. - * Can be used in marker for blur or leave blur the markers - */ - ComponentView.prototype.toggleBlurSeries = function (seriesModels, isBlur, ecModel) { - // Do nothing; - }; - /** - * Traverse the new rendered elements. - * - * It will traverse the new added element in progressive rendering. - * And traverse all in normal rendering. - */ - ComponentView.prototype.eachRendered = function (cb) { - var group = this.group; - if (group) { - group.traverse(cb); - } - }; - return ComponentView; -}(); -enableClassExtend(ComponentView); -enableClassManagement(ComponentView); - -/** - * @return {string} If large mode changed, return string 'reset'; - */ -function createRenderPlanner() { - var inner = makeInner(); - return function (seriesModel) { - var fields = inner(seriesModel); - var pipelineContext = seriesModel.pipelineContext; - var originalLarge = !!fields.large; - var originalProgressive = !!fields.progressiveRender; - // FIXME: if the planner works on a filtered series, `pipelineContext` does not - // exists. See #11611 . Probably we need to modify this structure, see the comment - // on `performRawSeries` in `Schedular.js`. - var large = fields.large = !!(pipelineContext && pipelineContext.large); - var progressive = fields.progressiveRender = !!(pipelineContext && pipelineContext.progressiveRender); - return !!(originalLarge !== large || originalProgressive !== progressive) && 'reset'; - }; -} - -var inner$7 = makeInner(); -var renderPlanner = createRenderPlanner(); -var ChartView = ( - /** @class */ - function() { - function ChartView2() { - this.group = new Group$2(); - this.uid = getUID("viewChart"); - this.renderTask = createTask({ - plan: renderTaskPlan, - reset: renderTaskReset - }); - this.renderTask.context = { - view: this - }; - } - ChartView2.prototype.init = function(ecModel, api) { - }; - ChartView2.prototype.render = function(seriesModel, ecModel, api, payload) { - }; - ChartView2.prototype.highlight = function(seriesModel, ecModel, api, payload) { - var data = seriesModel.getData(payload && payload.dataType); - if (!data) { - return; - } - toggleHighlight(data, payload, "emphasis"); - }; - ChartView2.prototype.downplay = function(seriesModel, ecModel, api, payload) { - var data = seriesModel.getData(payload && payload.dataType); - if (!data) { - return; - } - toggleHighlight(data, payload, "normal"); - }; - ChartView2.prototype.remove = function(ecModel, api) { - this.group.removeAll(); - }; - ChartView2.prototype.dispose = function(ecModel, api) { - }; - ChartView2.prototype.updateView = function(seriesModel, ecModel, api, payload) { - this.render(seriesModel, ecModel, api, payload); - }; - ChartView2.prototype.updateLayout = function(seriesModel, ecModel, api, payload) { - this.render(seriesModel, ecModel, api, payload); - }; - ChartView2.prototype.updateVisual = function(seriesModel, ecModel, api, payload) { - this.render(seriesModel, ecModel, api, payload); - }; - ChartView2.prototype.eachRendered = function(cb) { - traverseElements(this.group, cb); - }; - ChartView2.markUpdateMethod = function(payload, methodName) { - inner$7(payload).updateMethod = methodName; - }; - ChartView2.protoInitialize = function() { - var proto = ChartView2.prototype; - proto.type = "chart"; - }(); - return ChartView2; - }() -); -function elSetState(el, state, highlightDigit) { - if (el && isHighDownDispatcher(el)) { - (state === "emphasis" ? enterEmphasis : leaveEmphasis)(el, highlightDigit); - } -} -function toggleHighlight(data, payload, state) { - var dataIndex = queryDataIndex(data, payload); - var highlightDigit = payload && payload.highlightKey != null ? getHighlightDigit(payload.highlightKey) : null; - if (dataIndex != null) { - each$4(normalizeToArray(dataIndex), function(dataIdx) { - elSetState(data.getItemGraphicEl(dataIdx), state, highlightDigit); - }); - } else { - data.eachItemGraphicEl(function(el) { - elSetState(el, state, highlightDigit); - }); - } -} -enableClassExtend(ChartView); -enableClassManagement(ChartView); -function renderTaskPlan(context) { - return renderPlanner(context.model); -} -function renderTaskReset(context) { - var seriesModel = context.model; - var ecModel = context.ecModel; - var api = context.api; - var payload = context.payload; - var progressiveRender = seriesModel.pipelineContext.progressiveRender; - var view = context.view; - var updateMethod = payload && inner$7(payload).updateMethod; - var methodName = progressiveRender ? "incrementalPrepareRender" : updateMethod && view[updateMethod] ? updateMethod : "render"; - if (methodName !== "render") { - view[methodName](seriesModel, ecModel, api, payload); - } - return progressMethodMap[methodName]; -} -var progressMethodMap = { - incrementalPrepareRender: { - progress: function(params, context) { - context.view.incrementalRender(params, context.model, context.ecModel, context.api, context.payload); - } - }, - render: { - // Put view.render in `progress` to support appendData. But in this case - // view.render should not be called in reset, otherwise it will be called - // twise. Use `forceFirstProgress` to make sure that view.render is called - // in any cases. - forceFirstProgress: true, - progress: function(params, context) { - context.view.render(context.model, context.ecModel, context.api, context.payload); - } - } -}; - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -var ORIGIN_METHOD = '\0__throttleOriginMethod'; -var RATE = '\0__throttleRate'; -var THROTTLE_TYPE = '\0__throttleType'; -/** - * @public - * @param {(Function)} fn - * @param {number} [delay=0] Unit: ms. - * @param {boolean} [debounce=false] - * true: If call interval less than `delay`, only the last call works. - * false: If call interval less than `delay, call works on fixed rate. - * @return {(Function)} throttled fn. - */ -function throttle(fn, delay, debounce) { - var currCall; - var lastCall = 0; - var lastExec = 0; - var timer = null; - var diff; - var scope; - var args; - var debounceNextCall; - delay = delay || 0; - function exec() { - lastExec = new Date().getTime(); - timer = null; - fn.apply(scope, args || []); - } - var cb = function () { - var cbArgs = []; - for (var _i = 0; _i < arguments.length; _i++) { - cbArgs[_i] = arguments[_i]; - } - currCall = new Date().getTime(); - scope = this; - args = cbArgs; - var thisDelay = debounceNextCall || delay; - var thisDebounce = debounceNextCall || debounce; - debounceNextCall = null; - diff = currCall - (thisDebounce ? lastCall : lastExec) - thisDelay; - clearTimeout(timer); - // Here we should make sure that: the `exec` SHOULD NOT be called later - // than a new call of `cb`, that is, preserving the command order. Consider - // calculating "scale rate" when roaming as an example. When a call of `cb` - // happens, either the `exec` is called dierectly, or the call is delayed. - // But the delayed call should never be later than next call of `cb`. Under - // this assurance, we can simply update view state each time `dispatchAction` - // triggered by user roaming, but not need to add extra code to avoid the - // state being "rolled-back". - if (thisDebounce) { - timer = setTimeout(exec, thisDelay); - } else { - if (diff >= 0) { - exec(); - } else { - timer = setTimeout(exec, -diff); - } - } - lastCall = currCall; - }; - /** - * Clear throttle. - * @public - */ - cb.clear = function () { - if (timer) { - clearTimeout(timer); - timer = null; - } - }; - /** - * Enable debounce once. - */ - cb.debounceNextCall = function (debounceDelay) { - debounceNextCall = debounceDelay; - }; - return cb; -} -/** - * Create throttle method or update throttle rate. - * - * @example - * ComponentView.prototype.render = function () { - * ... - * throttle.createOrUpdate( - * this, - * '_dispatchAction', - * this.model.get('throttle'), - * 'fixRate' - * ); - * }; - * ComponentView.prototype.remove = function () { - * throttle.clear(this, '_dispatchAction'); - * }; - * ComponentView.prototype.dispose = function () { - * throttle.clear(this, '_dispatchAction'); - * }; - * - */ -function createOrUpdate(obj, fnAttr, rate, throttleType) { - var fn = obj[fnAttr]; - if (!fn) { - return; - } - var originFn = fn[ORIGIN_METHOD] || fn; - var lastThrottleType = fn[THROTTLE_TYPE]; - var lastRate = fn[RATE]; - if (lastRate !== rate || lastThrottleType !== throttleType) { - if (rate == null || false) { - return obj[fnAttr] = originFn; - } - fn = obj[fnAttr] = throttle(originFn, rate, throttleType === 'debounce'); - fn[ORIGIN_METHOD] = originFn; - fn[THROTTLE_TYPE] = throttleType; - fn[RATE] = rate; - } - return fn; -} -/** - * Clear throttle. Example see throttle.createOrUpdate. - */ -function clear(obj, fnAttr) { - var fn = obj[fnAttr]; - if (fn && fn[ORIGIN_METHOD]) { - // Clear throttle - fn.clear && fn.clear(); - obj[fnAttr] = fn[ORIGIN_METHOD]; - } -} - -var inner$6 = makeInner(); -var defaultStyleMappers = { - itemStyle: makeStyleMapper(ITEM_STYLE_KEY_MAP, true), - lineStyle: makeStyleMapper(LINE_STYLE_KEY_MAP, true) -}; -var defaultColorKey = { - lineStyle: 'stroke', - itemStyle: 'fill' -}; -function getStyleMapper(seriesModel, stylePath) { - var styleMapper = seriesModel.visualStyleMapper || defaultStyleMappers[stylePath]; - if (!styleMapper) { - console.warn("Unknown style type '" + stylePath + "'."); - return defaultStyleMappers.itemStyle; - } - return styleMapper; -} -function getDefaultColorKey(seriesModel, stylePath) { - // return defaultColorKey[stylePath] || - var colorKey = seriesModel.visualDrawType || defaultColorKey[stylePath]; - if (!colorKey) { - console.warn("Unknown style type '" + stylePath + "'."); - return 'fill'; - } - return colorKey; -} -var seriesStyleTask = { - createOnAllSeries: true, - performRawSeries: true, - reset: function (seriesModel, ecModel) { - var data = seriesModel.getData(); - var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle'; - // Set in itemStyle - var styleModel = seriesModel.getModel(stylePath); - var getStyle = getStyleMapper(seriesModel, stylePath); - var globalStyle = getStyle(styleModel); - var decalOption = styleModel.getShallow('decal'); - if (decalOption) { - data.setVisual('decal', decalOption); - decalOption.dirty = true; - } - // TODO - var colorKey = getDefaultColorKey(seriesModel, stylePath); - var color = globalStyle[colorKey]; - // TODO style callback - var colorCallback = isFunction(color) ? color : null; - var hasAutoColor = globalStyle.fill === 'auto' || globalStyle.stroke === 'auto'; - // Get from color palette by default. - if (!globalStyle[colorKey] || colorCallback || hasAutoColor) { - // Note: If some series has color specified (e.g., by itemStyle.color), we DO NOT - // make it effect palette. Because some scenarios users need to make some series - // transparent or as background, which should better not effect the palette. - var colorPalette = seriesModel.getColorFromPalette( - // TODO series count changed. - seriesModel.name, null, ecModel.getSeriesCount()); - if (!globalStyle[colorKey]) { - globalStyle[colorKey] = colorPalette; - data.setVisual('colorFromPalette', true); - } - globalStyle.fill = globalStyle.fill === 'auto' || isFunction(globalStyle.fill) ? colorPalette : globalStyle.fill; - globalStyle.stroke = globalStyle.stroke === 'auto' || isFunction(globalStyle.stroke) ? colorPalette : globalStyle.stroke; - } - data.setVisual('style', globalStyle); - data.setVisual('drawType', colorKey); - // Only visible series has each data be visual encoded - if (!ecModel.isSeriesFiltered(seriesModel) && colorCallback) { - data.setVisual('colorFromPalette', false); - return { - dataEach: function (data, idx) { - var dataParams = seriesModel.getDataParams(idx); - var itemStyle = extend({}, globalStyle); - itemStyle[colorKey] = colorCallback(dataParams); - data.setItemVisual(idx, 'style', itemStyle); - } - }; - } - } -}; -var sharedModel = new Model(); -var dataStyleTask = { - createOnAllSeries: true, - performRawSeries: true, - reset: function (seriesModel, ecModel) { - if (seriesModel.ignoreStyleOnData || ecModel.isSeriesFiltered(seriesModel)) { - return; - } - var data = seriesModel.getData(); - var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle'; - // Set in itemStyle - var getStyle = getStyleMapper(seriesModel, stylePath); - var colorKey = data.getVisual('drawType'); - return { - dataEach: data.hasItemOption ? function (data, idx) { - // Not use getItemModel for performance considuration - var rawItem = data.getRawDataItem(idx); - if (rawItem && rawItem[stylePath]) { - sharedModel.option = rawItem[stylePath]; - var style = getStyle(sharedModel); - var existsStyle = data.ensureUniqueItemVisual(idx, 'style'); - extend(existsStyle, style); - if (sharedModel.option.decal) { - data.setItemVisual(idx, 'decal', sharedModel.option.decal); - sharedModel.option.decal.dirty = true; - } - if (colorKey in style) { - data.setItemVisual(idx, 'colorFromPalette', false); - } - } - } : null - }; - } -}; -// Pick color from palette for the data which has not been set with color yet. -// Note: do not support stream rendering. No such cases yet. -var dataColorPaletteTask = { - performRawSeries: true, - overallReset: function (ecModel) { - // Each type of series uses one scope. - // Pie and funnel are using different scopes. - var paletteScopeGroupByType = createHashMap(); - ecModel.eachSeries(function (seriesModel) { - var colorBy = seriesModel.getColorBy(); - if (seriesModel.isColorBySeries()) { - return; - } - var key = seriesModel.type + '-' + colorBy; - var colorScope = paletteScopeGroupByType.get(key); - if (!colorScope) { - colorScope = {}; - paletteScopeGroupByType.set(key, colorScope); - } - inner$6(seriesModel).scope = colorScope; - }); - ecModel.eachSeries(function (seriesModel) { - if (seriesModel.isColorBySeries() || ecModel.isSeriesFiltered(seriesModel)) { - return; - } - var dataAll = seriesModel.getRawData(); - var idxMap = {}; - var data = seriesModel.getData(); - var colorScope = inner$6(seriesModel).scope; - var stylePath = seriesModel.visualStyleAccessPath || 'itemStyle'; - var colorKey = getDefaultColorKey(seriesModel, stylePath); - data.each(function (idx) { - var rawIdx = data.getRawIndex(idx); - idxMap[rawIdx] = idx; - }); - // Iterate on data before filtered. To make sure color from palette can be - // Consistent when toggling legend. - dataAll.each(function (rawIdx) { - var idx = idxMap[rawIdx]; - var fromPalette = data.getItemVisual(idx, 'colorFromPalette'); - // Get color from palette for each data only when the color is inherited from series color, which is - // also picked from color palette. So following situation is not in the case: - // 1. series.itemStyle.color is set - // 2. color is encoded by visualMap - if (fromPalette) { - var itemStyle = data.ensureUniqueItemVisual(idx, 'style'); - var name_1 = dataAll.getName(rawIdx) || rawIdx + ''; - var dataCount = dataAll.count(); - itemStyle[colorKey] = seriesModel.getColorFromPalette(name_1, colorScope, dataCount); - } - }); - }); - } -}; - -var PI$1 = Math.PI; -/** - * @param {module:echarts/ExtensionAPI} api - * @param {Object} [opts] - * @param {string} [opts.text] - * @param {string} [opts.color] - * @param {string} [opts.textColor] - * @return {module:zrender/Element} - */ -function defaultLoading(api, opts) { - opts = opts || {}; - defaults(opts, { - text: 'loading', - textColor: '#000', - fontSize: 12, - fontWeight: 'normal', - fontStyle: 'normal', - fontFamily: 'sans-serif', - maskColor: 'rgba(255, 255, 255, 0.8)', - showSpinner: true, - color: '#5470c6', - spinnerRadius: 10, - lineWidth: 5, - zlevel: 0 - }); - var group = new Group$2(); - var mask = new Rect({ - style: { - fill: opts.maskColor - }, - zlevel: opts.zlevel, - z: 10000 - }); - group.add(mask); - var textContent = new ZRText({ - style: { - text: opts.text, - fill: opts.textColor, - fontSize: opts.fontSize, - fontWeight: opts.fontWeight, - fontStyle: opts.fontStyle, - fontFamily: opts.fontFamily - }, - zlevel: opts.zlevel, - z: 10001 - }); - var labelRect = new Rect({ - style: { - fill: 'none' - }, - textContent: textContent, - textConfig: { - position: 'right', - distance: 10 - }, - zlevel: opts.zlevel, - z: 10001 - }); - group.add(labelRect); - var arc; - if (opts.showSpinner) { - arc = new Arc({ - shape: { - startAngle: -PI$1 / 2, - endAngle: -PI$1 / 2 + 0.1, - r: opts.spinnerRadius - }, - style: { - stroke: opts.color, - lineCap: 'round', - lineWidth: opts.lineWidth - }, - zlevel: opts.zlevel, - z: 10001 - }); - arc.animateShape(true).when(1000, { - endAngle: PI$1 * 3 / 2 - }).start('circularInOut'); - arc.animateShape(true).when(1000, { - startAngle: PI$1 * 3 / 2 - }).delay(300).start('circularInOut'); - group.add(arc); - } - // Inject resize - group.resize = function () { - var textWidth = textContent.getBoundingRect().width; - var r = opts.showSpinner ? opts.spinnerRadius : 0; - // cx = (containerWidth - arcDiameter - textDistance - textWidth) / 2 - // textDistance needs to be calculated when both animation and text exist - var cx = (api.getWidth() - r * 2 - (opts.showSpinner && textWidth ? 10 : 0) - textWidth) / 2 - (opts.showSpinner && textWidth ? 0 : 5 + textWidth / 2) - // only show the text - + (opts.showSpinner ? 0 : textWidth / 2) - // only show the spinner - + (textWidth ? 0 : r); - var cy = api.getHeight() / 2; - opts.showSpinner && arc.setShape({ - cx: cx, - cy: cy - }); - labelRect.setShape({ - x: cx - r, - y: cy - r, - width: r * 2, - height: r * 2 - }); - mask.setShape({ - x: 0, - y: 0, - width: api.getWidth(), - height: api.getHeight() - }); - }; - group.resize(); - return group; -} - -var Scheduler = ( - /** @class */ - function() { - function Scheduler2(ecInstance, api, dataProcessorHandlers, visualHandlers) { - this._stageTaskMap = createHashMap(); - this.ecInstance = ecInstance; - this.api = api; - dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice(); - visualHandlers = this._visualHandlers = visualHandlers.slice(); - this._allHandlers = dataProcessorHandlers.concat(visualHandlers); - } - Scheduler2.prototype.restoreData = function(ecModel, payload) { - ecModel.restoreData(payload); - this._stageTaskMap.each(function(taskRecord) { - var overallTask = taskRecord.overallTask; - overallTask && overallTask.dirty(); - }); - }; - Scheduler2.prototype.getPerformArgs = function(task, isBlock) { - if (!task.__pipeline) { - return; - } - var pipeline = this._pipelineMap.get(task.__pipeline.id); - var pCtx = pipeline.context; - var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex; - var step = incremental ? pipeline.step : null; - var modDataCount = pCtx && pCtx.modDataCount; - var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null; - return { - step, - modBy, - modDataCount - }; - }; - Scheduler2.prototype.getPipeline = function(pipelineId) { - return this._pipelineMap.get(pipelineId); - }; - Scheduler2.prototype.updateStreamModes = function(seriesModel, view) { - var pipeline = this._pipelineMap.get(seriesModel.uid); - var data = seriesModel.getData(); - var dataLen = data.count(); - var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold; - var large = seriesModel.get("large") && dataLen >= seriesModel.get("largeThreshold"); - var modDataCount = seriesModel.get("progressiveChunkMode") === "mod" ? dataLen : null; - seriesModel.pipelineContext = pipeline.context = { - progressiveRender, - modDataCount, - large - }; - }; - Scheduler2.prototype.restorePipelines = function(ecModel) { - var scheduler = this; - var pipelineMap = scheduler._pipelineMap = createHashMap(); - ecModel.eachSeries(function(seriesModel) { - var progressive = seriesModel.getProgressive(); - var pipelineId = seriesModel.uid; - pipelineMap.set(pipelineId, { - id: pipelineId, - head: null, - tail: null, - threshold: seriesModel.getProgressiveThreshold(), - progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()), - blockIndex: -1, - step: Math.round(progressive || 700), - count: 0 - }); - scheduler._pipe(seriesModel, seriesModel.dataTask); - }); - }; - Scheduler2.prototype.prepareStageTasks = function() { - var stageTaskMap = this._stageTaskMap; - var ecModel = this.api.getModel(); - var api = this.api; - each$4(this._allHandlers, function(handler) { - var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, {}); - var errMsg = ""; - assert(!(handler.reset && handler.overallReset), errMsg); - handler.reset && this._createSeriesStageTask(handler, record, ecModel, api); - handler.overallReset && this._createOverallStageTask(handler, record, ecModel, api); - }, this); - }; - Scheduler2.prototype.prepareView = function(view, model, ecModel, api) { - var renderTask = view.renderTask; - var context = renderTask.context; - context.model = model; - context.ecModel = ecModel; - context.api = api; - renderTask.__block = !view.incrementalPrepareRender; - this._pipe(model, renderTask); - }; - Scheduler2.prototype.performDataProcessorTasks = function(ecModel, payload) { - this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, { - block: true - }); - }; - Scheduler2.prototype.performVisualTasks = function(ecModel, payload, opt) { - this._performStageTasks(this._visualHandlers, ecModel, payload, opt); - }; - Scheduler2.prototype._performStageTasks = function(stageHandlers, ecModel, payload, opt) { - opt = opt || {}; - var unfinished = false; - var scheduler = this; - each$4(stageHandlers, function(stageHandler, idx) { - if (opt.visualType && opt.visualType !== stageHandler.visualType) { - return; - } - var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid); - var seriesTaskMap = stageHandlerRecord.seriesTaskMap; - var overallTask = stageHandlerRecord.overallTask; - if (overallTask) { - var overallNeedDirty_1; - var agentStubMap = overallTask.agentStubMap; - agentStubMap.each(function(stub) { - if (needSetDirty(opt, stub)) { - stub.dirty(); - overallNeedDirty_1 = true; - } - }); - overallNeedDirty_1 && overallTask.dirty(); - scheduler.updatePayload(overallTask, payload); - var performArgs_1 = scheduler.getPerformArgs(overallTask, opt.block); - agentStubMap.each(function(stub) { - stub.perform(performArgs_1); - }); - if (overallTask.perform(performArgs_1)) { - unfinished = true; - } - } else if (seriesTaskMap) { - seriesTaskMap.each(function(task, pipelineId) { - if (needSetDirty(opt, task)) { - task.dirty(); - } - var performArgs = scheduler.getPerformArgs(task, opt.block); - performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task.context.model); - scheduler.updatePayload(task, payload); - if (task.perform(performArgs)) { - unfinished = true; - } - }); - } - }); - function needSetDirty(opt2, task) { - return opt2.setDirty && (!opt2.dirtyMap || opt2.dirtyMap.get(task.__pipeline.id)); - } - this.unfinished = unfinished || this.unfinished; - }; - Scheduler2.prototype.performSeriesTasks = function(ecModel) { - var unfinished; - ecModel.eachSeries(function(seriesModel) { - unfinished = seriesModel.dataTask.perform() || unfinished; - }); - this.unfinished = unfinished || this.unfinished; - }; - Scheduler2.prototype.plan = function() { - this._pipelineMap.each(function(pipeline) { - var task = pipeline.tail; - do { - if (task.__block) { - pipeline.blockIndex = task.__idxInPipeline; - break; - } - task = task.getUpstream(); - } while (task); - }); - }; - Scheduler2.prototype.updatePayload = function(task, payload) { - payload !== "remain" && (task.context.payload = payload); - }; - Scheduler2.prototype._createSeriesStageTask = function(stageHandler, stageHandlerRecord, ecModel, api) { - var scheduler = this; - var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap; - var newSeriesTaskMap = stageHandlerRecord.seriesTaskMap = createHashMap(); - var seriesType2 = stageHandler.seriesType; - var getTargetSeries = stageHandler.getTargetSeries; - if (stageHandler.createOnAllSeries) { - ecModel.eachRawSeries(create); - } else if (seriesType2) { - ecModel.eachRawSeriesByType(seriesType2, create); - } else if (getTargetSeries) { - getTargetSeries(ecModel, api).each(create); - } - function create(seriesModel) { - var pipelineId = seriesModel.uid; - var task = newSeriesTaskMap.set(pipelineId, oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId) || createTask({ - plan: seriesTaskPlan, - reset: seriesTaskReset, - count: seriesTaskCount - })); - task.context = { - model: seriesModel, - ecModel, - api, - // PENDING: `useClearVisual` not used? - useClearVisual: stageHandler.isVisual && !stageHandler.isLayout, - plan: stageHandler.plan, - reset: stageHandler.reset, - scheduler - }; - scheduler._pipe(seriesModel, task); - } - }; - Scheduler2.prototype._createOverallStageTask = function(stageHandler, stageHandlerRecord, ecModel, api) { - var scheduler = this; - var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask || createTask({ - reset: overallTaskReset - }); - overallTask.context = { - ecModel, - api, - overallReset: stageHandler.overallReset, - scheduler - }; - var oldAgentStubMap = overallTask.agentStubMap; - var newAgentStubMap = overallTask.agentStubMap = createHashMap(); - var seriesType2 = stageHandler.seriesType; - var getTargetSeries = stageHandler.getTargetSeries; - var overallProgress = true; - var shouldOverallTaskDirty = false; - var errMsg = ""; - assert(!stageHandler.createOnAllSeries, errMsg); - if (seriesType2) { - ecModel.eachRawSeriesByType(seriesType2, createStub); - } else if (getTargetSeries) { - getTargetSeries(ecModel, api).each(createStub); - } else { - overallProgress = false; - each$4(ecModel.getSeries(), createStub); - } - function createStub(seriesModel) { - var pipelineId = seriesModel.uid; - var stub = newAgentStubMap.set(pipelineId, oldAgentStubMap && oldAgentStubMap.get(pipelineId) || // When the result of `getTargetSeries` changed, the overallTask - // should be set as dirty and re-performed. - (shouldOverallTaskDirty = true, createTask({ - reset: stubReset, - onDirty: stubOnDirty - }))); - stub.context = { - model: seriesModel, - overallProgress - // FIXME:TS never used, so comment it - // modifyOutputEnd: modifyOutputEnd - }; - stub.agent = overallTask; - stub.__block = overallProgress; - scheduler._pipe(seriesModel, stub); - } - if (shouldOverallTaskDirty) { - overallTask.dirty(); - } - }; - Scheduler2.prototype._pipe = function(seriesModel, task) { - var pipelineId = seriesModel.uid; - var pipeline = this._pipelineMap.get(pipelineId); - !pipeline.head && (pipeline.head = task); - pipeline.tail && pipeline.tail.pipe(task); - pipeline.tail = task; - task.__idxInPipeline = pipeline.count++; - task.__pipeline = pipeline; - }; - Scheduler2.wrapStageHandler = function(stageHandler, visualType) { - if (isFunction(stageHandler)) { - stageHandler = { - overallReset: stageHandler, - seriesType: detectSeriseType(stageHandler) - }; - } - stageHandler.uid = getUID("stageHandler"); - visualType && (stageHandler.visualType = visualType); - return stageHandler; - }; - return Scheduler2; - }() -); -function overallTaskReset(context) { - context.overallReset(context.ecModel, context.api, context.payload); -} -function stubReset(context) { - return context.overallProgress && stubProgress; -} -function stubProgress() { - this.agent.dirty(); - this.getDownstream().dirty(); -} -function stubOnDirty() { - this.agent && this.agent.dirty(); -} -function seriesTaskPlan(context) { - return context.plan ? context.plan(context.model, context.ecModel, context.api, context.payload) : null; -} -function seriesTaskReset(context) { - if (context.useClearVisual) { - context.data.clearAllVisual(); - } - var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload)); - return resetDefines.length > 1 ? map$1(resetDefines, function(v, idx) { - return makeSeriesTaskProgress(idx); - }) : singleSeriesTaskProgress; -} -var singleSeriesTaskProgress = makeSeriesTaskProgress(0); -function makeSeriesTaskProgress(resetDefineIdx) { - return function(params, context) { - var data = context.data; - var resetDefine = context.resetDefines[resetDefineIdx]; - if (resetDefine && resetDefine.dataEach) { - for (var i = params.start; i < params.end; i++) { - resetDefine.dataEach(data, i); - } - } else if (resetDefine && resetDefine.progress) { - resetDefine.progress(params, data); - } - }; -} -function seriesTaskCount(context) { - return context.data.count(); -} -function detectSeriseType(legacyFunc) { - seriesType = null; - try { - legacyFunc(ecModelMock, apiMock); - } catch (e) { - } - return seriesType; -} -var ecModelMock = {}; -var apiMock = {}; -var seriesType; -mockMethods(ecModelMock, GlobalModel); -mockMethods(apiMock, ExtensionAPI); -ecModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function(type) { - seriesType = type; -}; -ecModelMock.eachComponent = function(cond) { - if (cond.mainType === "series" && cond.subType) { - seriesType = cond.subType; - } -}; -function mockMethods(target, Clz) { - for (var name_1 in Clz.prototype) { - target[name_1] = noop; - } -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -var colorAll = ['#37A2DA', '#32C5E9', '#67E0E3', '#9FE6B8', '#FFDB5C', '#ff9f7f', '#fb7293', '#E062AE', '#E690D1', '#e7bcf3', '#9d96f5', '#8378EA', '#96BFFF']; -const lightTheme = { - color: colorAll, - colorLayer: [['#37A2DA', '#ffd85c', '#fd7b5f'], ['#37A2DA', '#67E0E3', '#FFDB5C', '#ff9f7f', '#E062AE', '#9d96f5'], ['#37A2DA', '#32C5E9', '#9FE6B8', '#FFDB5C', '#ff9f7f', '#fb7293', '#e7bcf3', '#8378EA', '#96BFFF'], colorAll] -}; - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -var contrastColor = '#B9B8CE'; -var backgroundColor = '#100C2A'; -var axisCommon = function () { - return { - axisLine: { - lineStyle: { - color: contrastColor - } - }, - splitLine: { - lineStyle: { - color: '#484753' - } - }, - splitArea: { - areaStyle: { - color: ['rgba(255,255,255,0.02)', 'rgba(255,255,255,0.05)'] - } - }, - minorSplitLine: { - lineStyle: { - color: '#20203B' - } - } - }; -}; -var colorPalette = ['#4992ff', '#7cffb2', '#fddd60', '#ff6e76', '#58d9f9', '#05c091', '#ff8a45', '#8d48e3', '#dd79ff']; -var theme = { - darkMode: true, - color: colorPalette, - backgroundColor: backgroundColor, - axisPointer: { - lineStyle: { - color: '#817f91' - }, - crossStyle: { - color: '#817f91' - }, - label: { - // TODO Contrast of label backgorundColor - color: '#fff' - } - }, - legend: { - textStyle: { - color: contrastColor - }, - pageTextStyle: { - color: contrastColor - } - }, - textStyle: { - color: contrastColor - }, - title: { - textStyle: { - color: '#EEF1FA' - }, - subtextStyle: { - color: '#B9B8CE' - } - }, - toolbox: { - iconStyle: { - borderColor: contrastColor - } - }, - dataZoom: { - borderColor: '#71708A', - textStyle: { - color: contrastColor - }, - brushStyle: { - color: 'rgba(135,163,206,0.3)' - }, - handleStyle: { - color: '#353450', - borderColor: '#C5CBE3' - }, - moveHandleStyle: { - color: '#B0B6C3', - opacity: 0.3 - }, - fillerColor: 'rgba(135,163,206,0.2)', - emphasis: { - handleStyle: { - borderColor: '#91B7F2', - color: '#4D587D' - }, - moveHandleStyle: { - color: '#636D9A', - opacity: 0.7 - } - }, - dataBackground: { - lineStyle: { - color: '#71708A', - width: 1 - }, - areaStyle: { - color: '#71708A' - } - }, - selectedDataBackground: { - lineStyle: { - color: '#87A3CE' - }, - areaStyle: { - color: '#87A3CE' - } - } - }, - visualMap: { - textStyle: { - color: contrastColor - } - }, - timeline: { - lineStyle: { - color: contrastColor - }, - label: { - color: contrastColor - }, - controlStyle: { - color: contrastColor, - borderColor: contrastColor - } - }, - calendar: { - itemStyle: { - color: backgroundColor - }, - dayLabel: { - color: contrastColor - }, - monthLabel: { - color: contrastColor - }, - yearLabel: { - color: contrastColor - } - }, - timeAxis: axisCommon(), - logAxis: axisCommon(), - valueAxis: axisCommon(), - categoryAxis: axisCommon(), - line: { - symbol: 'circle' - }, - graph: { - color: colorPalette - }, - gauge: { - title: { - color: contrastColor - }, - axisLine: { - lineStyle: { - color: [[1, 'rgba(207,212,219,0.2)']] - } - }, - axisLabel: { - color: contrastColor - }, - detail: { - color: '#EEF1FA' - } - }, - candlestick: { - itemStyle: { - color: '#f64e56', - color0: '#54ea92', - borderColor: '#f64e56', - borderColor0: '#54ea92' - // borderColor: '#ca2824', - // borderColor0: '#09a443' - } - } -}; -theme.categoryAxis.splitLine.show = false; - -/** - * Usage of query: - * `chart.on('click', query, handler);` - * The `query` can be: - * + The component type query string, only `mainType` or `mainType.subType`, - * like: 'xAxis', 'series', 'xAxis.category' or 'series.line'. - * + The component query object, like: - * `{seriesIndex: 2}`, `{seriesName: 'xx'}`, `{seriesId: 'some'}`, - * `{xAxisIndex: 2}`, `{xAxisName: 'xx'}`, `{xAxisId: 'some'}`. - * + The data query object, like: - * `{dataIndex: 123}`, `{dataType: 'link'}`, `{name: 'some'}`. - * + The other query object (cmponent customized query), like: - * `{element: 'some'}` (only available in custom series). - * - * Caveat: If a prop in the `query` object is `null/undefined`, it is the - * same as there is no such prop in the `query` object. - */ -var ECEventProcessor = /** @class */function () { - function ECEventProcessor() {} - ECEventProcessor.prototype.normalizeQuery = function (query) { - var cptQuery = {}; - var dataQuery = {}; - var otherQuery = {}; - // `query` is `mainType` or `mainType.subType` of component. - if (isString(query)) { - var condCptType = parseClassType(query); - // `.main` and `.sub` may be ''. - cptQuery.mainType = condCptType.main || null; - cptQuery.subType = condCptType.sub || null; - } - // `query` is an object, convert to {mainType, index, name, id}. - else { - // `xxxIndex`, `xxxName`, `xxxId`, `name`, `dataIndex`, `dataType` is reserved, - // can not be used in `compomentModel.filterForExposedEvent`. - var suffixes_1 = ['Index', 'Name', 'Id']; - var dataKeys_1 = { - name: 1, - dataIndex: 1, - dataType: 1 - }; - each$4(query, function (val, key) { - var reserved = false; - for (var i = 0; i < suffixes_1.length; i++) { - var propSuffix = suffixes_1[i]; - var suffixPos = key.lastIndexOf(propSuffix); - if (suffixPos > 0 && suffixPos === key.length - propSuffix.length) { - var mainType = key.slice(0, suffixPos); - // Consider `dataIndex`. - if (mainType !== 'data') { - cptQuery.mainType = mainType; - cptQuery[propSuffix.toLowerCase()] = val; - reserved = true; - } - } - } - if (dataKeys_1.hasOwnProperty(key)) { - dataQuery[key] = val; - reserved = true; - } - if (!reserved) { - otherQuery[key] = val; - } - }); - } - return { - cptQuery: cptQuery, - dataQuery: dataQuery, - otherQuery: otherQuery - }; - }; - ECEventProcessor.prototype.filter = function (eventType, query) { - // They should be assigned before each trigger call. - var eventInfo = this.eventInfo; - if (!eventInfo) { - return true; - } - var targetEl = eventInfo.targetEl; - var packedEvent = eventInfo.packedEvent; - var model = eventInfo.model; - var view = eventInfo.view; - // For event like 'globalout'. - if (!model || !view) { - return true; - } - var cptQuery = query.cptQuery; - var dataQuery = query.dataQuery; - return check(cptQuery, model, 'mainType') && check(cptQuery, model, 'subType') && check(cptQuery, model, 'index', 'componentIndex') && check(cptQuery, model, 'name') && check(cptQuery, model, 'id') && check(dataQuery, packedEvent, 'name') && check(dataQuery, packedEvent, 'dataIndex') && check(dataQuery, packedEvent, 'dataType') && (!view.filterForExposedEvent || view.filterForExposedEvent(eventType, query.otherQuery, targetEl, packedEvent)); - function check(query, host, prop, propOnHost) { - return query[prop] == null || host[propOnHost || prop] === query[prop]; - } - }; - ECEventProcessor.prototype.afterTrigger = function () { - // Make sure the eventInfo won't be used in next trigger. - this.eventInfo = null; - }; - return ECEventProcessor; -}(); - -var SYMBOL_PROPS_WITH_CB = ['symbol', 'symbolSize', 'symbolRotate', 'symbolOffset']; -var SYMBOL_PROPS = SYMBOL_PROPS_WITH_CB.concat(['symbolKeepAspect']); -// Encoding visual for all series include which is filtered for legend drawing -var seriesSymbolTask = { - createOnAllSeries: true, - // For legend. - performRawSeries: true, - reset: function (seriesModel, ecModel) { - var data = seriesModel.getData(); - if (seriesModel.legendIcon) { - data.setVisual('legendIcon', seriesModel.legendIcon); - } - if (!seriesModel.hasSymbolVisual) { - return; - } - var symbolOptions = {}; - var symbolOptionsCb = {}; - var hasCallback = false; - for (var i = 0; i < SYMBOL_PROPS_WITH_CB.length; i++) { - var symbolPropName = SYMBOL_PROPS_WITH_CB[i]; - var val = seriesModel.get(symbolPropName); - if (isFunction(val)) { - hasCallback = true; - symbolOptionsCb[symbolPropName] = val; - } else { - symbolOptions[symbolPropName] = val; - } - } - symbolOptions.symbol = symbolOptions.symbol || seriesModel.defaultSymbol; - data.setVisual(extend({ - legendIcon: seriesModel.legendIcon || symbolOptions.symbol, - symbolKeepAspect: seriesModel.get('symbolKeepAspect') - }, symbolOptions)); - // Only visible series has each data be visual encoded - if (ecModel.isSeriesFiltered(seriesModel)) { - return; - } - var symbolPropsCb = keys(symbolOptionsCb); - function dataEach(data, idx) { - var rawValue = seriesModel.getRawValue(idx); - var params = seriesModel.getDataParams(idx); - for (var i = 0; i < symbolPropsCb.length; i++) { - var symbolPropName = symbolPropsCb[i]; - data.setItemVisual(idx, symbolPropName, symbolOptionsCb[symbolPropName](rawValue, params)); - } - } - return { - dataEach: hasCallback ? dataEach : null - }; - } -}; -var dataSymbolTask = { - createOnAllSeries: true, - // For legend. - performRawSeries: true, - reset: function (seriesModel, ecModel) { - if (!seriesModel.hasSymbolVisual) { - return; - } - // Only visible series has each data be visual encoded - if (ecModel.isSeriesFiltered(seriesModel)) { - return; - } - var data = seriesModel.getData(); - function dataEach(data, idx) { - var itemModel = data.getItemModel(idx); - for (var i = 0; i < SYMBOL_PROPS.length; i++) { - var symbolPropName = SYMBOL_PROPS[i]; - var val = itemModel.getShallow(symbolPropName, true); - if (val != null) { - data.setItemVisual(idx, symbolPropName, val); - } - } - } - return { - dataEach: data.hasItemOption ? dataEach : null - }; - } -}; - -function getItemVisualFromData(data, dataIndex, key) { - switch (key) { - case "color": - var style = data.getItemVisual(dataIndex, "style"); - return style[data.getVisual("drawType")]; - case "opacity": - return data.getItemVisual(dataIndex, "style").opacity; - case "symbol": - case "symbolSize": - case "liftZ": - return data.getItemVisual(dataIndex, key); - } -} -function getVisualFromData(data, key) { - switch (key) { - case "color": - var style = data.getVisual("style"); - return style[data.getVisual("drawType")]; - case "opacity": - return data.getVisual("style").opacity; - case "symbol": - case "symbolSize": - case "liftZ": - return data.getVisual(key); - } -} - -function createLegacyDataSelectAction(seriesType, ecRegisterAction) { - function getSeriesIndices(ecModel, payload) { - var seriesIndices = []; - ecModel.eachComponent({ - mainType: "series", - subType: seriesType, - query: payload - }, function(seriesModel) { - seriesIndices.push(seriesModel.seriesIndex); - }); - return seriesIndices; - } - each$4([[seriesType + "ToggleSelect", "toggleSelect"], [seriesType + "Select", "select"], [seriesType + "UnSelect", "unselect"]], function(eventsMap) { - ecRegisterAction(eventsMap[0], function(payload, ecModel, api) { - payload = extend({}, payload); - api.dispatchAction(extend(payload, { - type: eventsMap[1], - seriesIndex: getSeriesIndices(ecModel, payload) - })); - }); - }); -} -function handleSeriesLegacySelectEvents(type, eventPostfix, ecIns, ecModel, payload) { - var legacyEventName = type + eventPostfix; - if (!ecIns.isSilent(legacyEventName)) { - ecModel.eachComponent({ - mainType: "series", - subType: "pie" - }, function(seriesModel) { - var seriesIndex = seriesModel.seriesIndex; - var selectedMap = seriesModel.option.selectedMap; - var selected = payload.selected; - for (var i = 0; i < selected.length; i++) { - if (selected[i].seriesIndex === seriesIndex) { - var data = seriesModel.getData(); - var dataIndex = queryDataIndex(data, payload.fromActionPayload); - ecIns.trigger(legacyEventName, { - type: legacyEventName, - seriesId: seriesModel.id, - name: isArray(dataIndex) ? data.getName(dataIndex[0]) : data.getName(dataIndex), - selected: isString(selectedMap) ? selectedMap : extend({}, selectedMap) - }); - } - } - }); - } -} -function handleLegacySelectEvents(messageCenter, ecIns, api) { - messageCenter.on("selectchanged", function(params) { - var ecModel = api.getModel(); - if (params.isFromClick) { - handleSeriesLegacySelectEvents("map", "selectchanged", ecIns, ecModel, params); - handleSeriesLegacySelectEvents("pie", "selectchanged", ecIns, ecModel, params); - } else if (params.fromAction === "select") { - handleSeriesLegacySelectEvents("map", "selected", ecIns, ecModel, params); - handleSeriesLegacySelectEvents("pie", "selected", ecIns, ecModel, params); - } else if (params.fromAction === "unselect") { - handleSeriesLegacySelectEvents("map", "unselected", ecIns, ecModel, params); - handleSeriesLegacySelectEvents("pie", "unselected", ecIns, ecModel, params); - } - }); -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function findEventDispatcher(target, det, returnFirstMatch) { - var found; - while (target) { - if (det(target)) { - found = target; - if (returnFirstMatch) { - break; - } - } - target = target.__hostTarget || target.parent; - } - return found; -} - -var wmUniqueIndex = Math.round(Math.random() * 9); -var supportDefineProperty = typeof Object.defineProperty === 'function'; -var WeakMap = (function () { - function WeakMap() { - this._id = '__ec_inner_' + wmUniqueIndex++; - } - WeakMap.prototype.get = function (key) { - return this._guard(key)[this._id]; - }; - WeakMap.prototype.set = function (key, value) { - var target = this._guard(key); - if (supportDefineProperty) { - Object.defineProperty(target, this._id, { - value: value, - enumerable: false, - configurable: true - }); - } - else { - target[this._id] = value; - } - return this; - }; - WeakMap.prototype["delete"] = function (key) { - if (this.has(key)) { - delete this._guard(key)[this._id]; - return true; - } - return false; - }; - WeakMap.prototype.has = function (key) { - return !!this._guard(key)[this._id]; - }; - WeakMap.prototype._guard = function (key) { - if (key !== Object(key)) { - throw TypeError('Value of WeakMap is not a non-null object.'); - } - return key; - }; - return WeakMap; -}()); - -/** - * Triangle shape - * @inner - */ -var Triangle = Path.extend({ - type: 'triangle', - shape: { - cx: 0, - cy: 0, - width: 0, - height: 0 - }, - buildPath: function (path, shape) { - var cx = shape.cx; - var cy = shape.cy; - var width = shape.width / 2; - var height = shape.height / 2; - path.moveTo(cx, cy - height); - path.lineTo(cx + width, cy + height); - path.lineTo(cx - width, cy + height); - path.closePath(); - } -}); -/** - * Diamond shape - * @inner - */ -var Diamond = Path.extend({ - type: 'diamond', - shape: { - cx: 0, - cy: 0, - width: 0, - height: 0 - }, - buildPath: function (path, shape) { - var cx = shape.cx; - var cy = shape.cy; - var width = shape.width / 2; - var height = shape.height / 2; - path.moveTo(cx, cy - height); - path.lineTo(cx + width, cy); - path.lineTo(cx, cy + height); - path.lineTo(cx - width, cy); - path.closePath(); - } -}); -/** - * Pin shape - * @inner - */ -var Pin = Path.extend({ - type: 'pin', - shape: { - // x, y on the cusp - x: 0, - y: 0, - width: 0, - height: 0 - }, - buildPath: function (path, shape) { - var x = shape.x; - var y = shape.y; - var w = shape.width / 5 * 3; - // Height must be larger than width - var h = Math.max(w, shape.height); - var r = w / 2; - // Dist on y with tangent point and circle center - var dy = r * r / (h - r); - var cy = y - h + r + dy; - var angle = Math.asin(dy / r); - // Dist on x with tangent point and circle center - var dx = Math.cos(angle) * r; - var tanX = Math.sin(angle); - var tanY = Math.cos(angle); - var cpLen = r * 0.6; - var cpLen2 = r * 0.7; - path.moveTo(x - dx, cy + dy); - path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle); - path.bezierCurveTo(x + dx - tanX * cpLen, cy + dy + tanY * cpLen, x, y - cpLen2, x, y); - path.bezierCurveTo(x, y - cpLen2, x - dx + tanX * cpLen, cy + dy + tanY * cpLen, x - dx, cy + dy); - path.closePath(); - } -}); -/** - * Arrow shape - * @inner - */ -var Arrow = Path.extend({ - type: 'arrow', - shape: { - x: 0, - y: 0, - width: 0, - height: 0 - }, - buildPath: function (ctx, shape) { - var height = shape.height; - var width = shape.width; - var x = shape.x; - var y = shape.y; - var dx = width / 3 * 2; - ctx.moveTo(x, y); - ctx.lineTo(x + dx, y + height); - ctx.lineTo(x, y + height / 4 * 3); - ctx.lineTo(x - dx, y + height); - ctx.lineTo(x, y); - ctx.closePath(); - } -}); -/** - * Map of path constructors - */ -// TODO Use function to build symbol path. -var symbolCtors = { - line: Line, - rect: Rect, - roundRect: Rect, - square: Rect, - circle: Circle, - diamond: Diamond, - pin: Pin, - arrow: Arrow, - triangle: Triangle -}; -var symbolShapeMakers = { - line: function (x, y, w, h, shape) { - shape.x1 = x; - shape.y1 = y + h / 2; - shape.x2 = x + w; - shape.y2 = y + h / 2; - }, - rect: function (x, y, w, h, shape) { - shape.x = x; - shape.y = y; - shape.width = w; - shape.height = h; - }, - roundRect: function (x, y, w, h, shape) { - shape.x = x; - shape.y = y; - shape.width = w; - shape.height = h; - shape.r = Math.min(w, h) / 4; - }, - square: function (x, y, w, h, shape) { - var size = Math.min(w, h); - shape.x = x; - shape.y = y; - shape.width = size; - shape.height = size; - }, - circle: function (x, y, w, h, shape) { - // Put circle in the center of square - shape.cx = x + w / 2; - shape.cy = y + h / 2; - shape.r = Math.min(w, h) / 2; - }, - diamond: function (x, y, w, h, shape) { - shape.cx = x + w / 2; - shape.cy = y + h / 2; - shape.width = w; - shape.height = h; - }, - pin: function (x, y, w, h, shape) { - shape.x = x + w / 2; - shape.y = y + h / 2; - shape.width = w; - shape.height = h; - }, - arrow: function (x, y, w, h, shape) { - shape.x = x + w / 2; - shape.y = y + h / 2; - shape.width = w; - shape.height = h; - }, - triangle: function (x, y, w, h, shape) { - shape.cx = x + w / 2; - shape.cy = y + h / 2; - shape.width = w; - shape.height = h; - } -}; -var symbolBuildProxies = {}; -each$4(symbolCtors, function (Ctor, name) { - symbolBuildProxies[name] = new Ctor(); -}); -var SymbolClz = Path.extend({ - type: 'symbol', - shape: { - symbolType: '', - x: 0, - y: 0, - width: 0, - height: 0 - }, - calculateTextPosition: function (out, config, rect) { - var res = calculateTextPosition(out, config, rect); - var shape = this.shape; - if (shape && shape.symbolType === 'pin' && config.position === 'inside') { - res.y = rect.y + rect.height * 0.4; - } - return res; - }, - buildPath: function (ctx, shape, inBundle) { - var symbolType = shape.symbolType; - if (symbolType !== 'none') { - var proxySymbol = symbolBuildProxies[symbolType]; - if (!proxySymbol) { - // Default rect - symbolType = 'rect'; - proxySymbol = symbolBuildProxies[symbolType]; - } - symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape); - proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle); - } - } -}); -// Provide setColor helper method to avoid determine if set the fill or stroke outside -function symbolPathSetColor(color, innerColor) { - if (this.type !== 'image') { - var symbolStyle = this.style; - if (this.__isEmptyBrush) { - symbolStyle.stroke = color; - symbolStyle.fill = innerColor || '#fff'; - // TODO Same width with lineStyle in LineView - symbolStyle.lineWidth = 2; - } else if (this.shape.symbolType === 'line') { - symbolStyle.stroke = color; - } else { - symbolStyle.fill = color; - } - this.markRedraw(); - } -} -/** - * Create a symbol element with given symbol configuration: shape, x, y, width, height, color - */ -function createSymbol(symbolType, x, y, w, h, color, -// whether to keep the ratio of w/h, -keepAspect) { - // TODO Support image object, DynamicImage. - var isEmpty = symbolType.indexOf('empty') === 0; - if (isEmpty) { - symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6); - } - var symbolPath; - if (symbolType.indexOf('image://') === 0) { - symbolPath = makeImage(symbolType.slice(8), new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover'); - } else if (symbolType.indexOf('path://') === 0) { - symbolPath = makePath(symbolType.slice(7), {}, new BoundingRect(x, y, w, h), keepAspect ? 'center' : 'cover'); - } else { - symbolPath = new SymbolClz({ - shape: { - symbolType: symbolType, - x: x, - y: y, - width: w, - height: h - } - }); - } - symbolPath.__isEmptyBrush = isEmpty; - // TODO Should deprecate setColor - symbolPath.setColor = symbolPathSetColor; - if (color) { - symbolPath.setColor(color); - } - return symbolPath; -} -function normalizeSymbolSize(symbolSize) { - if (!isArray(symbolSize)) { - symbolSize = [+symbolSize, +symbolSize]; - } - return [symbolSize[0] || 0, symbolSize[1] || 0]; -} -function normalizeSymbolOffset(symbolOffset, symbolSize) { - if (symbolOffset == null) { - return; - } - if (!isArray(symbolOffset)) { - symbolOffset = [symbolOffset, symbolOffset]; - } - return [parsePercent(symbolOffset[0], symbolSize[0]) || 0, parsePercent(retrieve2(symbolOffset[1], symbolOffset[0]), symbolSize[1]) || 0]; -} - -function isSafeNum(num) { - return isFinite(num); -} -function createLinearGradient(ctx, obj, rect) { - var x = obj.x == null ? 0 : obj.x; - var x2 = obj.x2 == null ? 1 : obj.x2; - var y = obj.y == null ? 0 : obj.y; - var y2 = obj.y2 == null ? 0 : obj.y2; - if (!obj.global) { - x = x * rect.width + rect.x; - x2 = x2 * rect.width + rect.x; - y = y * rect.height + rect.y; - y2 = y2 * rect.height + rect.y; - } - x = isSafeNum(x) ? x : 0; - x2 = isSafeNum(x2) ? x2 : 1; - y = isSafeNum(y) ? y : 0; - y2 = isSafeNum(y2) ? y2 : 0; - var canvasGradient = ctx.createLinearGradient(x, y, x2, y2); - return canvasGradient; -} -function createRadialGradient(ctx, obj, rect) { - var width = rect.width; - var height = rect.height; - var min = Math.min(width, height); - var x = obj.x == null ? 0.5 : obj.x; - var y = obj.y == null ? 0.5 : obj.y; - var r = obj.r == null ? 0.5 : obj.r; - if (!obj.global) { - x = x * width + rect.x; - y = y * height + rect.y; - r = r * min; - } - x = isSafeNum(x) ? x : 0.5; - y = isSafeNum(y) ? y : 0.5; - r = r >= 0 && isSafeNum(r) ? r : 0.5; - var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r); - return canvasGradient; -} -function getCanvasGradient(ctx, obj, rect) { - var canvasGradient = obj.type === 'radial' - ? createRadialGradient(ctx, obj, rect) - : createLinearGradient(ctx, obj, rect); - var colorStops = obj.colorStops; - for (var i = 0; i < colorStops.length; i++) { - canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color); - } - return canvasGradient; -} -function isClipPathChanged(clipPaths, prevClipPaths) { - if (clipPaths === prevClipPaths || (!clipPaths && !prevClipPaths)) { - return false; - } - if (!clipPaths || !prevClipPaths || (clipPaths.length !== prevClipPaths.length)) { - return true; - } - for (var i = 0; i < clipPaths.length; i++) { - if (clipPaths[i] !== prevClipPaths[i]) { - return true; - } - } - return false; -} -function parseInt10(val) { - return parseInt(val, 10); -} -function getSize(root, whIdx, opts) { - var wh = ['width', 'height'][whIdx]; - var cwh = ['clientWidth', 'clientHeight'][whIdx]; - var plt = ['paddingLeft', 'paddingTop'][whIdx]; - var prb = ['paddingRight', 'paddingBottom'][whIdx]; - if (opts[wh] != null && opts[wh] !== 'auto') { - return parseFloat(opts[wh]); - } - var stl = document.defaultView.getComputedStyle(root); - return ((root[cwh] || parseInt10(stl[wh]) || parseInt10(root.style[wh])) - - (parseInt10(stl[plt]) || 0) - - (parseInt10(stl[prb]) || 0)) | 0; -} - -function normalizeLineDash(lineType, lineWidth) { - if (!lineType || lineType === 'solid' || !(lineWidth > 0)) { - return null; - } - return lineType === 'dashed' - ? [4 * lineWidth, 2 * lineWidth] - : lineType === 'dotted' - ? [lineWidth] - : isNumber(lineType) - ? [lineType] : isArray(lineType) ? lineType : null; -} -function getLineDash(el) { - var style = el.style; - var lineDash = style.lineDash && style.lineWidth > 0 && normalizeLineDash(style.lineDash, style.lineWidth); - var lineDashOffset = style.lineDashOffset; - if (lineDash) { - var lineScale_1 = (style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1; - if (lineScale_1 && lineScale_1 !== 1) { - lineDash = map$1(lineDash, function (rawVal) { - return rawVal / lineScale_1; - }); - lineDashOffset /= lineScale_1; - } - } - return [lineDash, lineDashOffset]; -} - -var pathProxyForDraw = new PathProxy(true); -function styleHasStroke(style) { - var stroke = style.stroke; - return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0)); -} -function isValidStrokeFillStyle(strokeOrFill) { - return typeof strokeOrFill === 'string' && strokeOrFill !== 'none'; -} -function styleHasFill(style) { - var fill = style.fill; - return fill != null && fill !== 'none'; -} -function doFillPath(ctx, style) { - if (style.fillOpacity != null && style.fillOpacity !== 1) { - var originalGlobalAlpha = ctx.globalAlpha; - ctx.globalAlpha = style.fillOpacity * style.opacity; - ctx.fill(); - ctx.globalAlpha = originalGlobalAlpha; - } - else { - ctx.fill(); - } -} -function doStrokePath(ctx, style) { - if (style.strokeOpacity != null && style.strokeOpacity !== 1) { - var originalGlobalAlpha = ctx.globalAlpha; - ctx.globalAlpha = style.strokeOpacity * style.opacity; - ctx.stroke(); - ctx.globalAlpha = originalGlobalAlpha; - } - else { - ctx.stroke(); - } -} -function createCanvasPattern(ctx, pattern, el) { - var image = createOrUpdateImage(pattern.image, pattern.__image, el); - if (isImageReady(image)) { - var canvasPattern = ctx.createPattern(image, pattern.repeat || 'repeat'); - if (typeof DOMMatrix === 'function' - && canvasPattern - && canvasPattern.setTransform) { - var matrix = new DOMMatrix(); - matrix.translateSelf((pattern.x || 0), (pattern.y || 0)); - matrix.rotateSelf(0, 0, (pattern.rotation || 0) * RADIAN_TO_DEGREE); - matrix.scaleSelf((pattern.scaleX || 1), (pattern.scaleY || 1)); - canvasPattern.setTransform(matrix); - } - return canvasPattern; - } -} -function brushPath(ctx, el, style, inBatch) { - var _a; - var hasStroke = styleHasStroke(style); - var hasFill = styleHasFill(style); - var strokePercent = style.strokePercent; - var strokePart = strokePercent < 1; - var firstDraw = !el.path; - if ((!el.silent || strokePart) && firstDraw) { - el.createPathProxy(); - } - var path = el.path || pathProxyForDraw; - var dirtyFlag = el.__dirty; - if (!inBatch) { - var fill = style.fill; - var stroke = style.stroke; - var hasFillGradient = hasFill && !!fill.colorStops; - var hasStrokeGradient = hasStroke && !!stroke.colorStops; - var hasFillPattern = hasFill && !!fill.image; - var hasStrokePattern = hasStroke && !!stroke.image; - var fillGradient = void 0; - var strokeGradient = void 0; - var fillPattern = void 0; - var strokePattern = void 0; - var rect = void 0; - if (hasFillGradient || hasStrokeGradient) { - rect = el.getBoundingRect(); - } - if (hasFillGradient) { - fillGradient = dirtyFlag - ? getCanvasGradient(ctx, fill, rect) - : el.__canvasFillGradient; - el.__canvasFillGradient = fillGradient; - } - if (hasStrokeGradient) { - strokeGradient = dirtyFlag - ? getCanvasGradient(ctx, stroke, rect) - : el.__canvasStrokeGradient; - el.__canvasStrokeGradient = strokeGradient; - } - if (hasFillPattern) { - fillPattern = (dirtyFlag || !el.__canvasFillPattern) - ? createCanvasPattern(ctx, fill, el) - : el.__canvasFillPattern; - el.__canvasFillPattern = fillPattern; - } - if (hasStrokePattern) { - strokePattern = (dirtyFlag || !el.__canvasStrokePattern) - ? createCanvasPattern(ctx, stroke, el) - : el.__canvasStrokePattern; - el.__canvasStrokePattern = fillPattern; - } - if (hasFillGradient) { - ctx.fillStyle = fillGradient; - } - else if (hasFillPattern) { - if (fillPattern) { - ctx.fillStyle = fillPattern; - } - else { - hasFill = false; - } - } - if (hasStrokeGradient) { - ctx.strokeStyle = strokeGradient; - } - else if (hasStrokePattern) { - if (strokePattern) { - ctx.strokeStyle = strokePattern; - } - else { - hasStroke = false; - } - } - } - var scale = el.getGlobalScale(); - path.setScale(scale[0], scale[1], el.segmentIgnoreThreshold); - var lineDash; - var lineDashOffset; - if (ctx.setLineDash && style.lineDash) { - _a = getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1]; - } - var needsRebuild = true; - if (firstDraw || (dirtyFlag & SHAPE_CHANGED_BIT)) { - path.setDPR(ctx.dpr); - if (strokePart) { - path.setContext(null); - } - else { - path.setContext(ctx); - needsRebuild = false; - } - path.reset(); - el.buildPath(path, el.shape, inBatch); - path.toStatic(); - el.pathUpdated(); - } - if (needsRebuild) { - path.rebuildPath(ctx, strokePart ? strokePercent : 1); - } - if (lineDash) { - ctx.setLineDash(lineDash); - ctx.lineDashOffset = lineDashOffset; - } - if (!inBatch) { - if (style.strokeFirst) { - if (hasStroke) { - doStrokePath(ctx, style); - } - if (hasFill) { - doFillPath(ctx, style); - } - } - else { - if (hasFill) { - doFillPath(ctx, style); - } - if (hasStroke) { - doStrokePath(ctx, style); - } - } - } - if (lineDash) { - ctx.setLineDash([]); - } -} -function brushImage(ctx, el, style) { - var image = el.__image = createOrUpdateImage(style.image, el.__image, el, el.onload); - if (!image || !isImageReady(image)) { - return; - } - var x = style.x || 0; - var y = style.y || 0; - var width = el.getWidth(); - var height = el.getHeight(); - var aspect = image.width / image.height; - if (width == null && height != null) { - width = height * aspect; - } - else if (height == null && width != null) { - height = width / aspect; - } - else if (width == null && height == null) { - width = image.width; - height = image.height; - } - if (style.sWidth && style.sHeight) { - var sx = style.sx || 0; - var sy = style.sy || 0; - ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height); - } - else if (style.sx && style.sy) { - var sx = style.sx; - var sy = style.sy; - var sWidth = width - sx; - var sHeight = height - sy; - ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height); - } - else { - ctx.drawImage(image, x, y, width, height); - } -} -function brushText(ctx, el, style) { - var _a; - var text = style.text; - text != null && (text += ''); - if (text) { - ctx.font = style.font || DEFAULT_FONT; - ctx.textAlign = style.textAlign; - ctx.textBaseline = style.textBaseline; - var lineDash = void 0; - var lineDashOffset = void 0; - if (ctx.setLineDash && style.lineDash) { - _a = getLineDash(el), lineDash = _a[0], lineDashOffset = _a[1]; - } - if (lineDash) { - ctx.setLineDash(lineDash); - ctx.lineDashOffset = lineDashOffset; - } - if (style.strokeFirst) { - if (styleHasStroke(style)) { - ctx.strokeText(text, style.x, style.y); - } - if (styleHasFill(style)) { - ctx.fillText(text, style.x, style.y); - } - } - else { - if (styleHasFill(style)) { - ctx.fillText(text, style.x, style.y); - } - if (styleHasStroke(style)) { - ctx.strokeText(text, style.x, style.y); - } - } - if (lineDash) { - ctx.setLineDash([]); - } - } -} -var SHADOW_NUMBER_PROPS = ['shadowBlur', 'shadowOffsetX', 'shadowOffsetY']; -var STROKE_PROPS = [ - ['lineCap', 'butt'], ['lineJoin', 'miter'], ['miterLimit', 10] -]; -function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) { - var styleChanged = false; - if (!forceSetAll) { - prevStyle = prevStyle || {}; - if (style === prevStyle) { - return false; - } - } - if (forceSetAll || style.opacity !== prevStyle.opacity) { - flushPathDrawn(ctx, scope); - styleChanged = true; - var opacity = Math.max(Math.min(style.opacity, 1), 0); - ctx.globalAlpha = isNaN(opacity) ? DEFAULT_COMMON_STYLE.opacity : opacity; - } - if (forceSetAll || style.blend !== prevStyle.blend) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend; - } - for (var i = 0; i < SHADOW_NUMBER_PROPS.length; i++) { - var propName = SHADOW_NUMBER_PROPS[i]; - if (forceSetAll || style[propName] !== prevStyle[propName]) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx[propName] = ctx.dpr * (style[propName] || 0); - } - } - if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor; - } - return styleChanged; -} -function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) { - var style = getStyle(el, scope.inHover); - var prevStyle = forceSetAll - ? null - : (prevEl && getStyle(prevEl, scope.inHover) || {}); - if (style === prevStyle) { - return false; - } - var styleChanged = bindCommonProps(ctx, style, prevStyle, forceSetAll, scope); - if (forceSetAll || style.fill !== prevStyle.fill) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - isValidStrokeFillStyle(style.fill) && (ctx.fillStyle = style.fill); - } - if (forceSetAll || style.stroke !== prevStyle.stroke) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - isValidStrokeFillStyle(style.stroke) && (ctx.strokeStyle = style.stroke); - } - if (forceSetAll || style.opacity !== prevStyle.opacity) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx.globalAlpha = style.opacity == null ? 1 : style.opacity; - } - if (el.hasStroke()) { - var lineWidth = style.lineWidth; - var newLineWidth = lineWidth / ((style.strokeNoScale && el.getLineScale) ? el.getLineScale() : 1); - if (ctx.lineWidth !== newLineWidth) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx.lineWidth = newLineWidth; - } - } - for (var i = 0; i < STROKE_PROPS.length; i++) { - var prop = STROKE_PROPS[i]; - var propName = prop[0]; - if (forceSetAll || style[propName] !== prevStyle[propName]) { - if (!styleChanged) { - flushPathDrawn(ctx, scope); - styleChanged = true; - } - ctx[propName] = style[propName] || prop[1]; - } - } - return styleChanged; -} -function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) { - return bindCommonProps(ctx, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope); -} -function setContextTransform(ctx, el) { - var m = el.transform; - var dpr = ctx.dpr || 1; - if (m) { - ctx.setTransform(dpr * m[0], dpr * m[1], dpr * m[2], dpr * m[3], dpr * m[4], dpr * m[5]); - } - else { - ctx.setTransform(dpr, 0, 0, dpr, 0, 0); - } -} -function updateClipStatus(clipPaths, ctx, scope) { - var allClipped = false; - for (var i = 0; i < clipPaths.length; i++) { - var clipPath = clipPaths[i]; - allClipped = allClipped || clipPath.isZeroArea(); - setContextTransform(ctx, clipPath); - ctx.beginPath(); - clipPath.buildPath(ctx, clipPath.shape); - ctx.clip(); - } - scope.allClipped = allClipped; -} -function isTransformChanged(m0, m1) { - if (m0 && m1) { - return m0[0] !== m1[0] - || m0[1] !== m1[1] - || m0[2] !== m1[2] - || m0[3] !== m1[3] - || m0[4] !== m1[4] - || m0[5] !== m1[5]; - } - else if (!m0 && !m1) { - return false; - } - return true; -} -var DRAW_TYPE_PATH = 1; -var DRAW_TYPE_IMAGE = 2; -var DRAW_TYPE_TEXT = 3; -var DRAW_TYPE_INCREMENTAL = 4; -function canPathBatch(style) { - var hasFill = styleHasFill(style); - var hasStroke = styleHasStroke(style); - return !(style.lineDash - || !(+hasFill ^ +hasStroke) - || (hasFill && typeof style.fill !== 'string') - || (hasStroke && typeof style.stroke !== 'string') - || style.strokePercent < 1 - || style.strokeOpacity < 1 - || style.fillOpacity < 1); -} -function flushPathDrawn(ctx, scope) { - scope.batchFill && ctx.fill(); - scope.batchStroke && ctx.stroke(); - scope.batchFill = ''; - scope.batchStroke = ''; -} -function getStyle(el, inHover) { - return inHover ? (el.__hoverStyle || el.style) : el.style; -} -function brushSingle(ctx, el) { - brush(ctx, el, { inHover: false, viewWidth: 0, viewHeight: 0 }, true); -} -function brush(ctx, el, scope, isLast) { - var m = el.transform; - if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) { - el.__dirty &= -2; - el.__isRendered = false; - return; - } - var clipPaths = el.__clipPaths; - var prevElClipPaths = scope.prevElClipPaths; - var forceSetTransform = false; - var forceSetStyle = false; - if (!prevElClipPaths || isClipPathChanged(clipPaths, prevElClipPaths)) { - if (prevElClipPaths && prevElClipPaths.length) { - flushPathDrawn(ctx, scope); - ctx.restore(); - forceSetStyle = forceSetTransform = true; - scope.prevElClipPaths = null; - scope.allClipped = false; - scope.prevEl = null; - } - if (clipPaths && clipPaths.length) { - flushPathDrawn(ctx, scope); - ctx.save(); - updateClipStatus(clipPaths, ctx, scope); - forceSetTransform = true; - } - scope.prevElClipPaths = clipPaths; - } - if (scope.allClipped) { - el.__isRendered = false; - return; - } - el.beforeBrush && el.beforeBrush(); - el.innerBeforeBrush(); - var prevEl = scope.prevEl; - if (!prevEl) { - forceSetStyle = forceSetTransform = true; - } - var canBatchPath = el instanceof Path - && el.autoBatch - && canPathBatch(el.style); - if (forceSetTransform || isTransformChanged(m, prevEl.transform)) { - flushPathDrawn(ctx, scope); - setContextTransform(ctx, el); - } - else if (!canBatchPath) { - flushPathDrawn(ctx, scope); - } - var style = getStyle(el, scope.inHover); - if (el instanceof Path) { - if (scope.lastDrawType !== DRAW_TYPE_PATH) { - forceSetStyle = true; - scope.lastDrawType = DRAW_TYPE_PATH; - } - bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope); - if (!canBatchPath || (!scope.batchFill && !scope.batchStroke)) { - ctx.beginPath(); - } - brushPath(ctx, el, style, canBatchPath); - if (canBatchPath) { - scope.batchFill = style.fill || ''; - scope.batchStroke = style.stroke || ''; - } - } - else { - if (el instanceof TSpan) { - if (scope.lastDrawType !== DRAW_TYPE_TEXT) { - forceSetStyle = true; - scope.lastDrawType = DRAW_TYPE_TEXT; - } - bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope); - brushText(ctx, el, style); - } - else if (el instanceof ZRImage) { - if (scope.lastDrawType !== DRAW_TYPE_IMAGE) { - forceSetStyle = true; - scope.lastDrawType = DRAW_TYPE_IMAGE; - } - bindImageStyle(ctx, el, prevEl, forceSetStyle, scope); - brushImage(ctx, el, style); - } - else if (el.getTemporalDisplayables) { - if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) { - forceSetStyle = true; - scope.lastDrawType = DRAW_TYPE_INCREMENTAL; - } - brushIncremental(ctx, el, scope); - } - } - if (canBatchPath && isLast) { - flushPathDrawn(ctx, scope); - } - el.innerAfterBrush(); - el.afterBrush && el.afterBrush(); - scope.prevEl = el; - el.__dirty = 0; - el.__isRendered = true; -} -function brushIncremental(ctx, el, scope) { - var displayables = el.getDisplayables(); - var temporalDisplayables = el.getTemporalDisplayables(); - ctx.save(); - var innerScope = { - prevElClipPaths: null, - prevEl: null, - allClipped: false, - viewWidth: scope.viewWidth, - viewHeight: scope.viewHeight, - inHover: scope.inHover - }; - var i; - var len; - for (i = el.getCursor(), len = displayables.length; i < len; i++) { - var displayable = displayables[i]; - displayable.beforeBrush && displayable.beforeBrush(); - displayable.innerBeforeBrush(); - brush(ctx, displayable, innerScope, i === len - 1); - displayable.innerAfterBrush(); - displayable.afterBrush && displayable.afterBrush(); - innerScope.prevEl = displayable; - } - for (var i_1 = 0, len_1 = temporalDisplayables.length; i_1 < len_1; i_1++) { - var displayable = temporalDisplayables[i_1]; - displayable.beforeBrush && displayable.beforeBrush(); - displayable.innerBeforeBrush(); - brush(ctx, displayable, innerScope, i_1 === len_1 - 1); - displayable.innerAfterBrush(); - displayable.afterBrush && displayable.afterBrush(); - innerScope.prevEl = displayable; - } - el.clearTemporalDisplayables(); - el.notClear = true; - ctx.restore(); -} - -var decalMap = new WeakMap(); -var decalCache = new LRU(100); -var decalKeys = ["symbol", "symbolSize", "symbolKeepAspect", "color", "backgroundColor", "dashArrayX", "dashArrayY", "maxTileWidth", "maxTileHeight"]; -function createOrUpdatePatternFromDecal(decalObject, api) { - if (decalObject === "none") { - return null; - } - var dpr = api.getDevicePixelRatio(); - var zr = api.getZr(); - var isSVG = zr.painter.type === "svg"; - if (decalObject.dirty) { - decalMap["delete"](decalObject); - } - var oldPattern = decalMap.get(decalObject); - if (oldPattern) { - return oldPattern; - } - var decalOpt = defaults(decalObject, { - symbol: "rect", - symbolSize: 1, - symbolKeepAspect: true, - color: "rgba(0, 0, 0, 0.2)", - backgroundColor: null, - dashArrayX: 5, - dashArrayY: 5, - rotation: 0, - maxTileWidth: 512, - maxTileHeight: 512 - }); - if (decalOpt.backgroundColor === "none") { - decalOpt.backgroundColor = null; - } - var pattern = { - repeat: "repeat" - }; - setPatternnSource(pattern); - pattern.rotation = decalOpt.rotation; - pattern.scaleX = pattern.scaleY = isSVG ? 1 : 1 / dpr; - decalMap.set(decalObject, pattern); - decalObject.dirty = false; - return pattern; - function setPatternnSource(pattern2) { - var keys = [dpr]; - var isValidKey = true; - for (var i = 0; i < decalKeys.length; ++i) { - var value = decalOpt[decalKeys[i]]; - if (value != null && !isArray(value) && !isString(value) && !isNumber(value) && typeof value !== "boolean") { - isValidKey = false; - break; - } - keys.push(value); - } - var cacheKey; - if (isValidKey) { - cacheKey = keys.join(",") + (isSVG ? "-svg" : ""); - var cache = decalCache.get(cacheKey); - if (cache) { - isSVG ? pattern2.svgElement = cache : pattern2.image = cache; - } - } - var dashArrayX = normalizeDashArrayX(decalOpt.dashArrayX); - var dashArrayY = normalizeDashArrayY(decalOpt.dashArrayY); - var symbolArray = normalizeSymbolArray(decalOpt.symbol); - var lineBlockLengthsX = getLineBlockLengthX(dashArrayX); - var lineBlockLengthY = getLineBlockLengthY(dashArrayY); - var canvas = !isSVG && platformApi.createCanvas(); - var svgRoot = isSVG && { - tag: "g", - attrs: {}, - key: "dcl", - children: [] - }; - var pSize = getPatternSize(); - var ctx; - if (canvas) { - canvas.width = pSize.width * dpr; - canvas.height = pSize.height * dpr; - ctx = canvas.getContext("2d"); - } - brushDecal(); - if (isValidKey) { - decalCache.put(cacheKey, canvas || svgRoot); - } - pattern2.image = canvas; - pattern2.svgElement = svgRoot; - pattern2.svgWidth = pSize.width; - pattern2.svgHeight = pSize.height; - function getPatternSize() { - var width = 1; - for (var i2 = 0, xlen = lineBlockLengthsX.length; i2 < xlen; ++i2) { - width = getLeastCommonMultiple(width, lineBlockLengthsX[i2]); - } - var symbolRepeats = 1; - for (var i2 = 0, xlen = symbolArray.length; i2 < xlen; ++i2) { - symbolRepeats = getLeastCommonMultiple(symbolRepeats, symbolArray[i2].length); - } - width *= symbolRepeats; - var height = lineBlockLengthY * lineBlockLengthsX.length * symbolArray.length; - return { - width: Math.max(1, Math.min(width, decalOpt.maxTileWidth)), - height: Math.max(1, Math.min(height, decalOpt.maxTileHeight)) - }; - } - function brushDecal() { - if (ctx) { - ctx.clearRect(0, 0, canvas.width, canvas.height); - if (decalOpt.backgroundColor) { - ctx.fillStyle = decalOpt.backgroundColor; - ctx.fillRect(0, 0, canvas.width, canvas.height); - } - } - var ySum = 0; - for (var i2 = 0; i2 < dashArrayY.length; ++i2) { - ySum += dashArrayY[i2]; - } - if (ySum <= 0) { - return; - } - var y = -lineBlockLengthY; - var yId = 0; - var yIdTotal = 0; - var xId0 = 0; - while (y < pSize.height) { - if (yId % 2 === 0) { - var symbolYId = yIdTotal / 2 % symbolArray.length; - var x = 0; - var xId1 = 0; - var xId1Total = 0; - while (x < pSize.width * 2) { - var xSum = 0; - for (var i2 = 0; i2 < dashArrayX[xId0].length; ++i2) { - xSum += dashArrayX[xId0][i2]; - } - if (xSum <= 0) { - break; - } - if (xId1 % 2 === 0) { - var size = (1 - decalOpt.symbolSize) * 0.5; - var left = x + dashArrayX[xId0][xId1] * size; - var top_1 = y + dashArrayY[yId] * size; - var width = dashArrayX[xId0][xId1] * decalOpt.symbolSize; - var height = dashArrayY[yId] * decalOpt.symbolSize; - var symbolXId = xId1Total / 2 % symbolArray[symbolYId].length; - brushSymbol(left, top_1, width, height, symbolArray[symbolYId][symbolXId]); - } - x += dashArrayX[xId0][xId1]; - ++xId1Total; - ++xId1; - if (xId1 === dashArrayX[xId0].length) { - xId1 = 0; - } - } - ++xId0; - if (xId0 === dashArrayX.length) { - xId0 = 0; - } - } - y += dashArrayY[yId]; - ++yIdTotal; - ++yId; - if (yId === dashArrayY.length) { - yId = 0; - } - } - function brushSymbol(x2, y2, width2, height2, symbolType) { - var scale = isSVG ? 1 : dpr; - var symbol = createSymbol(symbolType, x2 * scale, y2 * scale, width2 * scale, height2 * scale, decalOpt.color, decalOpt.symbolKeepAspect); - if (isSVG) { - var symbolVNode = zr.painter.renderOneToVNode(symbol); - if (symbolVNode) { - svgRoot.children.push(symbolVNode); - } - } else { - brushSingle(ctx, symbol); - } - } - } - } -} -function normalizeSymbolArray(symbol) { - if (!symbol || symbol.length === 0) { - return [["rect"]]; - } - if (isString(symbol)) { - return [[symbol]]; - } - var isAllString = true; - for (var i = 0; i < symbol.length; ++i) { - if (!isString(symbol[i])) { - isAllString = false; - break; - } - } - if (isAllString) { - return normalizeSymbolArray([symbol]); - } - var result = []; - for (var i = 0; i < symbol.length; ++i) { - if (isString(symbol[i])) { - result.push([symbol[i]]); - } else { - result.push(symbol[i]); - } - } - return result; -} -function normalizeDashArrayX(dash) { - if (!dash || dash.length === 0) { - return [[0, 0]]; - } - if (isNumber(dash)) { - var dashValue = Math.ceil(dash); - return [[dashValue, dashValue]]; - } - var isAllNumber = true; - for (var i = 0; i < dash.length; ++i) { - if (!isNumber(dash[i])) { - isAllNumber = false; - break; - } - } - if (isAllNumber) { - return normalizeDashArrayX([dash]); - } - var result = []; - for (var i = 0; i < dash.length; ++i) { - if (isNumber(dash[i])) { - var dashValue = Math.ceil(dash[i]); - result.push([dashValue, dashValue]); - } else { - var dashValue = map$1(dash[i], function(n) { - return Math.ceil(n); - }); - if (dashValue.length % 2 === 1) { - result.push(dashValue.concat(dashValue)); - } else { - result.push(dashValue); - } - } - } - return result; -} -function normalizeDashArrayY(dash) { - if (!dash || typeof dash === "object" && dash.length === 0) { - return [0, 0]; - } - if (isNumber(dash)) { - var dashValue_1 = Math.ceil(dash); - return [dashValue_1, dashValue_1]; - } - var dashValue = map$1(dash, function(n) { - return Math.ceil(n); - }); - return dash.length % 2 ? dashValue.concat(dashValue) : dashValue; -} -function getLineBlockLengthX(dash) { - return map$1(dash, function(line) { - return getLineBlockLengthY(line); - }); -} -function getLineBlockLengthY(dash) { - var blockLength = 0; - for (var i = 0; i < dash.length; ++i) { - blockLength += dash[i]; - } - if (dash.length % 2 === 1) { - return blockLength * 2; - } - return blockLength; -} - -function decalVisual(ecModel, api) { - ecModel.eachRawSeries(function (seriesModel) { - if (ecModel.isSeriesFiltered(seriesModel)) { - return; - } - var data = seriesModel.getData(); - if (data.hasItemVisual()) { - data.each(function (idx) { - var decal = data.getItemVisual(idx, 'decal'); - if (decal) { - var itemStyle = data.ensureUniqueItemVisual(idx, 'style'); - itemStyle.decal = createOrUpdatePatternFromDecal(decal, api); - } - }); - } - var decal = data.getVisual('decal'); - if (decal) { - var style = data.getVisual('style'); - style.decal = createOrUpdatePatternFromDecal(decal, api); - } - }); -} - -var lifecycle = new Eventful(); - -var implsStore = {}; -function registerImpl(name, impl) { - implsStore[name] = impl; -} -function getImpl(name) { - return implsStore[name]; -} - -var TEST_FRAME_REMAIN_TIME = 1; -var PRIORITY_PROCESSOR_SERIES_FILTER = 800; -var PRIORITY_PROCESSOR_DATASTACK = 900; -var PRIORITY_PROCESSOR_FILTER = 1e3; -var PRIORITY_PROCESSOR_DEFAULT = 2e3; -var PRIORITY_PROCESSOR_STATISTIC = 5e3; -var PRIORITY_VISUAL_LAYOUT = 1e3; -var PRIORITY_VISUAL_PROGRESSIVE_LAYOUT = 1100; -var PRIORITY_VISUAL_GLOBAL = 2e3; -var PRIORITY_VISUAL_CHART = 3e3; -var PRIORITY_VISUAL_COMPONENT = 4e3; -var PRIORITY_VISUAL_CHART_DATA_CUSTOM = 4500; -var PRIORITY_VISUAL_POST_CHART_LAYOUT = 4600; -var PRIORITY_VISUAL_BRUSH = 5e3; -var PRIORITY_VISUAL_ARIA = 6e3; -var PRIORITY_VISUAL_DECAL = 7e3; -var PRIORITY = { - PROCESSOR: { - FILTER: PRIORITY_PROCESSOR_FILTER, - SERIES_FILTER: PRIORITY_PROCESSOR_SERIES_FILTER, - STATISTIC: PRIORITY_PROCESSOR_STATISTIC - }, - VISUAL: { - LAYOUT: PRIORITY_VISUAL_LAYOUT, - PROGRESSIVE_LAYOUT: PRIORITY_VISUAL_PROGRESSIVE_LAYOUT, - GLOBAL: PRIORITY_VISUAL_GLOBAL, - CHART: PRIORITY_VISUAL_CHART, - POST_CHART_LAYOUT: PRIORITY_VISUAL_POST_CHART_LAYOUT, - COMPONENT: PRIORITY_VISUAL_COMPONENT, - BRUSH: PRIORITY_VISUAL_BRUSH, - CHART_ITEM: PRIORITY_VISUAL_CHART_DATA_CUSTOM, - ARIA: PRIORITY_VISUAL_ARIA, - DECAL: PRIORITY_VISUAL_DECAL - } -}; -var IN_MAIN_PROCESS_KEY = "__flagInMainProcess"; -var PENDING_UPDATE = "__pendingUpdate"; -var STATUS_NEEDS_UPDATE_KEY = "__needsUpdateStatus"; -var ACTION_REG = /^[a-zA-Z0-9_]+$/; -var CONNECT_STATUS_KEY = "__connectUpdateStatus"; -var CONNECT_STATUS_PENDING = 0; -var CONNECT_STATUS_UPDATING = 1; -var CONNECT_STATUS_UPDATED = 2; -function createRegisterEventWithLowercaseECharts(method) { - return function() { - var args = []; - for (var _i = 0; _i < arguments.length; _i++) { - args[_i] = arguments[_i]; - } - if (this.isDisposed()) { - disposedWarning(this.id); - return; - } - return toLowercaseNameAndCallEventful(this, method, args); - }; -} -function createRegisterEventWithLowercaseMessageCenter(method) { - return function() { - var args = []; - for (var _i = 0; _i < arguments.length; _i++) { - args[_i] = arguments[_i]; - } - return toLowercaseNameAndCallEventful(this, method, args); - }; -} -function toLowercaseNameAndCallEventful(host, method, args) { - args[0] = args[0] && args[0].toLowerCase(); - return Eventful.prototype[method].apply(host, args); -} -var MessageCenter = ( - /** @class */ - function(_super) { - __extends(MessageCenter2, _super); - function MessageCenter2() { - return _super !== null && _super.apply(this, arguments) || this; - } - return MessageCenter2; - }(Eventful) -); -var messageCenterProto = MessageCenter.prototype; -messageCenterProto.on = createRegisterEventWithLowercaseMessageCenter("on"); -messageCenterProto.off = createRegisterEventWithLowercaseMessageCenter("off"); -var prepare; -var prepareView; -var updateDirectly; -var updateMethods; -var doConvertPixel; -var updateStreamModes; -var doDispatchAction; -var flushPendingActions; -var triggerUpdatedEvent; -var bindRenderedEvent; -var bindMouseEvent; -var render; -var renderComponents; -var renderSeries; -var createExtensionAPI; -var enableConnect; -var markStatusToUpdate; -var applyChangedStates; -var ECharts = ( - /** @class */ - function(_super) { - __extends(ECharts2, _super); - function ECharts2(dom, theme, opts) { - var _this = _super.call(this, new ECEventProcessor()) || this; - _this._chartsViews = []; - _this._chartsMap = {}; - _this._componentsViews = []; - _this._componentsMap = {}; - _this._pendingActions = []; - opts = opts || {}; - if (isString(theme)) { - theme = themeStorage[theme]; - } - _this._dom = dom; - var defaultRenderer = "canvas"; - var defaultCoarsePointer = "auto"; - var defaultUseDirtyRect = false; - if (opts.ssr) ; - var zr = _this._zr = init$1(dom, { - renderer: opts.renderer || defaultRenderer, - devicePixelRatio: opts.devicePixelRatio, - width: opts.width, - height: opts.height, - ssr: opts.ssr, - useDirtyRect: retrieve2(opts.useDirtyRect, defaultUseDirtyRect), - useCoarsePointer: retrieve2(opts.useCoarsePointer, defaultCoarsePointer), - pointerSize: opts.pointerSize - }); - _this._ssr = opts.ssr; - _this._throttledZrFlush = throttle(bind$1(zr.flush, zr), 17); - theme = clone$2(theme); - theme && globalBackwardCompat(theme, true); - _this._theme = theme; - _this._locale = createLocaleObject(opts.locale || SYSTEM_LANG); - _this._coordSysMgr = new CoordinateSystemManager(); - var api = _this._api = createExtensionAPI(_this); - function prioritySortFunc(a, b) { - return a.__prio - b.__prio; - } - sort(visualFuncs, prioritySortFunc); - sort(dataProcessorFuncs, prioritySortFunc); - _this._scheduler = new Scheduler(_this, api, dataProcessorFuncs, visualFuncs); - _this._messageCenter = new MessageCenter(); - _this._initEvents(); - _this.resize = bind$1(_this.resize, _this); - zr.animation.on("frame", _this._onframe, _this); - bindRenderedEvent(zr, _this); - bindMouseEvent(zr, _this); - setAsPrimitive(_this); - return _this; - } - ECharts2.prototype._onframe = function() { - if (this._disposed) { - return; - } - applyChangedStates(this); - var scheduler = this._scheduler; - if (this[PENDING_UPDATE]) { - var silent = this[PENDING_UPDATE].silent; - this[IN_MAIN_PROCESS_KEY] = true; - try { - prepare(this); - updateMethods.update.call(this, null, this[PENDING_UPDATE].updateParams); - } catch (e) { - this[IN_MAIN_PROCESS_KEY] = false; - this[PENDING_UPDATE] = null; - throw e; - } - this._zr.flush(); - this[IN_MAIN_PROCESS_KEY] = false; - this[PENDING_UPDATE] = null; - flushPendingActions.call(this, silent); - triggerUpdatedEvent.call(this, silent); - } else if (scheduler.unfinished) { - var remainTime = TEST_FRAME_REMAIN_TIME; - var ecModel = this._model; - var api = this._api; - scheduler.unfinished = false; - do { - var startTime = +/* @__PURE__ */ new Date(); - scheduler.performSeriesTasks(ecModel); - scheduler.performDataProcessorTasks(ecModel); - updateStreamModes(this, ecModel); - scheduler.performVisualTasks(ecModel); - renderSeries(this, this._model, api, "remain", {}); - remainTime -= +/* @__PURE__ */ new Date() - startTime; - } while (remainTime > 0 && scheduler.unfinished); - if (!scheduler.unfinished) { - this._zr.flush(); - } - } - }; - ECharts2.prototype.getDom = function() { - return this._dom; - }; - ECharts2.prototype.getId = function() { - return this.id; - }; - ECharts2.prototype.getZr = function() { - return this._zr; - }; - ECharts2.prototype.isSSR = function() { - return this._ssr; - }; - ECharts2.prototype.setOption = function(option, notMerge, lazyUpdate) { - if (this[IN_MAIN_PROCESS_KEY]) { - return; - } - if (this._disposed) { - disposedWarning(this.id); - return; - } - var silent; - var replaceMerge; - var transitionOpt; - if (isObject$2(notMerge)) { - lazyUpdate = notMerge.lazyUpdate; - silent = notMerge.silent; - replaceMerge = notMerge.replaceMerge; - transitionOpt = notMerge.transition; - notMerge = notMerge.notMerge; - } - this[IN_MAIN_PROCESS_KEY] = true; - if (!this._model || notMerge) { - var optionManager = new OptionManager(this._api); - var theme = this._theme; - var ecModel = this._model = new GlobalModel(); - ecModel.scheduler = this._scheduler; - ecModel.ssr = this._ssr; - ecModel.init(null, null, null, theme, this._locale, optionManager); - } - this._model.setOption(option, { - replaceMerge - }, optionPreprocessorFuncs); - var updateParams = { - seriesTransition: transitionOpt, - optionChanged: true - }; - if (lazyUpdate) { - this[PENDING_UPDATE] = { - silent, - updateParams - }; - this[IN_MAIN_PROCESS_KEY] = false; - this.getZr().wakeUp(); - } else { - try { - prepare(this); - updateMethods.update.call(this, null, updateParams); - } catch (e) { - this[PENDING_UPDATE] = null; - this[IN_MAIN_PROCESS_KEY] = false; - throw e; - } - if (!this._ssr) { - this._zr.flush(); - } - this[PENDING_UPDATE] = null; - this[IN_MAIN_PROCESS_KEY] = false; - flushPendingActions.call(this, silent); - triggerUpdatedEvent.call(this, silent); - } - }; - ECharts2.prototype.setTheme = function() { - }; - ECharts2.prototype.getModel = function() { - return this._model; - }; - ECharts2.prototype.getOption = function() { - return this._model && this._model.getOption(); - }; - ECharts2.prototype.getWidth = function() { - return this._zr.getWidth(); - }; - ECharts2.prototype.getHeight = function() { - return this._zr.getHeight(); - }; - ECharts2.prototype.getDevicePixelRatio = function() { - return this._zr.painter.dpr || env.hasGlobalWindow && window.devicePixelRatio || 1; - }; - ECharts2.prototype.getRenderedCanvas = function(opts) { - return this.renderToCanvas(opts); - }; - ECharts2.prototype.renderToCanvas = function(opts) { - opts = opts || {}; - var painter = this._zr.painter; - return painter.getRenderedCanvas({ - backgroundColor: opts.backgroundColor || this._model.get("backgroundColor"), - pixelRatio: opts.pixelRatio || this.getDevicePixelRatio() - }); - }; - ECharts2.prototype.renderToSVGString = function(opts) { - opts = opts || {}; - var painter = this._zr.painter; - return painter.renderToString({ - useViewBox: opts.useViewBox - }); - }; - ECharts2.prototype.getSvgDataURL = function() { - if (!env.svgSupported) { - return; - } - var zr = this._zr; - var list = zr.storage.getDisplayList(); - each$4(list, function(el) { - el.stopAnimation(null, true); - }); - return zr.painter.toDataURL(); - }; - ECharts2.prototype.getDataURL = function(opts) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - opts = opts || {}; - var excludeComponents = opts.excludeComponents; - var ecModel = this._model; - var excludesComponentViews = []; - var self = this; - each$4(excludeComponents, function(componentType) { - ecModel.eachComponent({ - mainType: componentType - }, function(component) { - var view = self._componentsMap[component.__viewId]; - if (!view.group.ignore) { - excludesComponentViews.push(view); - view.group.ignore = true; - } - }); - }); - var url = this._zr.painter.getType() === "svg" ? this.getSvgDataURL() : this.renderToCanvas(opts).toDataURL("image/" + (opts && opts.type || "png")); - each$4(excludesComponentViews, function(view) { - view.group.ignore = false; - }); - return url; - }; - ECharts2.prototype.getConnectedDataURL = function(opts) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - var isSvg = opts.type === "svg"; - var groupId = this.group; - var mathMin = Math.min; - var mathMax = Math.max; - var MAX_NUMBER = Infinity; - if (connectedGroups[groupId]) { - var left_1 = MAX_NUMBER; - var top_1 = MAX_NUMBER; - var right_1 = -MAX_NUMBER; - var bottom_1 = -MAX_NUMBER; - var canvasList_1 = []; - var dpr_1 = opts && opts.pixelRatio || this.getDevicePixelRatio(); - each$4(instances, function(chart, id) { - if (chart.group === groupId) { - var canvas = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.renderToCanvas(clone$2(opts)); - var boundingRect = chart.getDom().getBoundingClientRect(); - left_1 = mathMin(boundingRect.left, left_1); - top_1 = mathMin(boundingRect.top, top_1); - right_1 = mathMax(boundingRect.right, right_1); - bottom_1 = mathMax(boundingRect.bottom, bottom_1); - canvasList_1.push({ - dom: canvas, - left: boundingRect.left, - top: boundingRect.top - }); - } - }); - left_1 *= dpr_1; - top_1 *= dpr_1; - right_1 *= dpr_1; - bottom_1 *= dpr_1; - var width = right_1 - left_1; - var height = bottom_1 - top_1; - var targetCanvas = platformApi.createCanvas(); - var zr_1 = init$1(targetCanvas, { - renderer: isSvg ? "svg" : "canvas" - }); - zr_1.resize({ - width, - height - }); - if (isSvg) { - var content_1 = ""; - each$4(canvasList_1, function(item) { - var x = item.left - left_1; - var y = item.top - top_1; - content_1 += '' + item.dom + ""; - }); - zr_1.painter.getSvgRoot().innerHTML = content_1; - if (opts.connectedBackgroundColor) { - zr_1.painter.setBackgroundColor(opts.connectedBackgroundColor); - } - zr_1.refreshImmediately(); - return zr_1.painter.toDataURL(); - } else { - if (opts.connectedBackgroundColor) { - zr_1.add(new Rect({ - shape: { - x: 0, - y: 0, - width, - height - }, - style: { - fill: opts.connectedBackgroundColor - } - })); - } - each$4(canvasList_1, function(item) { - var img = new ZRImage({ - style: { - x: item.left * dpr_1 - left_1, - y: item.top * dpr_1 - top_1, - image: item.dom - } - }); - zr_1.add(img); - }); - zr_1.refreshImmediately(); - return targetCanvas.toDataURL("image/" + (opts && opts.type || "png")); - } - } else { - return this.getDataURL(opts); - } - }; - ECharts2.prototype.convertToPixel = function(finder, value) { - return doConvertPixel(this, "convertToPixel", finder, value); - }; - ECharts2.prototype.convertFromPixel = function(finder, value) { - return doConvertPixel(this, "convertFromPixel", finder, value); - }; - ECharts2.prototype.containPixel = function(finder, value) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - var ecModel = this._model; - var result; - var findResult = parseFinder(ecModel, finder); - each$4(findResult, function(models, key) { - key.indexOf("Models") >= 0 && each$4(models, function(model) { - var coordSys = model.coordinateSystem; - if (coordSys && coordSys.containPoint) { - result = result || !!coordSys.containPoint(value); - } else if (key === "seriesModels") { - var view = this._chartsMap[model.__viewId]; - if (view && view.containPoint) { - result = result || view.containPoint(value, model); - } - } else ; - }, this); - }, this); - return !!result; - }; - ECharts2.prototype.getVisual = function(finder, visualType) { - var ecModel = this._model; - var parsedFinder = parseFinder(ecModel, finder, { - defaultMainType: "series" - }); - var seriesModel = parsedFinder.seriesModel; - var data = seriesModel.getData(); - var dataIndexInside = parsedFinder.hasOwnProperty("dataIndexInside") ? parsedFinder.dataIndexInside : parsedFinder.hasOwnProperty("dataIndex") ? data.indexOfRawIndex(parsedFinder.dataIndex) : null; - return dataIndexInside != null ? getItemVisualFromData(data, dataIndexInside, visualType) : getVisualFromData(data, visualType); - }; - ECharts2.prototype.getViewOfComponentModel = function(componentModel) { - return this._componentsMap[componentModel.__viewId]; - }; - ECharts2.prototype.getViewOfSeriesModel = function(seriesModel) { - return this._chartsMap[seriesModel.__viewId]; - }; - ECharts2.prototype._initEvents = function() { - var _this = this; - each$4(MOUSE_EVENT_NAMES, function(eveName) { - var handler = function(e) { - var ecModel = _this.getModel(); - var el = e.target; - var params; - var isGlobalOut = eveName === "globalout"; - if (isGlobalOut) { - params = {}; - } else { - el && findEventDispatcher(el, function(parent) { - var ecData = getECData(parent); - if (ecData && ecData.dataIndex != null) { - var dataModel = ecData.dataModel || ecModel.getSeriesByIndex(ecData.seriesIndex); - params = dataModel && dataModel.getDataParams(ecData.dataIndex, ecData.dataType, el) || {}; - return true; - } else if (ecData.eventData) { - params = extend({}, ecData.eventData); - return true; - } - }, true); - } - if (params) { - var componentType = params.componentType; - var componentIndex = params.componentIndex; - if (componentType === "markLine" || componentType === "markPoint" || componentType === "markArea") { - componentType = "series"; - componentIndex = params.seriesIndex; - } - var model = componentType && componentIndex != null && ecModel.getComponent(componentType, componentIndex); - var view = model && _this[model.mainType === "series" ? "_chartsMap" : "_componentsMap"][model.__viewId]; - params.event = e; - params.type = eveName; - _this._$eventProcessor.eventInfo = { - targetEl: el, - packedEvent: params, - model, - view - }; - _this.trigger(eveName, params); - } - }; - handler.zrEventfulCallAtLast = true; - _this._zr.on(eveName, handler, _this); - }); - each$4(eventActionMap, function(actionType, eventType) { - _this._messageCenter.on(eventType, function(event) { - this.trigger(eventType, event); - }, _this); - }); - each$4(["selectchanged"], function(eventType) { - _this._messageCenter.on(eventType, function(event) { - this.trigger(eventType, event); - }, _this); - }); - handleLegacySelectEvents(this._messageCenter, this, this._api); - }; - ECharts2.prototype.isDisposed = function() { - return this._disposed; - }; - ECharts2.prototype.clear = function() { - if (this._disposed) { - disposedWarning(this.id); - return; - } - this.setOption({ - series: [] - }, true); - }; - ECharts2.prototype.dispose = function() { - if (this._disposed) { - disposedWarning(this.id); - return; - } - this._disposed = true; - var dom = this.getDom(); - if (dom) { - setAttribute(this.getDom(), DOM_ATTRIBUTE_KEY, ""); - } - var chart = this; - var api = chart._api; - var ecModel = chart._model; - each$4(chart._componentsViews, function(component) { - component.dispose(ecModel, api); - }); - each$4(chart._chartsViews, function(chart2) { - chart2.dispose(ecModel, api); - }); - chart._zr.dispose(); - chart._dom = chart._model = chart._chartsMap = chart._componentsMap = chart._chartsViews = chart._componentsViews = chart._scheduler = chart._api = chart._zr = chart._throttledZrFlush = chart._theme = chart._coordSysMgr = chart._messageCenter = null; - delete instances[chart.id]; - }; - ECharts2.prototype.resize = function(opts) { - if (this[IN_MAIN_PROCESS_KEY]) { - return; - } - if (this._disposed) { - disposedWarning(this.id); - return; - } - this._zr.resize(opts); - var ecModel = this._model; - this._loadingFX && this._loadingFX.resize(); - if (!ecModel) { - return; - } - var needPrepare = ecModel.resetOption("media"); - var silent = opts && opts.silent; - if (this[PENDING_UPDATE]) { - if (silent == null) { - silent = this[PENDING_UPDATE].silent; - } - needPrepare = true; - this[PENDING_UPDATE] = null; - } - this[IN_MAIN_PROCESS_KEY] = true; - try { - needPrepare && prepare(this); - updateMethods.update.call(this, { - type: "resize", - animation: extend({ - // Disable animation - duration: 0 - }, opts && opts.animation) - }); - } catch (e) { - this[IN_MAIN_PROCESS_KEY] = false; - throw e; - } - this[IN_MAIN_PROCESS_KEY] = false; - flushPendingActions.call(this, silent); - triggerUpdatedEvent.call(this, silent); - }; - ECharts2.prototype.showLoading = function(name, cfg) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - if (isObject$2(name)) { - cfg = name; - name = ""; - } - name = name || "default"; - this.hideLoading(); - if (!loadingEffects[name]) { - return; - } - var el = loadingEffects[name](this._api, cfg); - var zr = this._zr; - this._loadingFX = el; - zr.add(el); - }; - ECharts2.prototype.hideLoading = function() { - if (this._disposed) { - disposedWarning(this.id); - return; - } - this._loadingFX && this._zr.remove(this._loadingFX); - this._loadingFX = null; - }; - ECharts2.prototype.makeActionFromEvent = function(eventObj) { - var payload = extend({}, eventObj); - payload.type = eventActionMap[eventObj.type]; - return payload; - }; - ECharts2.prototype.dispatchAction = function(payload, opt) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - if (!isObject$2(opt)) { - opt = { - silent: !!opt - }; - } - if (!actions[payload.type]) { - return; - } - if (!this._model) { - return; - } - if (this[IN_MAIN_PROCESS_KEY]) { - this._pendingActions.push(payload); - return; - } - var silent = opt.silent; - doDispatchAction.call(this, payload, silent); - var flush = opt.flush; - if (flush) { - this._zr.flush(); - } else if (flush !== false && env.browser.weChat) { - this._throttledZrFlush(); - } - flushPendingActions.call(this, silent); - triggerUpdatedEvent.call(this, silent); - }; - ECharts2.prototype.updateLabelLayout = function() { - lifecycle.trigger("series:layoutlabels", this._model, this._api, { - // Not adding series labels. - // TODO - updatedSeries: [] - }); - }; - ECharts2.prototype.appendData = function(params) { - if (this._disposed) { - disposedWarning(this.id); - return; - } - var seriesIndex = params.seriesIndex; - var ecModel = this.getModel(); - var seriesModel = ecModel.getSeriesByIndex(seriesIndex); - seriesModel.appendData(params); - this._scheduler.unfinished = true; - this.getZr().wakeUp(); - }; - ECharts2.internalField = function() { - prepare = function(ecIns) { - var scheduler = ecIns._scheduler; - scheduler.restorePipelines(ecIns._model); - scheduler.prepareStageTasks(); - prepareView(ecIns, true); - prepareView(ecIns, false); - scheduler.plan(); - }; - prepareView = function(ecIns, isComponent) { - var ecModel = ecIns._model; - var scheduler = ecIns._scheduler; - var viewList = isComponent ? ecIns._componentsViews : ecIns._chartsViews; - var viewMap = isComponent ? ecIns._componentsMap : ecIns._chartsMap; - var zr = ecIns._zr; - var api = ecIns._api; - for (var i = 0; i < viewList.length; i++) { - viewList[i].__alive = false; - } - isComponent ? ecModel.eachComponent(function(componentType, model) { - componentType !== "series" && doPrepare(model); - }) : ecModel.eachSeries(doPrepare); - function doPrepare(model) { - var requireNewView = model.__requireNewView; - model.__requireNewView = false; - var viewId = "_ec_" + model.id + "_" + model.type; - var view2 = !requireNewView && viewMap[viewId]; - if (!view2) { - var classType = parseClassType(model.type); - var Clazz = isComponent ? ComponentView.getClass(classType.main, classType.sub) : ( - // FIXME:TS - // (ChartView as ChartViewConstructor).getClass('series', classType.sub) - // For backward compat, still support a chart type declared as only subType - // like "liquidfill", but recommend "series.liquidfill" - // But need a base class to make a type series. - ChartView.getClass(classType.sub) - ); - view2 = new Clazz(); - view2.init(ecModel, api); - viewMap[viewId] = view2; - viewList.push(view2); - zr.add(view2.group); - } - model.__viewId = view2.__id = viewId; - view2.__alive = true; - view2.__model = model; - view2.group.__ecComponentInfo = { - mainType: model.mainType, - index: model.componentIndex - }; - !isComponent && scheduler.prepareView(view2, model, ecModel, api); - } - for (var i = 0; i < viewList.length; ) { - var view = viewList[i]; - if (!view.__alive) { - !isComponent && view.renderTask.dispose(); - zr.remove(view.group); - view.dispose(ecModel, api); - viewList.splice(i, 1); - if (viewMap[view.__id] === view) { - delete viewMap[view.__id]; - } - view.__id = view.group.__ecComponentInfo = null; - } else { - i++; - } - } - }; - updateDirectly = function(ecIns, method, payload, mainType, subType) { - var ecModel = ecIns._model; - ecModel.setUpdatePayload(payload); - if (!mainType) { - each$4([].concat(ecIns._componentsViews).concat(ecIns._chartsViews), callView); - return; - } - var query = {}; - query[mainType + "Id"] = payload[mainType + "Id"]; - query[mainType + "Index"] = payload[mainType + "Index"]; - query[mainType + "Name"] = payload[mainType + "Name"]; - var condition = { - mainType, - query - }; - subType && (condition.subType = subType); - var excludeSeriesId = payload.excludeSeriesId; - var excludeSeriesIdMap; - if (excludeSeriesId != null) { - excludeSeriesIdMap = createHashMap(); - each$4(normalizeToArray(excludeSeriesId), function(id) { - var modelId = convertOptionIdName(id, null); - if (modelId != null) { - excludeSeriesIdMap.set(modelId, true); - } - }); - } - ecModel && ecModel.eachComponent(condition, function(model) { - var isExcluded = excludeSeriesIdMap && excludeSeriesIdMap.get(model.id) != null; - if (isExcluded) { - return; - } - if (isHighDownPayload(payload)) { - if (model instanceof SeriesModel) { - if (payload.type === HIGHLIGHT_ACTION_TYPE && !payload.notBlur && !model.get(["emphasis", "disabled"])) { - blurSeriesFromHighlightPayload(model, payload, ecIns._api); - } - } else { - var _a = findComponentHighDownDispatchers(model.mainType, model.componentIndex, payload.name, ecIns._api), focusSelf = _a.focusSelf, dispatchers = _a.dispatchers; - if (payload.type === HIGHLIGHT_ACTION_TYPE && focusSelf && !payload.notBlur) { - blurComponent(model.mainType, model.componentIndex, ecIns._api); - } - if (dispatchers) { - each$4(dispatchers, function(dispatcher) { - payload.type === HIGHLIGHT_ACTION_TYPE ? enterEmphasis(dispatcher) : leaveEmphasis(dispatcher); - }); - } - } - } else if (isSelectChangePayload(payload)) { - if (model instanceof SeriesModel) { - toggleSelectionFromPayload(model, payload, ecIns._api); - updateSeriesElementSelection(model); - markStatusToUpdate(ecIns); - } - } - }, ecIns); - ecModel && ecModel.eachComponent(condition, function(model) { - var isExcluded = excludeSeriesIdMap && excludeSeriesIdMap.get(model.id) != null; - if (isExcluded) { - return; - } - callView(ecIns[mainType === "series" ? "_chartsMap" : "_componentsMap"][model.__viewId]); - }, ecIns); - function callView(view) { - view && view.__alive && view[method] && view[method](view.__model, ecModel, ecIns._api, payload); - } - }; - updateMethods = { - prepareAndUpdate: function(payload) { - prepare(this); - updateMethods.update.call(this, payload, { - // Needs to mark option changed if newOption is given. - // It's from MagicType. - // TODO If use a separate flag optionChanged in payload? - optionChanged: payload.newOption != null - }); - }, - update: function(payload, updateParams) { - var ecModel = this._model; - var api = this._api; - var zr = this._zr; - var coordSysMgr = this._coordSysMgr; - var scheduler = this._scheduler; - if (!ecModel) { - return; - } - ecModel.setUpdatePayload(payload); - scheduler.restoreData(ecModel, payload); - scheduler.performSeriesTasks(ecModel); - coordSysMgr.create(ecModel, api); - scheduler.performDataProcessorTasks(ecModel, payload); - updateStreamModes(this, ecModel); - coordSysMgr.update(ecModel, api); - clearColorPalette(ecModel); - scheduler.performVisualTasks(ecModel, payload); - render(this, ecModel, api, payload, updateParams); - var backgroundColor = ecModel.get("backgroundColor") || "transparent"; - var darkMode = ecModel.get("darkMode"); - zr.setBackgroundColor(backgroundColor); - if (darkMode != null && darkMode !== "auto") { - zr.setDarkMode(darkMode); - } - lifecycle.trigger("afterupdate", ecModel, api); - }, - updateTransform: function(payload) { - var _this = this; - var ecModel = this._model; - var api = this._api; - if (!ecModel) { - return; - } - ecModel.setUpdatePayload(payload); - var componentDirtyList = []; - ecModel.eachComponent(function(componentType, componentModel) { - if (componentType === "series") { - return; - } - var componentView = _this.getViewOfComponentModel(componentModel); - if (componentView && componentView.__alive) { - if (componentView.updateTransform) { - var result = componentView.updateTransform(componentModel, ecModel, api, payload); - result && result.update && componentDirtyList.push(componentView); - } else { - componentDirtyList.push(componentView); - } - } - }); - var seriesDirtyMap = createHashMap(); - ecModel.eachSeries(function(seriesModel) { - var chartView = _this._chartsMap[seriesModel.__viewId]; - if (chartView.updateTransform) { - var result = chartView.updateTransform(seriesModel, ecModel, api, payload); - result && result.update && seriesDirtyMap.set(seriesModel.uid, 1); - } else { - seriesDirtyMap.set(seriesModel.uid, 1); - } - }); - clearColorPalette(ecModel); - this._scheduler.performVisualTasks(ecModel, payload, { - setDirty: true, - dirtyMap: seriesDirtyMap - }); - renderSeries(this, ecModel, api, payload, {}, seriesDirtyMap); - lifecycle.trigger("afterupdate", ecModel, api); - }, - updateView: function(payload) { - var ecModel = this._model; - if (!ecModel) { - return; - } - ecModel.setUpdatePayload(payload); - ChartView.markUpdateMethod(payload, "updateView"); - clearColorPalette(ecModel); - this._scheduler.performVisualTasks(ecModel, payload, { - setDirty: true - }); - render(this, ecModel, this._api, payload, {}); - lifecycle.trigger("afterupdate", ecModel, this._api); - }, - updateVisual: function(payload) { - var _this = this; - var ecModel = this._model; - if (!ecModel) { - return; - } - ecModel.setUpdatePayload(payload); - ecModel.eachSeries(function(seriesModel) { - seriesModel.getData().clearAllVisual(); - }); - ChartView.markUpdateMethod(payload, "updateVisual"); - clearColorPalette(ecModel); - this._scheduler.performVisualTasks(ecModel, payload, { - visualType: "visual", - setDirty: true - }); - ecModel.eachComponent(function(componentType, componentModel) { - if (componentType !== "series") { - var componentView = _this.getViewOfComponentModel(componentModel); - componentView && componentView.__alive && componentView.updateVisual(componentModel, ecModel, _this._api, payload); - } - }); - ecModel.eachSeries(function(seriesModel) { - var chartView = _this._chartsMap[seriesModel.__viewId]; - chartView.updateVisual(seriesModel, ecModel, _this._api, payload); - }); - lifecycle.trigger("afterupdate", ecModel, this._api); - }, - updateLayout: function(payload) { - updateMethods.update.call(this, payload); - } - }; - doConvertPixel = function(ecIns, methodName, finder, value) { - if (ecIns._disposed) { - disposedWarning(ecIns.id); - return; - } - var ecModel = ecIns._model; - var coordSysList = ecIns._coordSysMgr.getCoordinateSystems(); - var result; - var parsedFinder = parseFinder(ecModel, finder); - for (var i = 0; i < coordSysList.length; i++) { - var coordSys = coordSysList[i]; - if (coordSys[methodName] && (result = coordSys[methodName](ecModel, parsedFinder, value)) != null) { - return result; - } - } - }; - updateStreamModes = function(ecIns, ecModel) { - var chartsMap = ecIns._chartsMap; - var scheduler = ecIns._scheduler; - ecModel.eachSeries(function(seriesModel) { - scheduler.updateStreamModes(seriesModel, chartsMap[seriesModel.__viewId]); - }); - }; - doDispatchAction = function(payload, silent) { - var _this = this; - var ecModel = this.getModel(); - var payloadType = payload.type; - var escapeConnect = payload.escapeConnect; - var actionWrap = actions[payloadType]; - var actionInfo = actionWrap.actionInfo; - var cptTypeTmp = (actionInfo.update || "update").split(":"); - var updateMethod = cptTypeTmp.pop(); - var cptType = cptTypeTmp[0] != null && parseClassType(cptTypeTmp[0]); - this[IN_MAIN_PROCESS_KEY] = true; - var payloads = [payload]; - var batched = false; - if (payload.batch) { - batched = true; - payloads = map$1(payload.batch, function(item) { - item = defaults(extend({}, item), payload); - item.batch = null; - return item; - }); - } - var eventObjBatch = []; - var eventObj; - var isSelectChange = isSelectChangePayload(payload); - var isHighDown = isHighDownPayload(payload); - if (isHighDown) { - allLeaveBlur(this._api); - } - each$4(payloads, function(batchItem) { - eventObj = actionWrap.action(batchItem, _this._model, _this._api); - eventObj = eventObj || extend({}, batchItem); - eventObj.type = actionInfo.event || eventObj.type; - eventObjBatch.push(eventObj); - if (isHighDown) { - var _a = preParseFinder(payload), queryOptionMap = _a.queryOptionMap, mainTypeSpecified = _a.mainTypeSpecified; - var componentMainType = mainTypeSpecified ? queryOptionMap.keys()[0] : "series"; - updateDirectly(_this, updateMethod, batchItem, componentMainType); - markStatusToUpdate(_this); - } else if (isSelectChange) { - updateDirectly(_this, updateMethod, batchItem, "series"); - markStatusToUpdate(_this); - } else if (cptType) { - updateDirectly(_this, updateMethod, batchItem, cptType.main, cptType.sub); - } - }); - if (updateMethod !== "none" && !isHighDown && !isSelectChange && !cptType) { - try { - if (this[PENDING_UPDATE]) { - prepare(this); - updateMethods.update.call(this, payload); - this[PENDING_UPDATE] = null; - } else { - updateMethods[updateMethod].call(this, payload); - } - } catch (e) { - this[IN_MAIN_PROCESS_KEY] = false; - throw e; - } - } - if (batched) { - eventObj = { - type: actionInfo.event || payloadType, - escapeConnect, - batch: eventObjBatch - }; - } else { - eventObj = eventObjBatch[0]; - } - this[IN_MAIN_PROCESS_KEY] = false; - if (!silent) { - var messageCenter = this._messageCenter; - messageCenter.trigger(eventObj.type, eventObj); - if (isSelectChange) { - var newObj = { - type: "selectchanged", - escapeConnect, - selected: getAllSelectedIndices(ecModel), - isFromClick: payload.isFromClick || false, - fromAction: payload.type, - fromActionPayload: payload - }; - messageCenter.trigger(newObj.type, newObj); - } - } - }; - flushPendingActions = function(silent) { - var pendingActions = this._pendingActions; - while (pendingActions.length) { - var payload = pendingActions.shift(); - doDispatchAction.call(this, payload, silent); - } - }; - triggerUpdatedEvent = function(silent) { - !silent && this.trigger("updated"); - }; - bindRenderedEvent = function(zr, ecIns) { - zr.on("rendered", function(params) { - ecIns.trigger("rendered", params); - if ( - // Although zr is dirty if initial animation is not finished - // and this checking is called on frame, we also check - // animation finished for robustness. - zr.animation.isFinished() && !ecIns[PENDING_UPDATE] && !ecIns._scheduler.unfinished && !ecIns._pendingActions.length - ) { - ecIns.trigger("finished"); - } - }); - }; - bindMouseEvent = function(zr, ecIns) { - zr.on("mouseover", function(e) { - var el = e.target; - var dispatcher = findEventDispatcher(el, isHighDownDispatcher); - if (dispatcher) { - handleGlobalMouseOverForHighDown(dispatcher, e, ecIns._api); - markStatusToUpdate(ecIns); - } - }).on("mouseout", function(e) { - var el = e.target; - var dispatcher = findEventDispatcher(el, isHighDownDispatcher); - if (dispatcher) { - handleGlobalMouseOutForHighDown(dispatcher, e, ecIns._api); - markStatusToUpdate(ecIns); - } - }).on("click", function(e) { - var el = e.target; - var dispatcher = findEventDispatcher(el, function(target) { - return getECData(target).dataIndex != null; - }, true); - if (dispatcher) { - var actionType = dispatcher.selected ? "unselect" : "select"; - var ecData = getECData(dispatcher); - ecIns._api.dispatchAction({ - type: actionType, - dataType: ecData.dataType, - dataIndexInside: ecData.dataIndex, - seriesIndex: ecData.seriesIndex, - isFromClick: true - }); - } - }); - }; - function clearColorPalette(ecModel) { - ecModel.clearColorPalette(); - ecModel.eachSeries(function(seriesModel) { - seriesModel.clearColorPalette(); - }); - } - function allocateZlevels(ecModel) { - var componentZLevels = []; - var seriesZLevels = []; - var hasSeparateZLevel = false; - ecModel.eachComponent(function(componentType, componentModel) { - var zlevel = componentModel.get("zlevel") || 0; - var z = componentModel.get("z") || 0; - var zlevelKey = componentModel.getZLevelKey(); - hasSeparateZLevel = hasSeparateZLevel || !!zlevelKey; - (componentType === "series" ? seriesZLevels : componentZLevels).push({ - zlevel, - z, - idx: componentModel.componentIndex, - type: componentType, - key: zlevelKey - }); - }); - if (hasSeparateZLevel) { - var zLevels = componentZLevels.concat(seriesZLevels); - var lastSeriesZLevel_1; - var lastSeriesKey_1; - sort(zLevels, function(a, b) { - if (a.zlevel === b.zlevel) { - return a.z - b.z; - } - return a.zlevel - b.zlevel; - }); - each$4(zLevels, function(item) { - var componentModel = ecModel.getComponent(item.type, item.idx); - var zlevel = item.zlevel; - var key = item.key; - if (lastSeriesZLevel_1 != null) { - zlevel = Math.max(lastSeriesZLevel_1, zlevel); - } - if (key) { - if (zlevel === lastSeriesZLevel_1 && key !== lastSeriesKey_1) { - zlevel++; - } - lastSeriesKey_1 = key; - } else if (lastSeriesKey_1) { - if (zlevel === lastSeriesZLevel_1) { - zlevel++; - } - lastSeriesKey_1 = ""; - } - lastSeriesZLevel_1 = zlevel; - componentModel.setZLevel(zlevel); - }); - } - } - render = function(ecIns, ecModel, api, payload, updateParams) { - allocateZlevels(ecModel); - renderComponents(ecIns, ecModel, api, payload, updateParams); - each$4(ecIns._chartsViews, function(chart) { - chart.__alive = false; - }); - renderSeries(ecIns, ecModel, api, payload, updateParams); - each$4(ecIns._chartsViews, function(chart) { - if (!chart.__alive) { - chart.remove(ecModel, api); - } - }); - }; - renderComponents = function(ecIns, ecModel, api, payload, updateParams, dirtyList) { - each$4(dirtyList || ecIns._componentsViews, function(componentView) { - var componentModel = componentView.__model; - clearStates(componentModel, componentView); - componentView.render(componentModel, ecModel, api, payload); - updateZ(componentModel, componentView); - updateStates(componentModel, componentView); - }); - }; - renderSeries = function(ecIns, ecModel, api, payload, updateParams, dirtyMap) { - var scheduler = ecIns._scheduler; - updateParams = extend(updateParams || {}, { - updatedSeries: ecModel.getSeries() - }); - lifecycle.trigger("series:beforeupdate", ecModel, api, updateParams); - var unfinished = false; - ecModel.eachSeries(function(seriesModel) { - var chartView = ecIns._chartsMap[seriesModel.__viewId]; - chartView.__alive = true; - var renderTask = chartView.renderTask; - scheduler.updatePayload(renderTask, payload); - clearStates(seriesModel, chartView); - if (dirtyMap && dirtyMap.get(seriesModel.uid)) { - renderTask.dirty(); - } - if (renderTask.perform(scheduler.getPerformArgs(renderTask))) { - unfinished = true; - } - chartView.group.silent = !!seriesModel.get("silent"); - updateBlend(seriesModel, chartView); - updateSeriesElementSelection(seriesModel); - }); - scheduler.unfinished = unfinished || scheduler.unfinished; - lifecycle.trigger("series:layoutlabels", ecModel, api, updateParams); - lifecycle.trigger("series:transition", ecModel, api, updateParams); - ecModel.eachSeries(function(seriesModel) { - var chartView = ecIns._chartsMap[seriesModel.__viewId]; - updateZ(seriesModel, chartView); - updateStates(seriesModel, chartView); - }); - updateHoverLayerStatus(ecIns, ecModel); - lifecycle.trigger("series:afterupdate", ecModel, api, updateParams); - }; - markStatusToUpdate = function(ecIns) { - ecIns[STATUS_NEEDS_UPDATE_KEY] = true; - ecIns.getZr().wakeUp(); - }; - applyChangedStates = function(ecIns) { - if (!ecIns[STATUS_NEEDS_UPDATE_KEY]) { - return; - } - ecIns.getZr().storage.traverse(function(el) { - if (isElementRemoved(el)) { - return; - } - applyElementStates(el); - }); - ecIns[STATUS_NEEDS_UPDATE_KEY] = false; - }; - function applyElementStates(el) { - var newStates = []; - var oldStates = el.currentStates; - for (var i = 0; i < oldStates.length; i++) { - var stateName = oldStates[i]; - if (!(stateName === "emphasis" || stateName === "blur" || stateName === "select")) { - newStates.push(stateName); - } - } - if (el.selected && el.states.select) { - newStates.push("select"); - } - if (el.hoverState === HOVER_STATE_EMPHASIS && el.states.emphasis) { - newStates.push("emphasis"); - } else if (el.hoverState === HOVER_STATE_BLUR && el.states.blur) { - newStates.push("blur"); - } - el.useStates(newStates); - } - function updateHoverLayerStatus(ecIns, ecModel) { - var zr = ecIns._zr; - var storage = zr.storage; - var elCount = 0; - storage.traverse(function(el) { - if (!el.isGroup) { - elCount++; - } - }); - if (elCount > ecModel.get("hoverLayerThreshold") && !env.node && !env.worker) { - ecModel.eachSeries(function(seriesModel) { - if (seriesModel.preventUsingHoverLayer) { - return; - } - var chartView = ecIns._chartsMap[seriesModel.__viewId]; - if (chartView.__alive) { - chartView.eachRendered(function(el) { - if (el.states.emphasis) { - el.states.emphasis.hoverLayer = true; - } - }); - } - }); - } - } - function updateBlend(seriesModel, chartView) { - var blendMode = seriesModel.get("blendMode") || null; - chartView.eachRendered(function(el) { - if (!el.isGroup) { - el.style.blend = blendMode; - } - }); - } - function updateZ(model, view) { - if (model.preventAutoZ) { - return; - } - var z = model.get("z") || 0; - var zlevel = model.get("zlevel") || 0; - view.eachRendered(function(el) { - doUpdateZ(el, z, zlevel, -Infinity); - return true; - }); - } - function doUpdateZ(el, z, zlevel, maxZ2) { - var label = el.getTextContent(); - var labelLine = el.getTextGuideLine(); - var isGroup = el.isGroup; - if (isGroup) { - var children = el.childrenRef(); - for (var i = 0; i < children.length; i++) { - maxZ2 = Math.max(doUpdateZ(children[i], z, zlevel, maxZ2), maxZ2); - } - } else { - el.z = z; - el.zlevel = zlevel; - maxZ2 = Math.max(el.z2, maxZ2); - } - if (label) { - label.z = z; - label.zlevel = zlevel; - isFinite(maxZ2) && (label.z2 = maxZ2 + 2); - } - if (labelLine) { - var textGuideLineConfig = el.textGuideLineConfig; - labelLine.z = z; - labelLine.zlevel = zlevel; - isFinite(maxZ2) && (labelLine.z2 = maxZ2 + (textGuideLineConfig && textGuideLineConfig.showAbove ? 1 : -1)); - } - return maxZ2; - } - function clearStates(model, view) { - view.eachRendered(function(el) { - if (isElementRemoved(el)) { - return; - } - var textContent = el.getTextContent(); - var textGuide = el.getTextGuideLine(); - if (el.stateTransition) { - el.stateTransition = null; - } - if (textContent && textContent.stateTransition) { - textContent.stateTransition = null; - } - if (textGuide && textGuide.stateTransition) { - textGuide.stateTransition = null; - } - if (el.hasState()) { - el.prevStates = el.currentStates; - el.clearStates(); - } else if (el.prevStates) { - el.prevStates = null; - } - }); - } - function updateStates(model, view) { - var stateAnimationModel = model.getModel("stateAnimation"); - var enableAnimation = model.isAnimationEnabled(); - var duration = stateAnimationModel.get("duration"); - var stateTransition = duration > 0 ? { - duration, - delay: stateAnimationModel.get("delay"), - easing: stateAnimationModel.get("easing") - // additive: stateAnimationModel.get('additive') - } : null; - view.eachRendered(function(el) { - if (el.states && el.states.emphasis) { - if (isElementRemoved(el)) { - return; - } - if (el instanceof Path) { - savePathStates(el); - } - if (el.__dirty) { - var prevStates = el.prevStates; - if (prevStates) { - el.useStates(prevStates); - } - } - if (enableAnimation) { - el.stateTransition = stateTransition; - var textContent = el.getTextContent(); - var textGuide = el.getTextGuideLine(); - if (textContent) { - textContent.stateTransition = stateTransition; - } - if (textGuide) { - textGuide.stateTransition = stateTransition; - } - } - if (el.__dirty) { - applyElementStates(el); - } - } - }); - } - createExtensionAPI = function(ecIns) { - return new /** @class */ - (function(_super2) { - __extends(class_1, _super2); - function class_1() { - return _super2 !== null && _super2.apply(this, arguments) || this; - } - class_1.prototype.getCoordinateSystems = function() { - return ecIns._coordSysMgr.getCoordinateSystems(); - }; - class_1.prototype.getComponentByElement = function(el) { - while (el) { - var modelInfo = el.__ecComponentInfo; - if (modelInfo != null) { - return ecIns._model.getComponent(modelInfo.mainType, modelInfo.index); - } - el = el.parent; - } - }; - class_1.prototype.enterEmphasis = function(el, highlightDigit) { - enterEmphasis(el, highlightDigit); - markStatusToUpdate(ecIns); - }; - class_1.prototype.leaveEmphasis = function(el, highlightDigit) { - leaveEmphasis(el, highlightDigit); - markStatusToUpdate(ecIns); - }; - class_1.prototype.enterBlur = function(el) { - enterBlur(el); - markStatusToUpdate(ecIns); - }; - class_1.prototype.leaveBlur = function(el) { - leaveBlur(el); - markStatusToUpdate(ecIns); - }; - class_1.prototype.enterSelect = function(el) { - enterSelect(el); - markStatusToUpdate(ecIns); - }; - class_1.prototype.leaveSelect = function(el) { - leaveSelect(el); - markStatusToUpdate(ecIns); - }; - class_1.prototype.getModel = function() { - return ecIns.getModel(); - }; - class_1.prototype.getViewOfComponentModel = function(componentModel) { - return ecIns.getViewOfComponentModel(componentModel); - }; - class_1.prototype.getViewOfSeriesModel = function(seriesModel) { - return ecIns.getViewOfSeriesModel(seriesModel); - }; - return class_1; - }(ExtensionAPI))(ecIns); - }; - enableConnect = function(chart) { - function updateConnectedChartsStatus(charts, status) { - for (var i = 0; i < charts.length; i++) { - var otherChart = charts[i]; - otherChart[CONNECT_STATUS_KEY] = status; - } - } - each$4(eventActionMap, function(actionType, eventType) { - chart._messageCenter.on(eventType, function(event) { - if (connectedGroups[chart.group] && chart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_PENDING) { - if (event && event.escapeConnect) { - return; - } - var action_1 = chart.makeActionFromEvent(event); - var otherCharts_1 = []; - each$4(instances, function(otherChart) { - if (otherChart !== chart && otherChart.group === chart.group) { - otherCharts_1.push(otherChart); - } - }); - updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_PENDING); - each$4(otherCharts_1, function(otherChart) { - if (otherChart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_UPDATING) { - otherChart.dispatchAction(action_1); - } - }); - updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_UPDATED); - } - }); - }); - }; - }(); - return ECharts2; - }(Eventful) -); -var echartsProto = ECharts.prototype; -echartsProto.on = createRegisterEventWithLowercaseECharts("on"); -echartsProto.off = createRegisterEventWithLowercaseECharts("off"); -echartsProto.one = function(eventName, cb, ctx) { - var self = this; - function wrapped() { - var args2 = []; - for (var _i = 0; _i < arguments.length; _i++) { - args2[_i] = arguments[_i]; - } - cb && cb.apply && cb.apply(this, args2); - self.off(eventName, wrapped); - } - this.on.call(this, eventName, wrapped, ctx); -}; -var MOUSE_EVENT_NAMES = ["click", "dblclick", "mouseover", "mouseout", "mousemove", "mousedown", "mouseup", "globalout", "contextmenu"]; -function disposedWarning(id) { -} -var actions = {}; -var eventActionMap = {}; -var dataProcessorFuncs = []; -var optionPreprocessorFuncs = []; -var visualFuncs = []; -var themeStorage = {}; -var loadingEffects = {}; -var instances = {}; -var connectedGroups = {}; -var idBase = +/* @__PURE__ */ new Date() - 0; -var DOM_ATTRIBUTE_KEY = "_echarts_instance_"; -function init(dom, theme, opts) { - var isClient = !(opts && opts.ssr); - if (isClient) { - var existInstance = getInstanceByDom(dom); - if (existInstance) { - return existInstance; - } - } - var chart = new ECharts(dom, theme, opts); - chart.id = "ec_" + idBase++; - instances[chart.id] = chart; - isClient && setAttribute(dom, DOM_ATTRIBUTE_KEY, chart.id); - enableConnect(chart); - lifecycle.trigger("afterinit", chart); - return chart; -} -function getInstanceByDom(dom) { - return instances[getAttribute(dom, DOM_ATTRIBUTE_KEY)]; -} -function registerTheme(name, theme) { - themeStorage[name] = theme; -} -function registerPreprocessor(preprocessorFunc) { - if (indexOf(optionPreprocessorFuncs, preprocessorFunc) < 0) { - optionPreprocessorFuncs.push(preprocessorFunc); - } -} -function registerProcessor(priority, processor) { - normalizeRegister(dataProcessorFuncs, priority, processor, PRIORITY_PROCESSOR_DEFAULT); -} -function registerPostInit(postInitFunc) { - registerUpdateLifecycle("afterinit", postInitFunc); -} -function registerPostUpdate(postUpdateFunc) { - registerUpdateLifecycle("afterupdate", postUpdateFunc); -} -function registerUpdateLifecycle(name, cb) { - lifecycle.on(name, cb); -} -function registerAction(actionInfo, eventName, action) { - if (isFunction(eventName)) { - action = eventName; - eventName = ""; - } - var actionType = isObject$2(actionInfo) ? actionInfo.type : [actionInfo, actionInfo = { - event: eventName - }][0]; - actionInfo.event = (actionInfo.event || actionType).toLowerCase(); - eventName = actionInfo.event; - if (eventActionMap[eventName]) { - return; - } - assert(ACTION_REG.test(actionType) && ACTION_REG.test(eventName)); - if (!actions[actionType]) { - actions[actionType] = { - action, - actionInfo - }; - } - eventActionMap[eventName] = actionType; -} -function registerCoordinateSystem(type, coordSysCreator) { - CoordinateSystemManager.register(type, coordSysCreator); -} -function registerLayout(priority, layoutTask) { - normalizeRegister(visualFuncs, priority, layoutTask, PRIORITY_VISUAL_LAYOUT, "layout"); -} -function registerVisual(priority, visualTask) { - normalizeRegister(visualFuncs, priority, visualTask, PRIORITY_VISUAL_CHART, "visual"); -} -var registeredTasks = []; -function normalizeRegister(targetList, priority, fn, defaultPriority, visualType) { - if (isFunction(priority) || isObject$2(priority)) { - fn = priority; - priority = defaultPriority; - } - if (indexOf(registeredTasks, fn) >= 0) { - return; - } - registeredTasks.push(fn); - var stageHandler = Scheduler.wrapStageHandler(fn, visualType); - stageHandler.__prio = priority; - stageHandler.__raw = fn; - targetList.push(stageHandler); -} -function registerLoading(name, loadingFx) { - loadingEffects[name] = loadingFx; -} -function registerMap(mapName, geoJson, specialAreas) { - var registerMap2 = getImpl("registerMap"); - registerMap2 && registerMap2(mapName, geoJson, specialAreas); -} -var registerTransform = registerExternalTransform; -registerVisual(PRIORITY_VISUAL_GLOBAL, seriesStyleTask); -registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataStyleTask); -registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataColorPaletteTask); -registerVisual(PRIORITY_VISUAL_GLOBAL, seriesSymbolTask); -registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataSymbolTask); -registerVisual(PRIORITY_VISUAL_DECAL, decalVisual); -registerPreprocessor(globalBackwardCompat); -registerProcessor(PRIORITY_PROCESSOR_DATASTACK, dataStack); -registerLoading("default", defaultLoading); -registerAction({ - type: HIGHLIGHT_ACTION_TYPE, - event: HIGHLIGHT_ACTION_TYPE, - update: HIGHLIGHT_ACTION_TYPE -}, noop); -registerAction({ - type: DOWNPLAY_ACTION_TYPE, - event: DOWNPLAY_ACTION_TYPE, - update: DOWNPLAY_ACTION_TYPE -}, noop); -registerAction({ - type: SELECT_ACTION_TYPE, - event: SELECT_ACTION_TYPE, - update: SELECT_ACTION_TYPE -}, noop); -registerAction({ - type: UNSELECT_ACTION_TYPE, - event: UNSELECT_ACTION_TYPE, - update: UNSELECT_ACTION_TYPE -}, noop); -registerAction({ - type: TOGGLE_SELECT_ACTION_TYPE, - event: TOGGLE_SELECT_ACTION_TYPE, - update: TOGGLE_SELECT_ACTION_TYPE -}, noop); -registerTheme("light", lightTheme); -registerTheme("dark", theme); - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function dataIndexMapValueLength(valNumOrArrLengthMoreThan2) { - return valNumOrArrLengthMoreThan2 == null ? 0 : valNumOrArrLengthMoreThan2.length || 1; -} -function defaultKeyGetter(item) { - return item; -} -var DataDiffer = /** @class */function () { - /** - * @param context Can be visited by this.context in callback. - */ - function DataDiffer(oldArr, newArr, oldKeyGetter, newKeyGetter, context, - // By default: 'oneToOne'. - diffMode) { - this._old = oldArr; - this._new = newArr; - this._oldKeyGetter = oldKeyGetter || defaultKeyGetter; - this._newKeyGetter = newKeyGetter || defaultKeyGetter; - // Visible in callback via `this.context`; - this.context = context; - this._diffModeMultiple = diffMode === 'multiple'; - } - /** - * Callback function when add a data - */ - DataDiffer.prototype.add = function (func) { - this._add = func; - return this; - }; - /** - * Callback function when update a data - */ - DataDiffer.prototype.update = function (func) { - this._update = func; - return this; - }; - /** - * Callback function when update a data and only work in `cbMode: 'byKey'`. - */ - DataDiffer.prototype.updateManyToOne = function (func) { - this._updateManyToOne = func; - return this; - }; - /** - * Callback function when update a data and only work in `cbMode: 'byKey'`. - */ - DataDiffer.prototype.updateOneToMany = function (func) { - this._updateOneToMany = func; - return this; - }; - /** - * Callback function when update a data and only work in `cbMode: 'byKey'`. - */ - DataDiffer.prototype.updateManyToMany = function (func) { - this._updateManyToMany = func; - return this; - }; - /** - * Callback function when remove a data - */ - DataDiffer.prototype.remove = function (func) { - this._remove = func; - return this; - }; - DataDiffer.prototype.execute = function () { - this[this._diffModeMultiple ? '_executeMultiple' : '_executeOneToOne'](); - }; - DataDiffer.prototype._executeOneToOne = function () { - var oldArr = this._old; - var newArr = this._new; - var newDataIndexMap = {}; - var oldDataKeyArr = new Array(oldArr.length); - var newDataKeyArr = new Array(newArr.length); - this._initIndexMap(oldArr, null, oldDataKeyArr, '_oldKeyGetter'); - this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter'); - for (var i = 0; i < oldArr.length; i++) { - var oldKey = oldDataKeyArr[i]; - var newIdxMapVal = newDataIndexMap[oldKey]; - var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal); - // idx can never be empty array here. see 'set null' logic below. - if (newIdxMapValLen > 1) { - // Consider there is duplicate key (for example, use dataItem.name as key). - // We should make sure every item in newArr and oldArr can be visited. - var newIdx = newIdxMapVal.shift(); - if (newIdxMapVal.length === 1) { - newDataIndexMap[oldKey] = newIdxMapVal[0]; - } - this._update && this._update(newIdx, i); - } else if (newIdxMapValLen === 1) { - newDataIndexMap[oldKey] = null; - this._update && this._update(newIdxMapVal, i); - } else { - this._remove && this._remove(i); - } - } - this._performRestAdd(newDataKeyArr, newDataIndexMap); - }; - /** - * For example, consider the case: - * oldData: [o0, o1, o2, o3, o4, o5, o6, o7], - * newData: [n0, n1, n2, n3, n4, n5, n6, n7, n8], - * Where: - * o0, o1, n0 has key 'a' (many to one) - * o5, n4, n5, n6 has key 'b' (one to many) - * o2, n1 has key 'c' (one to one) - * n2, n3 has key 'd' (add) - * o3, o4 has key 'e' (remove) - * o6, o7, n7, n8 has key 'f' (many to many, treated as add and remove) - * Then: - * (The order of the following directives are not ensured.) - * this._updateManyToOne(n0, [o0, o1]); - * this._updateOneToMany([n4, n5, n6], o5); - * this._update(n1, o2); - * this._remove(o3); - * this._remove(o4); - * this._remove(o6); - * this._remove(o7); - * this._add(n2); - * this._add(n3); - * this._add(n7); - * this._add(n8); - */ - DataDiffer.prototype._executeMultiple = function () { - var oldArr = this._old; - var newArr = this._new; - var oldDataIndexMap = {}; - var newDataIndexMap = {}; - var oldDataKeyArr = []; - var newDataKeyArr = []; - this._initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, '_oldKeyGetter'); - this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter'); - for (var i = 0; i < oldDataKeyArr.length; i++) { - var oldKey = oldDataKeyArr[i]; - var oldIdxMapVal = oldDataIndexMap[oldKey]; - var newIdxMapVal = newDataIndexMap[oldKey]; - var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal); - var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal); - if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) { - this._updateManyToOne && this._updateManyToOne(newIdxMapVal, oldIdxMapVal); - newDataIndexMap[oldKey] = null; - } else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) { - this._updateOneToMany && this._updateOneToMany(newIdxMapVal, oldIdxMapVal); - newDataIndexMap[oldKey] = null; - } else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) { - this._update && this._update(newIdxMapVal, oldIdxMapVal); - newDataIndexMap[oldKey] = null; - } else if (oldIdxMapValLen > 1 && newIdxMapValLen > 1) { - this._updateManyToMany && this._updateManyToMany(newIdxMapVal, oldIdxMapVal); - newDataIndexMap[oldKey] = null; - } else if (oldIdxMapValLen > 1) { - for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) { - this._remove && this._remove(oldIdxMapVal[i_1]); - } - } else { - this._remove && this._remove(oldIdxMapVal); - } - } - this._performRestAdd(newDataKeyArr, newDataIndexMap); - }; - DataDiffer.prototype._performRestAdd = function (newDataKeyArr, newDataIndexMap) { - for (var i = 0; i < newDataKeyArr.length; i++) { - var newKey = newDataKeyArr[i]; - var newIdxMapVal = newDataIndexMap[newKey]; - var idxMapValLen = dataIndexMapValueLength(newIdxMapVal); - if (idxMapValLen > 1) { - for (var j = 0; j < idxMapValLen; j++) { - this._add && this._add(newIdxMapVal[j]); - } - } else if (idxMapValLen === 1) { - this._add && this._add(newIdxMapVal); - } - // Support both `newDataKeyArr` are duplication removed or not removed. - newDataIndexMap[newKey] = null; - } - }; - DataDiffer.prototype._initIndexMap = function (arr, - // Can be null. - map, - // In 'byKey', the output `keyArr` is duplication removed. - // In 'byIndex', the output `keyArr` is not duplication removed and - // its indices are accurately corresponding to `arr`. - keyArr, keyGetterName) { - var cbModeMultiple = this._diffModeMultiple; - for (var i = 0; i < arr.length; i++) { - // Add prefix to avoid conflict with Object.prototype. - var key = '_ec_' + this[keyGetterName](arr[i], i); - if (!cbModeMultiple) { - keyArr[i] = key; - } - if (!map) { - continue; - } - var idxMapVal = map[key]; - var idxMapValLen = dataIndexMapValueLength(idxMapVal); - if (idxMapValLen === 0) { - // Simple optimize: in most cases, one index has one key, - // do not need array. - map[key] = i; - if (cbModeMultiple) { - keyArr.push(key); - } - } else if (idxMapValLen === 1) { - map[key] = [idxMapVal, i]; - } else { - idxMapVal.push(i); - } - } - }; - return DataDiffer; -}(); - -var DimensionUserOuput = ( - /** @class */ - function() { - function DimensionUserOuput2(encode, dimRequest) { - this._encode = encode; - this._schema = dimRequest; - } - DimensionUserOuput2.prototype.get = function() { - return { - // Do not generate full dimension name until fist used. - fullDimensions: this._getFullDimensionNames(), - encode: this._encode - }; - }; - DimensionUserOuput2.prototype._getFullDimensionNames = function() { - if (!this._cachedDimNames) { - this._cachedDimNames = this._schema ? this._schema.makeOutputDimensionNames() : []; - } - return this._cachedDimNames; - }; - return DimensionUserOuput2; - }() -); -function summarizeDimensions(data, schema) { - var summary = {}; - var encode = summary.encode = {}; - var notExtraCoordDimMap = createHashMap(); - var defaultedLabel = []; - var defaultedTooltip = []; - var userOutputEncode = {}; - each$4(data.dimensions, function(dimName) { - var dimItem = data.getDimensionInfo(dimName); - var coordDim = dimItem.coordDim; - if (coordDim) { - var coordDimIndex = dimItem.coordDimIndex; - getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName; - if (!dimItem.isExtraCoord) { - notExtraCoordDimMap.set(coordDim, 1); - if (mayLabelDimType(dimItem.type)) { - defaultedLabel[0] = dimName; - } - getOrCreateEncodeArr(userOutputEncode, coordDim)[coordDimIndex] = data.getDimensionIndex(dimItem.name); - } - if (dimItem.defaultTooltip) { - defaultedTooltip.push(dimName); - } - } - VISUAL_DIMENSIONS.each(function(v, otherDim) { - var encodeArr = getOrCreateEncodeArr(encode, otherDim); - var dimIndex = dimItem.otherDims[otherDim]; - if (dimIndex != null && dimIndex !== false) { - encodeArr[dimIndex] = dimItem.name; - } - }); - }); - var dataDimsOnCoord = []; - var encodeFirstDimNotExtra = {}; - notExtraCoordDimMap.each(function(v, coordDim) { - var dimArr = encode[coordDim]; - encodeFirstDimNotExtra[coordDim] = dimArr[0]; - dataDimsOnCoord = dataDimsOnCoord.concat(dimArr); - }); - summary.dataDimsOnCoord = dataDimsOnCoord; - summary.dataDimIndicesOnCoord = map$1(dataDimsOnCoord, function(dimName) { - return data.getDimensionInfo(dimName).storeDimIndex; - }); - summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra; - var encodeLabel = encode.label; - if (encodeLabel && encodeLabel.length) { - defaultedLabel = encodeLabel.slice(); - } - var encodeTooltip = encode.tooltip; - if (encodeTooltip && encodeTooltip.length) { - defaultedTooltip = encodeTooltip.slice(); - } else if (!defaultedTooltip.length) { - defaultedTooltip = defaultedLabel.slice(); - } - encode.defaultedLabel = defaultedLabel; - encode.defaultedTooltip = defaultedTooltip; - summary.userOutput = new DimensionUserOuput(userOutputEncode, schema); - return summary; -} -function getOrCreateEncodeArr(encode, dim) { - if (!encode.hasOwnProperty(dim)) { - encode[dim] = []; - } - return encode[dim]; -} -function getDimensionTypeByAxis(axisType) { - return axisType === "category" ? "ordinal" : axisType === "time" ? "time" : "float"; -} -function mayLabelDimType(dimType) { - return !(dimType === "ordinal" || dimType === "time"); -} - -var SeriesDimensionDefine = /** @class */function () { - /** - * @param opt All of the fields will be shallow copied. - */ - function SeriesDimensionDefine(opt) { - /** - * The format of `otherDims` is: - * ```js - * { - * tooltip?: number - * label?: number - * itemName?: number - * seriesName?: number - * } - * ``` - * - * A `series.encode` can specified these fields: - * ```js - * encode: { - * // "3, 1, 5" is the index of data dimension. - * tooltip: [3, 1, 5], - * label: [0, 3], - * ... - * } - * ``` - * `otherDims` is the parse result of the `series.encode` above, like: - * ```js - * // Suppose the index of this data dimension is `3`. - * this.otherDims = { - * // `3` is at the index `0` of the `encode.tooltip` - * tooltip: 0, - * // `3` is at the index `1` of the `encode.label` - * label: 1 - * }; - * ``` - * - * This prop should never be `null`/`undefined` after initialized. - */ - this.otherDims = {}; - if (opt != null) { - extend(this, opt); - } - } - return SeriesDimensionDefine; -}(); - -var inner$5 = makeInner(); -var dimTypeShort = { - float: 'f', - int: 'i', - ordinal: 'o', - number: 'n', - time: 't' -}; -/** - * Represents the dimension requirement of a series. - * - * NOTICE: - * When there are too many dimensions in dataset and many series, only the used dimensions - * (i.e., used by coord sys and declared in `series.encode`) are add to `dimensionDefineList`. - * But users may query data by other unused dimension names. - * In this case, users can only query data if and only if they have defined dimension names - * via ec option, so we provide `getDimensionIndexFromSource`, which only query them from - * `source` dimensions. - */ -var SeriesDataSchema = /** @class */function () { - function SeriesDataSchema(opt) { - this.dimensions = opt.dimensions; - this._dimOmitted = opt.dimensionOmitted; - this.source = opt.source; - this._fullDimCount = opt.fullDimensionCount; - this._updateDimOmitted(opt.dimensionOmitted); - } - SeriesDataSchema.prototype.isDimensionOmitted = function () { - return this._dimOmitted; - }; - SeriesDataSchema.prototype._updateDimOmitted = function (dimensionOmitted) { - this._dimOmitted = dimensionOmitted; - if (!dimensionOmitted) { - return; - } - if (!this._dimNameMap) { - this._dimNameMap = ensureSourceDimNameMap(this.source); - } - }; - /** - * @caution Can only be used when `dimensionOmitted: true`. - * - * Get index by user defined dimension name (i.e., not internal generate name). - * That is, get index from `dimensionsDefine`. - * If no `dimensionsDefine`, or no name get, return -1. - */ - SeriesDataSchema.prototype.getSourceDimensionIndex = function (dimName) { - return retrieve2(this._dimNameMap.get(dimName), -1); - }; - /** - * @caution Can only be used when `dimensionOmitted: true`. - * - * Notice: may return `null`/`undefined` if user not specify dimension names. - */ - SeriesDataSchema.prototype.getSourceDimension = function (dimIndex) { - var dimensionsDefine = this.source.dimensionsDefine; - if (dimensionsDefine) { - return dimensionsDefine[dimIndex]; - } - }; - SeriesDataSchema.prototype.makeStoreSchema = function () { - var dimCount = this._fullDimCount; - var willRetrieveDataByName = shouldRetrieveDataByName(this.source); - var makeHashStrict = !shouldOmitUnusedDimensions(dimCount); - // If source don't have dimensions or series don't omit unsed dimensions. - // Generate from seriesDimList directly - var dimHash = ''; - var dims = []; - for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < dimCount; fullDimIdx++) { - var property = void 0; - var type = void 0; - var ordinalMeta = void 0; - var seriesDimDef = this.dimensions[seriesDimIdx]; - // The list has been sorted by `storeDimIndex` asc. - if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) { - property = willRetrieveDataByName ? seriesDimDef.name : null; - type = seriesDimDef.type; - ordinalMeta = seriesDimDef.ordinalMeta; - seriesDimIdx++; - } else { - var sourceDimDef = this.getSourceDimension(fullDimIdx); - if (sourceDimDef) { - property = willRetrieveDataByName ? sourceDimDef.name : null; - type = sourceDimDef.type; - } - } - dims.push({ - property: property, - type: type, - ordinalMeta: ordinalMeta - }); - // If retrieving data by index, - // use to determine whether data can be shared. - // (Because in this case there might be no dimension name defined in dataset, but indices always exists). - // (Indices are always 0, 1, 2, ..., so we can ignore them to shorten the hash). - // Otherwise if retrieving data by property name (like `data: [{aa: 123, bb: 765}, ...]`), - // use in hash. - if (willRetrieveDataByName && property != null - // For data stack, we have make sure each series has its own dim on this store. - // So we do not add property to hash to make sure they can share this store. - && (!seriesDimDef || !seriesDimDef.isCalculationCoord)) { - dimHash += makeHashStrict - // Use escape character '`' in case that property name contains '$'. - ? property.replace(/\`/g, '`1').replace(/\$/g, '`2') - // For better performance, when there are large dimensions, tolerant this defects that hardly meet. - : property; - } - dimHash += '$'; - dimHash += dimTypeShort[type] || 'f'; - if (ordinalMeta) { - dimHash += ordinalMeta.uid; - } - dimHash += '$'; - } - // Source from endpoint(usually series) will be read differently - // when seriesLayoutBy or startIndex(which is affected by sourceHeader) are different. - // So we use this three props as key. - var source = this.source; - var hash = [source.seriesLayoutBy, source.startIndex, dimHash].join('$$'); - return { - dimensions: dims, - hash: hash - }; - }; - SeriesDataSchema.prototype.makeOutputDimensionNames = function () { - var result = []; - for (var fullDimIdx = 0, seriesDimIdx = 0; fullDimIdx < this._fullDimCount; fullDimIdx++) { - var name_1 = void 0; - var seriesDimDef = this.dimensions[seriesDimIdx]; - // The list has been sorted by `storeDimIndex` asc. - if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) { - if (!seriesDimDef.isCalculationCoord) { - name_1 = seriesDimDef.name; - } - seriesDimIdx++; - } else { - var sourceDimDef = this.getSourceDimension(fullDimIdx); - if (sourceDimDef) { - name_1 = sourceDimDef.name; - } - } - result.push(name_1); - } - return result; - }; - SeriesDataSchema.prototype.appendCalculationDimension = function (dimDef) { - this.dimensions.push(dimDef); - dimDef.isCalculationCoord = true; - this._fullDimCount++; - // If append dimension on a data store, consider the store - // might be shared by different series, series dimensions not - // really map to store dimensions. - this._updateDimOmitted(true); - }; - return SeriesDataSchema; -}(); -function isSeriesDataSchema(schema) { - return schema instanceof SeriesDataSchema; -} -function createDimNameMap(dimsDef) { - var dataDimNameMap = createHashMap(); - for (var i = 0; i < (dimsDef || []).length; i++) { - var dimDefItemRaw = dimsDef[i]; - var userDimName = isObject$2(dimDefItemRaw) ? dimDefItemRaw.name : dimDefItemRaw; - if (userDimName != null && dataDimNameMap.get(userDimName) == null) { - dataDimNameMap.set(userDimName, i); - } - } - return dataDimNameMap; -} -function ensureSourceDimNameMap(source) { - var innerSource = inner$5(source); - return innerSource.dimNameMap || (innerSource.dimNameMap = createDimNameMap(source.dimensionsDefine)); -} -function shouldOmitUnusedDimensions(dimCount) { - return dimCount > 30; -} - -var isObject = isObject$2; -var map = map$1; -var CtorInt32Array = typeof Int32Array === "undefined" ? Array : Int32Array; -var ID_PREFIX = "e\0\0"; -var INDEX_NOT_FOUND = -1; -var TRANSFERABLE_PROPERTIES = ["hasItemOption", "_nameList", "_idList", "_invertedIndicesMap", "_dimSummary", "userOutput", "_rawData", "_dimValueGetter", "_nameDimIdx", "_idDimIdx", "_nameRepeatCount"]; -var CLONE_PROPERTIES = ["_approximateExtent"]; -var prepareInvertedIndex; -var getId; -var getIdNameFromStore; -var normalizeDimensions; -var transferProperties; -var cloneListForMapAndSample; -var makeIdFromName; -var SeriesData = ( - /** @class */ - function() { - function SeriesData2(dimensionsInput, hostModel) { - this.type = "list"; - this._dimOmitted = false; - this._nameList = []; - this._idList = []; - this._visual = {}; - this._layout = {}; - this._itemVisuals = []; - this._itemLayouts = []; - this._graphicEls = []; - this._approximateExtent = {}; - this._calculationInfo = {}; - this.hasItemOption = false; - this.TRANSFERABLE_METHODS = ["cloneShallow", "downSample", "minmaxDownSample", "lttbDownSample", "map"]; - this.CHANGABLE_METHODS = ["filterSelf", "selectRange"]; - this.DOWNSAMPLE_METHODS = ["downSample", "minmaxDownSample", "lttbDownSample"]; - var dimensions; - var assignStoreDimIdx = false; - if (isSeriesDataSchema(dimensionsInput)) { - dimensions = dimensionsInput.dimensions; - this._dimOmitted = dimensionsInput.isDimensionOmitted(); - this._schema = dimensionsInput; - } else { - assignStoreDimIdx = true; - dimensions = dimensionsInput; - } - dimensions = dimensions || ["x", "y"]; - var dimensionInfos = {}; - var dimensionNames = []; - var invertedIndicesMap = {}; - var needsHasOwn = false; - var emptyObj = {}; - for (var i = 0; i < dimensions.length; i++) { - var dimInfoInput = dimensions[i]; - var dimensionInfo = isString(dimInfoInput) ? new SeriesDimensionDefine({ - name: dimInfoInput - }) : !(dimInfoInput instanceof SeriesDimensionDefine) ? new SeriesDimensionDefine(dimInfoInput) : dimInfoInput; - var dimensionName = dimensionInfo.name; - dimensionInfo.type = dimensionInfo.type || "float"; - if (!dimensionInfo.coordDim) { - dimensionInfo.coordDim = dimensionName; - dimensionInfo.coordDimIndex = 0; - } - var otherDims = dimensionInfo.otherDims = dimensionInfo.otherDims || {}; - dimensionNames.push(dimensionName); - dimensionInfos[dimensionName] = dimensionInfo; - if (emptyObj[dimensionName] != null) { - needsHasOwn = true; - } - if (dimensionInfo.createInvertedIndices) { - invertedIndicesMap[dimensionName] = []; - } - if (otherDims.itemName === 0) { - this._nameDimIdx = i; - } - if (otherDims.itemId === 0) { - this._idDimIdx = i; - } - if (assignStoreDimIdx) { - dimensionInfo.storeDimIndex = i; - } - } - this.dimensions = dimensionNames; - this._dimInfos = dimensionInfos; - this._initGetDimensionInfo(needsHasOwn); - this.hostModel = hostModel; - this._invertedIndicesMap = invertedIndicesMap; - if (this._dimOmitted) { - var dimIdxToName_1 = this._dimIdxToName = createHashMap(); - each$4(dimensionNames, function(dimName) { - dimIdxToName_1.set(dimensionInfos[dimName].storeDimIndex, dimName); - }); - } - } - SeriesData2.prototype.getDimension = function(dim) { - var dimIdx = this._recognizeDimIndex(dim); - if (dimIdx == null) { - return dim; - } - dimIdx = dim; - if (!this._dimOmitted) { - return this.dimensions[dimIdx]; - } - var dimName = this._dimIdxToName.get(dimIdx); - if (dimName != null) { - return dimName; - } - var sourceDimDef = this._schema.getSourceDimension(dimIdx); - if (sourceDimDef) { - return sourceDimDef.name; - } - }; - SeriesData2.prototype.getDimensionIndex = function(dim) { - var dimIdx = this._recognizeDimIndex(dim); - if (dimIdx != null) { - return dimIdx; - } - if (dim == null) { - return -1; - } - var dimInfo = this._getDimInfo(dim); - return dimInfo ? dimInfo.storeDimIndex : this._dimOmitted ? this._schema.getSourceDimensionIndex(dim) : -1; - }; - SeriesData2.prototype._recognizeDimIndex = function(dim) { - if (isNumber(dim) || dim != null && !isNaN(dim) && !this._getDimInfo(dim) && (!this._dimOmitted || this._schema.getSourceDimensionIndex(dim) < 0)) { - return +dim; - } - }; - SeriesData2.prototype._getStoreDimIndex = function(dim) { - var dimIdx = this.getDimensionIndex(dim); - return dimIdx; - }; - SeriesData2.prototype.getDimensionInfo = function(dim) { - return this._getDimInfo(this.getDimension(dim)); - }; - SeriesData2.prototype._initGetDimensionInfo = function(needsHasOwn) { - var dimensionInfos = this._dimInfos; - this._getDimInfo = needsHasOwn ? function(dimName) { - return dimensionInfos.hasOwnProperty(dimName) ? dimensionInfos[dimName] : void 0; - } : function(dimName) { - return dimensionInfos[dimName]; - }; - }; - SeriesData2.prototype.getDimensionsOnCoord = function() { - return this._dimSummary.dataDimsOnCoord.slice(); - }; - SeriesData2.prototype.mapDimension = function(coordDim, idx) { - var dimensionsSummary = this._dimSummary; - if (idx == null) { - return dimensionsSummary.encodeFirstDimNotExtra[coordDim]; - } - var dims = dimensionsSummary.encode[coordDim]; - return dims ? dims[idx] : null; - }; - SeriesData2.prototype.mapDimensionsAll = function(coordDim) { - var dimensionsSummary = this._dimSummary; - var dims = dimensionsSummary.encode[coordDim]; - return (dims || []).slice(); - }; - SeriesData2.prototype.getStore = function() { - return this._store; - }; - SeriesData2.prototype.initData = function(data, nameList, dimValueGetter) { - var _this = this; - var store; - if (data instanceof DataStore) { - store = data; - } - if (!store) { - var dimensions = this.dimensions; - var provider = isSourceInstance(data) || isArrayLike(data) ? new DefaultDataProvider(data, dimensions.length) : data; - store = new DataStore(); - var dimensionInfos = map(dimensions, function(dimName) { - return { - type: _this._dimInfos[dimName].type, - property: dimName - }; - }); - store.initData(provider, dimensionInfos, dimValueGetter); - } - this._store = store; - this._nameList = (nameList || []).slice(); - this._idList = []; - this._nameRepeatCount = {}; - this._doInit(0, store.count()); - this._dimSummary = summarizeDimensions(this, this._schema); - this.userOutput = this._dimSummary.userOutput; - }; - SeriesData2.prototype.appendData = function(data) { - var range = this._store.appendData(data); - this._doInit(range[0], range[1]); - }; - SeriesData2.prototype.appendValues = function(values, names) { - var _a = this._store.appendValues(values, names && names.length), start = _a.start, end = _a.end; - var shouldMakeIdFromName = this._shouldMakeIdFromName(); - this._updateOrdinalMeta(); - if (names) { - for (var idx = start; idx < end; idx++) { - var sourceIdx = idx - start; - this._nameList[idx] = names[sourceIdx]; - if (shouldMakeIdFromName) { - makeIdFromName(this, idx); - } - } - } - }; - SeriesData2.prototype._updateOrdinalMeta = function() { - var store = this._store; - var dimensions = this.dimensions; - for (var i = 0; i < dimensions.length; i++) { - var dimInfo = this._dimInfos[dimensions[i]]; - if (dimInfo.ordinalMeta) { - store.collectOrdinalMeta(dimInfo.storeDimIndex, dimInfo.ordinalMeta); - } - } - }; - SeriesData2.prototype._shouldMakeIdFromName = function() { - var provider = this._store.getProvider(); - return this._idDimIdx == null && provider.getSource().sourceFormat !== SOURCE_FORMAT_TYPED_ARRAY && !provider.fillStorage; - }; - SeriesData2.prototype._doInit = function(start, end) { - if (start >= end) { - return; - } - var store = this._store; - var provider = store.getProvider(); - this._updateOrdinalMeta(); - var nameList = this._nameList; - var idList = this._idList; - var sourceFormat = provider.getSource().sourceFormat; - var isFormatOriginal = sourceFormat === SOURCE_FORMAT_ORIGINAL; - if (isFormatOriginal && !provider.pure) { - var sharedDataItem = []; - for (var idx = start; idx < end; idx++) { - var dataItem = provider.getItem(idx, sharedDataItem); - if (!this.hasItemOption && isDataItemOption(dataItem)) { - this.hasItemOption = true; - } - if (dataItem) { - var itemName = dataItem.name; - if (nameList[idx] == null && itemName != null) { - nameList[idx] = convertOptionIdName(itemName, null); - } - var itemId = dataItem.id; - if (idList[idx] == null && itemId != null) { - idList[idx] = convertOptionIdName(itemId, null); - } - } - } - } - if (this._shouldMakeIdFromName()) { - for (var idx = start; idx < end; idx++) { - makeIdFromName(this, idx); - } - } - prepareInvertedIndex(this); - }; - SeriesData2.prototype.getApproximateExtent = function(dim) { - return this._approximateExtent[dim] || this._store.getDataExtent(this._getStoreDimIndex(dim)); - }; - SeriesData2.prototype.setApproximateExtent = function(extent, dim) { - dim = this.getDimension(dim); - this._approximateExtent[dim] = extent.slice(); - }; - SeriesData2.prototype.getCalculationInfo = function(key) { - return this._calculationInfo[key]; - }; - SeriesData2.prototype.setCalculationInfo = function(key, value) { - isObject(key) ? extend(this._calculationInfo, key) : this._calculationInfo[key] = value; - }; - SeriesData2.prototype.getName = function(idx) { - var rawIndex = this.getRawIndex(idx); - var name = this._nameList[rawIndex]; - if (name == null && this._nameDimIdx != null) { - name = getIdNameFromStore(this, this._nameDimIdx, rawIndex); - } - if (name == null) { - name = ""; - } - return name; - }; - SeriesData2.prototype._getCategory = function(dimIdx, idx) { - var ordinal = this._store.get(dimIdx, idx); - var ordinalMeta = this._store.getOrdinalMeta(dimIdx); - if (ordinalMeta) { - return ordinalMeta.categories[ordinal]; - } - return ordinal; - }; - SeriesData2.prototype.getId = function(idx) { - return getId(this, this.getRawIndex(idx)); - }; - SeriesData2.prototype.count = function() { - return this._store.count(); - }; - SeriesData2.prototype.get = function(dim, idx) { - var store = this._store; - var dimInfo = this._dimInfos[dim]; - if (dimInfo) { - return store.get(dimInfo.storeDimIndex, idx); - } - }; - SeriesData2.prototype.getByRawIndex = function(dim, rawIdx) { - var store = this._store; - var dimInfo = this._dimInfos[dim]; - if (dimInfo) { - return store.getByRawIndex(dimInfo.storeDimIndex, rawIdx); - } - }; - SeriesData2.prototype.getIndices = function() { - return this._store.getIndices(); - }; - SeriesData2.prototype.getDataExtent = function(dim) { - return this._store.getDataExtent(this._getStoreDimIndex(dim)); - }; - SeriesData2.prototype.getSum = function(dim) { - return this._store.getSum(this._getStoreDimIndex(dim)); - }; - SeriesData2.prototype.getMedian = function(dim) { - return this._store.getMedian(this._getStoreDimIndex(dim)); - }; - SeriesData2.prototype.getValues = function(dimensions, idx) { - var _this = this; - var store = this._store; - return isArray(dimensions) ? store.getValues(map(dimensions, function(dim) { - return _this._getStoreDimIndex(dim); - }), idx) : store.getValues(dimensions); - }; - SeriesData2.prototype.hasValue = function(idx) { - var dataDimIndicesOnCoord = this._dimSummary.dataDimIndicesOnCoord; - for (var i = 0, len = dataDimIndicesOnCoord.length; i < len; i++) { - if (isNaN(this._store.get(dataDimIndicesOnCoord[i], idx))) { - return false; - } - } - return true; - }; - SeriesData2.prototype.indexOfName = function(name) { - for (var i = 0, len = this._store.count(); i < len; i++) { - if (this.getName(i) === name) { - return i; - } - } - return -1; - }; - SeriesData2.prototype.getRawIndex = function(idx) { - return this._store.getRawIndex(idx); - }; - SeriesData2.prototype.indexOfRawIndex = function(rawIndex) { - return this._store.indexOfRawIndex(rawIndex); - }; - SeriesData2.prototype.rawIndexOf = function(dim, value) { - var invertedIndices = dim && this._invertedIndicesMap[dim]; - var rawIndex = invertedIndices && invertedIndices[value]; - if (rawIndex == null || isNaN(rawIndex)) { - return INDEX_NOT_FOUND; - } - return rawIndex; - }; - SeriesData2.prototype.indicesOfNearest = function(dim, value, maxDistance) { - return this._store.indicesOfNearest(this._getStoreDimIndex(dim), value, maxDistance); - }; - SeriesData2.prototype.each = function(dims, cb, ctx) { - if (isFunction(dims)) { - ctx = cb; - cb = dims; - dims = []; - } - var fCtx = ctx || this; - var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this); - this._store.each(dimIndices, fCtx ? bind$1(cb, fCtx) : cb); - }; - SeriesData2.prototype.filterSelf = function(dims, cb, ctx) { - if (isFunction(dims)) { - ctx = cb; - cb = dims; - dims = []; - } - var fCtx = ctx || this; - var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this); - this._store = this._store.filter(dimIndices, fCtx ? bind$1(cb, fCtx) : cb); - return this; - }; - SeriesData2.prototype.selectRange = function(range) { - var _this = this; - var innerRange = {}; - var dims = keys(range); - each$4(dims, function(dim) { - var dimIdx = _this._getStoreDimIndex(dim); - innerRange[dimIdx] = range[dim]; - }); - this._store = this._store.selectRange(innerRange); - return this; - }; - SeriesData2.prototype.mapArray = function(dims, cb, ctx) { - if (isFunction(dims)) { - ctx = cb; - cb = dims; - dims = []; - } - ctx = ctx || this; - var result = []; - this.each(dims, function() { - result.push(cb && cb.apply(this, arguments)); - }, ctx); - return result; - }; - SeriesData2.prototype.map = function(dims, cb, ctx, ctxCompat) { - var fCtx = ctx || ctxCompat || this; - var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this); - var list = cloneListForMapAndSample(this); - list._store = this._store.map(dimIndices, fCtx ? bind$1(cb, fCtx) : cb); - return list; - }; - SeriesData2.prototype.modify = function(dims, cb, ctx, ctxCompat) { - var fCtx = ctx || ctxCompat || this; - var dimIndices = map(normalizeDimensions(dims), this._getStoreDimIndex, this); - this._store.modify(dimIndices, fCtx ? bind$1(cb, fCtx) : cb); - }; - SeriesData2.prototype.downSample = function(dimension, rate, sampleValue, sampleIndex) { - var list = cloneListForMapAndSample(this); - list._store = this._store.downSample(this._getStoreDimIndex(dimension), rate, sampleValue, sampleIndex); - return list; - }; - SeriesData2.prototype.minmaxDownSample = function(valueDimension, rate) { - var list = cloneListForMapAndSample(this); - list._store = this._store.minmaxDownSample(this._getStoreDimIndex(valueDimension), rate); - return list; - }; - SeriesData2.prototype.lttbDownSample = function(valueDimension, rate) { - var list = cloneListForMapAndSample(this); - list._store = this._store.lttbDownSample(this._getStoreDimIndex(valueDimension), rate); - return list; - }; - SeriesData2.prototype.getRawDataItem = function(idx) { - return this._store.getRawDataItem(idx); - }; - SeriesData2.prototype.getItemModel = function(idx) { - var hostModel = this.hostModel; - var dataItem = this.getRawDataItem(idx); - return new Model(dataItem, hostModel, hostModel && hostModel.ecModel); - }; - SeriesData2.prototype.diff = function(otherList) { - var thisList = this; - return new DataDiffer(otherList ? otherList.getStore().getIndices() : [], this.getStore().getIndices(), function(idx) { - return getId(otherList, idx); - }, function(idx) { - return getId(thisList, idx); - }); - }; - SeriesData2.prototype.getVisual = function(key) { - var visual = this._visual; - return visual && visual[key]; - }; - SeriesData2.prototype.setVisual = function(kvObj, val) { - this._visual = this._visual || {}; - if (isObject(kvObj)) { - extend(this._visual, kvObj); - } else { - this._visual[kvObj] = val; - } - }; - SeriesData2.prototype.getItemVisual = function(idx, key) { - var itemVisual = this._itemVisuals[idx]; - var val = itemVisual && itemVisual[key]; - if (val == null) { - return this.getVisual(key); - } - return val; - }; - SeriesData2.prototype.hasItemVisual = function() { - return this._itemVisuals.length > 0; - }; - SeriesData2.prototype.ensureUniqueItemVisual = function(idx, key) { - var itemVisuals = this._itemVisuals; - var itemVisual = itemVisuals[idx]; - if (!itemVisual) { - itemVisual = itemVisuals[idx] = {}; - } - var val = itemVisual[key]; - if (val == null) { - val = this.getVisual(key); - if (isArray(val)) { - val = val.slice(); - } else if (isObject(val)) { - val = extend({}, val); - } - itemVisual[key] = val; - } - return val; - }; - SeriesData2.prototype.setItemVisual = function(idx, key, value) { - var itemVisual = this._itemVisuals[idx] || {}; - this._itemVisuals[idx] = itemVisual; - if (isObject(key)) { - extend(itemVisual, key); - } else { - itemVisual[key] = value; - } - }; - SeriesData2.prototype.clearAllVisual = function() { - this._visual = {}; - this._itemVisuals = []; - }; - SeriesData2.prototype.setLayout = function(key, val) { - isObject(key) ? extend(this._layout, key) : this._layout[key] = val; - }; - SeriesData2.prototype.getLayout = function(key) { - return this._layout[key]; - }; - SeriesData2.prototype.getItemLayout = function(idx) { - return this._itemLayouts[idx]; - }; - SeriesData2.prototype.setItemLayout = function(idx, layout, merge) { - this._itemLayouts[idx] = merge ? extend(this._itemLayouts[idx] || {}, layout) : layout; - }; - SeriesData2.prototype.clearItemLayouts = function() { - this._itemLayouts.length = 0; - }; - SeriesData2.prototype.setItemGraphicEl = function(idx, el) { - var seriesIndex = this.hostModel && this.hostModel.seriesIndex; - setCommonECData(seriesIndex, this.dataType, idx, el); - this._graphicEls[idx] = el; - }; - SeriesData2.prototype.getItemGraphicEl = function(idx) { - return this._graphicEls[idx]; - }; - SeriesData2.prototype.eachItemGraphicEl = function(cb, context) { - each$4(this._graphicEls, function(el, idx) { - if (el) { - cb && cb.call(context, el, idx); - } - }); - }; - SeriesData2.prototype.cloneShallow = function(list) { - if (!list) { - list = new SeriesData2(this._schema ? this._schema : map(this.dimensions, this._getDimInfo, this), this.hostModel); - } - transferProperties(list, this); - list._store = this._store; - return list; - }; - SeriesData2.prototype.wrapMethod = function(methodName, injectFunction) { - var originalMethod = this[methodName]; - if (!isFunction(originalMethod)) { - return; - } - this.__wrappedMethods = this.__wrappedMethods || []; - this.__wrappedMethods.push(methodName); - this[methodName] = function() { - var res = originalMethod.apply(this, arguments); - return injectFunction.apply(this, [res].concat(slice(arguments))); - }; - }; - SeriesData2.internalField = function() { - prepareInvertedIndex = function(data) { - var invertedIndicesMap = data._invertedIndicesMap; - each$4(invertedIndicesMap, function(invertedIndices, dim) { - var dimInfo = data._dimInfos[dim]; - var ordinalMeta = dimInfo.ordinalMeta; - var store = data._store; - if (ordinalMeta) { - invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array(ordinalMeta.categories.length); - for (var i = 0; i < invertedIndices.length; i++) { - invertedIndices[i] = INDEX_NOT_FOUND; - } - for (var i = 0; i < store.count(); i++) { - invertedIndices[store.get(dimInfo.storeDimIndex, i)] = i; - } - } - }); - }; - getIdNameFromStore = function(data, dimIdx, idx) { - return convertOptionIdName(data._getCategory(dimIdx, idx), null); - }; - getId = function(data, rawIndex) { - var id = data._idList[rawIndex]; - if (id == null && data._idDimIdx != null) { - id = getIdNameFromStore(data, data._idDimIdx, rawIndex); - } - if (id == null) { - id = ID_PREFIX + rawIndex; - } - return id; - }; - normalizeDimensions = function(dimensions) { - if (!isArray(dimensions)) { - dimensions = dimensions != null ? [dimensions] : []; - } - return dimensions; - }; - cloneListForMapAndSample = function(original) { - var list = new SeriesData2(original._schema ? original._schema : map(original.dimensions, original._getDimInfo, original), original.hostModel); - transferProperties(list, original); - return list; - }; - transferProperties = function(target, source) { - each$4(TRANSFERABLE_PROPERTIES.concat(source.__wrappedMethods || []), function(propName) { - if (source.hasOwnProperty(propName)) { - target[propName] = source[propName]; - } - }); - target.__wrappedMethods = source.__wrappedMethods; - each$4(CLONE_PROPERTIES, function(propName) { - target[propName] = clone$2(source[propName]); - }); - target._calculationInfo = extend({}, source._calculationInfo); - }; - makeIdFromName = function(data, idx) { - var nameList = data._nameList; - var idList = data._idList; - var nameDimIdx = data._nameDimIdx; - var idDimIdx = data._idDimIdx; - var name = nameList[idx]; - var id = idList[idx]; - if (name == null && nameDimIdx != null) { - nameList[idx] = name = getIdNameFromStore(data, nameDimIdx, idx); - } - if (id == null && idDimIdx != null) { - idList[idx] = id = getIdNameFromStore(data, idDimIdx, idx); - } - if (id == null && name != null) { - var nameRepeatCount = data._nameRepeatCount; - var nmCnt = nameRepeatCount[name] = (nameRepeatCount[name] || 0) + 1; - id = name; - if (nmCnt > 1) { - id += "__ec__" + nmCnt; - } - idList[idx] = id; - } - }; - }(); - return SeriesData2; - }() -); - -/** - * This method builds the relationship between: - * + "what the coord sys or series requires (see `coordDimensions`)", - * + "what the user defines (in `encode` and `dimensions`, see `opt.dimensionsDefine` and `opt.encodeDefine`)" - * + "what the data source provids (see `source`)". - * - * Some guess strategy will be adapted if user does not define something. - * If no 'value' dimension specified, the first no-named dimension will be - * named as 'value'. - * - * @return The results are always sorted by `storeDimIndex` asc. - */ -function prepareSeriesDataSchema( -// TODO: TYPE completeDimensions type -source, opt) { - if (!isSourceInstance(source)) { - source = createSourceFromSeriesDataOption(source); - } - opt = opt || {}; - var sysDims = opt.coordDimensions || []; - var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || []; - var coordDimNameMap = createHashMap(); - var resultList = []; - var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount); - // Try to ignore unused dimensions if sharing a high dimension datastore - // 30 is an experience value. - var omitUnusedDimensions = opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount); - var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine; - var dataDimNameMap = isUsingSourceDimensionsDef ? ensureSourceDimNameMap(source) : createDimNameMap(dimsDef); - var encodeDef = opt.encodeDefine; - if (!encodeDef && opt.encodeDefaulter) { - encodeDef = opt.encodeDefaulter(source, dimCount); - } - var encodeDefMap = createHashMap(encodeDef); - var indicesMap = new CtorInt32Array$1(dimCount); - for (var i = 0; i < indicesMap.length; i++) { - indicesMap[i] = -1; - } - function getResultItem(dimIdx) { - var idx = indicesMap[dimIdx]; - if (idx < 0) { - var dimDefItemRaw = dimsDef[dimIdx]; - var dimDefItem = isObject$2(dimDefItemRaw) ? dimDefItemRaw : { - name: dimDefItemRaw - }; - var resultItem = new SeriesDimensionDefine(); - var userDimName = dimDefItem.name; - if (userDimName != null && dataDimNameMap.get(userDimName) != null) { - // Only if `series.dimensions` is defined in option - // displayName, will be set, and dimension will be displayed vertically in - // tooltip by default. - resultItem.name = resultItem.displayName = userDimName; - } - dimDefItem.type != null && (resultItem.type = dimDefItem.type); - dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName); - var newIdx = resultList.length; - indicesMap[dimIdx] = newIdx; - resultItem.storeDimIndex = dimIdx; - resultList.push(resultItem); - return resultItem; - } - return resultList[idx]; - } - if (!omitUnusedDimensions) { - for (var i = 0; i < dimCount; i++) { - getResultItem(i); - } - } - // Set `coordDim` and `coordDimIndex` by `encodeDefMap` and normalize `encodeDefMap`. - encodeDefMap.each(function (dataDimsRaw, coordDim) { - var dataDims = normalizeToArray(dataDimsRaw).slice(); - // Note: It is allowed that `dataDims.length` is `0`, e.g., options is - // `{encode: {x: -1, y: 1}}`. Should not filter anything in - // this case. - if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) { - encodeDefMap.set(coordDim, false); - return; - } - var validDataDims = encodeDefMap.set(coordDim, []); - each$4(dataDims, function (resultDimIdxOrName, idx) { - // The input resultDimIdx can be dim name or index. - var resultDimIdx = isString(resultDimIdxOrName) ? dataDimNameMap.get(resultDimIdxOrName) : resultDimIdxOrName; - if (resultDimIdx != null && resultDimIdx < dimCount) { - validDataDims[idx] = resultDimIdx; - applyDim(getResultItem(resultDimIdx), coordDim, idx); - } - }); - }); - // Apply templates and default order from `sysDims`. - var availDimIdx = 0; - each$4(sysDims, function (sysDimItemRaw) { - var coordDim; - var sysDimItemDimsDef; - var sysDimItemOtherDims; - var sysDimItem; - if (isString(sysDimItemRaw)) { - coordDim = sysDimItemRaw; - sysDimItem = {}; - } else { - sysDimItem = sysDimItemRaw; - coordDim = sysDimItem.name; - var ordinalMeta = sysDimItem.ordinalMeta; - sysDimItem.ordinalMeta = null; - sysDimItem = extend({}, sysDimItem); - sysDimItem.ordinalMeta = ordinalMeta; - // `coordDimIndex` should not be set directly. - sysDimItemDimsDef = sysDimItem.dimsDef; - sysDimItemOtherDims = sysDimItem.otherDims; - sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null; - } - var dataDims = encodeDefMap.get(coordDim); - // negative resultDimIdx means no need to mapping. - if (dataDims === false) { - return; - } - dataDims = normalizeToArray(dataDims); - // dimensions provides default dim sequences. - if (!dataDims.length) { - for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) { - while (availDimIdx < dimCount && getResultItem(availDimIdx).coordDim != null) { - availDimIdx++; - } - availDimIdx < dimCount && dataDims.push(availDimIdx++); - } - } - // Apply templates. - each$4(dataDims, function (resultDimIdx, coordDimIndex) { - var resultItem = getResultItem(resultDimIdx); - // Coordinate system has a higher priority on dim type than source. - if (isUsingSourceDimensionsDef && sysDimItem.type != null) { - resultItem.type = sysDimItem.type; - } - applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex); - if (resultItem.name == null && sysDimItemDimsDef) { - var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex]; - !isObject$2(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = { - name: sysDimItemDimsDefItem - }); - resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name; - resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip; - } - // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}} - sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims); - }); - }); - function applyDim(resultItem, coordDim, coordDimIndex) { - if (VISUAL_DIMENSIONS.get(coordDim) != null) { - resultItem.otherDims[coordDim] = coordDimIndex; - } else { - resultItem.coordDim = coordDim; - resultItem.coordDimIndex = coordDimIndex; - coordDimNameMap.set(coordDim, true); - } - } - // Make sure the first extra dim is 'value'. - var generateCoord = opt.generateCoord; - var generateCoordCount = opt.generateCoordCount; - var fromZero = generateCoordCount != null; - generateCoordCount = generateCoord ? generateCoordCount || 1 : 0; - var extra = generateCoord || 'value'; - function ifNoNameFillWithCoordName(resultItem) { - if (resultItem.name == null) { - // Duplication will be removed in the next step. - resultItem.name = resultItem.coordDim; - } - } - // Set dim `name` and other `coordDim` and other props. - if (!omitUnusedDimensions) { - for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) { - var resultItem = getResultItem(resultDimIdx); - var coordDim = resultItem.coordDim; - if (coordDim == null) { - // TODO no need to generate coordDim for isExtraCoord? - resultItem.coordDim = genCoordDimName(extra, coordDimNameMap, fromZero); - resultItem.coordDimIndex = 0; - // Series specified generateCoord is using out. - if (!generateCoord || generateCoordCount <= 0) { - resultItem.isExtraCoord = true; - } - generateCoordCount--; - } - ifNoNameFillWithCoordName(resultItem); - if (resultItem.type == null && (guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must - // Consider the case: - // { - // dataset: {source: [ - // ['2001', 123], - // ['2002', 456], - // ... - // ['The others', 987], - // ]}, - // series: {type: 'pie'} - // } - // The first column should better be treated as a "ordinal" although it - // might not be detected as an "ordinal" by `guessOrdinal`. - || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) { - resultItem.type = 'ordinal'; - } - } - } else { - each$4(resultList, function (resultItem) { - // PENDING: guessOrdinal or let user specify type: 'ordinal' manually? - ifNoNameFillWithCoordName(resultItem); - }); - // Sort dimensions: there are some rule that use the last dim as label, - // and for some latter travel process easier. - resultList.sort(function (item0, item1) { - return item0.storeDimIndex - item1.storeDimIndex; - }); - } - removeDuplication(resultList); - return new SeriesDataSchema({ - source: source, - dimensions: resultList, - fullDimensionCount: dimCount, - dimensionOmitted: omitUnusedDimensions - }); -} -function removeDuplication(result) { - var duplicationMap = createHashMap(); - for (var i = 0; i < result.length; i++) { - var dim = result[i]; - var dimOriginalName = dim.name; - var count = duplicationMap.get(dimOriginalName) || 0; - if (count > 0) { - // Starts from 0. - dim.name = dimOriginalName + (count - 1); - } - count++; - duplicationMap.set(dimOriginalName, count); - } -} -// ??? TODO -// Originally detect dimCount by data[0]. Should we -// optimize it to only by sysDims and dimensions and encode. -// So only necessary dims will be initialized. -// But -// (1) custom series should be considered. where other dims -// may be visited. -// (2) sometimes user need to calculate bubble size or use visualMap -// on other dimensions besides coordSys needed. -// So, dims that is not used by system, should be shared in data store? -function getDimCount(source, sysDims, dimsDef, optDimCount) { - // Note that the result dimCount should not small than columns count - // of data, otherwise `dataDimNameMap` checking will be incorrect. - var dimCount = Math.max(source.dimensionsDetectedCount || 1, sysDims.length, dimsDef.length, optDimCount || 0); - each$4(sysDims, function (sysDimItem) { - var sysDimItemDimsDef; - if (isObject$2(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) { - dimCount = Math.max(dimCount, sysDimItemDimsDef.length); - } - }); - return dimCount; -} -function genCoordDimName(name, map, fromZero) { - if (fromZero || map.hasKey(name)) { - var i = 0; - while (map.hasKey(name + i)) { - i++; - } - name += i; - } - map.set(name, true); - return name; -} - -var CoordSysInfo = ( - /** @class */ - /* @__PURE__ */ function() { - function CoordSysInfo2(coordSysName) { - this.coordSysDims = []; - this.axisMap = createHashMap(); - this.categoryAxisMap = createHashMap(); - this.coordSysName = coordSysName; - } - return CoordSysInfo2; - }() -); -function getCoordSysInfoBySeries(seriesModel) { - var coordSysName = seriesModel.get("coordinateSystem"); - var result = new CoordSysInfo(coordSysName); - var fetch = fetchers[coordSysName]; - if (fetch) { - fetch(seriesModel, result, result.axisMap, result.categoryAxisMap); - return result; - } -} -var fetchers = { - cartesian2d: function(seriesModel, result, axisMap, categoryAxisMap) { - var xAxisModel = seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0]; - var yAxisModel = seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0]; - result.coordSysDims = ["x", "y"]; - axisMap.set("x", xAxisModel); - axisMap.set("y", yAxisModel); - if (isCategory(xAxisModel)) { - categoryAxisMap.set("x", xAxisModel); - result.firstCategoryDimIndex = 0; - } - if (isCategory(yAxisModel)) { - categoryAxisMap.set("y", yAxisModel); - result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1); - } - }, - singleAxis: function(seriesModel, result, axisMap, categoryAxisMap) { - var singleAxisModel = seriesModel.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0]; - result.coordSysDims = ["single"]; - axisMap.set("single", singleAxisModel); - if (isCategory(singleAxisModel)) { - categoryAxisMap.set("single", singleAxisModel); - result.firstCategoryDimIndex = 0; - } - }, - polar: function(seriesModel, result, axisMap, categoryAxisMap) { - var polarModel = seriesModel.getReferringComponents("polar", SINGLE_REFERRING).models[0]; - var radiusAxisModel = polarModel.findAxisModel("radiusAxis"); - var angleAxisModel = polarModel.findAxisModel("angleAxis"); - result.coordSysDims = ["radius", "angle"]; - axisMap.set("radius", radiusAxisModel); - axisMap.set("angle", angleAxisModel); - if (isCategory(radiusAxisModel)) { - categoryAxisMap.set("radius", radiusAxisModel); - result.firstCategoryDimIndex = 0; - } - if (isCategory(angleAxisModel)) { - categoryAxisMap.set("angle", angleAxisModel); - result.firstCategoryDimIndex == null && (result.firstCategoryDimIndex = 1); - } - }, - geo: function(seriesModel, result, axisMap, categoryAxisMap) { - result.coordSysDims = ["lng", "lat"]; - }, - parallel: function(seriesModel, result, axisMap, categoryAxisMap) { - var ecModel = seriesModel.ecModel; - var parallelModel = ecModel.getComponent("parallel", seriesModel.get("parallelIndex")); - var coordSysDims = result.coordSysDims = parallelModel.dimensions.slice(); - each$4(parallelModel.parallelAxisIndex, function(axisIndex, index) { - var axisModel = ecModel.getComponent("parallelAxis", axisIndex); - var axisDim = coordSysDims[index]; - axisMap.set(axisDim, axisModel); - if (isCategory(axisModel)) { - categoryAxisMap.set(axisDim, axisModel); - if (result.firstCategoryDimIndex == null) { - result.firstCategoryDimIndex = index; - } - } - }); - } -}; -function isCategory(axisModel) { - return axisModel.get("type") === "category"; -} - -/** - * Note that it is too complicated to support 3d stack by value - * (have to create two-dimension inverted index), so in 3d case - * we just support that stacked by index. - * - * @param seriesModel - * @param dimensionsInput The same as the input of . - * The input will be modified. - * @param opt - * @param opt.stackedCoordDimension Specify a coord dimension if needed. - * @param opt.byIndex=false - * @return calculationInfo - * { - * stackedDimension: string - * stackedByDimension: string - * isStackedByIndex: boolean - * stackedOverDimension: string - * stackResultDimension: string - * } - */ -function enableDataStack(seriesModel, dimensionsInput, opt) { - opt = opt || {}; - var byIndex = opt.byIndex; - var stackedCoordDimension = opt.stackedCoordDimension; - var dimensionDefineList; - var schema; - var store; - if (isLegacyDimensionsInput(dimensionsInput)) { - dimensionDefineList = dimensionsInput; - } else { - schema = dimensionsInput.schema; - dimensionDefineList = schema.dimensions; - store = dimensionsInput.store; - } - // Compatibal: when `stack` is set as '', do not stack. - var mayStack = !!(seriesModel && seriesModel.get('stack')); - var stackedByDimInfo; - var stackedDimInfo; - var stackResultDimension; - var stackedOverDimension; - each$4(dimensionDefineList, function (dimensionInfo, index) { - if (isString(dimensionInfo)) { - dimensionDefineList[index] = dimensionInfo = { - name: dimensionInfo - }; - } - if (mayStack && !dimensionInfo.isExtraCoord) { - // Find the first ordinal dimension as the stackedByDimInfo. - if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) { - stackedByDimInfo = dimensionInfo; - } - // Find the first stackable dimension as the stackedDimInfo. - if (!stackedDimInfo && dimensionInfo.type !== 'ordinal' && dimensionInfo.type !== 'time' && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) { - stackedDimInfo = dimensionInfo; - } - } - }); - if (stackedDimInfo && !byIndex && !stackedByDimInfo) { - // Compatible with previous design, value axis (time axis) only stack by index. - // It may make sense if the user provides elaborately constructed data. - byIndex = true; - } - // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`. - // That put stack logic in List is for using conveniently in echarts extensions, but it - // might not be a good way. - if (stackedDimInfo) { - // Use a weird name that not duplicated with other names. - // Also need to use seriesModel.id as postfix because different - // series may share same data store. The stack dimension needs to be distinguished. - stackResultDimension = '__\0ecstackresult_' + seriesModel.id; - stackedOverDimension = '__\0ecstackedover_' + seriesModel.id; - // Create inverted index to fast query index by value. - if (stackedByDimInfo) { - stackedByDimInfo.createInvertedIndices = true; - } - var stackedDimCoordDim_1 = stackedDimInfo.coordDim; - var stackedDimType = stackedDimInfo.type; - var stackedDimCoordIndex_1 = 0; - each$4(dimensionDefineList, function (dimensionInfo) { - if (dimensionInfo.coordDim === stackedDimCoordDim_1) { - stackedDimCoordIndex_1++; - } - }); - var stackedOverDimensionDefine = { - name: stackResultDimension, - coordDim: stackedDimCoordDim_1, - coordDimIndex: stackedDimCoordIndex_1, - type: stackedDimType, - isExtraCoord: true, - isCalculationCoord: true, - storeDimIndex: dimensionDefineList.length - }; - var stackResultDimensionDefine = { - name: stackedOverDimension, - // This dimension contains stack base (generally, 0), so do not set it as - // `stackedDimCoordDim` to avoid extent calculation, consider log scale. - coordDim: stackedOverDimension, - coordDimIndex: stackedDimCoordIndex_1 + 1, - type: stackedDimType, - isExtraCoord: true, - isCalculationCoord: true, - storeDimIndex: dimensionDefineList.length + 1 - }; - if (schema) { - if (store) { - stackedOverDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackedOverDimension, stackedDimType); - stackResultDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackResultDimension, stackedDimType); - } - schema.appendCalculationDimension(stackedOverDimensionDefine); - schema.appendCalculationDimension(stackResultDimensionDefine); - } else { - dimensionDefineList.push(stackedOverDimensionDefine); - dimensionDefineList.push(stackResultDimensionDefine); - } - } - return { - stackedDimension: stackedDimInfo && stackedDimInfo.name, - stackedByDimension: stackedByDimInfo && stackedByDimInfo.name, - isStackedByIndex: byIndex, - stackedOverDimension: stackedOverDimension, - stackResultDimension: stackResultDimension - }; -} -function isLegacyDimensionsInput(dimensionsInput) { - return !isSeriesDataSchema(dimensionsInput.schema); -} -function isDimensionStacked(data, stackedDim) { - // Each single series only maps to one pair of axis. So we do not need to - // check stackByDim, whatever stacked by a dimension or stacked by index. - return !!stackedDim && stackedDim === data.getCalculationInfo('stackedDimension'); -} -function getStackedDimension(data, targetDim) { - return isDimensionStacked(data, targetDim) ? data.getCalculationInfo('stackResultDimension') : targetDim; -} - -function getCoordSysDimDefs(seriesModel, coordSysInfo) { - var coordSysName = seriesModel.get('coordinateSystem'); - var registeredCoordSys = CoordinateSystemManager.get(coordSysName); - var coordSysDimDefs; - if (coordSysInfo && coordSysInfo.coordSysDims) { - coordSysDimDefs = map$1(coordSysInfo.coordSysDims, function (dim) { - var dimInfo = { - name: dim - }; - var axisModel = coordSysInfo.axisMap.get(dim); - if (axisModel) { - var axisType = axisModel.get('type'); - dimInfo.type = getDimensionTypeByAxis(axisType); - } - return dimInfo; - }); - } - if (!coordSysDimDefs) { - // Get dimensions from registered coordinate system - coordSysDimDefs = registeredCoordSys && (registeredCoordSys.getDimensionsInfo ? registeredCoordSys.getDimensionsInfo() : registeredCoordSys.dimensions.slice()) || ['x', 'y']; - } - return coordSysDimDefs; -} -function injectOrdinalMeta(dimInfoList, createInvertedIndices, coordSysInfo) { - var firstCategoryDimIndex; - var hasNameEncode; - coordSysInfo && each$4(dimInfoList, function (dimInfo, dimIndex) { - var coordDim = dimInfo.coordDim; - var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim); - if (categoryAxisModel) { - if (firstCategoryDimIndex == null) { - firstCategoryDimIndex = dimIndex; - } - dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta(); - if (createInvertedIndices) { - dimInfo.createInvertedIndices = true; - } - } - if (dimInfo.otherDims.itemName != null) { - hasNameEncode = true; - } - }); - if (!hasNameEncode && firstCategoryDimIndex != null) { - dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0; - } - return firstCategoryDimIndex; -} -/** - * Caution: there are side effects to `sourceManager` in this method. - * Should better only be called in `Series['getInitialData']`. - */ -function createSeriesData(sourceRaw, seriesModel, opt) { - opt = opt || {}; - var sourceManager = seriesModel.getSourceManager(); - var source; - var isOriginalSource = false; - { - source = sourceManager.getSource(); - // Is series.data. not dataset. - isOriginalSource = source.sourceFormat === SOURCE_FORMAT_ORIGINAL; - } - var coordSysInfo = getCoordSysInfoBySeries(seriesModel); - var coordSysDimDefs = getCoordSysDimDefs(seriesModel, coordSysInfo); - var useEncodeDefaulter = opt.useEncodeDefaulter; - var encodeDefaulter = isFunction(useEncodeDefaulter) ? useEncodeDefaulter : useEncodeDefaulter ? curry$1(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null; - var createDimensionOptions = { - coordDimensions: coordSysDimDefs, - generateCoord: opt.generateCoord, - encodeDefine: seriesModel.getEncode(), - encodeDefaulter: encodeDefaulter, - canOmitUnusedDimensions: !isOriginalSource - }; - var schema = prepareSeriesDataSchema(source, createDimensionOptions); - var firstCategoryDimIndex = injectOrdinalMeta(schema.dimensions, opt.createInvertedIndices, coordSysInfo); - var store = !isOriginalSource ? sourceManager.getSharedDataStore(schema) : null; - var stackCalculationInfo = enableDataStack(seriesModel, { - schema: schema, - store: store - }); - var data = new SeriesData(schema, seriesModel); - data.setCalculationInfo(stackCalculationInfo); - var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source) ? function (itemOpt, dimName, dataIndex, dimIndex) { - // Use dataIndex as ordinal value in categoryAxis - return dimIndex === firstCategoryDimIndex ? dataIndex : this.defaultDimValueGetter(itemOpt, dimName, dataIndex, dimIndex); - } : null; - data.hasItemOption = false; - data.initData( - // Try to reuse the data store in sourceManager if using dataset. - isOriginalSource ? source : store, null, dimValueGetter); - return data; -} -function isNeedCompleteOrdinalData(source) { - if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) { - var sampleItem = firstDataNotNull(source.data || []); - return !isArray(getDataItemValue(sampleItem)); - } -} -function firstDataNotNull(arr) { - var i = 0; - while (i < arr.length && arr[i] == null) { - i++; - } - return arr[i]; -} - -var Scale = /** @class */function () { - function Scale(setting) { - this._setting = setting || {}; - this._extent = [Infinity, -Infinity]; - } - Scale.prototype.getSetting = function (name) { - return this._setting[name]; - }; - /** - * Set extent from data - */ - Scale.prototype.unionExtent = function (other) { - var extent = this._extent; - other[0] < extent[0] && (extent[0] = other[0]); - other[1] > extent[1] && (extent[1] = other[1]); - // not setExtent because in log axis it may transformed to power - // this.setExtent(extent[0], extent[1]); - }; - /** - * Set extent from data - */ - Scale.prototype.unionExtentFromData = function (data, dim) { - this.unionExtent(data.getApproximateExtent(dim)); - }; - /** - * Get extent - * - * Extent is always in increase order. - */ - Scale.prototype.getExtent = function () { - return this._extent.slice(); - }; - /** - * Set extent - */ - Scale.prototype.setExtent = function (start, end) { - var thisExtent = this._extent; - if (!isNaN(start)) { - thisExtent[0] = start; - } - if (!isNaN(end)) { - thisExtent[1] = end; - } - }; - /** - * If value is in extent range - */ - Scale.prototype.isInExtentRange = function (value) { - return this._extent[0] <= value && this._extent[1] >= value; - }; - /** - * When axis extent depends on data and no data exists, - * axis ticks should not be drawn, which is named 'blank'. - */ - Scale.prototype.isBlank = function () { - return this._isBlank; - }; - /** - * When axis extent depends on data and no data exists, - * axis ticks should not be drawn, which is named 'blank'. - */ - Scale.prototype.setBlank = function (isBlank) { - this._isBlank = isBlank; - }; - return Scale; -}(); -enableClassManagement(Scale); - -var uidBase = 0; -var OrdinalMeta = /** @class */function () { - function OrdinalMeta(opt) { - this.categories = opt.categories || []; - this._needCollect = opt.needCollect; - this._deduplication = opt.deduplication; - this.uid = ++uidBase; - } - OrdinalMeta.createByAxisModel = function (axisModel) { - var option = axisModel.option; - var data = option.data; - var categories = data && map$1(data, getName); - return new OrdinalMeta({ - categories: categories, - needCollect: !categories, - // deduplication is default in axis. - deduplication: option.dedplication !== false - }); - }; - OrdinalMeta.prototype.getOrdinal = function (category) { - // @ts-ignore - return this._getOrCreateMap().get(category); - }; - /** - * @return The ordinal. If not found, return NaN. - */ - OrdinalMeta.prototype.parseAndCollect = function (category) { - var index; - var needCollect = this._needCollect; - // The value of category dim can be the index of the given category set. - // This feature is only supported when !needCollect, because we should - // consider a common case: a value is 2017, which is a number but is - // expected to be tread as a category. This case usually happen in dataset, - // where it happent to be no need of the index feature. - if (!isString(category) && !needCollect) { - return category; - } - // Optimize for the scenario: - // category is ['2012-01-01', '2012-01-02', ...], where the input - // data has been ensured not duplicate and is large data. - // Notice, if a dataset dimension provide categroies, usually echarts - // should remove duplication except user tell echarts dont do that - // (set axis.deduplication = false), because echarts do not know whether - // the values in the category dimension has duplication (consider the - // parallel-aqi example) - if (needCollect && !this._deduplication) { - index = this.categories.length; - this.categories[index] = category; - return index; - } - var map = this._getOrCreateMap(); - // @ts-ignore - index = map.get(category); - if (index == null) { - if (needCollect) { - index = this.categories.length; - this.categories[index] = category; - // @ts-ignore - map.set(category, index); - } else { - index = NaN; - } - } - return index; - }; - // Consider big data, do not create map until needed. - OrdinalMeta.prototype._getOrCreateMap = function () { - return this._map || (this._map = createHashMap(this.categories)); - }; - return OrdinalMeta; -}(); -function getName(obj) { - if (isObject$2(obj) && obj.value != null) { - return obj.value; - } else { - return obj + ''; - } -} - -function isIntervalOrLogScale(scale) { - return scale.type === 'interval' || scale.type === 'log'; -} -/** - * @param extent Both extent[0] and extent[1] should be valid number. - * Should be extent[0] < extent[1]. - * @param splitNumber splitNumber should be >= 1. - */ -function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) { - var result = {}; - var span = extent[1] - extent[0]; - var interval = result.interval = nice(span / splitNumber); - if (minInterval != null && interval < minInterval) { - interval = result.interval = minInterval; - } - if (maxInterval != null && interval > maxInterval) { - interval = result.interval = maxInterval; - } - // Tow more digital for tick. - var precision = result.intervalPrecision = getIntervalPrecision(interval); - // Niced extent inside original extent - var niceTickExtent = result.niceTickExtent = [round$1(Math.ceil(extent[0] / interval) * interval, precision), round$1(Math.floor(extent[1] / interval) * interval, precision)]; - fixExtent(niceTickExtent, extent); - return result; -} -function increaseInterval(interval) { - var exp10 = Math.pow(10, quantityExponent(interval)); - // Increase interval - var f = interval / exp10; - if (!f) { - f = 1; - } else if (f === 2) { - f = 3; - } else if (f === 3) { - f = 5; - } else { - // f is 1 or 5 - f *= 2; - } - return round$1(f * exp10); -} -/** - * @return interval precision - */ -function getIntervalPrecision(interval) { - // Tow more digital for tick. - return getPrecision(interval) + 2; -} -function clamp(niceTickExtent, idx, extent) { - niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]); -} -// In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent. -function fixExtent(niceTickExtent, extent) { - !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]); - !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]); - clamp(niceTickExtent, 0, extent); - clamp(niceTickExtent, 1, extent); - if (niceTickExtent[0] > niceTickExtent[1]) { - niceTickExtent[0] = niceTickExtent[1]; - } -} -function contain(val, extent) { - return val >= extent[0] && val <= extent[1]; -} -function normalize(val, extent) { - if (extent[1] === extent[0]) { - return 0.5; - } - return (val - extent[0]) / (extent[1] - extent[0]); -} -function scale(val, extent) { - return val * (extent[1] - extent[0]) + extent[0]; -} - -var OrdinalScale = /** @class */function (_super) { - __extends(OrdinalScale, _super); - function OrdinalScale(setting) { - var _this = _super.call(this, setting) || this; - _this.type = 'ordinal'; - var ordinalMeta = _this.getSetting('ordinalMeta'); - // Caution: Should not use instanceof, consider ec-extensions using - // import approach to get OrdinalMeta class. - if (!ordinalMeta) { - ordinalMeta = new OrdinalMeta({}); - } - if (isArray(ordinalMeta)) { - ordinalMeta = new OrdinalMeta({ - categories: map$1(ordinalMeta, function (item) { - return isObject$2(item) ? item.value : item; - }) - }); - } - _this._ordinalMeta = ordinalMeta; - _this._extent = _this.getSetting('extent') || [0, ordinalMeta.categories.length - 1]; - return _this; - } - OrdinalScale.prototype.parse = function (val) { - // Caution: Math.round(null) will return `0` rather than `NaN` - if (val == null) { - return NaN; - } - return isString(val) ? this._ordinalMeta.getOrdinal(val) - // val might be float. - : Math.round(val); - }; - OrdinalScale.prototype.contain = function (rank) { - rank = this.parse(rank); - return contain(rank, this._extent) && this._ordinalMeta.categories[rank] != null; - }; - /** - * Normalize given rank or name to linear [0, 1] - * @param val raw ordinal number. - * @return normalized value in [0, 1]. - */ - OrdinalScale.prototype.normalize = function (val) { - val = this._getTickNumber(this.parse(val)); - return normalize(val, this._extent); - }; - /** - * @param val normalized value in [0, 1]. - * @return raw ordinal number. - */ - OrdinalScale.prototype.scale = function (val) { - val = Math.round(scale(val, this._extent)); - return this.getRawOrdinalNumber(val); - }; - OrdinalScale.prototype.getTicks = function () { - var ticks = []; - var extent = this._extent; - var rank = extent[0]; - while (rank <= extent[1]) { - ticks.push({ - value: rank - }); - rank++; - } - return ticks; - }; - OrdinalScale.prototype.getMinorTicks = function (splitNumber) { - // Not support. - return; - }; - /** - * @see `Ordinal['_ordinalNumbersByTick']` - */ - OrdinalScale.prototype.setSortInfo = function (info) { - if (info == null) { - this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null; - return; - } - var infoOrdinalNumbers = info.ordinalNumbers; - var ordinalsByTick = this._ordinalNumbersByTick = []; - var ticksByOrdinal = this._ticksByOrdinalNumber = []; - // Unnecessary support negative tick in `realtimeSort`. - var tickNum = 0; - var allCategoryLen = this._ordinalMeta.categories.length; - for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) { - var ordinalNumber = infoOrdinalNumbers[tickNum]; - ordinalsByTick[tickNum] = ordinalNumber; - ticksByOrdinal[ordinalNumber] = tickNum; - } - // Handle that `series.data` only covers part of the `axis.category.data`. - var unusedOrdinal = 0; - for (; tickNum < allCategoryLen; ++tickNum) { - while (ticksByOrdinal[unusedOrdinal] != null) { - unusedOrdinal++; - } - ordinalsByTick.push(unusedOrdinal); - ticksByOrdinal[unusedOrdinal] = tickNum; - } - }; - OrdinalScale.prototype._getTickNumber = function (ordinal) { - var ticksByOrdinalNumber = this._ticksByOrdinalNumber; - // also support ordinal out of range of `ordinalMeta.categories.length`, - // where ordinal numbers are used as tick value directly. - return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal; - }; - /** - * @usage - * ```js - * const ordinalNumber = ordinalScale.getRawOrdinalNumber(tickVal); - * - * // case0 - * const rawOrdinalValue = axisModel.getCategories()[ordinalNumber]; - * // case1 - * const rawOrdinalValue = this._ordinalMeta.categories[ordinalNumber]; - * // case2 - * const coord = axis.dataToCoord(ordinalNumber); - * ``` - * - * @param {OrdinalNumber} tickNumber index of display - */ - OrdinalScale.prototype.getRawOrdinalNumber = function (tickNumber) { - var ordinalNumbersByTick = this._ordinalNumbersByTick; - // tickNumber may be out of range, e.g., when axis max is larger than `ordinalMeta.categories.length`., - // where ordinal numbers are used as tick value directly. - return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber; - }; - /** - * Get item on tick - */ - OrdinalScale.prototype.getLabel = function (tick) { - if (!this.isBlank()) { - var ordinalNumber = this.getRawOrdinalNumber(tick.value); - var cateogry = this._ordinalMeta.categories[ordinalNumber]; - // Note that if no data, ordinalMeta.categories is an empty array. - // Return empty if it's not exist. - return cateogry == null ? '' : cateogry + ''; - } - }; - OrdinalScale.prototype.count = function () { - return this._extent[1] - this._extent[0] + 1; - }; - OrdinalScale.prototype.unionExtentFromData = function (data, dim) { - this.unionExtent(data.getApproximateExtent(dim)); - }; - /** - * @override - * If value is in extent range - */ - OrdinalScale.prototype.isInExtentRange = function (value) { - value = this._getTickNumber(value); - return this._extent[0] <= value && this._extent[1] >= value; - }; - OrdinalScale.prototype.getOrdinalMeta = function () { - return this._ordinalMeta; - }; - OrdinalScale.prototype.calcNiceTicks = function () {}; - OrdinalScale.prototype.calcNiceExtent = function () {}; - OrdinalScale.type = 'ordinal'; - return OrdinalScale; -}(Scale); -Scale.registerClass(OrdinalScale); - -var roundNumber = round$1; -var IntervalScale = /** @class */function (_super) { - __extends(IntervalScale, _super); - function IntervalScale() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = 'interval'; - // Step is calculated in adjustExtent. - _this._interval = 0; - _this._intervalPrecision = 2; - return _this; - } - IntervalScale.prototype.parse = function (val) { - return val; - }; - IntervalScale.prototype.contain = function (val) { - return contain(val, this._extent); - }; - IntervalScale.prototype.normalize = function (val) { - return normalize(val, this._extent); - }; - IntervalScale.prototype.scale = function (val) { - return scale(val, this._extent); - }; - IntervalScale.prototype.setExtent = function (start, end) { - var thisExtent = this._extent; - // start,end may be a Number like '25',so... - if (!isNaN(start)) { - thisExtent[0] = parseFloat(start); - } - if (!isNaN(end)) { - thisExtent[1] = parseFloat(end); - } - }; - IntervalScale.prototype.unionExtent = function (other) { - var extent = this._extent; - other[0] < extent[0] && (extent[0] = other[0]); - other[1] > extent[1] && (extent[1] = other[1]); - // unionExtent may called by it's sub classes - this.setExtent(extent[0], extent[1]); - }; - IntervalScale.prototype.getInterval = function () { - return this._interval; - }; - IntervalScale.prototype.setInterval = function (interval) { - this._interval = interval; - // Dropped auto calculated niceExtent and use user-set extent. - // We assume user wants to set both interval, min, max to get a better result. - this._niceExtent = this._extent.slice(); - this._intervalPrecision = getIntervalPrecision(interval); - }; - /** - * @param expandToNicedExtent Whether expand the ticks to niced extent. - */ - IntervalScale.prototype.getTicks = function (expandToNicedExtent) { - var interval = this._interval; - var extent = this._extent; - var niceTickExtent = this._niceExtent; - var intervalPrecision = this._intervalPrecision; - var ticks = []; - // If interval is 0, return []; - if (!interval) { - return ticks; - } - // Consider this case: using dataZoom toolbox, zoom and zoom. - var safeLimit = 10000; - if (extent[0] < niceTickExtent[0]) { - if (expandToNicedExtent) { - ticks.push({ - value: roundNumber(niceTickExtent[0] - interval, intervalPrecision) - }); - } else { - ticks.push({ - value: extent[0] - }); - } - } - var tick = niceTickExtent[0]; - while (tick <= niceTickExtent[1]) { - ticks.push({ - value: tick - }); - // Avoid rounding error - tick = roundNumber(tick + interval, intervalPrecision); - if (tick === ticks[ticks.length - 1].value) { - // Consider out of safe float point, e.g., - // -3711126.9907707 + 2e-10 === -3711126.9907707 - break; - } - if (ticks.length > safeLimit) { - return []; - } - } - // Consider this case: the last item of ticks is smaller - // than niceTickExtent[1] and niceTickExtent[1] === extent[1]. - var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1]; - if (extent[1] > lastNiceTick) { - if (expandToNicedExtent) { - ticks.push({ - value: roundNumber(lastNiceTick + interval, intervalPrecision) - }); - } else { - ticks.push({ - value: extent[1] - }); - } - } - return ticks; - }; - IntervalScale.prototype.getMinorTicks = function (splitNumber) { - var ticks = this.getTicks(true); - var minorTicks = []; - var extent = this.getExtent(); - for (var i = 1; i < ticks.length; i++) { - var nextTick = ticks[i]; - var prevTick = ticks[i - 1]; - var count = 0; - var minorTicksGroup = []; - var interval = nextTick.value - prevTick.value; - var minorInterval = interval / splitNumber; - while (count < splitNumber - 1) { - var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval); - // For the first and last interval. The count may be less than splitNumber. - if (minorTick > extent[0] && minorTick < extent[1]) { - minorTicksGroup.push(minorTick); - } - count++; - } - minorTicks.push(minorTicksGroup); - } - return minorTicks; - }; - /** - * @param opt.precision If 'auto', use nice presision. - * @param opt.pad returns 1.50 but not 1.5 if precision is 2. - */ - IntervalScale.prototype.getLabel = function (data, opt) { - if (data == null) { - return ''; - } - var precision = opt && opt.precision; - if (precision == null) { - precision = getPrecision(data.value) || 0; - } else if (precision === 'auto') { - // Should be more precise then tick. - precision = this._intervalPrecision; - } - // (1) If `precision` is set, 12.005 should be display as '12.00500'. - // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'. - var dataNum = roundNumber(data.value, precision, true); - return addCommas(dataNum); - }; - /** - * @param splitNumber By default `5`. - */ - IntervalScale.prototype.calcNiceTicks = function (splitNumber, minInterval, maxInterval) { - splitNumber = splitNumber || 5; - var extent = this._extent; - var span = extent[1] - extent[0]; - if (!isFinite(span)) { - return; - } - // User may set axis min 0 and data are all negative - // FIXME If it needs to reverse ? - if (span < 0) { - span = -span; - extent.reverse(); - } - var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval); - this._intervalPrecision = result.intervalPrecision; - this._interval = result.interval; - this._niceExtent = result.niceTickExtent; - }; - IntervalScale.prototype.calcNiceExtent = function (opt) { - var extent = this._extent; - // If extent start and end are same, expand them - if (extent[0] === extent[1]) { - if (extent[0] !== 0) { - // Expand extent - // Note that extents can be both negative. See #13154 - var expandSize = Math.abs(extent[0]); - // In the fowllowing case - // Axis has been fixed max 100 - // Plus data are all 100 and axis extent are [100, 100]. - // Extend to the both side will cause expanded max is larger than fixed max. - // So only expand to the smaller side. - if (!opt.fixMax) { - extent[1] += expandSize / 2; - extent[0] -= expandSize / 2; - } else { - extent[0] -= expandSize / 2; - } - } else { - extent[1] = 1; - } - } - var span = extent[1] - extent[0]; - // If there are no data and extent are [Infinity, -Infinity] - if (!isFinite(span)) { - extent[0] = 0; - extent[1] = 1; - } - this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); - // let extent = this._extent; - var interval = this._interval; - if (!opt.fixMin) { - extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval); - } - if (!opt.fixMax) { - extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval); - } - }; - IntervalScale.prototype.setNiceExtent = function (min, max) { - this._niceExtent = [min, max]; - }; - IntervalScale.type = 'interval'; - return IntervalScale; -}(Scale); -Scale.registerClass(IntervalScale); - -/* global Float32Array */ -var supportFloat32Array = typeof Float32Array !== 'undefined'; -var Float32ArrayCtor = !supportFloat32Array ? Array : Float32Array; -function createFloat32Array(arg) { - if (isArray(arg)) { - // Return self directly if don't support TypedArray. - return supportFloat32Array ? new Float32Array(arg) : arg; - } - // Else is number - return new Float32ArrayCtor(arg); -} - -var STACK_PREFIX = '__ec_stack_'; -function getSeriesStackId(seriesModel) { - return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex; -} -function getAxisKey(axis) { - return axis.dim + axis.index; -} -function prepareLayoutBarSeries(seriesType, ecModel) { - var seriesModels = []; - ecModel.eachSeriesByType(seriesType, function (seriesModel) { - // Check series coordinate, do layout for cartesian2d only - if (isOnCartesian(seriesModel)) { - seriesModels.push(seriesModel); - } - }); - return seriesModels; -} -/** - * Map from (baseAxis.dim + '_' + baseAxis.index) to min gap of two adjacent - * values. - * This works for time axes, value axes, and log axes. - * For a single time axis, return value is in the form like - * {'x_0': [1000000]}. - * The value of 1000000 is in milliseconds. - */ -function getValueAxesMinGaps(barSeries) { - /** - * Map from axis.index to values. - * For a single time axis, axisValues is in the form like - * {'x_0': [1495555200000, 1495641600000, 1495728000000]}. - * Items in axisValues[x], e.g. 1495555200000, are time values of all - * series. - */ - var axisValues = {}; - each$4(barSeries, function (seriesModel) { - var cartesian = seriesModel.coordinateSystem; - var baseAxis = cartesian.getBaseAxis(); - if (baseAxis.type !== 'time' && baseAxis.type !== 'value') { - return; - } - var data = seriesModel.getData(); - var key = baseAxis.dim + '_' + baseAxis.index; - var dimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim)); - var store = data.getStore(); - for (var i = 0, cnt = store.count(); i < cnt; ++i) { - var value = store.get(dimIdx, i); - if (!axisValues[key]) { - // No previous data for the axis - axisValues[key] = [value]; - } else { - // No value in previous series - axisValues[key].push(value); - } - // Ignore duplicated time values in the same axis - } - }); - var axisMinGaps = {}; - for (var key in axisValues) { - if (axisValues.hasOwnProperty(key)) { - var valuesInAxis = axisValues[key]; - if (valuesInAxis) { - // Sort axis values into ascending order to calculate gaps - valuesInAxis.sort(function (a, b) { - return a - b; - }); - var min = null; - for (var j = 1; j < valuesInAxis.length; ++j) { - var delta = valuesInAxis[j] - valuesInAxis[j - 1]; - if (delta > 0) { - // Ignore 0 delta because they are of the same axis value - min = min === null ? delta : Math.min(min, delta); - } - } - // Set to null if only have one data - axisMinGaps[key] = min; - } - } - } - return axisMinGaps; -} -function makeColumnLayout(barSeries) { - var axisMinGaps = getValueAxesMinGaps(barSeries); - var seriesInfoList = []; - each$4(barSeries, function (seriesModel) { - var cartesian = seriesModel.coordinateSystem; - var baseAxis = cartesian.getBaseAxis(); - var axisExtent = baseAxis.getExtent(); - var bandWidth; - if (baseAxis.type === 'category') { - bandWidth = baseAxis.getBandWidth(); - } else if (baseAxis.type === 'value' || baseAxis.type === 'time') { - var key = baseAxis.dim + '_' + baseAxis.index; - var minGap = axisMinGaps[key]; - var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]); - var scale = baseAxis.scale.getExtent(); - var scaleSpan = Math.abs(scale[1] - scale[0]); - bandWidth = minGap ? extentSpan / scaleSpan * minGap : extentSpan; // When there is only one data value - } else { - var data = seriesModel.getData(); - bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count(); - } - var barWidth = parsePercent(seriesModel.get('barWidth'), bandWidth); - var barMaxWidth = parsePercent(seriesModel.get('barMaxWidth'), bandWidth); - var barMinWidth = parsePercent( - // barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis, - // the auto-calculated bar width might be less than 0.5 / 1. - seriesModel.get('barMinWidth') || (isInLargeMode(seriesModel) ? 0.5 : 1), bandWidth); - var barGap = seriesModel.get('barGap'); - var barCategoryGap = seriesModel.get('barCategoryGap'); - seriesInfoList.push({ - bandWidth: bandWidth, - barWidth: barWidth, - barMaxWidth: barMaxWidth, - barMinWidth: barMinWidth, - barGap: barGap, - barCategoryGap: barCategoryGap, - axisKey: getAxisKey(baseAxis), - stackId: getSeriesStackId(seriesModel) - }); - }); - return doCalBarWidthAndOffset(seriesInfoList); -} -function doCalBarWidthAndOffset(seriesInfoList) { - // Columns info on each category axis. Key is cartesian name - var columnsMap = {}; - each$4(seriesInfoList, function (seriesInfo, idx) { - var axisKey = seriesInfo.axisKey; - var bandWidth = seriesInfo.bandWidth; - var columnsOnAxis = columnsMap[axisKey] || { - bandWidth: bandWidth, - remainedWidth: bandWidth, - autoWidthCount: 0, - categoryGap: null, - gap: '20%', - stacks: {} - }; - var stacks = columnsOnAxis.stacks; - columnsMap[axisKey] = columnsOnAxis; - var stackId = seriesInfo.stackId; - if (!stacks[stackId]) { - columnsOnAxis.autoWidthCount++; - } - stacks[stackId] = stacks[stackId] || { - width: 0, - maxWidth: 0 - }; - // Caution: In a single coordinate system, these barGrid attributes - // will be shared by series. Consider that they have default values, - // only the attributes set on the last series will work. - // Do not change this fact unless there will be a break change. - var barWidth = seriesInfo.barWidth; - if (barWidth && !stacks[stackId].width) { - // See #6312, do not restrict width. - stacks[stackId].width = barWidth; - barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth); - columnsOnAxis.remainedWidth -= barWidth; - } - var barMaxWidth = seriesInfo.barMaxWidth; - barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth); - var barMinWidth = seriesInfo.barMinWidth; - barMinWidth && (stacks[stackId].minWidth = barMinWidth); - var barGap = seriesInfo.barGap; - barGap != null && (columnsOnAxis.gap = barGap); - var barCategoryGap = seriesInfo.barCategoryGap; - barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap); - }); - var result = {}; - each$4(columnsMap, function (columnsOnAxis, coordSysName) { - result[coordSysName] = {}; - var stacks = columnsOnAxis.stacks; - var bandWidth = columnsOnAxis.bandWidth; - var categoryGapPercent = columnsOnAxis.categoryGap; - if (categoryGapPercent == null) { - var columnCount = keys(stacks).length; - // More columns in one group - // the spaces between group is smaller. Or the column will be too thin. - categoryGapPercent = Math.max(35 - columnCount * 4, 15) + '%'; - } - var categoryGap = parsePercent(categoryGapPercent, bandWidth); - var barGapPercent = parsePercent(columnsOnAxis.gap, 1); - var remainedWidth = columnsOnAxis.remainedWidth; - var autoWidthCount = columnsOnAxis.autoWidthCount; - var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent); - autoWidth = Math.max(autoWidth, 0); - // Find if any auto calculated bar exceeded maxBarWidth - each$4(stacks, function (column) { - var maxWidth = column.maxWidth; - var minWidth = column.minWidth; - if (!column.width) { - var finalWidth = autoWidth; - if (maxWidth && maxWidth < finalWidth) { - finalWidth = Math.min(maxWidth, remainedWidth); - } - // `minWidth` has higher priority. `minWidth` decide that whether the - // bar is able to be visible. So `minWidth` should not be restricted - // by `maxWidth` or `remainedWidth` (which is from `bandWidth`). In - // the extreme cases for `value` axis, bars are allowed to overlap - // with each other if `minWidth` specified. - if (minWidth && minWidth > finalWidth) { - finalWidth = minWidth; - } - if (finalWidth !== autoWidth) { - column.width = finalWidth; - remainedWidth -= finalWidth + barGapPercent * finalWidth; - autoWidthCount--; - } - } else { - // `barMinWidth/barMaxWidth` has higher priority than `barWidth`, as - // CSS does. Because barWidth can be a percent value, where - // `barMaxWidth` can be used to restrict the final width. - var finalWidth = column.width; - if (maxWidth) { - finalWidth = Math.min(finalWidth, maxWidth); - } - // `minWidth` has higher priority, as described above - if (minWidth) { - finalWidth = Math.max(finalWidth, minWidth); - } - column.width = finalWidth; - remainedWidth -= finalWidth + barGapPercent * finalWidth; - autoWidthCount--; - } - }); - // Recalculate width again - autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent); - autoWidth = Math.max(autoWidth, 0); - var widthSum = 0; - var lastColumn; - each$4(stacks, function (column, idx) { - if (!column.width) { - column.width = autoWidth; - } - lastColumn = column; - widthSum += column.width * (1 + barGapPercent); - }); - if (lastColumn) { - widthSum -= lastColumn.width * barGapPercent; - } - var offset = -widthSum / 2; - each$4(stacks, function (column, stackId) { - result[coordSysName][stackId] = result[coordSysName][stackId] || { - bandWidth: bandWidth, - offset: offset, - width: column.width - }; - offset += column.width * (1 + barGapPercent); - }); - }); - return result; -} -function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) { - if (barWidthAndOffset && axis) { - var result = barWidthAndOffset[getAxisKey(axis)]; - return result; - } -} -function isOnCartesian(seriesModel) { - return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d'; -} -function isInLargeMode(seriesModel) { - return seriesModel.pipelineContext && seriesModel.pipelineContext.large; -} - -var bisect = function(a, x, lo, hi) { - while (lo < hi) { - var mid = lo + hi >>> 1; - if (a[mid][1] < x) { - lo = mid + 1; - } else { - hi = mid; - } - } - return lo; -}; -var TimeScale = ( - /** @class */ - function(_super) { - __extends(TimeScale2, _super); - function TimeScale2(settings) { - var _this = _super.call(this, settings) || this; - _this.type = "time"; - return _this; - } - TimeScale2.prototype.getLabel = function(tick) { - var useUTC = this.getSetting("useUTC"); - return format(tick.value, fullLeveledFormatter[getDefaultFormatPrecisionOfInterval(getPrimaryTimeUnit(this._minLevelUnit))] || fullLeveledFormatter.second, useUTC, this.getSetting("locale")); - }; - TimeScale2.prototype.getFormattedLabel = function(tick, idx, labelFormatter) { - var isUTC = this.getSetting("useUTC"); - var lang = this.getSetting("locale"); - return leveledFormat(tick, idx, labelFormatter, lang, isUTC); - }; - TimeScale2.prototype.getTicks = function() { - var interval = this._interval; - var extent = this._extent; - var ticks = []; - if (!interval) { - return ticks; - } - ticks.push({ - value: extent[0], - level: 0 - }); - var useUTC = this.getSetting("useUTC"); - var innerTicks = getIntervalTicks(this._minLevelUnit, this._approxInterval, useUTC, extent); - ticks = ticks.concat(innerTicks); - ticks.push({ - value: extent[1], - level: 0 - }); - return ticks; - }; - TimeScale2.prototype.calcNiceExtent = function(opt) { - var extent = this._extent; - if (extent[0] === extent[1]) { - extent[0] -= ONE_DAY; - extent[1] += ONE_DAY; - } - if (extent[1] === -Infinity && extent[0] === Infinity) { - var d = /* @__PURE__ */ new Date(); - extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate()); - extent[0] = extent[1] - ONE_DAY; - } - this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); - }; - TimeScale2.prototype.calcNiceTicks = function(approxTickNum, minInterval, maxInterval) { - approxTickNum = approxTickNum || 10; - var extent = this._extent; - var span = extent[1] - extent[0]; - this._approxInterval = span / approxTickNum; - if (minInterval != null && this._approxInterval < minInterval) { - this._approxInterval = minInterval; - } - if (maxInterval != null && this._approxInterval > maxInterval) { - this._approxInterval = maxInterval; - } - var scaleIntervalsLen = scaleIntervals.length; - var idx = Math.min(bisect(scaleIntervals, this._approxInterval, 0, scaleIntervalsLen), scaleIntervalsLen - 1); - this._interval = scaleIntervals[idx][1]; - this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0]; - }; - TimeScale2.prototype.parse = function(val) { - return isNumber(val) ? val : +parseDate(val); - }; - TimeScale2.prototype.contain = function(val) { - return contain(this.parse(val), this._extent); - }; - TimeScale2.prototype.normalize = function(val) { - return normalize(this.parse(val), this._extent); - }; - TimeScale2.prototype.scale = function(val) { - return scale(val, this._extent); - }; - TimeScale2.type = "time"; - return TimeScale2; - }(IntervalScale) -); -var scaleIntervals = [ - // Format interval - ["second", ONE_SECOND], - ["minute", ONE_MINUTE], - ["hour", ONE_HOUR], - ["quarter-day", ONE_HOUR * 6], - ["half-day", ONE_HOUR * 12], - ["day", ONE_DAY * 1.2], - ["half-week", ONE_DAY * 3.5], - ["week", ONE_DAY * 7], - ["month", ONE_DAY * 31], - ["quarter", ONE_DAY * 95], - ["half-year", ONE_YEAR / 2], - ["year", ONE_YEAR] - // 1Y -]; -function isUnitValueSame(unit, valueA, valueB, isUTC) { - var dateA = parseDate(valueA); - var dateB = parseDate(valueB); - var isSame = function(unit2) { - return getUnitValue(dateA, unit2, isUTC) === getUnitValue(dateB, unit2, isUTC); - }; - var isSameYear = function() { - return isSame("year"); - }; - var isSameMonth = function() { - return isSameYear() && isSame("month"); - }; - var isSameDay = function() { - return isSameMonth() && isSame("day"); - }; - var isSameHour = function() { - return isSameDay() && isSame("hour"); - }; - var isSameMinute = function() { - return isSameHour() && isSame("minute"); - }; - var isSameSecond = function() { - return isSameMinute() && isSame("second"); - }; - var isSameMilliSecond = function() { - return isSameSecond() && isSame("millisecond"); - }; - switch (unit) { - case "year": - return isSameYear(); - case "month": - return isSameMonth(); - case "day": - return isSameDay(); - case "hour": - return isSameHour(); - case "minute": - return isSameMinute(); - case "second": - return isSameSecond(); - case "millisecond": - return isSameMilliSecond(); - } -} -function getDateInterval(approxInterval, daysInMonth) { - approxInterval /= ONE_DAY; - return approxInterval > 16 ? 16 : approxInterval > 7.5 ? 7 : approxInterval > 3.5 ? 4 : approxInterval > 1.5 ? 2 : 1; -} -function getMonthInterval(approxInterval) { - var APPROX_ONE_MONTH = 30 * ONE_DAY; - approxInterval /= APPROX_ONE_MONTH; - return approxInterval > 6 ? 6 : approxInterval > 3 ? 3 : approxInterval > 2 ? 2 : 1; -} -function getHourInterval(approxInterval) { - approxInterval /= ONE_HOUR; - return approxInterval > 12 ? 12 : approxInterval > 6 ? 6 : approxInterval > 3.5 ? 4 : approxInterval > 2 ? 2 : 1; -} -function getMinutesAndSecondsInterval(approxInterval, isMinutes) { - approxInterval /= isMinutes ? ONE_MINUTE : ONE_SECOND; - return approxInterval > 30 ? 30 : approxInterval > 20 ? 20 : approxInterval > 15 ? 15 : approxInterval > 10 ? 10 : approxInterval > 5 ? 5 : approxInterval > 2 ? 2 : 1; -} -function getMillisecondsInterval(approxInterval) { - return nice(approxInterval); -} -function getFirstTimestampOfUnit(date, unitName, isUTC) { - var outDate = new Date(date); - switch (getPrimaryTimeUnit(unitName)) { - case "year": - case "month": - outDate[monthSetterName(isUTC)](0); - case "day": - outDate[dateSetterName(isUTC)](1); - case "hour": - outDate[hoursSetterName(isUTC)](0); - case "minute": - outDate[minutesSetterName(isUTC)](0); - case "second": - outDate[secondsSetterName(isUTC)](0); - outDate[millisecondsSetterName(isUTC)](0); - } - return outDate.getTime(); -} -function getIntervalTicks(bottomUnitName, approxInterval, isUTC, extent) { - var safeLimit = 1e4; - var unitNames = timeUnits; - var iter = 0; - function addTicksInSpan(interval, minTimestamp, maxTimestamp, getMethodName, setMethodName, isDate, out) { - var date = new Date(minTimestamp); - var dateTime = minTimestamp; - var d = date[getMethodName](); - while (dateTime < maxTimestamp && dateTime <= extent[1]) { - out.push({ - value: dateTime - }); - d += interval; - date[setMethodName](d); - dateTime = date.getTime(); - } - out.push({ - value: dateTime, - notAdd: true - }); - } - function addLevelTicks(unitName, lastLevelTicks, levelTicks2) { - var newAddedTicks = []; - var isFirstLevel = !lastLevelTicks.length; - if (isUnitValueSame(getPrimaryTimeUnit(unitName), extent[0], extent[1], isUTC)) { - return; - } - if (isFirstLevel) { - lastLevelTicks = [{ - // TODO Optimize. Not include so may ticks. - value: getFirstTimestampOfUnit(new Date(extent[0]), unitName, isUTC) - }, { - value: extent[1] - }]; - } - for (var i2 = 0; i2 < lastLevelTicks.length - 1; i2++) { - var startTick = lastLevelTicks[i2].value; - var endTick = lastLevelTicks[i2 + 1].value; - if (startTick === endTick) { - continue; - } - var interval = void 0; - var getterName = void 0; - var setterName = void 0; - var isDate = false; - switch (unitName) { - case "year": - interval = Math.max(1, Math.round(approxInterval / ONE_DAY / 365)); - getterName = fullYearGetterName(isUTC); - setterName = fullYearSetterName(isUTC); - break; - case "half-year": - case "quarter": - case "month": - interval = getMonthInterval(approxInterval); - getterName = monthGetterName(isUTC); - setterName = monthSetterName(isUTC); - break; - case "week": - case "half-week": - case "day": - interval = getDateInterval(approxInterval); - getterName = dateGetterName(isUTC); - setterName = dateSetterName(isUTC); - isDate = true; - break; - case "half-day": - case "quarter-day": - case "hour": - interval = getHourInterval(approxInterval); - getterName = hoursGetterName(isUTC); - setterName = hoursSetterName(isUTC); - break; - case "minute": - interval = getMinutesAndSecondsInterval(approxInterval, true); - getterName = minutesGetterName(isUTC); - setterName = minutesSetterName(isUTC); - break; - case "second": - interval = getMinutesAndSecondsInterval(approxInterval, false); - getterName = secondsGetterName(isUTC); - setterName = secondsSetterName(isUTC); - break; - case "millisecond": - interval = getMillisecondsInterval(approxInterval); - getterName = millisecondsGetterName(isUTC); - setterName = millisecondsSetterName(isUTC); - break; - } - addTicksInSpan(interval, startTick, endTick, getterName, setterName, isDate, newAddedTicks); - if (unitName === "year" && levelTicks2.length > 1 && i2 === 0) { - levelTicks2.unshift({ - value: levelTicks2[0].value - interval - }); - } - } - for (var i2 = 0; i2 < newAddedTicks.length; i2++) { - levelTicks2.push(newAddedTicks[i2]); - } - return newAddedTicks; - } - var levelsTicks = []; - var currentLevelTicks = []; - var tickCount = 0; - var lastLevelTickCount = 0; - for (var i = 0; i < unitNames.length && iter++ < safeLimit; ++i) { - var primaryTimeUnit = getPrimaryTimeUnit(unitNames[i]); - if (!isPrimaryTimeUnit(unitNames[i])) { - continue; - } - addLevelTicks(unitNames[i], levelsTicks[levelsTicks.length - 1] || [], currentLevelTicks); - var nextPrimaryTimeUnit = unitNames[i + 1] ? getPrimaryTimeUnit(unitNames[i + 1]) : null; - if (primaryTimeUnit !== nextPrimaryTimeUnit) { - if (currentLevelTicks.length) { - lastLevelTickCount = tickCount; - currentLevelTicks.sort(function(a, b) { - return a.value - b.value; - }); - var levelTicksRemoveDuplicated = []; - for (var i_1 = 0; i_1 < currentLevelTicks.length; ++i_1) { - var tickValue = currentLevelTicks[i_1].value; - if (i_1 === 0 || currentLevelTicks[i_1 - 1].value !== tickValue) { - levelTicksRemoveDuplicated.push(currentLevelTicks[i_1]); - if (tickValue >= extent[0] && tickValue <= extent[1]) { - tickCount++; - } - } - } - var targetTickNum = (extent[1] - extent[0]) / approxInterval; - if (tickCount > targetTickNum * 1.5 && lastLevelTickCount > targetTickNum / 1.5) { - break; - } - levelsTicks.push(levelTicksRemoveDuplicated); - if (tickCount > targetTickNum || bottomUnitName === unitNames[i]) { - break; - } - } - currentLevelTicks = []; - } - } - var levelsTicksInExtent = filter(map$1(levelsTicks, function(levelTicks2) { - return filter(levelTicks2, function(tick) { - return tick.value >= extent[0] && tick.value <= extent[1] && !tick.notAdd; - }); - }), function(levelTicks2) { - return levelTicks2.length > 0; - }); - var ticks = []; - var maxLevel = levelsTicksInExtent.length - 1; - for (var i = 0; i < levelsTicksInExtent.length; ++i) { - var levelTicks = levelsTicksInExtent[i]; - for (var k = 0; k < levelTicks.length; ++k) { - ticks.push({ - value: levelTicks[k].value, - level: maxLevel - i - }); - } - } - ticks.sort(function(a, b) { - return a.value - b.value; - }); - var result = []; - for (var i = 0; i < ticks.length; ++i) { - if (i === 0 || ticks[i].value !== ticks[i - 1].value) { - result.push(ticks[i]); - } - } - return result; -} -Scale.registerClass(TimeScale); - -var scaleProto = Scale.prototype; -// FIXME:TS refactor: not good to call it directly with `this`? -var intervalScaleProto = IntervalScale.prototype; -var roundingErrorFix = round$1; -var mathFloor = Math.floor; -var mathCeil = Math.ceil; -var mathPow = Math.pow; -var mathLog$1 = Math.log; -var LogScale = /** @class */function (_super) { - __extends(LogScale, _super); - function LogScale() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = 'log'; - _this.base = 10; - _this._originalScale = new IntervalScale(); - // FIXME:TS actually used by `IntervalScale` - _this._interval = 0; - return _this; - } - /** - * @param Whether expand the ticks to niced extent. - */ - LogScale.prototype.getTicks = function (expandToNicedExtent) { - var originalScale = this._originalScale; - var extent = this._extent; - var originalExtent = originalScale.getExtent(); - var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent); - return map$1(ticks, function (tick) { - var val = tick.value; - var powVal = round$1(mathPow(this.base, val)); - // Fix #4158 - powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal; - powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal; - return { - value: powVal - }; - }, this); - }; - LogScale.prototype.setExtent = function (start, end) { - var base = mathLog$1(this.base); - // log(-Infinity) is NaN, so safe guard here - start = mathLog$1(Math.max(0, start)) / base; - end = mathLog$1(Math.max(0, end)) / base; - intervalScaleProto.setExtent.call(this, start, end); - }; - /** - * @return {number} end - */ - LogScale.prototype.getExtent = function () { - var base = this.base; - var extent = scaleProto.getExtent.call(this); - extent[0] = mathPow(base, extent[0]); - extent[1] = mathPow(base, extent[1]); - // Fix #4158 - var originalScale = this._originalScale; - var originalExtent = originalScale.getExtent(); - this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0])); - this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1])); - return extent; - }; - LogScale.prototype.unionExtent = function (extent) { - this._originalScale.unionExtent(extent); - var base = this.base; - extent[0] = mathLog$1(extent[0]) / mathLog$1(base); - extent[1] = mathLog$1(extent[1]) / mathLog$1(base); - scaleProto.unionExtent.call(this, extent); - }; - LogScale.prototype.unionExtentFromData = function (data, dim) { - // TODO - // filter value that <= 0 - this.unionExtent(data.getApproximateExtent(dim)); - }; - /** - * Update interval and extent of intervals for nice ticks - * @param approxTickNum default 10 Given approx tick number - */ - LogScale.prototype.calcNiceTicks = function (approxTickNum) { - approxTickNum = approxTickNum || 10; - var extent = this._extent; - var span = extent[1] - extent[0]; - if (span === Infinity || span <= 0) { - return; - } - var interval = quantity(span); - var err = approxTickNum / span * interval; - // Filter ticks to get closer to the desired count. - if (err <= 0.5) { - interval *= 10; - } - // Interval should be integer - while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) { - interval *= 10; - } - var niceExtent = [round$1(mathCeil(extent[0] / interval) * interval), round$1(mathFloor(extent[1] / interval) * interval)]; - this._interval = interval; - this._niceExtent = niceExtent; - }; - LogScale.prototype.calcNiceExtent = function (opt) { - intervalScaleProto.calcNiceExtent.call(this, opt); - this._fixMin = opt.fixMin; - this._fixMax = opt.fixMax; - }; - LogScale.prototype.parse = function (val) { - return val; - }; - LogScale.prototype.contain = function (val) { - val = mathLog$1(val) / mathLog$1(this.base); - return contain(val, this._extent); - }; - LogScale.prototype.normalize = function (val) { - val = mathLog$1(val) / mathLog$1(this.base); - return normalize(val, this._extent); - }; - LogScale.prototype.scale = function (val) { - val = scale(val, this._extent); - return mathPow(this.base, val); - }; - LogScale.type = 'log'; - return LogScale; -}(Scale); -var proto = LogScale.prototype; -proto.getMinorTicks = intervalScaleProto.getMinorTicks; -proto.getLabel = intervalScaleProto.getLabel; -function fixRoundingError(val, originalVal) { - return roundingErrorFix(val, getPrecision(originalVal)); -} -Scale.registerClass(LogScale); - -var ScaleRawExtentInfo = ( - /** @class */ - function() { - function ScaleRawExtentInfo2(scale, model, originalExtent) { - this._prepareParams(scale, model, originalExtent); - } - ScaleRawExtentInfo2.prototype._prepareParams = function(scale, model, dataExtent) { - if (dataExtent[1] < dataExtent[0]) { - dataExtent = [NaN, NaN]; - } - this._dataMin = dataExtent[0]; - this._dataMax = dataExtent[1]; - var isOrdinal = this._isOrdinal = scale.type === "ordinal"; - this._needCrossZero = scale.type === "interval" && model.getNeedCrossZero && model.getNeedCrossZero(); - var axisMinValue = model.get("min", true); - if (axisMinValue == null) { - axisMinValue = model.get("startValue", true); - } - var modelMinRaw = this._modelMinRaw = axisMinValue; - if (isFunction(modelMinRaw)) { - this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw({ - min: dataExtent[0], - max: dataExtent[1] - })); - } else if (modelMinRaw !== "dataMin") { - this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw); - } - var modelMaxRaw = this._modelMaxRaw = model.get("max", true); - if (isFunction(modelMaxRaw)) { - this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw({ - min: dataExtent[0], - max: dataExtent[1] - })); - } else if (modelMaxRaw !== "dataMax") { - this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw); - } - if (isOrdinal) { - this._axisDataLen = model.getCategories().length; - } else { - var boundaryGap = model.get("boundaryGap"); - var boundaryGapArr = isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0]; - if (typeof boundaryGapArr[0] === "boolean" || typeof boundaryGapArr[1] === "boolean") { - this._boundaryGapInner = [0, 0]; - } else { - this._boundaryGapInner = [parsePercent$1(boundaryGapArr[0], 1), parsePercent$1(boundaryGapArr[1], 1)]; - } - } - }; - ScaleRawExtentInfo2.prototype.calculate = function() { - var isOrdinal = this._isOrdinal; - var dataMin = this._dataMin; - var dataMax = this._dataMax; - var axisDataLen = this._axisDataLen; - var boundaryGapInner = this._boundaryGapInner; - var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null; - var min = this._modelMinRaw === "dataMin" ? dataMin : this._modelMinNum; - var max = this._modelMaxRaw === "dataMax" ? dataMax : this._modelMaxNum; - var minFixed = min != null; - var maxFixed = max != null; - if (min == null) { - min = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span; - } - if (max == null) { - max = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span; - } - (min == null || !isFinite(min)) && (min = NaN); - (max == null || !isFinite(max)) && (max = NaN); - var isBlank = eqNaN(min) || eqNaN(max) || isOrdinal && !axisDataLen; - if (this._needCrossZero) { - if (min > 0 && max > 0 && !minFixed) { - min = 0; - } - if (min < 0 && max < 0 && !maxFixed) { - max = 0; - } - } - var determinedMin = this._determinedMin; - var determinedMax = this._determinedMax; - if (determinedMin != null) { - min = determinedMin; - minFixed = true; - } - if (determinedMax != null) { - max = determinedMax; - maxFixed = true; - } - return { - min, - max, - minFixed, - maxFixed, - isBlank - }; - }; - ScaleRawExtentInfo2.prototype.modifyDataMinMax = function(minMaxName, val) { - this[DATA_MIN_MAX_ATTR[minMaxName]] = val; - }; - ScaleRawExtentInfo2.prototype.setDeterminedMinMax = function(minMaxName, val) { - var attr = DETERMINED_MIN_MAX_ATTR[minMaxName]; - this[attr] = val; - }; - ScaleRawExtentInfo2.prototype.freeze = function() { - this.frozen = true; - }; - return ScaleRawExtentInfo2; - }() -); -var DETERMINED_MIN_MAX_ATTR = { - min: "_determinedMin", - max: "_determinedMax" -}; -var DATA_MIN_MAX_ATTR = { - min: "_dataMin", - max: "_dataMax" -}; -function ensureScaleRawExtentInfo(scale, model, originalExtent) { - var rawExtentInfo = scale.rawExtentInfo; - if (rawExtentInfo) { - return rawExtentInfo; - } - rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent); - scale.rawExtentInfo = rawExtentInfo; - return rawExtentInfo; -} -function parseAxisModelMinMax(scale, minMax) { - return minMax == null ? null : eqNaN(minMax) ? NaN : scale.parse(minMax); -} - -/** - * Get axis scale extent before niced. - * Item of returned array can only be number (including Infinity and NaN). - * - * Caution: - * Precondition of calling this method: - * The scale extent has been initialized using series data extent via - * `scale.setExtent` or `scale.unionExtentFromData`; - */ -function getScaleExtent(scale, model) { - var scaleType = scale.type; - var rawExtentResult = ensureScaleRawExtentInfo(scale, model, scale.getExtent()).calculate(); - scale.setBlank(rawExtentResult.isBlank); - var min = rawExtentResult.min; - var max = rawExtentResult.max; - // If bars are placed on a base axis of type time or interval account for axis boundary overflow and current axis - // is base axis - // FIXME - // (1) Consider support value axis, where below zero and axis `onZero` should be handled properly. - // (2) Refactor the logic with `barGrid`. Is it not need to `makeBarWidthAndOffsetInfo` twice with different extent? - // Should not depend on series type `bar`? - // (3) Fix that might overlap when using dataZoom. - // (4) Consider other chart types using `barGrid`? - // See #6728, #4862, `test/bar-overflow-time-plot.html` - var ecModel = model.ecModel; - if (ecModel && scaleType === 'time' /* || scaleType === 'interval' */) { - var barSeriesModels = prepareLayoutBarSeries('bar', ecModel); - var isBaseAxisAndHasBarSeries_1 = false; - each$4(barSeriesModels, function (seriesModel) { - isBaseAxisAndHasBarSeries_1 = isBaseAxisAndHasBarSeries_1 || seriesModel.getBaseAxis() === model.axis; - }); - if (isBaseAxisAndHasBarSeries_1) { - // Calculate placement of bars on axis. TODO should be decoupled - // with barLayout - var barWidthAndOffset = makeColumnLayout(barSeriesModels); - // Adjust axis min and max to account for overflow - var adjustedScale = adjustScaleForOverflow(min, max, model, barWidthAndOffset); - min = adjustedScale.min; - max = adjustedScale.max; - } - } - return { - extent: [min, max], - // "fix" means "fixed", the value should not be - // changed in the subsequent steps. - fixMin: rawExtentResult.minFixed, - fixMax: rawExtentResult.maxFixed - }; -} -function adjustScaleForOverflow(min, max, model, -// Only support cartesian coord yet. -barWidthAndOffset) { - // Get Axis Length - var axisExtent = model.axis.getExtent(); - var axisLength = Math.abs(axisExtent[1] - axisExtent[0]); - // Get bars on current base axis and calculate min and max overflow - var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis); - if (barsOnCurrentAxis === undefined) { - return { - min: min, - max: max - }; - } - var minOverflow = Infinity; - each$4(barsOnCurrentAxis, function (item) { - minOverflow = Math.min(item.offset, minOverflow); - }); - var maxOverflow = -Infinity; - each$4(barsOnCurrentAxis, function (item) { - maxOverflow = Math.max(item.offset + item.width, maxOverflow); - }); - minOverflow = Math.abs(minOverflow); - maxOverflow = Math.abs(maxOverflow); - var totalOverFlow = minOverflow + maxOverflow; - // Calculate required buffer based on old range and overflow - var oldRange = max - min; - var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength; - var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange; - max += overflowBuffer * (maxOverflow / totalOverFlow); - min -= overflowBuffer * (minOverflow / totalOverFlow); - return { - min: min, - max: max - }; -} -// Precondition of calling this method: -// The scale extent has been initialized using series data extent via -// `scale.setExtent` or `scale.unionExtentFromData`; -function niceScaleExtent(scale, inModel) { - var model = inModel; - var extentInfo = getScaleExtent(scale, model); - var extent = extentInfo.extent; - var splitNumber = model.get('splitNumber'); - if (scale instanceof LogScale) { - scale.base = model.get('logBase'); - } - var scaleType = scale.type; - var interval = model.get('interval'); - var isIntervalOrTime = scaleType === 'interval' || scaleType === 'time'; - scale.setExtent(extent[0], extent[1]); - scale.calcNiceExtent({ - splitNumber: splitNumber, - fixMin: extentInfo.fixMin, - fixMax: extentInfo.fixMax, - minInterval: isIntervalOrTime ? model.get('minInterval') : null, - maxInterval: isIntervalOrTime ? model.get('maxInterval') : null - }); - // If some one specified the min, max. And the default calculated interval - // is not good enough. He can specify the interval. It is often appeared - // in angle axis with angle 0 - 360. Interval calculated in interval scale is hard - // to be 60. - // FIXME - if (interval != null) { - scale.setInterval && scale.setInterval(interval); - } -} -/** - * @param axisType Default retrieve from model.type - */ -function createScaleByModel(model, axisType) { - axisType = axisType || model.get('type'); - if (axisType) { - switch (axisType) { - // Buildin scale - case 'category': - return new OrdinalScale({ - ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(), - extent: [Infinity, -Infinity] - }); - case 'time': - return new TimeScale({ - locale: model.ecModel.getLocaleModel(), - useUTC: model.ecModel.get('useUTC') - }); - default: - // case 'value'/'interval', 'log', or others. - return new (Scale.getClass(axisType) || IntervalScale)(); - } - } -} -/** - * Check if the axis cross 0 - */ -function ifAxisCrossZero(axis) { - var dataExtent = axis.scale.getExtent(); - var min = dataExtent[0]; - var max = dataExtent[1]; - return !(min > 0 && max > 0 || min < 0 && max < 0); -} -/** - * @param axis - * @return Label formatter function. - * param: {number} tickValue, - * param: {number} idx, the index in all ticks. - * If category axis, this param is not required. - * return: {string} label string. - */ -function makeLabelFormatter(axis) { - var labelFormatter = axis.getLabelModel().get('formatter'); - var categoryTickStart = axis.type === 'category' ? axis.scale.getExtent()[0] : null; - if (axis.scale.type === 'time') { - return function (tpl) { - return function (tick, idx) { - return axis.scale.getFormattedLabel(tick, idx, tpl); - }; - }(labelFormatter); - } else if (isString(labelFormatter)) { - return function (tpl) { - return function (tick) { - // For category axis, get raw value; for numeric axis, - // get formatted label like '1,333,444'. - var label = axis.scale.getLabel(tick); - var text = tpl.replace('{value}', label != null ? label : ''); - return text; - }; - }(labelFormatter); - } else if (isFunction(labelFormatter)) { - return function (cb) { - return function (tick, idx) { - // The original intention of `idx` is "the index of the tick in all ticks". - // But the previous implementation of category axis do not consider the - // `axisLabel.interval`, which cause that, for example, the `interval` is - // `1`, then the ticks "name5", "name7", "name9" are displayed, where the - // corresponding `idx` are `0`, `2`, `4`, but not `0`, `1`, `2`. So we keep - // the definition here for back compatibility. - if (categoryTickStart != null) { - idx = tick.value - categoryTickStart; - } - return cb(getAxisRawValue(axis, tick), idx, tick.level != null ? { - level: tick.level - } : null); - }; - }(labelFormatter); - } else { - return function (tick) { - return axis.scale.getLabel(tick); - }; - } -} -function getAxisRawValue(axis, tick) { - // In category axis with data zoom, tick is not the original - // index of axis.data. So tick should not be exposed to user - // in category axis. - return axis.type === 'category' ? axis.scale.getLabel(tick) : tick.value; -} -/** - * @param axis - * @return Be null/undefined if no labels. - */ -function estimateLabelUnionRect(axis) { - var axisModel = axis.model; - var scale = axis.scale; - if (!axisModel.get(['axisLabel', 'show']) || scale.isBlank()) { - return; - } - var realNumberScaleTicks; - var tickCount; - var categoryScaleExtent = scale.getExtent(); - // Optimize for large category data, avoid call `getTicks()`. - if (scale instanceof OrdinalScale) { - tickCount = scale.count(); - } else { - realNumberScaleTicks = scale.getTicks(); - tickCount = realNumberScaleTicks.length; - } - var axisLabelModel = axis.getLabelModel(); - var labelFormatter = makeLabelFormatter(axis); - var rect; - var step = 1; - // Simple optimization for large amount of labels - if (tickCount > 40) { - step = Math.ceil(tickCount / 40); - } - for (var i = 0; i < tickCount; i += step) { - var tick = realNumberScaleTicks ? realNumberScaleTicks[i] : { - value: categoryScaleExtent[0] + i - }; - var label = labelFormatter(tick, i); - var unrotatedSingleRect = axisLabelModel.getTextRect(label); - var singleRect = rotateTextRect(unrotatedSingleRect, axisLabelModel.get('rotate') || 0); - rect ? rect.union(singleRect) : rect = singleRect; - } - return rect; -} -function rotateTextRect(textRect, rotate) { - var rotateRadians = rotate * Math.PI / 180; - var beforeWidth = textRect.width; - var beforeHeight = textRect.height; - var afterWidth = beforeWidth * Math.abs(Math.cos(rotateRadians)) + Math.abs(beforeHeight * Math.sin(rotateRadians)); - var afterHeight = beforeWidth * Math.abs(Math.sin(rotateRadians)) + Math.abs(beforeHeight * Math.cos(rotateRadians)); - var rotatedRect = new BoundingRect(textRect.x, textRect.y, afterWidth, afterHeight); - return rotatedRect; -} -/** - * @param model axisLabelModel or axisTickModel - * @return {number|String} Can be null|'auto'|number|function - */ -function getOptionCategoryInterval(model) { - var interval = model.get('interval'); - return interval == null ? 'auto' : interval; -} -/** - * Set `categoryInterval` as 0 implicitly indicates that - * show all labels regardless of overlap. - * @param {Object} axis axisModel.axis - */ -function shouldShowAllLabels(axis) { - return axis.type === 'category' && getOptionCategoryInterval(axis.getLabelModel()) === 0; -} -function getDataDimensionsOnAxis(data, axisDim) { - // Remove duplicated dat dimensions caused by `getStackedDimension`. - var dataDimMap = {}; - // Currently `mapDimensionsAll` will contain stack result dimension ('__\0ecstackresult'). - // PENDING: is it reasonable? Do we need to remove the original dim from "coord dim" since - // there has been stacked result dim? - each$4(data.mapDimensionsAll(axisDim), function (dataDim) { - // For example, the extent of the original dimension - // is [0.1, 0.5], the extent of the `stackResultDimension` - // is [7, 9], the final extent should NOT include [0.1, 0.5], - // because there is no graphic corresponding to [0.1, 0.5]. - // See the case in `test/area-stack.html` `main1`, where area line - // stack needs `yAxis` not start from 0. - dataDimMap[getStackedDimension(data, dataDim)] = true; - }); - return keys(dataDimMap); -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -// eslint-disable-next-line @typescript-eslint/no-unused-vars -var AxisModelCommonMixin = /** @class */function () { - function AxisModelCommonMixin() {} - AxisModelCommonMixin.prototype.getNeedCrossZero = function () { - var option = this.option; - return !option.scale; - }; - /** - * Should be implemented by each axis model if necessary. - * @return coordinate system model - */ - AxisModelCommonMixin.prototype.getCoordSysModel = function () { - return; - }; - return AxisModelCommonMixin; -}(); - -var extensions = []; -var extensionRegisters = { - registerPreprocessor: registerPreprocessor, - registerProcessor: registerProcessor, - registerPostInit: registerPostInit, - registerPostUpdate: registerPostUpdate, - registerUpdateLifecycle: registerUpdateLifecycle, - registerAction: registerAction, - registerCoordinateSystem: registerCoordinateSystem, - registerLayout: registerLayout, - registerVisual: registerVisual, - registerTransform: registerTransform, - registerLoading: registerLoading, - registerMap: registerMap, - registerImpl: registerImpl, - PRIORITY: PRIORITY, - ComponentModel: ComponentModel, - ComponentView: ComponentView, - SeriesModel: SeriesModel, - ChartView: ChartView, - // TODO Use ComponentModel and SeriesModel instead of Constructor - registerComponentModel: function (ComponentModelClass) { - ComponentModel.registerClass(ComponentModelClass); - }, - registerComponentView: function (ComponentViewClass) { - ComponentView.registerClass(ComponentViewClass); - }, - registerSeriesModel: function (SeriesModelClass) { - SeriesModel.registerClass(SeriesModelClass); - }, - registerChartView: function (ChartViewClass) { - ChartView.registerClass(ChartViewClass); - }, - registerSubTypeDefaulter: function (componentType, defaulter) { - ComponentModel.registerSubTypeDefaulter(componentType, defaulter); - }, - registerPainter: function (painterType, PainterCtor) { - registerPainter(painterType, PainterCtor); - } -}; -function use(ext) { - if (isArray(ext)) { - // use([ChartLine, ChartBar]); - each$4(ext, function (singleExt) { - use(singleExt); - }); - return; - } - if (indexOf(extensions, ext) >= 0) { - return; - } - extensions.push(ext); - if (isFunction(ext)) { - ext = { - install: ext - }; - } - ext.install(extensionRegisters); -} - -var inner$4 = makeInner(); -function tickValuesToNumbers(axis, values) { - var nums = map$1(values, function (val) { - return axis.scale.parse(val); - }); - if (axis.type === 'time' && nums.length > 0) { - // Time axis needs duplicate first/last tick (see TimeScale.getTicks()) - // The first and last tick/label don't get drawn - nums.sort(); - nums.unshift(nums[0]); - nums.push(nums[nums.length - 1]); - } - return nums; -} -function createAxisLabels(axis) { - var custom = axis.getLabelModel().get('customValues'); - if (custom) { - var labelFormatter_1 = makeLabelFormatter(axis); - var extent_1 = axis.scale.getExtent(); - var tickNumbers = tickValuesToNumbers(axis, custom); - var ticks = filter(tickNumbers, function (val) { - return val >= extent_1[0] && val <= extent_1[1]; - }); - return { - labels: map$1(ticks, function (numval) { - var tick = { - value: numval - }; - return { - formattedLabel: labelFormatter_1(tick), - rawLabel: axis.scale.getLabel(tick), - tickValue: numval - }; - }) - }; - } - // Only ordinal scale support tick interval - return axis.type === 'category' ? makeCategoryLabels(axis) : makeRealNumberLabels(axis); -} -/** - * @param {module:echats/coord/Axis} axis - * @param {module:echarts/model/Model} tickModel For example, can be axisTick, splitLine, splitArea. - * @return {Object} { - * ticks: Array. - * tickCategoryInterval: number - * } - */ -function createAxisTicks(axis, tickModel) { - var custom = axis.getTickModel().get('customValues'); - if (custom) { - var extent_2 = axis.scale.getExtent(); - var tickNumbers = tickValuesToNumbers(axis, custom); - return { - ticks: filter(tickNumbers, function (val) { - return val >= extent_2[0] && val <= extent_2[1]; - }) - }; - } - // Only ordinal scale support tick interval - return axis.type === 'category' ? makeCategoryTicks(axis, tickModel) : { - ticks: map$1(axis.scale.getTicks(), function (tick) { - return tick.value; - }) - }; -} -function makeCategoryLabels(axis) { - var labelModel = axis.getLabelModel(); - var result = makeCategoryLabelsActually(axis, labelModel); - return !labelModel.get('show') || axis.scale.isBlank() ? { - labels: [], - labelCategoryInterval: result.labelCategoryInterval - } : result; -} -function makeCategoryLabelsActually(axis, labelModel) { - var labelsCache = getListCache(axis, 'labels'); - var optionLabelInterval = getOptionCategoryInterval(labelModel); - var result = listCacheGet(labelsCache, optionLabelInterval); - if (result) { - return result; - } - var labels; - var numericLabelInterval; - if (isFunction(optionLabelInterval)) { - labels = makeLabelsByCustomizedCategoryInterval(axis, optionLabelInterval); - } else { - numericLabelInterval = optionLabelInterval === 'auto' ? makeAutoCategoryInterval(axis) : optionLabelInterval; - labels = makeLabelsByNumericCategoryInterval(axis, numericLabelInterval); - } - // Cache to avoid calling interval function repeatedly. - return listCacheSet(labelsCache, optionLabelInterval, { - labels: labels, - labelCategoryInterval: numericLabelInterval - }); -} -function makeCategoryTicks(axis, tickModel) { - var ticksCache = getListCache(axis, 'ticks'); - var optionTickInterval = getOptionCategoryInterval(tickModel); - var result = listCacheGet(ticksCache, optionTickInterval); - if (result) { - return result; - } - var ticks; - var tickCategoryInterval; - // Optimize for the case that large category data and no label displayed, - // we should not return all ticks. - if (!tickModel.get('show') || axis.scale.isBlank()) { - ticks = []; - } - if (isFunction(optionTickInterval)) { - ticks = makeLabelsByCustomizedCategoryInterval(axis, optionTickInterval, true); - } - // Always use label interval by default despite label show. Consider this - // scenario, Use multiple grid with the xAxis sync, and only one xAxis shows - // labels. `splitLine` and `axisTick` should be consistent in this case. - else if (optionTickInterval === 'auto') { - var labelsResult = makeCategoryLabelsActually(axis, axis.getLabelModel()); - tickCategoryInterval = labelsResult.labelCategoryInterval; - ticks = map$1(labelsResult.labels, function (labelItem) { - return labelItem.tickValue; - }); - } else { - tickCategoryInterval = optionTickInterval; - ticks = makeLabelsByNumericCategoryInterval(axis, tickCategoryInterval, true); - } - // Cache to avoid calling interval function repeatedly. - return listCacheSet(ticksCache, optionTickInterval, { - ticks: ticks, - tickCategoryInterval: tickCategoryInterval - }); -} -function makeRealNumberLabels(axis) { - var ticks = axis.scale.getTicks(); - var labelFormatter = makeLabelFormatter(axis); - return { - labels: map$1(ticks, function (tick, idx) { - return { - level: tick.level, - formattedLabel: labelFormatter(tick, idx), - rawLabel: axis.scale.getLabel(tick), - tickValue: tick.value - }; - }) - }; -} -function getListCache(axis, prop) { - // Because key can be a function, and cache size always is small, we use array cache. - return inner$4(axis)[prop] || (inner$4(axis)[prop] = []); -} -function listCacheGet(cache, key) { - for (var i = 0; i < cache.length; i++) { - if (cache[i].key === key) { - return cache[i].value; - } - } -} -function listCacheSet(cache, key, value) { - cache.push({ - key: key, - value: value - }); - return value; -} -function makeAutoCategoryInterval(axis) { - var result = inner$4(axis).autoInterval; - return result != null ? result : inner$4(axis).autoInterval = axis.calculateCategoryInterval(); -} -/** - * Calculate interval for category axis ticks and labels. - * To get precise result, at least one of `getRotate` and `isHorizontal` - * should be implemented in axis. - */ -function calculateCategoryInterval(axis) { - var params = fetchAutoCategoryIntervalCalculationParams(axis); - var labelFormatter = makeLabelFormatter(axis); - var rotation = (params.axisRotate - params.labelRotate) / 180 * Math.PI; - var ordinalScale = axis.scale; - var ordinalExtent = ordinalScale.getExtent(); - // Providing this method is for optimization: - // avoid generating a long array by `getTicks` - // in large category data case. - var tickCount = ordinalScale.count(); - if (ordinalExtent[1] - ordinalExtent[0] < 1) { - return 0; - } - var step = 1; - // Simple optimization. Empirical value: tick count should less than 40. - if (tickCount > 40) { - step = Math.max(1, Math.floor(tickCount / 40)); - } - var tickValue = ordinalExtent[0]; - var unitSpan = axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue); - var unitW = Math.abs(unitSpan * Math.cos(rotation)); - var unitH = Math.abs(unitSpan * Math.sin(rotation)); - var maxW = 0; - var maxH = 0; - // Caution: Performance sensitive for large category data. - // Consider dataZoom, we should make appropriate step to avoid O(n) loop. - for (; tickValue <= ordinalExtent[1]; tickValue += step) { - var width = 0; - var height = 0; - // Not precise, do not consider align and vertical align - // and each distance from axis line yet. - var rect = getBoundingRect(labelFormatter({ - value: tickValue - }), params.font, 'center', 'top'); - // Magic number - width = rect.width * 1.3; - height = rect.height * 1.3; - // Min size, void long loop. - maxW = Math.max(maxW, width, 7); - maxH = Math.max(maxH, height, 7); - } - var dw = maxW / unitW; - var dh = maxH / unitH; - // 0/0 is NaN, 1/0 is Infinity. - isNaN(dw) && (dw = Infinity); - isNaN(dh) && (dh = Infinity); - var interval = Math.max(0, Math.floor(Math.min(dw, dh))); - var cache = inner$4(axis.model); - var axisExtent = axis.getExtent(); - var lastAutoInterval = cache.lastAutoInterval; - var lastTickCount = cache.lastTickCount; - // Use cache to keep interval stable while moving zoom window, - // otherwise the calculated interval might jitter when the zoom - // window size is close to the interval-changing size. - // For example, if all of the axis labels are `a, b, c, d, e, f, g`. - // The jitter will cause that sometimes the displayed labels are - // `a, d, g` (interval: 2) sometimes `a, c, e`(interval: 1). - if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 - // Always choose the bigger one, otherwise the critical - // point is not the same when zooming in or zooming out. - && lastAutoInterval > interval - // If the axis change is caused by chart resize, the cache should not - // be used. Otherwise some hidden labels might not be shown again. - && cache.axisExtent0 === axisExtent[0] && cache.axisExtent1 === axisExtent[1]) { - interval = lastAutoInterval; - } - // Only update cache if cache not used, otherwise the - // changing of interval is too insensitive. - else { - cache.lastTickCount = tickCount; - cache.lastAutoInterval = interval; - cache.axisExtent0 = axisExtent[0]; - cache.axisExtent1 = axisExtent[1]; - } - return interval; -} -function fetchAutoCategoryIntervalCalculationParams(axis) { - var labelModel = axis.getLabelModel(); - return { - axisRotate: axis.getRotate ? axis.getRotate() : axis.isHorizontal && !axis.isHorizontal() ? 90 : 0, - labelRotate: labelModel.get('rotate') || 0, - font: labelModel.getFont() - }; -} -function makeLabelsByNumericCategoryInterval(axis, categoryInterval, onlyTick) { - var labelFormatter = makeLabelFormatter(axis); - var ordinalScale = axis.scale; - var ordinalExtent = ordinalScale.getExtent(); - var labelModel = axis.getLabelModel(); - var result = []; - // TODO: axisType: ordinalTime, pick the tick from each month/day/year/... - var step = Math.max((categoryInterval || 0) + 1, 1); - var startTick = ordinalExtent[0]; - var tickCount = ordinalScale.count(); - // Calculate start tick based on zero if possible to keep label consistent - // while zooming and moving while interval > 0. Otherwise the selection - // of displayable ticks and symbols probably keep changing. - // 3 is empirical value. - if (startTick !== 0 && step > 1 && tickCount / step > 2) { - startTick = Math.round(Math.ceil(startTick / step) * step); - } - // (1) Only add min max label here but leave overlap checking - // to render stage, which also ensure the returned list - // suitable for splitLine and splitArea rendering. - // (2) Scales except category always contain min max label so - // do not need to perform this process. - var showAllLabel = shouldShowAllLabels(axis); - var includeMinLabel = labelModel.get('showMinLabel') || showAllLabel; - var includeMaxLabel = labelModel.get('showMaxLabel') || showAllLabel; - if (includeMinLabel && startTick !== ordinalExtent[0]) { - addItem(ordinalExtent[0]); - } - // Optimize: avoid generating large array by `ordinalScale.getTicks()`. - var tickValue = startTick; - for (; tickValue <= ordinalExtent[1]; tickValue += step) { - addItem(tickValue); - } - if (includeMaxLabel && tickValue - step !== ordinalExtent[1]) { - addItem(ordinalExtent[1]); - } - function addItem(tickValue) { - var tickObj = { - value: tickValue - }; - result.push(onlyTick ? tickValue : { - formattedLabel: labelFormatter(tickObj), - rawLabel: ordinalScale.getLabel(tickObj), - tickValue: tickValue - }); - } - return result; -} -function makeLabelsByCustomizedCategoryInterval(axis, categoryInterval, onlyTick) { - var ordinalScale = axis.scale; - var labelFormatter = makeLabelFormatter(axis); - var result = []; - each$4(ordinalScale.getTicks(), function (tick) { - var rawLabel = ordinalScale.getLabel(tick); - var tickValue = tick.value; - if (categoryInterval(tick.value, rawLabel)) { - result.push(onlyTick ? tickValue : { - formattedLabel: labelFormatter(tick), - rawLabel: rawLabel, - tickValue: tickValue - }); - } - }); - return result; -} - -var NORMALIZED_EXTENT = [0, 1]; -/** - * Base class of Axis. - */ -var Axis = /** @class */function () { - function Axis(dim, scale, extent) { - this.onBand = false; - this.inverse = false; - this.dim = dim; - this.scale = scale; - this._extent = extent || [0, 0]; - } - /** - * If axis extent contain given coord - */ - Axis.prototype.contain = function (coord) { - var extent = this._extent; - var min = Math.min(extent[0], extent[1]); - var max = Math.max(extent[0], extent[1]); - return coord >= min && coord <= max; - }; - /** - * If axis extent contain given data - */ - Axis.prototype.containData = function (data) { - return this.scale.contain(data); - }; - /** - * Get coord extent. - */ - Axis.prototype.getExtent = function () { - return this._extent.slice(); - }; - /** - * Get precision used for formatting - */ - Axis.prototype.getPixelPrecision = function (dataExtent) { - return getPixelPrecision(dataExtent || this.scale.getExtent(), this._extent); - }; - /** - * Set coord extent - */ - Axis.prototype.setExtent = function (start, end) { - var extent = this._extent; - extent[0] = start; - extent[1] = end; - }; - /** - * Convert data to coord. Data is the rank if it has an ordinal scale - */ - Axis.prototype.dataToCoord = function (data, clamp) { - var extent = this._extent; - var scale = this.scale; - data = scale.normalize(data); - if (this.onBand && scale.type === 'ordinal') { - extent = extent.slice(); - fixExtentWithBands(extent, scale.count()); - } - return linearMap(data, NORMALIZED_EXTENT, extent, clamp); - }; - /** - * Convert coord to data. Data is the rank if it has an ordinal scale - */ - Axis.prototype.coordToData = function (coord, clamp) { - var extent = this._extent; - var scale = this.scale; - if (this.onBand && scale.type === 'ordinal') { - extent = extent.slice(); - fixExtentWithBands(extent, scale.count()); - } - var t = linearMap(coord, extent, NORMALIZED_EXTENT, clamp); - return this.scale.scale(t); - }; - /** - * Convert pixel point to data in axis - */ - Axis.prototype.pointToData = function (point, clamp) { - // Should be implemented in derived class if necessary. - return; - }; - /** - * Different from `zrUtil.map(axis.getTicks(), axis.dataToCoord, axis)`, - * `axis.getTicksCoords` considers `onBand`, which is used by - * `boundaryGap:true` of category axis and splitLine and splitArea. - * @param opt.tickModel default: axis.model.getModel('axisTick') - * @param opt.clamp If `true`, the first and the last - * tick must be at the axis end points. Otherwise, clip ticks - * that outside the axis extent. - */ - Axis.prototype.getTicksCoords = function (opt) { - opt = opt || {}; - var tickModel = opt.tickModel || this.getTickModel(); - var result = createAxisTicks(this, tickModel); - var ticks = result.ticks; - var ticksCoords = map$1(ticks, function (tickVal) { - return { - coord: this.dataToCoord(this.scale.type === 'ordinal' ? this.scale.getRawOrdinalNumber(tickVal) : tickVal), - tickValue: tickVal - }; - }, this); - var alignWithLabel = tickModel.get('alignWithLabel'); - fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp); - return ticksCoords; - }; - Axis.prototype.getMinorTicksCoords = function () { - if (this.scale.type === 'ordinal') { - // Category axis doesn't support minor ticks - return []; - } - var minorTickModel = this.model.getModel('minorTick'); - var splitNumber = minorTickModel.get('splitNumber'); - // Protection. - if (!(splitNumber > 0 && splitNumber < 100)) { - splitNumber = 5; - } - var minorTicks = this.scale.getMinorTicks(splitNumber); - var minorTicksCoords = map$1(minorTicks, function (minorTicksGroup) { - return map$1(minorTicksGroup, function (minorTick) { - return { - coord: this.dataToCoord(minorTick), - tickValue: minorTick - }; - }, this); - }, this); - return minorTicksCoords; - }; - Axis.prototype.getViewLabels = function () { - return createAxisLabels(this).labels; - }; - Axis.prototype.getLabelModel = function () { - return this.model.getModel('axisLabel'); - }; - /** - * Notice here we only get the default tick model. For splitLine - * or splitArea, we should pass the splitLineModel or splitAreaModel - * manually when calling `getTicksCoords`. - * In GL, this method may be overridden to: - * `axisModel.getModel('axisTick', grid3DModel.getModel('axisTick'));` - */ - Axis.prototype.getTickModel = function () { - return this.model.getModel('axisTick'); - }; - /** - * Get width of band - */ - Axis.prototype.getBandWidth = function () { - var axisExtent = this._extent; - var dataExtent = this.scale.getExtent(); - var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0); - // Fix #2728, avoid NaN when only one data. - len === 0 && (len = 1); - var size = Math.abs(axisExtent[1] - axisExtent[0]); - return Math.abs(size) / len; - }; - /** - * Only be called in category axis. - * Can be overridden, consider other axes like in 3D. - * @return Auto interval for cateogry axis tick and label - */ - Axis.prototype.calculateCategoryInterval = function () { - return calculateCategoryInterval(this); - }; - return Axis; -}(); -function fixExtentWithBands(extent, nTick) { - var size = extent[1] - extent[0]; - var len = nTick; - var margin = size / len / 2; - extent[0] += margin; - extent[1] -= margin; -} -// If axis has labels [1, 2, 3, 4]. Bands on the axis are -// |---1---|---2---|---3---|---4---|. -// So the displayed ticks and splitLine/splitArea should between -// each data item, otherwise cause misleading (e.g., split tow bars -// of a single data item when there are two bar series). -// Also consider if tickCategoryInterval > 0 and onBand, ticks and -// splitLine/spliteArea should layout appropriately corresponding -// to displayed labels. (So we should not use `getBandWidth` in this -// case). -function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp) { - var ticksLen = ticksCoords.length; - if (!axis.onBand || alignWithLabel || !ticksLen) { - return; - } - var axisExtent = axis.getExtent(); - var last; - var diffSize; - if (ticksLen === 1) { - ticksCoords[0].coord = axisExtent[0]; - last = ticksCoords[1] = { - coord: axisExtent[1], - tickValue: ticksCoords[0].tickValue - }; - } else { - var crossLen = ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue; - var shift_1 = (ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen; - each$4(ticksCoords, function (ticksItem) { - ticksItem.coord -= shift_1 / 2; - }); - var dataExtent = axis.scale.getExtent(); - diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue; - last = { - coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize, - tickValue: dataExtent[1] + 1 - }; - ticksCoords.push(last); - } - var inverse = axisExtent[0] > axisExtent[1]; - // Handling clamp. - if (littleThan(ticksCoords[0].coord, axisExtent[0])) { - clamp ? ticksCoords[0].coord = axisExtent[0] : ticksCoords.shift(); - } - if (clamp && littleThan(axisExtent[0], ticksCoords[0].coord)) { - ticksCoords.unshift({ - coord: axisExtent[0] - }); - } - if (littleThan(axisExtent[1], last.coord)) { - clamp ? last.coord = axisExtent[1] : ticksCoords.pop(); - } - if (clamp && littleThan(last.coord, axisExtent[1])) { - ticksCoords.push({ - coord: axisExtent[1] - }); - } - function littleThan(a, b) { - // Avoid rounding error cause calculated tick coord different with extent. - // It may cause an extra unnecessary tick added. - a = round$1(a); - b = round$1(b); - return inverse ? a > b : a < b; - } -} - -function projectPointToLine(x1, y1, x2, y2, x, y, out, limitToEnds) { - var dx = x - x1; - var dy = y - y1; - var dx1 = x2 - x1; - var dy1 = y2 - y1; - var lineLen = Math.sqrt(dx1 * dx1 + dy1 * dy1); - dx1 /= lineLen; - dy1 /= lineLen; - // dot product - var projectedLen = dx * dx1 + dy * dy1; - var t = projectedLen / lineLen; - t *= lineLen; - var ox = out[0] = x1 + t * dx1; - var oy = out[1] = y1 + t * dy1; - return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y)); -} -// Temporal variable for intermediate usage. -var pt0 = new Point(); -var pt1 = new Point(); -var pt2 = new Point(); -var dir = new Point(); -var dir2 = new Point(); -// Temporal variable for the limitTurnAngle function -var tmpArr = []; -var tmpProjPoint = new Point(); -/** - * Reduce the line segment attached to the label to limit the turn angle between two segments. - * @param linePoints - * @param minTurnAngle Radian of minimum turn angle. 0 - 180 - */ -function limitTurnAngle(linePoints, minTurnAngle) { - if (!(minTurnAngle <= 180 && minTurnAngle > 0)) { - return; - } - minTurnAngle = minTurnAngle / 180 * Math.PI; - // The line points can be - // /pt1----pt2 (label) - // / - // pt0/ - pt0.fromArray(linePoints[0]); - pt1.fromArray(linePoints[1]); - pt2.fromArray(linePoints[2]); - Point.sub(dir, pt0, pt1); - Point.sub(dir2, pt2, pt1); - var len1 = dir.len(); - var len2 = dir2.len(); - if (len1 < 1e-3 || len2 < 1e-3) { - return; - } - dir.scale(1 / len1); - dir2.scale(1 / len2); - var angleCos = dir.dot(dir2); - var minTurnAngleCos = Math.cos(minTurnAngle); - if (minTurnAngleCos < angleCos) { - // Smaller than minTurnAngle - // Calculate project point of pt0 on pt1-pt2 - var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr); - tmpProjPoint.fromArray(tmpArr); - // Calculate new projected length with limited minTurnAngle and get the new connect point - tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI - minTurnAngle)); - // Limit the new calculated connect point between pt1 and pt2. - var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y); - if (isNaN(t)) { - return; - } - if (t < 0) { - Point.copy(tmpProjPoint, pt1); - } else if (t > 1) { - Point.copy(tmpProjPoint, pt2); - } - tmpProjPoint.toArray(linePoints[1]); - } -} -/** - * Limit the angle of line and the surface - * @param maxSurfaceAngle Radian of minimum turn angle. 0 - 180. 0 is same direction to normal. 180 is opposite - */ -function limitSurfaceAngle(linePoints, surfaceNormal, maxSurfaceAngle) { - if (!(maxSurfaceAngle <= 180 && maxSurfaceAngle > 0)) { - return; - } - maxSurfaceAngle = maxSurfaceAngle / 180 * Math.PI; - pt0.fromArray(linePoints[0]); - pt1.fromArray(linePoints[1]); - pt2.fromArray(linePoints[2]); - Point.sub(dir, pt1, pt0); - Point.sub(dir2, pt2, pt1); - var len1 = dir.len(); - var len2 = dir2.len(); - if (len1 < 1e-3 || len2 < 1e-3) { - return; - } - dir.scale(1 / len1); - dir2.scale(1 / len2); - var angleCos = dir.dot(surfaceNormal); - var maxSurfaceAngleCos = Math.cos(maxSurfaceAngle); - if (angleCos < maxSurfaceAngleCos) { - // Calculate project point of pt0 on pt1-pt2 - var d = projectPointToLine(pt1.x, pt1.y, pt2.x, pt2.y, pt0.x, pt0.y, tmpArr); - tmpProjPoint.fromArray(tmpArr); - var HALF_PI = Math.PI / 2; - var angle2 = Math.acos(dir2.dot(surfaceNormal)); - var newAngle = HALF_PI + angle2 - maxSurfaceAngle; - if (newAngle >= HALF_PI) { - // parallel - Point.copy(tmpProjPoint, pt2); - } else { - // Calculate new projected length with limited minTurnAngle and get the new connect point - tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI / 2 - newAngle)); - // Limit the new calculated connect point between pt1 and pt2. - var t = pt2.x !== pt1.x ? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x) : (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y); - if (isNaN(t)) { - return; - } - if (t < 0) { - Point.copy(tmpProjPoint, pt1); - } else if (t > 1) { - Point.copy(tmpProjPoint, pt2); - } - } - tmpProjPoint.toArray(linePoints[1]); - } -} -function setLabelLineState(labelLine, ignore, stateName, stateModel) { - var isNormal = stateName === 'normal'; - var stateObj = isNormal ? labelLine : labelLine.ensureState(stateName); - // Make sure display. - stateObj.ignore = ignore; - // Set smooth - var smooth = stateModel.get('smooth'); - if (smooth && smooth === true) { - smooth = 0.3; - } - stateObj.shape = stateObj.shape || {}; - if (smooth > 0) { - stateObj.shape.smooth = smooth; - } - var styleObj = stateModel.getModel('lineStyle').getLineStyle(); - isNormal ? labelLine.useStyle(styleObj) : stateObj.style = styleObj; -} -function buildLabelLinePath(path, shape) { - var smooth = shape.smooth; - var points = shape.points; - if (!points) { - return; - } - path.moveTo(points[0][0], points[0][1]); - if (smooth > 0 && points.length >= 3) { - var len1 = dist$1(points[0], points[1]); - var len2 = dist$1(points[1], points[2]); - if (!len1 || !len2) { - path.lineTo(points[1][0], points[1][1]); - path.lineTo(points[2][0], points[2][1]); - return; - } - var moveLen = Math.min(len1, len2) * smooth; - var midPoint0 = lerp$1([], points[1], points[0], moveLen / len1); - var midPoint2 = lerp$1([], points[1], points[2], moveLen / len2); - var midPoint1 = lerp$1([], midPoint0, midPoint2, 0.5); - path.bezierCurveTo(midPoint0[0], midPoint0[1], midPoint0[0], midPoint0[1], midPoint1[0], midPoint1[1]); - path.bezierCurveTo(midPoint2[0], midPoint2[1], midPoint2[0], midPoint2[1], points[2][0], points[2][1]); - } else { - for (var i = 1; i < points.length; i++) { - path.lineTo(points[i][0], points[i][1]); - } - } -} -/** - * Create a label line if necessary and set it's style. - */ -function setLabelLineStyle(targetEl, statesModels, defaultStyle) { - var labelLine = targetEl.getTextGuideLine(); - var label = targetEl.getTextContent(); - if (!label) { - // Not show label line if there is no label. - if (labelLine) { - targetEl.removeTextGuideLine(); - } - return; - } - var normalModel = statesModels.normal; - var showNormal = normalModel.get('show'); - var labelIgnoreNormal = label.ignore; - for (var i = 0; i < DISPLAY_STATES.length; i++) { - var stateName = DISPLAY_STATES[i]; - var stateModel = statesModels[stateName]; - var isNormal = stateName === 'normal'; - if (stateModel) { - var stateShow = stateModel.get('show'); - var isLabelIgnored = isNormal ? labelIgnoreNormal : retrieve2(label.states[stateName] && label.states[stateName].ignore, labelIgnoreNormal); - if (isLabelIgnored // Not show when label is not shown in this state. - || !retrieve2(stateShow, showNormal) // Use normal state by default if not set. - ) { - var stateObj = isNormal ? labelLine : labelLine && labelLine.states[stateName]; - if (stateObj) { - stateObj.ignore = true; - } - if (!!labelLine) { - setLabelLineState(labelLine, true, stateName, stateModel); - } - continue; - } - // Create labelLine if not exists - if (!labelLine) { - labelLine = new Polyline(); - targetEl.setTextGuideLine(labelLine); - // Reset state of normal because it's new created. - // NOTE: NORMAL should always been the first! - if (!isNormal && (labelIgnoreNormal || !showNormal)) { - setLabelLineState(labelLine, true, 'normal', statesModels.normal); - } - // Use same state proxy. - if (targetEl.stateProxy) { - labelLine.stateProxy = targetEl.stateProxy; - } - } - setLabelLineState(labelLine, false, stateName, stateModel); - } - } - if (labelLine) { - defaults(labelLine.style, defaultStyle); - // Not fill. - labelLine.style.fill = null; - var showAbove = normalModel.get('showAbove'); - var labelLineConfig = targetEl.textGuideLineConfig = targetEl.textGuideLineConfig || {}; - labelLineConfig.showAbove = showAbove || false; - // Custom the buildPath. - labelLine.buildPath = buildLabelLinePath; - } -} -function getLabelLineStatesModels(itemModel, labelLineName) { - labelLineName = labelLineName || 'labelLine'; - var statesModels = { - normal: itemModel.getModel(labelLineName) - }; - for (var i = 0; i < SPECIAL_STATES.length; i++) { - var stateName = SPECIAL_STATES[i]; - statesModels[stateName] = itemModel.getModel([stateName, labelLineName]); - } - return statesModels; -} - -function prepareLayoutList(input) { - var list = []; - for (var i = 0; i < input.length; i++) { - var rawItem = input[i]; - if (rawItem.defaultAttr.ignore) { - continue; - } - var label = rawItem.label; - var transform = label.getComputedTransform(); - // NOTE: Get bounding rect after getComputedTransform, or label may not been updated by the host el. - var localRect = label.getBoundingRect(); - var isAxisAligned = !transform || transform[1] < 1e-5 && transform[2] < 1e-5; - var minMargin = label.style.margin || 0; - var globalRect = localRect.clone(); - globalRect.applyTransform(transform); - globalRect.x -= minMargin / 2; - globalRect.y -= minMargin / 2; - globalRect.width += minMargin; - globalRect.height += minMargin; - var obb = isAxisAligned ? new OrientedBoundingRect(localRect, transform) : null; - list.push({ - label: label, - labelLine: rawItem.labelLine, - rect: globalRect, - localRect: localRect, - obb: obb, - priority: rawItem.priority, - defaultAttr: rawItem.defaultAttr, - layoutOption: rawItem.computedLayoutOption, - axisAligned: isAxisAligned, - transform: transform - }); - } - return list; -} -function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) { - var len = list.length; - if (len < 2) { - return; - } - list.sort(function (a, b) { - return a.rect[xyDim] - b.rect[xyDim]; - }); - var lastPos = 0; - var delta; - var adjusted = false; - for (var i = 0; i < len; i++) { - var item = list[i]; - var rect = item.rect; - delta = rect[xyDim] - lastPos; - if (delta < 0) { - // shiftForward(i, len, -delta); - rect[xyDim] -= delta; - item.label[xyDim] -= delta; - adjusted = true; - } - lastPos = rect[xyDim] + rect[sizeDim]; - } - // TODO bleedMargin? - var first = list[0]; - var last = list[len - 1]; - var minGap; - var maxGap; - updateMinMaxGap(); - // If ends exceed two bounds, squeeze at most 80%, then take the gap of two bounds. - minGap < 0 && squeezeGaps(-minGap, 0.8); - maxGap < 0 && squeezeGaps(maxGap, 0.8); - updateMinMaxGap(); - takeBoundsGap(minGap, maxGap, 1); - takeBoundsGap(maxGap, minGap, -1); - // Handle bailout when there is not enough space. - updateMinMaxGap(); - if (minGap < 0) { - squeezeWhenBailout(-minGap); - } - if (maxGap < 0) { - squeezeWhenBailout(maxGap); - } - function updateMinMaxGap() { - minGap = first.rect[xyDim] - minBound; - maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim]; - } - function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) { - if (gapThisBound < 0) { - // Move from other gap if can. - var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound); - if (moveFromMaxGap > 0) { - shiftList(moveFromMaxGap * moveDir, 0, len); - var remained = moveFromMaxGap + gapThisBound; - if (remained < 0) { - squeezeGaps(-remained * moveDir, 1); - } - } else { - squeezeGaps(-gapThisBound * moveDir, 1); - } - } - } - function shiftList(delta, start, end) { - if (delta !== 0) { - adjusted = true; - } - for (var i = start; i < end; i++) { - var item = list[i]; - var rect = item.rect; - rect[xyDim] += delta; - item.label[xyDim] += delta; - } - } - // Squeeze gaps if the labels exceed margin. - function squeezeGaps(delta, maxSqeezePercent) { - var gaps = []; - var totalGaps = 0; - for (var i = 1; i < len; i++) { - var prevItemRect = list[i - 1].rect; - var gap = Math.max(list[i].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim], 0); - gaps.push(gap); - totalGaps += gap; - } - if (!totalGaps) { - return; - } - var squeezePercent = Math.min(Math.abs(delta) / totalGaps, maxSqeezePercent); - if (delta > 0) { - for (var i = 0; i < len - 1; i++) { - // Distribute the shift delta to all gaps. - var movement = gaps[i] * squeezePercent; - // Forward - shiftList(movement, 0, i + 1); - } - } else { - // Backward - for (var i = len - 1; i > 0; i--) { - // Distribute the shift delta to all gaps. - var movement = gaps[i - 1] * squeezePercent; - shiftList(-movement, i, len); - } - } - } - /** - * Squeeze to allow overlap if there is no more space available. - * Let other overlapping strategy like hideOverlap do the job instead of keep exceeding the bounds. - */ - function squeezeWhenBailout(delta) { - var dir = delta < 0 ? -1 : 1; - delta = Math.abs(delta); - var moveForEachLabel = Math.ceil(delta / (len - 1)); - for (var i = 0; i < len - 1; i++) { - if (dir > 0) { - // Forward - shiftList(moveForEachLabel, 0, i + 1); - } else { - // Backward - shiftList(-moveForEachLabel, len - i - 1, len); - } - delta -= moveForEachLabel; - if (delta <= 0) { - return; - } - } - } - return adjusted; -} -/** - * Adjust labels on y direction to avoid overlap. - */ -function shiftLayoutOnY(list, topBound, bottomBound, -// If average the shifts on all labels and add them to 0 -balanceShift) { - return shiftLayout(list, 'y', 'height', topBound, bottomBound); -} -function hideOverlap(labelList) { - var displayedLabels = []; - // TODO, render overflow visible first, put in the displayedLabels. - labelList.sort(function (a, b) { - return b.priority - a.priority; - }); - var globalRect = new BoundingRect(0, 0, 0, 0); - function hideEl(el) { - if (!el.ignore) { - // Show on emphasis. - var emphasisState = el.ensureState('emphasis'); - if (emphasisState.ignore == null) { - emphasisState.ignore = false; - } - } - el.ignore = true; - } - for (var i = 0; i < labelList.length; i++) { - var labelItem = labelList[i]; - var isAxisAligned = labelItem.axisAligned; - var localRect = labelItem.localRect; - var transform = labelItem.transform; - var label = labelItem.label; - var labelLine = labelItem.labelLine; - globalRect.copy(labelItem.rect); - // Add a threshold because layout may be aligned precisely. - globalRect.width -= 0.1; - globalRect.height -= 0.1; - globalRect.x += 0.05; - globalRect.y += 0.05; - var obb = labelItem.obb; - var overlapped = false; - for (var j = 0; j < displayedLabels.length; j++) { - var existsTextCfg = displayedLabels[j]; - // Fast rejection. - if (!globalRect.intersect(existsTextCfg.rect)) { - continue; - } - if (isAxisAligned && existsTextCfg.axisAligned) { - // Is overlapped - overlapped = true; - break; - } - if (!existsTextCfg.obb) { - // If self is not axis aligned. But other is. - existsTextCfg.obb = new OrientedBoundingRect(existsTextCfg.localRect, existsTextCfg.transform); - } - if (!obb) { - // If self is axis aligned. But other is not. - obb = new OrientedBoundingRect(localRect, transform); - } - if (obb.intersect(existsTextCfg.obb)) { - overlapped = true; - break; - } - } - // TODO Callback to determine if this overlap should be handled? - if (overlapped) { - hideEl(label); - labelLine && hideEl(labelLine); - } else { - label.attr('ignore', labelItem.defaultAttr.ignore); - labelLine && labelLine.attr('ignore', labelItem.defaultAttr.labelGuideIgnore); - displayedLabels.push(labelItem); - } - } -} - -var raf = null; -function requestAnimationFrame (callback) { - if (!raf) { - raf = ( - window.requestAnimationFrame || - window.webkitRequestAnimationFrame || - window.mozRequestAnimationFrame || - function (callback) { - return setTimeout(callback, 16) - } - ).bind(window); - } - return raf(callback) -} - -var caf = null; -function cancelAnimationFrame (id) { - if (!caf) { - caf = ( - window.cancelAnimationFrame || - window.webkitCancelAnimationFrame || - window.mozCancelAnimationFrame || - function (id) { - clearTimeout(id); - } - ).bind(window); - } - - caf(id); -} - -function createStyles (styleText) { - var style = document.createElement('style'); - - if (style.styleSheet) { - style.styleSheet.cssText = styleText; - } else { - style.appendChild(document.createTextNode(styleText)); - } - (document.querySelector('head') || document.body).appendChild(style); - return style -} - -function createElement (tagName, props) { - if ( props === void 0 ) props = {}; - - var elem = document.createElement(tagName); - Object.keys(props).forEach(function (key) { - elem[key] = props[key]; - }); - return elem -} - -function getComputedStyle$1 (elem, prop, pseudo) { - // for older versions of Firefox, `getComputedStyle` required - // the second argument and may return `null` for some elements - // when `display: none` - var computedStyle = window.getComputedStyle(elem, null) || { - display: 'none' - }; - - return computedStyle[prop] -} - -function getRenderInfo (elem) { - if (!document.documentElement.contains(elem)) { - return { - detached: true, - rendered: false - } - } - - var current = elem; - while (current !== document) { - if (getComputedStyle$1(current, 'display') === 'none') { - return { - detached: false, - rendered: false - } - } - current = current.parentNode; - } - - return { - detached: false, - rendered: true - } -} - -var css_248z = ".resize-triggers{visibility:hidden;opacity:0;pointer-events:none}.resize-contract-trigger,.resize-contract-trigger:before,.resize-expand-trigger,.resize-triggers{content:\"\";position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden}.resize-contract-trigger,.resize-expand-trigger{background:#eee;overflow:auto}.resize-contract-trigger:before{width:200%;height:200%}"; - -var total = 0; -var style = null; - -function addListener (elem, callback) { - if (!elem.__resize_mutation_handler__) { - elem.__resize_mutation_handler__ = handleMutation.bind(elem); - } - - var listeners = elem.__resize_listeners__; - - if (!listeners) { - elem.__resize_listeners__ = []; - if (window.ResizeObserver) { - var offsetWidth = elem.offsetWidth; - var offsetHeight = elem.offsetHeight; - var ro = new ResizeObserver(function () { - if (!elem.__resize_observer_triggered__) { - elem.__resize_observer_triggered__ = true; - if (elem.offsetWidth === offsetWidth && elem.offsetHeight === offsetHeight) { - return - } - } - runCallbacks(elem); - }); - - // initially display none won't trigger ResizeObserver callback - var ref = getRenderInfo(elem); - var detached = ref.detached; - var rendered = ref.rendered; - elem.__resize_observer_triggered__ = detached === false && rendered === false; - elem.__resize_observer__ = ro; - ro.observe(elem); - } else if (elem.attachEvent && elem.addEventListener) { - // targeting IE9/10 - elem.__resize_legacy_resize_handler__ = function handleLegacyResize () { - runCallbacks(elem); - }; - elem.attachEvent('onresize', elem.__resize_legacy_resize_handler__); - document.addEventListener('DOMSubtreeModified', elem.__resize_mutation_handler__); - } else { - if (!total) { - style = createStyles(css_248z); - } - initTriggers(elem); - - elem.__resize_rendered__ = getRenderInfo(elem).rendered; - if (window.MutationObserver) { - var mo = new MutationObserver(elem.__resize_mutation_handler__); - mo.observe(document, { - attributes: true, - childList: true, - characterData: true, - subtree: true - }); - elem.__resize_mutation_observer__ = mo; - } - } - } - - elem.__resize_listeners__.push(callback); - total++; -} - -function removeListener (elem, callback) { - var listeners = elem.__resize_listeners__; - if (!listeners) { - return - } - - if (callback) { - listeners.splice(listeners.indexOf(callback), 1); - } - - // no listeners exist, or removing all listeners - if (!listeners.length || !callback) { - // targeting IE9/10 - if (elem.detachEvent && elem.removeEventListener) { - elem.detachEvent('onresize', elem.__resize_legacy_resize_handler__); - document.removeEventListener('DOMSubtreeModified', elem.__resize_mutation_handler__); - return - } - - if (elem.__resize_observer__) { - elem.__resize_observer__.unobserve(elem); - elem.__resize_observer__.disconnect(); - elem.__resize_observer__ = null; - } else { - if (elem.__resize_mutation_observer__) { - elem.__resize_mutation_observer__.disconnect(); - elem.__resize_mutation_observer__ = null; - } - elem.removeEventListener('scroll', handleScroll); - elem.removeChild(elem.__resize_triggers__.triggers); - elem.__resize_triggers__ = null; - } - elem.__resize_listeners__ = null; - } - - if (!--total && style) { - style.parentNode.removeChild(style); - } -} - -function getUpdatedSize (elem) { - var ref = elem.__resize_last__; - var width = ref.width; - var height = ref.height; - var offsetWidth = elem.offsetWidth; - var offsetHeight = elem.offsetHeight; - if (offsetWidth !== width || offsetHeight !== height) { - return { - width: offsetWidth, - height: offsetHeight - } - } - return null -} - -function handleMutation () { - // `this` denotes the scrolling element - var ref = getRenderInfo(this); - var rendered = ref.rendered; - var detached = ref.detached; - if (rendered !== this.__resize_rendered__) { - if (!detached && this.__resize_triggers__) { - resetTriggers(this); - this.addEventListener('scroll', handleScroll, true); - } - this.__resize_rendered__ = rendered; - runCallbacks(this); - } -} - -function handleScroll () { - var this$1$1 = this; - - // `this` denotes the scrolling element - resetTriggers(this); - if (this.__resize_raf__) { - cancelAnimationFrame(this.__resize_raf__); - } - this.__resize_raf__ = requestAnimationFrame(function () { - var updated = getUpdatedSize(this$1$1); - if (updated) { - this$1$1.__resize_last__ = updated; - runCallbacks(this$1$1); - } - }); -} - -function runCallbacks (elem) { - if (!elem || !elem.__resize_listeners__) { - return - } - elem.__resize_listeners__.forEach(function (callback) { - callback.call(elem, elem); - }); -} - -function initTriggers (elem) { - var position = getComputedStyle$1(elem, 'position'); - if (!position || position === 'static') { - elem.style.position = 'relative'; - } - - elem.__resize_old_position__ = position; - elem.__resize_last__ = {}; - - var triggers = createElement('div', { - className: 'resize-triggers' - }); - var expand = createElement('div', { - className: 'resize-expand-trigger' - }); - var expandChild = createElement('div'); - var contract = createElement('div', { - className: 'resize-contract-trigger' - }); - expand.appendChild(expandChild); - triggers.appendChild(expand); - triggers.appendChild(contract); - elem.appendChild(triggers); - - elem.__resize_triggers__ = { - triggers: triggers, - expand: expand, - expandChild: expandChild, - contract: contract - }; - - resetTriggers(elem); - elem.addEventListener('scroll', handleScroll, true); - - elem.__resize_last__ = { - width: elem.offsetWidth, - height: elem.offsetHeight - }; -} - -function resetTriggers (elem) { - var ref = elem.__resize_triggers__; - var expand = ref.expand; - var expandChild = ref.expandChild; - var contract = ref.contract; - - // batch read - var csw = contract.scrollWidth; - var csh = contract.scrollHeight; - var eow = expand.offsetWidth; - var eoh = expand.offsetHeight; - var esw = expand.scrollWidth; - var esh = expand.scrollHeight; - - // batch write - contract.scrollLeft = csw; - contract.scrollTop = csh; - expandChild.style.width = eow + 1 + 'px'; - expandChild.style.height = eoh + 1 + 'px'; - expand.scrollLeft = esw; - expand.scrollTop = esh; -} - -var b=function(){return b=Object.assign||function(e){for(var t,n=1,r=arguments.length;n= maxRepaintRectCount; - } - } - } - for (var i = this.__startIndex; i < this.__endIndex; ++i) { - var el = displayList[i]; - if (el) { - var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true); - var prevRect = el.__isRendered && ((el.__dirty & REDRAW_BIT) || !shouldPaint) - ? el.getPrevPaintRect() - : null; - if (prevRect) { - addRectToMergePool(prevRect); - } - var curRect = shouldPaint && ((el.__dirty & REDRAW_BIT) || !el.__isRendered) - ? el.getPaintRect() - : null; - if (curRect) { - addRectToMergePool(curRect); - } - } - } - for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) { - var el = prevList[i]; - var shouldPaint = el && el.shouldBePainted(viewWidth, viewHeight, true, true); - if (el && (!shouldPaint || !el.__zr) && el.__isRendered) { - var prevRect = el.getPrevPaintRect(); - if (prevRect) { - addRectToMergePool(prevRect); - } - } - } - var hasIntersections; - do { - hasIntersections = false; - for (var i = 0; i < mergedRepaintRects.length;) { - if (mergedRepaintRects[i].isZero()) { - mergedRepaintRects.splice(i, 1); - continue; - } - for (var j = i + 1; j < mergedRepaintRects.length;) { - if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) { - hasIntersections = true; - mergedRepaintRects[i].union(mergedRepaintRects[j]); - mergedRepaintRects.splice(j, 1); - } - else { - j++; - } - } - i++; - } - } while (hasIntersections); - this._paintRects = mergedRepaintRects; - return mergedRepaintRects; - }; - Layer.prototype.debugGetPaintRects = function () { - return (this._paintRects || []).slice(); - }; - Layer.prototype.resize = function (width, height) { - var dpr = this.dpr; - var dom = this.dom; - var domStyle = dom.style; - var domBack = this.domBack; - if (domStyle) { - domStyle.width = width + 'px'; - domStyle.height = height + 'px'; - } - dom.width = width * dpr; - dom.height = height * dpr; - if (domBack) { - domBack.width = width * dpr; - domBack.height = height * dpr; - if (dpr !== 1) { - this.ctxBack.scale(dpr, dpr); - } - } - }; - Layer.prototype.clear = function (clearAll, clearColor, repaintRects) { - var dom = this.dom; - var ctx = this.ctx; - var width = dom.width; - var height = dom.height; - clearColor = clearColor || this.clearColor; - var haveMotionBLur = this.motionBlur && !clearAll; - var lastFrameAlpha = this.lastFrameAlpha; - var dpr = this.dpr; - var self = this; - if (haveMotionBLur) { - if (!this.domBack) { - this.createBackBuffer(); - } - this.ctxBack.globalCompositeOperation = 'copy'; - this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr); - } - var domBack = this.domBack; - function doClear(x, y, width, height) { - ctx.clearRect(x, y, width, height); - if (clearColor && clearColor !== 'transparent') { - var clearColorGradientOrPattern = void 0; - if (isGradientObject(clearColor)) { - var shouldCache = clearColor.global || (clearColor.__width === width - && clearColor.__height === height); - clearColorGradientOrPattern = shouldCache - && clearColor.__canvasGradient - || getCanvasGradient(ctx, clearColor, { - x: 0, - y: 0, - width: width, - height: height - }); - clearColor.__canvasGradient = clearColorGradientOrPattern; - clearColor.__width = width; - clearColor.__height = height; - } - else if (isImagePatternObject(clearColor)) { - clearColor.scaleX = clearColor.scaleX || dpr; - clearColor.scaleY = clearColor.scaleY || dpr; - clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, { - dirty: function () { - self.setUnpainted(); - self.painter.refresh(); - } - }); - } - ctx.save(); - ctx.fillStyle = clearColorGradientOrPattern || clearColor; - ctx.fillRect(x, y, width, height); - ctx.restore(); - } - if (haveMotionBLur) { - ctx.save(); - ctx.globalAlpha = lastFrameAlpha; - ctx.drawImage(domBack, x, y, width, height); - ctx.restore(); - } - } - if (!repaintRects || haveMotionBLur) { - doClear(0, 0, width, height); - } - else if (repaintRects.length) { - each$4(repaintRects, function (rect) { - doClear(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr); - }); - } - }; - return Layer; -}(Eventful)); - -var HOVER_LAYER_ZLEVEL = 1e5; -var CANVAS_ZLEVEL = 314159; -var EL_AFTER_INCREMENTAL_INC = 0.01; -var INCREMENTAL_INC = 1e-3; -function isLayerValid(layer) { - if (!layer) { - return false; - } - if (layer.__builtin__) { - return true; - } - if (typeof layer.resize !== "function" || typeof layer.refresh !== "function") { - return false; - } - return true; -} -function createRoot(width, height) { - var domRoot = document.createElement("div"); - domRoot.style.cssText = [ - "position:relative", - "width:" + width + "px", - "height:" + height + "px", - "padding:0", - "margin:0", - "border-width:0" - ].join(";") + ";"; - return domRoot; -} -var CanvasPainter = function() { - function CanvasPainter2(root, storage, opts, id) { - this.type = "canvas"; - this._zlevelList = []; - this._prevDisplayList = []; - this._layers = {}; - this._layerConfig = {}; - this._needsManuallyCompositing = false; - this.type = "canvas"; - var singleCanvas = !root.nodeName || root.nodeName.toUpperCase() === "CANVAS"; - this._opts = opts = extend({}, opts || {}); - this.dpr = opts.devicePixelRatio || devicePixelRatio; - this._singleCanvas = singleCanvas; - this.root = root; - var rootStyle = root.style; - if (rootStyle) { - disableUserSelect(root); - root.innerHTML = ""; - } - this.storage = storage; - var zlevelList = this._zlevelList; - this._prevDisplayList = []; - var layers = this._layers; - if (!singleCanvas) { - this._width = getSize(root, 0, opts); - this._height = getSize(root, 1, opts); - var domRoot = this._domRoot = createRoot(this._width, this._height); - root.appendChild(domRoot); - } else { - var rootCanvas = root; - var width = rootCanvas.width; - var height = rootCanvas.height; - if (opts.width != null) { - width = opts.width; - } - if (opts.height != null) { - height = opts.height; - } - this.dpr = opts.devicePixelRatio || 1; - rootCanvas.width = width * this.dpr; - rootCanvas.height = height * this.dpr; - this._width = width; - this._height = height; - var mainLayer = new Layer(rootCanvas, this, this.dpr); - mainLayer.__builtin__ = true; - mainLayer.initContext(); - layers[CANVAS_ZLEVEL] = mainLayer; - mainLayer.zlevel = CANVAS_ZLEVEL; - zlevelList.push(CANVAS_ZLEVEL); - this._domRoot = root; - } - } - CanvasPainter2.prototype.getType = function() { - return "canvas"; - }; - CanvasPainter2.prototype.isSingleCanvas = function() { - return this._singleCanvas; - }; - CanvasPainter2.prototype.getViewportRoot = function() { - return this._domRoot; - }; - CanvasPainter2.prototype.getViewportRootOffset = function() { - var viewportRoot = this.getViewportRoot(); - if (viewportRoot) { - return { - offsetLeft: viewportRoot.offsetLeft || 0, - offsetTop: viewportRoot.offsetTop || 0 - }; - } - }; - CanvasPainter2.prototype.refresh = function(paintAll) { - var list = this.storage.getDisplayList(true); - var prevList = this._prevDisplayList; - var zlevelList = this._zlevelList; - this._redrawId = Math.random(); - this._paintList(list, prevList, paintAll, this._redrawId); - for (var i = 0; i < zlevelList.length; i++) { - var z = zlevelList[i]; - var layer = this._layers[z]; - if (!layer.__builtin__ && layer.refresh) { - var clearColor = i === 0 ? this._backgroundColor : null; - layer.refresh(clearColor); - } - } - if (this._opts.useDirtyRect) { - this._prevDisplayList = list.slice(); - } - return this; - }; - CanvasPainter2.prototype.refreshHover = function() { - this._paintHoverList(this.storage.getDisplayList(false)); - }; - CanvasPainter2.prototype._paintHoverList = function(list) { - var len = list.length; - var hoverLayer = this._hoverlayer; - hoverLayer && hoverLayer.clear(); - if (!len) { - return; - } - var scope = { - inHover: true, - viewWidth: this._width, - viewHeight: this._height - }; - var ctx; - for (var i = 0; i < len; i++) { - var el = list[i]; - if (el.__inHover) { - if (!hoverLayer) { - hoverLayer = this._hoverlayer = this.getLayer(HOVER_LAYER_ZLEVEL); - } - if (!ctx) { - ctx = hoverLayer.ctx; - ctx.save(); - } - brush(ctx, el, scope, i === len - 1); - } - } - if (ctx) { - ctx.restore(); - } - }; - CanvasPainter2.prototype.getHoverLayer = function() { - return this.getLayer(HOVER_LAYER_ZLEVEL); - }; - CanvasPainter2.prototype.paintOne = function(ctx, el) { - brushSingle(ctx, el); - }; - CanvasPainter2.prototype._paintList = function(list, prevList, paintAll, redrawId) { - if (this._redrawId !== redrawId) { - return; - } - paintAll = paintAll || false; - this._updateLayerStatus(list); - var _a = this._doPaintList(list, prevList, paintAll), finished = _a.finished, needsRefreshHover = _a.needsRefreshHover; - if (this._needsManuallyCompositing) { - this._compositeManually(); - } - if (needsRefreshHover) { - this._paintHoverList(list); - } - if (!finished) { - var self_1 = this; - requestAnimationFrame$1(function() { - self_1._paintList(list, prevList, paintAll, redrawId); - }); - } else { - this.eachLayer(function(layer) { - layer.afterBrush && layer.afterBrush(); - }); - } - }; - CanvasPainter2.prototype._compositeManually = function() { - var ctx = this.getLayer(CANVAS_ZLEVEL).ctx; - var width = this._domRoot.width; - var height = this._domRoot.height; - ctx.clearRect(0, 0, width, height); - this.eachBuiltinLayer(function(layer) { - if (layer.virtual) { - ctx.drawImage(layer.dom, 0, 0, width, height); - } - }); - }; - CanvasPainter2.prototype._doPaintList = function(list, prevList, paintAll) { - var _this = this; - var layerList = []; - var useDirtyRect = this._opts.useDirtyRect; - for (var zi = 0; zi < this._zlevelList.length; zi++) { - var zlevel = this._zlevelList[zi]; - var layer = this._layers[zlevel]; - if (layer.__builtin__ && layer !== this._hoverlayer && (layer.__dirty || paintAll)) { - layerList.push(layer); - } - } - var finished = true; - var needsRefreshHover = false; - var _loop_1 = function(k2) { - var layer2 = layerList[k2]; - var ctx = layer2.ctx; - var repaintRects = useDirtyRect && layer2.createRepaintRects(list, prevList, this_1._width, this_1._height); - var start = paintAll ? layer2.__startIndex : layer2.__drawIndex; - var useTimer = !paintAll && layer2.incremental && Date.now; - var startTime = useTimer && Date.now(); - var clearColor = layer2.zlevel === this_1._zlevelList[0] ? this_1._backgroundColor : null; - if (layer2.__startIndex === layer2.__endIndex) { - layer2.clear(false, clearColor, repaintRects); - } else if (start === layer2.__startIndex) { - var firstEl = list[start]; - if (!firstEl.incremental || !firstEl.notClear || paintAll) { - layer2.clear(false, clearColor, repaintRects); - } - } - if (start === -1) { - console.error("For some unknown reason. drawIndex is -1"); - start = layer2.__startIndex; - } - var i; - var repaint = function(repaintRect) { - var scope = { - inHover: false, - allClipped: false, - prevEl: null, - viewWidth: _this._width, - viewHeight: _this._height - }; - for (i = start; i < layer2.__endIndex; i++) { - var el = list[i]; - if (el.__inHover) { - needsRefreshHover = true; - } - _this._doPaintEl(el, layer2, useDirtyRect, repaintRect, scope, i === layer2.__endIndex - 1); - if (useTimer) { - var dTime = Date.now() - startTime; - if (dTime > 15) { - break; - } - } - } - if (scope.prevElClipPaths) { - ctx.restore(); - } - }; - if (repaintRects) { - if (repaintRects.length === 0) { - i = layer2.__endIndex; - } else { - var dpr = this_1.dpr; - for (var r = 0; r < repaintRects.length; ++r) { - var rect = repaintRects[r]; - ctx.save(); - ctx.beginPath(); - ctx.rect(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr); - ctx.clip(); - repaint(rect); - ctx.restore(); - } - } - } else { - ctx.save(); - repaint(); - ctx.restore(); - } - layer2.__drawIndex = i; - if (layer2.__drawIndex < layer2.__endIndex) { - finished = false; - } - }; - var this_1 = this; - for (var k = 0; k < layerList.length; k++) { - _loop_1(k); - } - if (env.wxa) { - each$4(this._layers, function(layer2) { - if (layer2 && layer2.ctx && layer2.ctx.draw) { - layer2.ctx.draw(); - } - }); - } - return { - finished, - needsRefreshHover - }; - }; - CanvasPainter2.prototype._doPaintEl = function(el, currentLayer, useDirtyRect, repaintRect, scope, isLast) { - var ctx = currentLayer.ctx; - if (useDirtyRect) { - var paintRect = el.getPaintRect(); - if (!repaintRect || paintRect && paintRect.intersect(repaintRect)) { - brush(ctx, el, scope, isLast); - el.setPrevPaintRect(paintRect); - } - } else { - brush(ctx, el, scope, isLast); - } - }; - CanvasPainter2.prototype.getLayer = function(zlevel, virtual) { - if (this._singleCanvas && !this._needsManuallyCompositing) { - zlevel = CANVAS_ZLEVEL; - } - var layer = this._layers[zlevel]; - if (!layer) { - layer = new Layer("zr_" + zlevel, this, this.dpr); - layer.zlevel = zlevel; - layer.__builtin__ = true; - if (this._layerConfig[zlevel]) { - merge(layer, this._layerConfig[zlevel], true); - } else if (this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC]) { - merge(layer, this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC], true); - } - if (virtual) { - layer.virtual = virtual; - } - this.insertLayer(zlevel, layer); - layer.initContext(); - } - return layer; - }; - CanvasPainter2.prototype.insertLayer = function(zlevel, layer) { - var layersMap = this._layers; - var zlevelList = this._zlevelList; - var len = zlevelList.length; - var domRoot = this._domRoot; - var prevLayer = null; - var i = -1; - if (layersMap[zlevel]) { - return; - } - if (!isLayerValid(layer)) { - return; - } - if (len > 0 && zlevel > zlevelList[0]) { - for (i = 0; i < len - 1; i++) { - if (zlevelList[i] < zlevel && zlevelList[i + 1] > zlevel) { - break; - } - } - prevLayer = layersMap[zlevelList[i]]; - } - zlevelList.splice(i + 1, 0, zlevel); - layersMap[zlevel] = layer; - if (!layer.virtual) { - if (prevLayer) { - var prevDom = prevLayer.dom; - if (prevDom.nextSibling) { - domRoot.insertBefore(layer.dom, prevDom.nextSibling); - } else { - domRoot.appendChild(layer.dom); - } - } else { - if (domRoot.firstChild) { - domRoot.insertBefore(layer.dom, domRoot.firstChild); - } else { - domRoot.appendChild(layer.dom); - } - } - } - layer.painter || (layer.painter = this); - }; - CanvasPainter2.prototype.eachLayer = function(cb, context) { - var zlevelList = this._zlevelList; - for (var i = 0; i < zlevelList.length; i++) { - var z = zlevelList[i]; - cb.call(context, this._layers[z], z); - } - }; - CanvasPainter2.prototype.eachBuiltinLayer = function(cb, context) { - var zlevelList = this._zlevelList; - for (var i = 0; i < zlevelList.length; i++) { - var z = zlevelList[i]; - var layer = this._layers[z]; - if (layer.__builtin__) { - cb.call(context, layer, z); - } - } - }; - CanvasPainter2.prototype.eachOtherLayer = function(cb, context) { - var zlevelList = this._zlevelList; - for (var i = 0; i < zlevelList.length; i++) { - var z = zlevelList[i]; - var layer = this._layers[z]; - if (!layer.__builtin__) { - cb.call(context, layer, z); - } - } - }; - CanvasPainter2.prototype.getLayers = function() { - return this._layers; - }; - CanvasPainter2.prototype._updateLayerStatus = function(list) { - this.eachBuiltinLayer(function(layer2, z) { - layer2.__dirty = layer2.__used = false; - }); - function updatePrevLayer(idx) { - if (prevLayer) { - if (prevLayer.__endIndex !== idx) { - prevLayer.__dirty = true; - } - prevLayer.__endIndex = idx; - } - } - if (this._singleCanvas) { - for (var i_1 = 1; i_1 < list.length; i_1++) { - var el = list[i_1]; - if (el.zlevel !== list[i_1 - 1].zlevel || el.incremental) { - this._needsManuallyCompositing = true; - break; - } - } - } - var prevLayer = null; - var incrementalLayerCount = 0; - var prevZlevel; - var i; - for (i = 0; i < list.length; i++) { - var el = list[i]; - var zlevel = el.zlevel; - var layer = void 0; - if (prevZlevel !== zlevel) { - prevZlevel = zlevel; - incrementalLayerCount = 0; - } - if (el.incremental) { - layer = this.getLayer(zlevel + INCREMENTAL_INC, this._needsManuallyCompositing); - layer.incremental = true; - incrementalLayerCount = 1; - } else { - layer = this.getLayer(zlevel + (incrementalLayerCount > 0 ? EL_AFTER_INCREMENTAL_INC : 0), this._needsManuallyCompositing); - } - if (!layer.__builtin__) { - logError("ZLevel " + zlevel + " has been used by unkown layer " + layer.id); - } - if (layer !== prevLayer) { - layer.__used = true; - if (layer.__startIndex !== i) { - layer.__dirty = true; - } - layer.__startIndex = i; - if (!layer.incremental) { - layer.__drawIndex = i; - } else { - layer.__drawIndex = -1; - } - updatePrevLayer(i); - prevLayer = layer; - } - if (el.__dirty & REDRAW_BIT && !el.__inHover) { - layer.__dirty = true; - if (layer.incremental && layer.__drawIndex < 0) { - layer.__drawIndex = i; - } - } - } - updatePrevLayer(i); - this.eachBuiltinLayer(function(layer2, z) { - if (!layer2.__used && layer2.getElementCount() > 0) { - layer2.__dirty = true; - layer2.__startIndex = layer2.__endIndex = layer2.__drawIndex = 0; - } - if (layer2.__dirty && layer2.__drawIndex < 0) { - layer2.__drawIndex = layer2.__startIndex; - } - }); - }; - CanvasPainter2.prototype.clear = function() { - this.eachBuiltinLayer(this._clearLayer); - return this; - }; - CanvasPainter2.prototype._clearLayer = function(layer) { - layer.clear(); - }; - CanvasPainter2.prototype.setBackgroundColor = function(backgroundColor) { - this._backgroundColor = backgroundColor; - each$4(this._layers, function(layer) { - layer.setUnpainted(); - }); - }; - CanvasPainter2.prototype.configLayer = function(zlevel, config) { - if (config) { - var layerConfig = this._layerConfig; - if (!layerConfig[zlevel]) { - layerConfig[zlevel] = config; - } else { - merge(layerConfig[zlevel], config, true); - } - for (var i = 0; i < this._zlevelList.length; i++) { - var _zlevel = this._zlevelList[i]; - if (_zlevel === zlevel || _zlevel === zlevel + EL_AFTER_INCREMENTAL_INC) { - var layer = this._layers[_zlevel]; - merge(layer, layerConfig[zlevel], true); - } - } - } - }; - CanvasPainter2.prototype.delLayer = function(zlevel) { - var layers = this._layers; - var zlevelList = this._zlevelList; - var layer = layers[zlevel]; - if (!layer) { - return; - } - layer.dom.parentNode.removeChild(layer.dom); - delete layers[zlevel]; - zlevelList.splice(indexOf(zlevelList, zlevel), 1); - }; - CanvasPainter2.prototype.resize = function(width, height) { - if (!this._domRoot.style) { - if (width == null || height == null) { - return; - } - this._width = width; - this._height = height; - this.getLayer(CANVAS_ZLEVEL).resize(width, height); - } else { - var domRoot = this._domRoot; - domRoot.style.display = "none"; - var opts = this._opts; - var root = this.root; - width != null && (opts.width = width); - height != null && (opts.height = height); - width = getSize(root, 0, opts); - height = getSize(root, 1, opts); - domRoot.style.display = ""; - if (this._width !== width || height !== this._height) { - domRoot.style.width = width + "px"; - domRoot.style.height = height + "px"; - for (var id in this._layers) { - if (this._layers.hasOwnProperty(id)) { - this._layers[id].resize(width, height); - } - } - this.refresh(true); - } - this._width = width; - this._height = height; - } - return this; - }; - CanvasPainter2.prototype.clearLayer = function(zlevel) { - var layer = this._layers[zlevel]; - if (layer) { - layer.clear(); - } - }; - CanvasPainter2.prototype.dispose = function() { - this.root.innerHTML = ""; - this.root = this.storage = this._domRoot = this._layers = null; - }; - CanvasPainter2.prototype.getRenderedCanvas = function(opts) { - opts = opts || {}; - if (this._singleCanvas && !this._compositeManually) { - return this._layers[CANVAS_ZLEVEL].dom; - } - var imageLayer = new Layer("image", this, opts.pixelRatio || this.dpr); - imageLayer.initContext(); - imageLayer.clear(false, opts.backgroundColor || this._backgroundColor); - var ctx = imageLayer.ctx; - if (opts.pixelRatio <= this.dpr) { - this.refresh(); - var width_1 = imageLayer.dom.width; - var height_1 = imageLayer.dom.height; - this.eachLayer(function(layer) { - if (layer.__builtin__) { - ctx.drawImage(layer.dom, 0, 0, width_1, height_1); - } else if (layer.renderToCanvas) { - ctx.save(); - layer.renderToCanvas(ctx); - ctx.restore(); - } - }); - } else { - var scope = { - inHover: false, - viewWidth: this._width, - viewHeight: this._height - }; - var displayList = this.storage.getDisplayList(true); - for (var i = 0, len = displayList.length; i < len; i++) { - var el = displayList[i]; - brush(ctx, el, scope, i === len - 1); - } - } - return imageLayer.dom; - }; - CanvasPainter2.prototype.getWidth = function() { - return this._width; - }; - CanvasPainter2.prototype.getHeight = function() { - return this._height; - }; - return CanvasPainter2; -}(); - -function install$a(registers) { - registers.registerPainter('canvas', CanvasPainter); -} - -var LineSeriesModel = ( - /** @class */ - function(_super) { - __extends(LineSeriesModel2, _super); - function LineSeriesModel2() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = LineSeriesModel2.type; - _this.hasSymbolVisual = true; - return _this; - } - LineSeriesModel2.prototype.getInitialData = function(option) { - return createSeriesData(null, this, { - useEncodeDefaulter: true - }); - }; - LineSeriesModel2.prototype.getLegendIcon = function(opt) { - var group = new Group$2(); - var line = createSymbol("line", 0, opt.itemHeight / 2, opt.itemWidth, 0, opt.lineStyle.stroke, false); - group.add(line); - line.setStyle(opt.lineStyle); - var visualType = this.getData().getVisual("symbol"); - var visualRotate = this.getData().getVisual("symbolRotate"); - var symbolType = visualType === "none" ? "circle" : visualType; - var size = opt.itemHeight * 0.8; - var symbol = createSymbol(symbolType, (opt.itemWidth - size) / 2, (opt.itemHeight - size) / 2, size, size, opt.itemStyle.fill); - group.add(symbol); - symbol.setStyle(opt.itemStyle); - var symbolRotate = opt.iconRotate === "inherit" ? visualRotate : opt.iconRotate || 0; - symbol.rotation = symbolRotate * Math.PI / 180; - symbol.setOrigin([opt.itemWidth / 2, opt.itemHeight / 2]); - if (symbolType.indexOf("empty") > -1) { - symbol.style.stroke = symbol.style.fill; - symbol.style.fill = "#fff"; - symbol.style.lineWidth = 2; - } - return group; - }; - LineSeriesModel2.type = "series.line"; - LineSeriesModel2.dependencies = ["grid", "polar"]; - LineSeriesModel2.defaultOption = { - // zlevel: 0, - z: 3, - coordinateSystem: "cartesian2d", - legendHoverLink: true, - clip: true, - label: { - position: "top" - }, - // itemStyle: { - // }, - endLabel: { - show: false, - valueAnimation: true, - distance: 8 - }, - lineStyle: { - width: 2, - type: "solid" - }, - emphasis: { - scale: true - }, - // areaStyle: { - // origin of areaStyle. Valid values: - // `'auto'/null/undefined`: from axisLine to data - // `'start'`: from min to data - // `'end'`: from data to max - // origin: 'auto' - // }, - // false, 'start', 'end', 'middle' - step: false, - // Disabled if step is true - smooth: false, - smoothMonotone: null, - symbol: "emptyCircle", - symbolSize: 4, - symbolRotate: null, - showSymbol: true, - // `false`: follow the label interval strategy. - // `true`: show all symbols. - // `'auto'`: If possible, show all symbols, otherwise - // follow the label interval strategy. - showAllSymbol: "auto", - // Whether to connect break point. - connectNulls: false, - // Sampling for large data. Can be: 'average', 'max', 'min', 'sum', 'lttb'. - sampling: "none", - animationEasing: "linear", - // Disable progressive - progressive: 0, - hoverLayerThreshold: Infinity, - universalTransition: { - divideShape: "clone" - }, - triggerLineEvent: false - }; - return LineSeriesModel2; - }(SeriesModel) -); - -/** - * @return label string. Not null/undefined - */ -function getDefaultLabel(data, dataIndex) { - var labelDims = data.mapDimensionsAll('defaultedLabel'); - var len = labelDims.length; - // Simple optimization (in lots of cases, label dims length is 1) - if (len === 1) { - var rawVal = retrieveRawValue(data, dataIndex, labelDims[0]); - return rawVal != null ? rawVal + '' : null; - } else if (len) { - var vals = []; - for (var i = 0; i < labelDims.length; i++) { - vals.push(retrieveRawValue(data, dataIndex, labelDims[i])); - } - return vals.join(' '); - } -} -function getDefaultInterpolatedLabel(data, interpolatedValue) { - var labelDims = data.mapDimensionsAll('defaultedLabel'); - if (!isArray(interpolatedValue)) { - return interpolatedValue + ''; - } - var vals = []; - for (var i = 0; i < labelDims.length; i++) { - var dimIndex = data.getDimensionIndex(labelDims[i]); - if (dimIndex >= 0) { - vals.push(interpolatedValue[dimIndex]); - } - } - return vals.join(' '); -} - -var Symbol$1 = /** @class */function (_super) { - __extends(Symbol, _super); - function Symbol(data, idx, seriesScope, opts) { - var _this = _super.call(this) || this; - _this.updateData(data, idx, seriesScope, opts); - return _this; - } - Symbol.prototype._createSymbol = function (symbolType, data, idx, symbolSize, keepAspect) { - // Remove paths created before - this.removeAll(); - // let symbolPath = createSymbol( - // symbolType, -0.5, -0.5, 1, 1, color - // ); - // If width/height are set too small (e.g., set to 1) on ios10 - // and macOS Sierra, a circle stroke become a rect, no matter what - // the scale is set. So we set width/height as 2. See #4150. - var symbolPath = createSymbol(symbolType, -1, -1, 2, 2, null, keepAspect); - symbolPath.attr({ - z2: 100, - culling: true, - scaleX: symbolSize[0] / 2, - scaleY: symbolSize[1] / 2 - }); - // Rewrite drift method - symbolPath.drift = driftSymbol; - this._symbolType = symbolType; - this.add(symbolPath); - }; - /** - * Stop animation - * @param {boolean} toLastFrame - */ - Symbol.prototype.stopSymbolAnimation = function (toLastFrame) { - this.childAt(0).stopAnimation(null, toLastFrame); - }; - Symbol.prototype.getSymbolType = function () { - return this._symbolType; - }; - /** - * FIXME: - * Caution: This method breaks the encapsulation of this module, - * but it indeed brings convenience. So do not use the method - * unless you detailedly know all the implements of `Symbol`, - * especially animation. - * - * Get symbol path element. - */ - Symbol.prototype.getSymbolPath = function () { - return this.childAt(0); - }; - /** - * Highlight symbol - */ - Symbol.prototype.highlight = function () { - enterEmphasis(this.childAt(0)); - }; - /** - * Downplay symbol - */ - Symbol.prototype.downplay = function () { - leaveEmphasis(this.childAt(0)); - }; - /** - * @param {number} zlevel - * @param {number} z - */ - Symbol.prototype.setZ = function (zlevel, z) { - var symbolPath = this.childAt(0); - symbolPath.zlevel = zlevel; - symbolPath.z = z; - }; - Symbol.prototype.setDraggable = function (draggable, hasCursorOption) { - var symbolPath = this.childAt(0); - symbolPath.draggable = draggable; - symbolPath.cursor = !hasCursorOption && draggable ? 'move' : symbolPath.cursor; - }; - /** - * Update symbol properties - */ - Symbol.prototype.updateData = function (data, idx, seriesScope, opts) { - this.silent = false; - var symbolType = data.getItemVisual(idx, 'symbol') || 'circle'; - var seriesModel = data.hostModel; - var symbolSize = Symbol.getSymbolSize(data, idx); - var isInit = symbolType !== this._symbolType; - var disableAnimation = opts && opts.disableAnimation; - if (isInit) { - var keepAspect = data.getItemVisual(idx, 'symbolKeepAspect'); - this._createSymbol(symbolType, data, idx, symbolSize, keepAspect); - } else { - var symbolPath = this.childAt(0); - symbolPath.silent = false; - var target = { - scaleX: symbolSize[0] / 2, - scaleY: symbolSize[1] / 2 - }; - disableAnimation ? symbolPath.attr(target) : updateProps$1(symbolPath, target, seriesModel, idx); - saveOldStyle(symbolPath); - } - this._updateCommon(data, idx, symbolSize, seriesScope, opts); - if (isInit) { - var symbolPath = this.childAt(0); - if (!disableAnimation) { - var target = { - scaleX: this._sizeX, - scaleY: this._sizeY, - style: { - // Always fadeIn. Because it has fadeOut animation when symbol is removed.. - opacity: symbolPath.style.opacity - } - }; - symbolPath.scaleX = symbolPath.scaleY = 0; - symbolPath.style.opacity = 0; - initProps(symbolPath, target, seriesModel, idx); - } - } - if (disableAnimation) { - // Must stop leave transition manually if don't call initProps or updateProps. - this.childAt(0).stopAnimation('leave'); - } - }; - Symbol.prototype._updateCommon = function (data, idx, symbolSize, seriesScope, opts) { - var symbolPath = this.childAt(0); - var seriesModel = data.hostModel; - var emphasisItemStyle; - var blurItemStyle; - var selectItemStyle; - var focus; - var blurScope; - var emphasisDisabled; - var labelStatesModels; - var hoverScale; - var cursorStyle; - if (seriesScope) { - emphasisItemStyle = seriesScope.emphasisItemStyle; - blurItemStyle = seriesScope.blurItemStyle; - selectItemStyle = seriesScope.selectItemStyle; - focus = seriesScope.focus; - blurScope = seriesScope.blurScope; - labelStatesModels = seriesScope.labelStatesModels; - hoverScale = seriesScope.hoverScale; - cursorStyle = seriesScope.cursorStyle; - emphasisDisabled = seriesScope.emphasisDisabled; - } - if (!seriesScope || data.hasItemOption) { - var itemModel = seriesScope && seriesScope.itemModel ? seriesScope.itemModel : data.getItemModel(idx); - var emphasisModel = itemModel.getModel('emphasis'); - emphasisItemStyle = emphasisModel.getModel('itemStyle').getItemStyle(); - selectItemStyle = itemModel.getModel(['select', 'itemStyle']).getItemStyle(); - blurItemStyle = itemModel.getModel(['blur', 'itemStyle']).getItemStyle(); - focus = emphasisModel.get('focus'); - blurScope = emphasisModel.get('blurScope'); - emphasisDisabled = emphasisModel.get('disabled'); - labelStatesModels = getLabelStatesModels(itemModel); - hoverScale = emphasisModel.getShallow('scale'); - cursorStyle = itemModel.getShallow('cursor'); - } - var symbolRotate = data.getItemVisual(idx, 'symbolRotate'); - symbolPath.attr('rotation', (symbolRotate || 0) * Math.PI / 180 || 0); - var symbolOffset = normalizeSymbolOffset(data.getItemVisual(idx, 'symbolOffset'), symbolSize); - if (symbolOffset) { - symbolPath.x = symbolOffset[0]; - symbolPath.y = symbolOffset[1]; - } - cursorStyle && symbolPath.attr('cursor', cursorStyle); - var symbolStyle = data.getItemVisual(idx, 'style'); - var visualColor = symbolStyle.fill; - if (symbolPath instanceof ZRImage) { - var pathStyle = symbolPath.style; - symbolPath.useStyle(extend({ - // TODO other properties like x, y ? - image: pathStyle.image, - x: pathStyle.x, - y: pathStyle.y, - width: pathStyle.width, - height: pathStyle.height - }, symbolStyle)); - } else { - if (symbolPath.__isEmptyBrush) { - // fill and stroke will be swapped if it's empty. - // So we cloned a new style to avoid it affecting the original style in visual storage. - // TODO Better implementation. No empty logic! - symbolPath.useStyle(extend({}, symbolStyle)); - } else { - symbolPath.useStyle(symbolStyle); - } - // Disable decal because symbol scale will been applied on the decal. - symbolPath.style.decal = null; - symbolPath.setColor(visualColor, opts && opts.symbolInnerColor); - symbolPath.style.strokeNoScale = true; - } - var liftZ = data.getItemVisual(idx, 'liftZ'); - var z2Origin = this._z2; - if (liftZ != null) { - if (z2Origin == null) { - this._z2 = symbolPath.z2; - symbolPath.z2 += liftZ; - } - } else if (z2Origin != null) { - symbolPath.z2 = z2Origin; - this._z2 = null; - } - var useNameLabel = opts && opts.useNameLabel; - setLabelStyle(symbolPath, labelStatesModels, { - labelFetcher: seriesModel, - labelDataIndex: idx, - defaultText: getLabelDefaultText, - inheritColor: visualColor, - defaultOpacity: symbolStyle.opacity - }); - // Do not execute util needed. - function getLabelDefaultText(idx) { - return useNameLabel ? data.getName(idx) : getDefaultLabel(data, idx); - } - this._sizeX = symbolSize[0] / 2; - this._sizeY = symbolSize[1] / 2; - var emphasisState = symbolPath.ensureState('emphasis'); - emphasisState.style = emphasisItemStyle; - symbolPath.ensureState('select').style = selectItemStyle; - symbolPath.ensureState('blur').style = blurItemStyle; - // null / undefined / true means to use default strategy. - // 0 / false / negative number / NaN / Infinity means no scale. - var scaleRatio = hoverScale == null || hoverScale === true ? Math.max(1.1, 3 / this._sizeY) - // PENDING: restrict hoverScale > 1? It seems unreasonable to scale down - : isFinite(hoverScale) && hoverScale > 0 ? +hoverScale : 1; - // always set scale to allow resetting - emphasisState.scaleX = this._sizeX * scaleRatio; - emphasisState.scaleY = this._sizeY * scaleRatio; - this.setSymbolScale(1); - toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled); - }; - Symbol.prototype.setSymbolScale = function (scale) { - this.scaleX = this.scaleY = scale; - }; - Symbol.prototype.fadeOut = function (cb, seriesModel, opt) { - var symbolPath = this.childAt(0); - var dataIndex = getECData(this).dataIndex; - var animationOpt = opt && opt.animation; - // Avoid mistaken hover when fading out - this.silent = symbolPath.silent = true; - // Not show text when animating - if (opt && opt.fadeLabel) { - var textContent = symbolPath.getTextContent(); - if (textContent) { - removeElement(textContent, { - style: { - opacity: 0 - } - }, seriesModel, { - dataIndex: dataIndex, - removeOpt: animationOpt, - cb: function () { - symbolPath.removeTextContent(); - } - }); - } - } else { - symbolPath.removeTextContent(); - } - removeElement(symbolPath, { - style: { - opacity: 0 - }, - scaleX: 0, - scaleY: 0 - }, seriesModel, { - dataIndex: dataIndex, - cb: cb, - removeOpt: animationOpt - }); - }; - Symbol.getSymbolSize = function (data, idx) { - return normalizeSymbolSize(data.getItemVisual(idx, 'symbolSize')); - }; - return Symbol; -}(Group$2); -function driftSymbol(dx, dy) { - this.parent.drift(dx, dy); -} - -function symbolNeedsDraw(data, point, idx, opt) { - return point && !isNaN(point[0]) && !isNaN(point[1]) && !(opt.isIgnore && opt.isIgnore(idx)) - // We do not set clipShape on group, because it will cut part of - // the symbol element shape. We use the same clip shape here as - // the line clip. - && !(opt.clipShape && !opt.clipShape.contain(point[0], point[1])) && data.getItemVisual(idx, 'symbol') !== 'none'; -} -function normalizeUpdateOpt(opt) { - if (opt != null && !isObject$2(opt)) { - opt = { - isIgnore: opt - }; - } - return opt || {}; -} -function makeSeriesScope(data) { - var seriesModel = data.hostModel; - var emphasisModel = seriesModel.getModel('emphasis'); - return { - emphasisItemStyle: emphasisModel.getModel('itemStyle').getItemStyle(), - blurItemStyle: seriesModel.getModel(['blur', 'itemStyle']).getItemStyle(), - selectItemStyle: seriesModel.getModel(['select', 'itemStyle']).getItemStyle(), - focus: emphasisModel.get('focus'), - blurScope: emphasisModel.get('blurScope'), - emphasisDisabled: emphasisModel.get('disabled'), - hoverScale: emphasisModel.get('scale'), - labelStatesModels: getLabelStatesModels(seriesModel), - cursorStyle: seriesModel.get('cursor') - }; -} -var SymbolDraw = /** @class */function () { - function SymbolDraw(SymbolCtor) { - this.group = new Group$2(); - this._SymbolCtor = SymbolCtor || Symbol$1; - } - /** - * Update symbols draw by new data - */ - SymbolDraw.prototype.updateData = function (data, opt) { - // Remove progressive els. - this._progressiveEls = null; - opt = normalizeUpdateOpt(opt); - var group = this.group; - var seriesModel = data.hostModel; - var oldData = this._data; - var SymbolCtor = this._SymbolCtor; - var disableAnimation = opt.disableAnimation; - var seriesScope = makeSeriesScope(data); - var symbolUpdateOpt = { - disableAnimation: disableAnimation - }; - var getSymbolPoint = opt.getSymbolPoint || function (idx) { - return data.getItemLayout(idx); - }; - // There is no oldLineData only when first rendering or switching from - // stream mode to normal mode, where previous elements should be removed. - if (!oldData) { - group.removeAll(); - } - data.diff(oldData).add(function (newIdx) { - var point = getSymbolPoint(newIdx); - if (symbolNeedsDraw(data, point, newIdx, opt)) { - var symbolEl = new SymbolCtor(data, newIdx, seriesScope, symbolUpdateOpt); - symbolEl.setPosition(point); - data.setItemGraphicEl(newIdx, symbolEl); - group.add(symbolEl); - } - }).update(function (newIdx, oldIdx) { - var symbolEl = oldData.getItemGraphicEl(oldIdx); - var point = getSymbolPoint(newIdx); - if (!symbolNeedsDraw(data, point, newIdx, opt)) { - group.remove(symbolEl); - return; - } - var newSymbolType = data.getItemVisual(newIdx, 'symbol') || 'circle'; - var oldSymbolType = symbolEl && symbolEl.getSymbolType && symbolEl.getSymbolType(); - if (!symbolEl - // Create a new if symbol type changed. - || oldSymbolType && oldSymbolType !== newSymbolType) { - group.remove(symbolEl); - symbolEl = new SymbolCtor(data, newIdx, seriesScope, symbolUpdateOpt); - symbolEl.setPosition(point); - } else { - symbolEl.updateData(data, newIdx, seriesScope, symbolUpdateOpt); - var target = { - x: point[0], - y: point[1] - }; - disableAnimation ? symbolEl.attr(target) : updateProps$1(symbolEl, target, seriesModel); - } - // Add back - group.add(symbolEl); - data.setItemGraphicEl(newIdx, symbolEl); - }).remove(function (oldIdx) { - var el = oldData.getItemGraphicEl(oldIdx); - el && el.fadeOut(function () { - group.remove(el); - }, seriesModel); - }).execute(); - this._getSymbolPoint = getSymbolPoint; - this._data = data; - }; - SymbolDraw.prototype.updateLayout = function () { - var _this = this; - var data = this._data; - if (data) { - // Not use animation - data.eachItemGraphicEl(function (el, idx) { - var point = _this._getSymbolPoint(idx); - el.setPosition(point); - el.markRedraw(); - }); - } - }; - SymbolDraw.prototype.incrementalPrepareUpdate = function (data) { - this._seriesScope = makeSeriesScope(data); - this._data = null; - this.group.removeAll(); - }; - /** - * Update symbols draw by new data - */ - SymbolDraw.prototype.incrementalUpdate = function (taskParams, data, opt) { - // Clear - this._progressiveEls = []; - opt = normalizeUpdateOpt(opt); - function updateIncrementalAndHover(el) { - if (!el.isGroup) { - el.incremental = true; - el.ensureState('emphasis').hoverLayer = true; - } - } - for (var idx = taskParams.start; idx < taskParams.end; idx++) { - var point = data.getItemLayout(idx); - if (symbolNeedsDraw(data, point, idx, opt)) { - var el = new this._SymbolCtor(data, idx, this._seriesScope); - el.traverse(updateIncrementalAndHover); - el.setPosition(point); - this.group.add(el); - data.setItemGraphicEl(idx, el); - this._progressiveEls.push(el); - } - } - }; - SymbolDraw.prototype.eachRendered = function (cb) { - traverseElements(this._progressiveEls || this.group, cb); - }; - SymbolDraw.prototype.remove = function (enableAnimation) { - var group = this.group; - var data = this._data; - // Incremental model do not have this._data. - if (data && enableAnimation) { - data.eachItemGraphicEl(function (el) { - el.fadeOut(function () { - group.remove(el); - }, data.hostModel); - }); - } else { - group.removeAll(); - } - }; - return SymbolDraw; -}(); - -function prepareDataCoordInfo(coordSys, data, valueOrigin) { - var baseAxis = coordSys.getBaseAxis(); - var valueAxis = coordSys.getOtherAxis(baseAxis); - var valueStart = getValueStart(valueAxis, valueOrigin); - var baseAxisDim = baseAxis.dim; - var valueAxisDim = valueAxis.dim; - var valueDim = data.mapDimension(valueAxisDim); - var baseDim = data.mapDimension(baseAxisDim); - var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0; - var dims = map$1(coordSys.dimensions, function (coordDim) { - return data.mapDimension(coordDim); - }); - var stacked = false; - var stackResultDim = data.getCalculationInfo('stackResultDimension'); - if (isDimensionStacked(data, dims[0] /* , dims[1] */)) { - // jshint ignore:line - stacked = true; - dims[0] = stackResultDim; - } - if (isDimensionStacked(data, dims[1] /* , dims[0] */)) { - // jshint ignore:line - stacked = true; - dims[1] = stackResultDim; - } - return { - dataDimsForPoint: dims, - valueStart: valueStart, - valueAxisDim: valueAxisDim, - baseAxisDim: baseAxisDim, - stacked: !!stacked, - valueDim: valueDim, - baseDim: baseDim, - baseDataOffset: baseDataOffset, - stackedOverDimension: data.getCalculationInfo('stackedOverDimension') - }; -} -function getValueStart(valueAxis, valueOrigin) { - var valueStart = 0; - var extent = valueAxis.scale.getExtent(); - if (valueOrigin === 'start') { - valueStart = extent[0]; - } else if (valueOrigin === 'end') { - valueStart = extent[1]; - } - // If origin is specified as a number, use it as - // valueStart directly - else if (isNumber(valueOrigin) && !isNaN(valueOrigin)) { - valueStart = valueOrigin; - } - // auto - else { - // Both positive - if (extent[0] > 0) { - valueStart = extent[0]; - } - // Both negative - else if (extent[1] < 0) { - valueStart = extent[1]; - } - // If is one positive, and one negative, onZero shall be true - } - return valueStart; -} -function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) { - var value = NaN; - if (dataCoordInfo.stacked) { - value = data.get(data.getCalculationInfo('stackedOverDimension'), idx); - } - if (isNaN(value)) { - value = dataCoordInfo.valueStart; - } - var baseDataOffset = dataCoordInfo.baseDataOffset; - var stackedData = []; - stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx); - stackedData[1 - baseDataOffset] = value; - return coordSys.dataToPoint(stackedData); -} - -function diffData(oldData, newData) { - var diffResult = []; - newData.diff(oldData).add(function (idx) { - diffResult.push({ - cmd: '+', - idx: idx - }); - }).update(function (newIdx, oldIdx) { - diffResult.push({ - cmd: '=', - idx: oldIdx, - idx1: newIdx - }); - }).remove(function (idx) { - diffResult.push({ - cmd: '-', - idx: idx - }); - }).execute(); - return diffResult; -} -function lineAnimationDiff(oldData, newData, oldStackedOnPoints, newStackedOnPoints, oldCoordSys, newCoordSys, oldValueOrigin, newValueOrigin) { - var diff = diffData(oldData, newData); - // let newIdList = newData.mapArray(newData.getId); - // let oldIdList = oldData.mapArray(oldData.getId); - // convertToIntId(newIdList, oldIdList); - // // FIXME One data ? - // diff = arrayDiff(oldIdList, newIdList); - var currPoints = []; - var nextPoints = []; - // Points for stacking base line - var currStackedPoints = []; - var nextStackedPoints = []; - var status = []; - var sortedIndices = []; - var rawIndices = []; - var newDataOldCoordInfo = prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin); - // const oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin); - var oldPoints = oldData.getLayout('points') || []; - var newPoints = newData.getLayout('points') || []; - for (var i = 0; i < diff.length; i++) { - var diffItem = diff[i]; - var pointAdded = true; - var oldIdx2 = void 0; - var newIdx2 = void 0; - // FIXME, animation is not so perfect when dataZoom window moves fast - // Which is in case remvoing or add more than one data in the tail or head - switch (diffItem.cmd) { - case '=': - oldIdx2 = diffItem.idx * 2; - newIdx2 = diffItem.idx1 * 2; - var currentX = oldPoints[oldIdx2]; - var currentY = oldPoints[oldIdx2 + 1]; - var nextX = newPoints[newIdx2]; - var nextY = newPoints[newIdx2 + 1]; - // If previous data is NaN, use next point directly - if (isNaN(currentX) || isNaN(currentY)) { - currentX = nextX; - currentY = nextY; - } - currPoints.push(currentX, currentY); - nextPoints.push(nextX, nextY); - currStackedPoints.push(oldStackedOnPoints[oldIdx2], oldStackedOnPoints[oldIdx2 + 1]); - nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]); - rawIndices.push(newData.getRawIndex(diffItem.idx1)); - break; - case '+': - var newIdx = diffItem.idx; - var newDataDimsForPoint = newDataOldCoordInfo.dataDimsForPoint; - var oldPt = oldCoordSys.dataToPoint([newData.get(newDataDimsForPoint[0], newIdx), newData.get(newDataDimsForPoint[1], newIdx)]); - newIdx2 = newIdx * 2; - currPoints.push(oldPt[0], oldPt[1]); - nextPoints.push(newPoints[newIdx2], newPoints[newIdx2 + 1]); - var stackedOnPoint = getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, newIdx); - currStackedPoints.push(stackedOnPoint[0], stackedOnPoint[1]); - nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]); - rawIndices.push(newData.getRawIndex(newIdx)); - break; - case '-': - pointAdded = false; - } - // Original indices - if (pointAdded) { - status.push(diffItem); - sortedIndices.push(sortedIndices.length); - } - } - // Diff result may be crossed if all items are changed - // Sort by data index - sortedIndices.sort(function (a, b) { - return rawIndices[a] - rawIndices[b]; - }); - var len = currPoints.length; - var sortedCurrPoints = createFloat32Array(len); - var sortedNextPoints = createFloat32Array(len); - var sortedCurrStackedPoints = createFloat32Array(len); - var sortedNextStackedPoints = createFloat32Array(len); - var sortedStatus = []; - for (var i = 0; i < sortedIndices.length; i++) { - var idx = sortedIndices[i]; - var i2 = i * 2; - var idx2 = idx * 2; - sortedCurrPoints[i2] = currPoints[idx2]; - sortedCurrPoints[i2 + 1] = currPoints[idx2 + 1]; - sortedNextPoints[i2] = nextPoints[idx2]; - sortedNextPoints[i2 + 1] = nextPoints[idx2 + 1]; - sortedCurrStackedPoints[i2] = currStackedPoints[idx2]; - sortedCurrStackedPoints[i2 + 1] = currStackedPoints[idx2 + 1]; - sortedNextStackedPoints[i2] = nextStackedPoints[idx2]; - sortedNextStackedPoints[i2 + 1] = nextStackedPoints[idx2 + 1]; - sortedStatus[i] = status[idx]; - } - return { - current: sortedCurrPoints, - next: sortedNextPoints, - stackedOnCurrent: sortedCurrStackedPoints, - stackedOnNext: sortedNextStackedPoints, - status: sortedStatus - }; -} - -var mathMin = Math.min; -var mathMax = Math.max; -function isPointNull$1(x, y) { - return isNaN(x) || isNaN(y); -} -/** - * Draw smoothed line in non-monotone, in may cause undesired curve in extreme - * situations. This should be used when points are non-monotone neither in x or - * y dimension. - */ -function drawSegment(ctx, points, start, segLen, allLen, dir, smooth, smoothMonotone, connectNulls) { - var prevX; - var prevY; - var cpx0; - var cpy0; - var cpx1; - var cpy1; - var idx = start; - var k = 0; - for (; k < segLen; k++) { - var x = points[idx * 2]; - var y = points[idx * 2 + 1]; - if (idx >= allLen || idx < 0) { - break; - } - if (isPointNull$1(x, y)) { - if (connectNulls) { - idx += dir; - continue; - } - break; - } - if (idx === start) { - ctx[dir > 0 ? 'moveTo' : 'lineTo'](x, y); - cpx0 = x; - cpy0 = y; - } else { - var dx = x - prevX; - var dy = y - prevY; - // Ignore tiny segment. - if (dx * dx + dy * dy < 0.5) { - idx += dir; - continue; - } - if (smooth > 0) { - var nextIdx = idx + dir; - var nextX = points[nextIdx * 2]; - var nextY = points[nextIdx * 2 + 1]; - // Ignore duplicate point - while (nextX === x && nextY === y && k < segLen) { - k++; - nextIdx += dir; - idx += dir; - nextX = points[nextIdx * 2]; - nextY = points[nextIdx * 2 + 1]; - x = points[idx * 2]; - y = points[idx * 2 + 1]; - dx = x - prevX; - dy = y - prevY; - } - var tmpK = k + 1; - if (connectNulls) { - // Find next point not null - while (isPointNull$1(nextX, nextY) && tmpK < segLen) { - tmpK++; - nextIdx += dir; - nextX = points[nextIdx * 2]; - nextY = points[nextIdx * 2 + 1]; - } - } - var ratioNextSeg = 0.5; - var vx = 0; - var vy = 0; - var nextCpx0 = void 0; - var nextCpy0 = void 0; - // Is last point - if (tmpK >= segLen || isPointNull$1(nextX, nextY)) { - cpx1 = x; - cpy1 = y; - } else { - vx = nextX - prevX; - vy = nextY - prevY; - var dx0 = x - prevX; - var dx1 = nextX - x; - var dy0 = y - prevY; - var dy1 = nextY - y; - var lenPrevSeg = void 0; - var lenNextSeg = void 0; - if (smoothMonotone === 'x') { - lenPrevSeg = Math.abs(dx0); - lenNextSeg = Math.abs(dx1); - var dir_1 = vx > 0 ? 1 : -1; - cpx1 = x - dir_1 * lenPrevSeg * smooth; - cpy1 = y; - nextCpx0 = x + dir_1 * lenNextSeg * smooth; - nextCpy0 = y; - } else if (smoothMonotone === 'y') { - lenPrevSeg = Math.abs(dy0); - lenNextSeg = Math.abs(dy1); - var dir_2 = vy > 0 ? 1 : -1; - cpx1 = x; - cpy1 = y - dir_2 * lenPrevSeg * smooth; - nextCpx0 = x; - nextCpy0 = y + dir_2 * lenNextSeg * smooth; - } else { - lenPrevSeg = Math.sqrt(dx0 * dx0 + dy0 * dy0); - lenNextSeg = Math.sqrt(dx1 * dx1 + dy1 * dy1); - // Use ratio of seg length - ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg); - cpx1 = x - vx * smooth * (1 - ratioNextSeg); - cpy1 = y - vy * smooth * (1 - ratioNextSeg); - // cp0 of next segment - nextCpx0 = x + vx * smooth * ratioNextSeg; - nextCpy0 = y + vy * smooth * ratioNextSeg; - // Smooth constraint between point and next point. - // Avoid exceeding extreme after smoothing. - nextCpx0 = mathMin(nextCpx0, mathMax(nextX, x)); - nextCpy0 = mathMin(nextCpy0, mathMax(nextY, y)); - nextCpx0 = mathMax(nextCpx0, mathMin(nextX, x)); - nextCpy0 = mathMax(nextCpy0, mathMin(nextY, y)); - // Reclaculate cp1 based on the adjusted cp0 of next seg. - vx = nextCpx0 - x; - vy = nextCpy0 - y; - cpx1 = x - vx * lenPrevSeg / lenNextSeg; - cpy1 = y - vy * lenPrevSeg / lenNextSeg; - // Smooth constraint between point and prev point. - // Avoid exceeding extreme after smoothing. - cpx1 = mathMin(cpx1, mathMax(prevX, x)); - cpy1 = mathMin(cpy1, mathMax(prevY, y)); - cpx1 = mathMax(cpx1, mathMin(prevX, x)); - cpy1 = mathMax(cpy1, mathMin(prevY, y)); - // Adjust next cp0 again. - vx = x - cpx1; - vy = y - cpy1; - nextCpx0 = x + vx * lenNextSeg / lenPrevSeg; - nextCpy0 = y + vy * lenNextSeg / lenPrevSeg; - } - } - ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y); - cpx0 = nextCpx0; - cpy0 = nextCpy0; - } else { - ctx.lineTo(x, y); - } - } - prevX = x; - prevY = y; - idx += dir; - } - return k; -} -var ECPolylineShape = /** @class */function () { - function ECPolylineShape() { - this.smooth = 0; - this.smoothConstraint = true; - } - return ECPolylineShape; -}(); -var ECPolyline = /** @class */function (_super) { - __extends(ECPolyline, _super); - function ECPolyline(opts) { - var _this = _super.call(this, opts) || this; - _this.type = 'ec-polyline'; - return _this; - } - ECPolyline.prototype.getDefaultStyle = function () { - return { - stroke: '#000', - fill: null - }; - }; - ECPolyline.prototype.getDefaultShape = function () { - return new ECPolylineShape(); - }; - ECPolyline.prototype.buildPath = function (ctx, shape) { - var points = shape.points; - var i = 0; - var len = points.length / 2; - // const result = getBoundingBox(points, shape.smoothConstraint); - if (shape.connectNulls) { - // Must remove first and last null values avoid draw error in polygon - for (; len > 0; len--) { - if (!isPointNull$1(points[len * 2 - 2], points[len * 2 - 1])) { - break; - } - } - for (; i < len; i++) { - if (!isPointNull$1(points[i * 2], points[i * 2 + 1])) { - break; - } - } - } - while (i < len) { - i += drawSegment(ctx, points, i, len, len, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1; - } - }; - ECPolyline.prototype.getPointOn = function (xOrY, dim) { - if (!this.path) { - this.createPathProxy(); - this.buildPath(this.path, this.shape); - } - var path = this.path; - var data = path.data; - var CMD = PathProxy.CMD; - var x0; - var y0; - var isDimX = dim === 'x'; - var roots = []; - for (var i = 0; i < data.length;) { - var cmd = data[i++]; - var x = void 0; - var y = void 0; - var x2 = void 0; - var y2 = void 0; - var x3 = void 0; - var y3 = void 0; - var t = void 0; - switch (cmd) { - case CMD.M: - x0 = data[i++]; - y0 = data[i++]; - break; - case CMD.L: - x = data[i++]; - y = data[i++]; - t = isDimX ? (xOrY - x0) / (x - x0) : (xOrY - y0) / (y - y0); - if (t <= 1 && t >= 0) { - var val = isDimX ? (y - y0) * t + y0 : (x - x0) * t + x0; - return isDimX ? [xOrY, val] : [val, xOrY]; - } - x0 = x; - y0 = y; - break; - case CMD.C: - x = data[i++]; - y = data[i++]; - x2 = data[i++]; - y2 = data[i++]; - x3 = data[i++]; - y3 = data[i++]; - var nRoot = isDimX ? cubicRootAt(x0, x, x2, x3, xOrY, roots) : cubicRootAt(y0, y, y2, y3, xOrY, roots); - if (nRoot > 0) { - for (var i_1 = 0; i_1 < nRoot; i_1++) { - var t_1 = roots[i_1]; - if (t_1 <= 1 && t_1 >= 0) { - var val = isDimX ? cubicAt(y0, y, y2, y3, t_1) : cubicAt(x0, x, x2, x3, t_1); - return isDimX ? [xOrY, val] : [val, xOrY]; - } - } - } - x0 = x3; - y0 = y3; - break; - } - } - }; - return ECPolyline; -}(Path); -var ECPolygonShape = /** @class */function (_super) { - __extends(ECPolygonShape, _super); - function ECPolygonShape() { - return _super !== null && _super.apply(this, arguments) || this; - } - return ECPolygonShape; -}(ECPolylineShape); -var ECPolygon = /** @class */function (_super) { - __extends(ECPolygon, _super); - function ECPolygon(opts) { - var _this = _super.call(this, opts) || this; - _this.type = 'ec-polygon'; - return _this; - } - ECPolygon.prototype.getDefaultShape = function () { - return new ECPolygonShape(); - }; - ECPolygon.prototype.buildPath = function (ctx, shape) { - var points = shape.points; - var stackedOnPoints = shape.stackedOnPoints; - var i = 0; - var len = points.length / 2; - var smoothMonotone = shape.smoothMonotone; - if (shape.connectNulls) { - // Must remove first and last null values avoid draw error in polygon - for (; len > 0; len--) { - if (!isPointNull$1(points[len * 2 - 2], points[len * 2 - 1])) { - break; - } - } - for (; i < len; i++) { - if (!isPointNull$1(points[i * 2], points[i * 2 + 1])) { - break; - } - } - } - while (i < len) { - var k = drawSegment(ctx, points, i, len, len, 1, shape.smooth, smoothMonotone, shape.connectNulls); - drawSegment(ctx, stackedOnPoints, i + k - 1, k, len, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls); - i += k + 1; - ctx.closePath(); - } - }; - return ECPolygon; -}(Path); - -function createGridClipPath(cartesian, hasAnimation, seriesModel, done, during) { - var rect = cartesian.getArea(); - var x = rect.x; - var y = rect.y; - var width = rect.width; - var height = rect.height; - var lineWidth = seriesModel.get(['lineStyle', 'width']) || 0; - // Expand the clip path a bit to avoid the border is clipped and looks thinner - x -= lineWidth / 2; - y -= lineWidth / 2; - width += lineWidth; - height += lineWidth; - // fix: https://github.com/apache/incubator-echarts/issues/11369 - width = Math.ceil(width); - if (x !== Math.floor(x)) { - x = Math.floor(x); - // if no extra 1px on `width`, it will still be clipped since `x` is floored - width++; - } - var clipPath = new Rect({ - shape: { - x: x, - y: y, - width: width, - height: height - } - }); - if (hasAnimation) { - var baseAxis = cartesian.getBaseAxis(); - var isHorizontal = baseAxis.isHorizontal(); - var isAxisInversed = baseAxis.inverse; - if (isHorizontal) { - if (isAxisInversed) { - clipPath.shape.x += width; - } - clipPath.shape.width = 0; - } else { - if (!isAxisInversed) { - clipPath.shape.y += height; - } - clipPath.shape.height = 0; - } - var duringCb = isFunction(during) ? function (percent) { - during(percent, clipPath); - } : null; - initProps(clipPath, { - shape: { - width: width, - height: height, - x: x, - y: y - } - }, seriesModel, null, done, duringCb); - } - return clipPath; -} -function createPolarClipPath(polar, hasAnimation, seriesModel) { - var sectorArea = polar.getArea(); - // Avoid float number rounding error for symbol on the edge of axis extent. - var r0 = round$1(sectorArea.r0, 1); - var r = round$1(sectorArea.r, 1); - var clipPath = new Sector({ - shape: { - cx: round$1(polar.cx, 1), - cy: round$1(polar.cy, 1), - r0: r0, - r: r, - startAngle: sectorArea.startAngle, - endAngle: sectorArea.endAngle, - clockwise: sectorArea.clockwise - } - }); - if (hasAnimation) { - var isRadial = polar.getBaseAxis().dim === 'angle'; - if (isRadial) { - clipPath.shape.endAngle = sectorArea.startAngle; - } else { - clipPath.shape.r = r0; - } - initProps(clipPath, { - shape: { - endAngle: sectorArea.endAngle, - r: r - } - }, seriesModel); - } - return clipPath; -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function isCoordinateSystemType(coordSys, type) { - return coordSys.type === type; -} - -function isPointsSame(points1, points2) { - if (points1.length !== points2.length) { - return; - } - for (var i = 0; i < points1.length; i++) { - if (points1[i] !== points2[i]) { - return; - } - } - return true; -} -function bboxFromPoints(points) { - var minX = Infinity; - var minY = Infinity; - var maxX = -Infinity; - var maxY = -Infinity; - for (var i = 0; i < points.length; ) { - var x = points[i++]; - var y = points[i++]; - if (!isNaN(x)) { - minX = Math.min(x, minX); - maxX = Math.max(x, maxX); - } - if (!isNaN(y)) { - minY = Math.min(y, minY); - maxY = Math.max(y, maxY); - } - } - return [[minX, minY], [maxX, maxY]]; -} -function getBoundingDiff(points1, points2) { - var _a = bboxFromPoints(points1), min1 = _a[0], max1 = _a[1]; - var _b = bboxFromPoints(points2), min2 = _b[0], max2 = _b[1]; - return Math.max(Math.abs(min1[0] - min2[0]), Math.abs(min1[1] - min2[1]), Math.abs(max1[0] - max2[0]), Math.abs(max1[1] - max2[1])); -} -function getSmooth(smooth) { - return isNumber(smooth) ? smooth : smooth ? 0.5 : 0; -} -function getStackedOnPoints(coordSys, data, dataCoordInfo) { - if (!dataCoordInfo.valueDim) { - return []; - } - var len = data.count(); - var points = createFloat32Array(len * 2); - for (var idx = 0; idx < len; idx++) { - var pt = getStackedOnPoint(dataCoordInfo, coordSys, data, idx); - points[idx * 2] = pt[0]; - points[idx * 2 + 1] = pt[1]; - } - return points; -} -function turnPointsIntoStep(points, basePoints, coordSys, stepTurnAt, connectNulls) { - var baseAxis = coordSys.getBaseAxis(); - var baseIndex = baseAxis.dim === "x" || baseAxis.dim === "radius" ? 0 : 1; - var stepPoints = []; - var i = 0; - var stepPt = []; - var pt = []; - var nextPt = []; - var filteredPoints = []; - if (connectNulls) { - for (i = 0; i < points.length; i += 2) { - var reference = basePoints || points; - if (!isNaN(reference[i]) && !isNaN(reference[i + 1])) { - filteredPoints.push(points[i], points[i + 1]); - } - } - points = filteredPoints; - } - for (i = 0; i < points.length - 2; i += 2) { - nextPt[0] = points[i + 2]; - nextPt[1] = points[i + 3]; - pt[0] = points[i]; - pt[1] = points[i + 1]; - stepPoints.push(pt[0], pt[1]); - switch (stepTurnAt) { - case "end": - stepPt[baseIndex] = nextPt[baseIndex]; - stepPt[1 - baseIndex] = pt[1 - baseIndex]; - stepPoints.push(stepPt[0], stepPt[1]); - break; - case "middle": - var middle = (pt[baseIndex] + nextPt[baseIndex]) / 2; - var stepPt2 = []; - stepPt[baseIndex] = stepPt2[baseIndex] = middle; - stepPt[1 - baseIndex] = pt[1 - baseIndex]; - stepPt2[1 - baseIndex] = nextPt[1 - baseIndex]; - stepPoints.push(stepPt[0], stepPt[1]); - stepPoints.push(stepPt2[0], stepPt2[1]); - break; - default: - stepPt[baseIndex] = pt[baseIndex]; - stepPt[1 - baseIndex] = nextPt[1 - baseIndex]; - stepPoints.push(stepPt[0], stepPt[1]); - } - } - stepPoints.push(points[i++], points[i++]); - return stepPoints; -} -function clipColorStops(colorStops, maxSize) { - var newColorStops = []; - var len = colorStops.length; - var prevOutOfRangeColorStop; - var prevInRangeColorStop; - function lerpStop(stop0, stop1, clippedCoord) { - var coord0 = stop0.coord; - var p = (clippedCoord - coord0) / (stop1.coord - coord0); - var color = lerp(p, [stop0.color, stop1.color]); - return { - coord: clippedCoord, - color - }; - } - for (var i = 0; i < len; i++) { - var stop_1 = colorStops[i]; - var coord = stop_1.coord; - if (coord < 0) { - prevOutOfRangeColorStop = stop_1; - } else if (coord > maxSize) { - if (prevInRangeColorStop) { - newColorStops.push(lerpStop(prevInRangeColorStop, stop_1, maxSize)); - } else if (prevOutOfRangeColorStop) { - newColorStops.push(lerpStop(prevOutOfRangeColorStop, stop_1, 0), lerpStop(prevOutOfRangeColorStop, stop_1, maxSize)); - } - break; - } else { - if (prevOutOfRangeColorStop) { - newColorStops.push(lerpStop(prevOutOfRangeColorStop, stop_1, 0)); - prevOutOfRangeColorStop = null; - } - newColorStops.push(stop_1); - prevInRangeColorStop = stop_1; - } - } - return newColorStops; -} -function getVisualGradient(data, coordSys, api) { - var visualMetaList = data.getVisual("visualMeta"); - if (!visualMetaList || !visualMetaList.length || !data.count()) { - return; - } - if (coordSys.type !== "cartesian2d") { - return; - } - var coordDim; - var visualMeta; - for (var i = visualMetaList.length - 1; i >= 0; i--) { - var dimInfo = data.getDimensionInfo(visualMetaList[i].dimension); - coordDim = dimInfo && dimInfo.coordDim; - if (coordDim === "x" || coordDim === "y") { - visualMeta = visualMetaList[i]; - break; - } - } - if (!visualMeta) { - return; - } - var axis = coordSys.getAxis(coordDim); - var colorStops = map$1(visualMeta.stops, function(stop) { - return { - coord: axis.toGlobalCoord(axis.dataToCoord(stop.value)), - color: stop.color - }; - }); - var stopLen = colorStops.length; - var outerColors = visualMeta.outerColors.slice(); - if (stopLen && colorStops[0].coord > colorStops[stopLen - 1].coord) { - colorStops.reverse(); - outerColors.reverse(); - } - var colorStopsInRange = clipColorStops(colorStops, coordDim === "x" ? api.getWidth() : api.getHeight()); - var inRangeStopLen = colorStopsInRange.length; - if (!inRangeStopLen && stopLen) { - return colorStops[0].coord < 0 ? outerColors[1] ? outerColors[1] : colorStops[stopLen - 1].color : outerColors[0] ? outerColors[0] : colorStops[0].color; - } - var tinyExtent = 10; - var minCoord = colorStopsInRange[0].coord - tinyExtent; - var maxCoord = colorStopsInRange[inRangeStopLen - 1].coord + tinyExtent; - var coordSpan = maxCoord - minCoord; - if (coordSpan < 1e-3) { - return "transparent"; - } - each$4(colorStopsInRange, function(stop) { - stop.offset = (stop.coord - minCoord) / coordSpan; - }); - colorStopsInRange.push({ - // NOTE: inRangeStopLen may still be 0 if stoplen is zero. - offset: inRangeStopLen ? colorStopsInRange[inRangeStopLen - 1].offset : 0.5, - color: outerColors[1] || "transparent" - }); - colorStopsInRange.unshift({ - offset: inRangeStopLen ? colorStopsInRange[0].offset : 0.5, - color: outerColors[0] || "transparent" - }); - var gradient = new LinearGradient(0, 0, 0, 0, colorStopsInRange, true); - gradient[coordDim] = minCoord; - gradient[coordDim + "2"] = maxCoord; - return gradient; -} -function getIsIgnoreFunc(seriesModel, data, coordSys) { - var showAllSymbol = seriesModel.get("showAllSymbol"); - var isAuto = showAllSymbol === "auto"; - if (showAllSymbol && !isAuto) { - return; - } - var categoryAxis = coordSys.getAxesByScale("ordinal")[0]; - if (!categoryAxis) { - return; - } - if (isAuto && canShowAllSymbolForCategory(categoryAxis, data)) { - return; - } - var categoryDataDim = data.mapDimension(categoryAxis.dim); - var labelMap = {}; - each$4(categoryAxis.getViewLabels(), function(labelItem) { - var ordinalNumber = categoryAxis.scale.getRawOrdinalNumber(labelItem.tickValue); - labelMap[ordinalNumber] = 1; - }); - return function(dataIndex) { - return !labelMap.hasOwnProperty(data.get(categoryDataDim, dataIndex)); - }; -} -function canShowAllSymbolForCategory(categoryAxis, data) { - var axisExtent = categoryAxis.getExtent(); - var availSize = Math.abs(axisExtent[1] - axisExtent[0]) / categoryAxis.scale.count(); - isNaN(availSize) && (availSize = 0); - var dataLen = data.count(); - var step = Math.max(1, Math.round(dataLen / 5)); - for (var dataIndex = 0; dataIndex < dataLen; dataIndex += step) { - if (Symbol$1.getSymbolSize( - data, - dataIndex - // Only for cartesian, where `isHorizontal` exists. - )[categoryAxis.isHorizontal() ? 1 : 0] * 1.5 > availSize) { - return false; - } - } - return true; -} -function isPointNull(x, y) { - return isNaN(x) || isNaN(y); -} -function getLastIndexNotNull(points) { - var len = points.length / 2; - for (; len > 0; len--) { - if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) { - break; - } - } - return len - 1; -} -function getPointAtIndex(points, idx) { - return [points[idx * 2], points[idx * 2 + 1]]; -} -function getIndexRange(points, xOrY, dim) { - var len = points.length / 2; - var dimIdx = dim === "x" ? 0 : 1; - var a; - var b; - var prevIndex = 0; - var nextIndex = -1; - for (var i = 0; i < len; i++) { - b = points[i * 2 + dimIdx]; - if (isNaN(b) || isNaN(points[i * 2 + 1 - dimIdx])) { - continue; - } - if (i === 0) { - a = b; - continue; - } - if (a <= xOrY && b >= xOrY || a >= xOrY && b <= xOrY) { - nextIndex = i; - break; - } - prevIndex = i; - a = b; - } - return { - range: [prevIndex, nextIndex], - t: (xOrY - a) / (b - a) - }; -} -function anyStateShowEndLabel(seriesModel) { - if (seriesModel.get(["endLabel", "show"])) { - return true; - } - for (var i = 0; i < SPECIAL_STATES.length; i++) { - if (seriesModel.get([SPECIAL_STATES[i], "endLabel", "show"])) { - return true; - } - } - return false; -} -function createLineClipPath(lineView, coordSys, hasAnimation, seriesModel) { - if (isCoordinateSystemType(coordSys, "cartesian2d")) { - var endLabelModel_1 = seriesModel.getModel("endLabel"); - var valueAnimation_1 = endLabelModel_1.get("valueAnimation"); - var data_1 = seriesModel.getData(); - var labelAnimationRecord_1 = { - lastFrameIndex: 0 - }; - var during = anyStateShowEndLabel(seriesModel) ? function(percent, clipRect) { - lineView._endLabelOnDuring(percent, clipRect, data_1, labelAnimationRecord_1, valueAnimation_1, endLabelModel_1, coordSys); - } : null; - var isHorizontal = coordSys.getBaseAxis().isHorizontal(); - var clipPath = createGridClipPath(coordSys, hasAnimation, seriesModel, function() { - var endLabel = lineView._endLabel; - if (endLabel && hasAnimation) { - if (labelAnimationRecord_1.originalX != null) { - endLabel.attr({ - x: labelAnimationRecord_1.originalX, - y: labelAnimationRecord_1.originalY - }); - } - } - }, during); - if (!seriesModel.get("clip", true)) { - var rectShape = clipPath.shape; - var expandSize = Math.max(rectShape.width, rectShape.height); - if (isHorizontal) { - rectShape.y -= expandSize; - rectShape.height += expandSize * 2; - } else { - rectShape.x -= expandSize; - rectShape.width += expandSize * 2; - } - } - if (during) { - during(1, clipPath); - } - return clipPath; - } else { - return createPolarClipPath(coordSys, hasAnimation, seriesModel); - } -} -function getEndLabelStateSpecified(endLabelModel, coordSys) { - var baseAxis = coordSys.getBaseAxis(); - var isHorizontal = baseAxis.isHorizontal(); - var isBaseInversed = baseAxis.inverse; - var align = isHorizontal ? isBaseInversed ? "right" : "left" : "center"; - var verticalAlign = isHorizontal ? "middle" : isBaseInversed ? "top" : "bottom"; - return { - normal: { - align: endLabelModel.get("align") || align, - verticalAlign: endLabelModel.get("verticalAlign") || verticalAlign - } - }; -} -var LineView = ( - /** @class */ - function(_super) { - __extends(LineView2, _super); - function LineView2() { - return _super !== null && _super.apply(this, arguments) || this; - } - LineView2.prototype.init = function() { - var lineGroup = new Group$2(); - var symbolDraw = new SymbolDraw(); - this.group.add(symbolDraw.group); - this._symbolDraw = symbolDraw; - this._lineGroup = lineGroup; - this._changePolyState = bind$1(this._changePolyState, this); - }; - LineView2.prototype.render = function(seriesModel, ecModel, api) { - var coordSys = seriesModel.coordinateSystem; - var group = this.group; - var data = seriesModel.getData(); - var lineStyleModel = seriesModel.getModel("lineStyle"); - var areaStyleModel = seriesModel.getModel("areaStyle"); - var points = data.getLayout("points") || []; - var isCoordSysPolar = coordSys.type === "polar"; - var prevCoordSys = this._coordSys; - var symbolDraw = this._symbolDraw; - var polyline = this._polyline; - var polygon = this._polygon; - var lineGroup = this._lineGroup; - var hasAnimation = !ecModel.ssr && seriesModel.get("animation"); - var isAreaChart = !areaStyleModel.isEmpty(); - var valueOrigin = areaStyleModel.get("origin"); - var dataCoordInfo = prepareDataCoordInfo(coordSys, data, valueOrigin); - var stackedOnPoints = isAreaChart && getStackedOnPoints(coordSys, data, dataCoordInfo); - var showSymbol = seriesModel.get("showSymbol"); - var connectNulls = seriesModel.get("connectNulls"); - var isIgnoreFunc = showSymbol && !isCoordSysPolar && getIsIgnoreFunc(seriesModel, data, coordSys); - var oldData = this._data; - oldData && oldData.eachItemGraphicEl(function(el, idx) { - if (el.__temp) { - group.remove(el); - oldData.setItemGraphicEl(idx, null); - } - }); - if (!showSymbol) { - symbolDraw.remove(); - } - group.add(lineGroup); - var step = !isCoordSysPolar ? seriesModel.get("step") : false; - var clipShapeForSymbol; - if (coordSys && coordSys.getArea && seriesModel.get("clip", true)) { - clipShapeForSymbol = coordSys.getArea(); - if (clipShapeForSymbol.width != null) { - clipShapeForSymbol.x -= 0.1; - clipShapeForSymbol.y -= 0.1; - clipShapeForSymbol.width += 0.2; - clipShapeForSymbol.height += 0.2; - } else if (clipShapeForSymbol.r0) { - clipShapeForSymbol.r0 -= 0.5; - clipShapeForSymbol.r += 0.5; - } - } - this._clipShapeForSymbol = clipShapeForSymbol; - var visualColor = getVisualGradient(data, coordSys, api) || data.getVisual("style")[data.getVisual("drawType")]; - if (!(polyline && prevCoordSys.type === coordSys.type && step === this._step)) { - showSymbol && symbolDraw.updateData(data, { - isIgnore: isIgnoreFunc, - clipShape: clipShapeForSymbol, - disableAnimation: true, - getSymbolPoint: function(idx) { - return [points[idx * 2], points[idx * 2 + 1]]; - } - }); - hasAnimation && this._initSymbolLabelAnimation(data, coordSys, clipShapeForSymbol); - if (step) { - if (stackedOnPoints) { - stackedOnPoints = turnPointsIntoStep(stackedOnPoints, points, coordSys, step, connectNulls); - } - points = turnPointsIntoStep(points, null, coordSys, step, connectNulls); - } - polyline = this._newPolyline(points); - if (isAreaChart) { - polygon = this._newPolygon(points, stackedOnPoints); - } else if (polygon) { - lineGroup.remove(polygon); - polygon = this._polygon = null; - } - if (!isCoordSysPolar) { - this._initOrUpdateEndLabel(seriesModel, coordSys, convertToColorString(visualColor)); - } - lineGroup.setClipPath(createLineClipPath(this, coordSys, true, seriesModel)); - } else { - if (isAreaChart && !polygon) { - polygon = this._newPolygon(points, stackedOnPoints); - } else if (polygon && !isAreaChart) { - lineGroup.remove(polygon); - polygon = this._polygon = null; - } - if (!isCoordSysPolar) { - this._initOrUpdateEndLabel(seriesModel, coordSys, convertToColorString(visualColor)); - } - var oldClipPath = lineGroup.getClipPath(); - if (oldClipPath) { - var newClipPath = createLineClipPath(this, coordSys, false, seriesModel); - initProps(oldClipPath, { - shape: newClipPath.shape - }, seriesModel); - } else { - lineGroup.setClipPath(createLineClipPath(this, coordSys, true, seriesModel)); - } - showSymbol && symbolDraw.updateData(data, { - isIgnore: isIgnoreFunc, - clipShape: clipShapeForSymbol, - disableAnimation: true, - getSymbolPoint: function(idx) { - return [points[idx * 2], points[idx * 2 + 1]]; - } - }); - if (!isPointsSame(this._stackedOnPoints, stackedOnPoints) || !isPointsSame(this._points, points)) { - if (hasAnimation) { - this._doUpdateAnimation(data, stackedOnPoints, coordSys, api, step, valueOrigin, connectNulls); - } else { - if (step) { - if (stackedOnPoints) { - stackedOnPoints = turnPointsIntoStep(stackedOnPoints, points, coordSys, step, connectNulls); - } - points = turnPointsIntoStep(points, null, coordSys, step, connectNulls); - } - polyline.setShape({ - points - }); - polygon && polygon.setShape({ - points, - stackedOnPoints - }); - } - } - } - var emphasisModel = seriesModel.getModel("emphasis"); - var focus = emphasisModel.get("focus"); - var blurScope = emphasisModel.get("blurScope"); - var emphasisDisabled = emphasisModel.get("disabled"); - polyline.useStyle(defaults( - // Use color in lineStyle first - lineStyleModel.getLineStyle(), - { - fill: "none", - stroke: visualColor, - lineJoin: "bevel" - } - )); - setStatesStylesFromModel(polyline, seriesModel, "lineStyle"); - if (polyline.style.lineWidth > 0 && seriesModel.get(["emphasis", "lineStyle", "width"]) === "bolder") { - var emphasisLineStyle = polyline.getState("emphasis").style; - emphasisLineStyle.lineWidth = +polyline.style.lineWidth + 1; - } - getECData(polyline).seriesIndex = seriesModel.seriesIndex; - toggleHoverEmphasis(polyline, focus, blurScope, emphasisDisabled); - var smooth = getSmooth(seriesModel.get("smooth")); - var smoothMonotone = seriesModel.get("smoothMonotone"); - polyline.setShape({ - smooth, - smoothMonotone, - connectNulls - }); - if (polygon) { - var stackedOnSeries = data.getCalculationInfo("stackedOnSeries"); - var stackedOnSmooth = 0; - polygon.useStyle(defaults(areaStyleModel.getAreaStyle(), { - fill: visualColor, - opacity: 0.7, - lineJoin: "bevel", - decal: data.getVisual("style").decal - })); - if (stackedOnSeries) { - stackedOnSmooth = getSmooth(stackedOnSeries.get("smooth")); - } - polygon.setShape({ - smooth, - stackedOnSmooth, - smoothMonotone, - connectNulls - }); - setStatesStylesFromModel(polygon, seriesModel, "areaStyle"); - getECData(polygon).seriesIndex = seriesModel.seriesIndex; - toggleHoverEmphasis(polygon, focus, blurScope, emphasisDisabled); - } - var changePolyState = this._changePolyState; - data.eachItemGraphicEl(function(el) { - el && (el.onHoverStateChange = changePolyState); - }); - this._polyline.onHoverStateChange = changePolyState; - this._data = data; - this._coordSys = coordSys; - this._stackedOnPoints = stackedOnPoints; - this._points = points; - this._step = step; - this._valueOrigin = valueOrigin; - if (seriesModel.get("triggerLineEvent")) { - this.packEventData(seriesModel, polyline); - polygon && this.packEventData(seriesModel, polygon); - } - }; - LineView2.prototype.packEventData = function(seriesModel, el) { - getECData(el).eventData = { - componentType: "series", - componentSubType: "line", - componentIndex: seriesModel.componentIndex, - seriesIndex: seriesModel.seriesIndex, - seriesName: seriesModel.name, - seriesType: "line" - }; - }; - LineView2.prototype.highlight = function(seriesModel, ecModel, api, payload) { - var data = seriesModel.getData(); - var dataIndex = queryDataIndex(data, payload); - this._changePolyState("emphasis"); - if (!(dataIndex instanceof Array) && dataIndex != null && dataIndex >= 0) { - var points = data.getLayout("points"); - var symbol = data.getItemGraphicEl(dataIndex); - if (!symbol) { - var x = points[dataIndex * 2]; - var y = points[dataIndex * 2 + 1]; - if (isNaN(x) || isNaN(y)) { - return; - } - if (this._clipShapeForSymbol && !this._clipShapeForSymbol.contain(x, y)) { - return; - } - var zlevel = seriesModel.get("zlevel") || 0; - var z = seriesModel.get("z") || 0; - symbol = new Symbol$1(data, dataIndex); - symbol.x = x; - symbol.y = y; - symbol.setZ(zlevel, z); - var symbolLabel = symbol.getSymbolPath().getTextContent(); - if (symbolLabel) { - symbolLabel.zlevel = zlevel; - symbolLabel.z = z; - symbolLabel.z2 = this._polyline.z2 + 1; - } - symbol.__temp = true; - data.setItemGraphicEl(dataIndex, symbol); - symbol.stopSymbolAnimation(true); - this.group.add(symbol); - } - symbol.highlight(); - } else { - ChartView.prototype.highlight.call(this, seriesModel, ecModel, api, payload); - } - }; - LineView2.prototype.downplay = function(seriesModel, ecModel, api, payload) { - var data = seriesModel.getData(); - var dataIndex = queryDataIndex(data, payload); - this._changePolyState("normal"); - if (dataIndex != null && dataIndex >= 0) { - var symbol = data.getItemGraphicEl(dataIndex); - if (symbol) { - if (symbol.__temp) { - data.setItemGraphicEl(dataIndex, null); - this.group.remove(symbol); - } else { - symbol.downplay(); - } - } - } else { - ChartView.prototype.downplay.call(this, seriesModel, ecModel, api, payload); - } - }; - LineView2.prototype._changePolyState = function(toState) { - var polygon = this._polygon; - setStatesFlag(this._polyline, toState); - polygon && setStatesFlag(polygon, toState); - }; - LineView2.prototype._newPolyline = function(points) { - var polyline = this._polyline; - if (polyline) { - this._lineGroup.remove(polyline); - } - polyline = new ECPolyline({ - shape: { - points - }, - segmentIgnoreThreshold: 2, - z2: 10 - }); - this._lineGroup.add(polyline); - this._polyline = polyline; - return polyline; - }; - LineView2.prototype._newPolygon = function(points, stackedOnPoints) { - var polygon = this._polygon; - if (polygon) { - this._lineGroup.remove(polygon); - } - polygon = new ECPolygon({ - shape: { - points, - stackedOnPoints - }, - segmentIgnoreThreshold: 2 - }); - this._lineGroup.add(polygon); - this._polygon = polygon; - return polygon; - }; - LineView2.prototype._initSymbolLabelAnimation = function(data, coordSys, clipShape) { - var isHorizontalOrRadial; - var isCoordSysPolar; - var baseAxis = coordSys.getBaseAxis(); - var isAxisInverse = baseAxis.inverse; - if (coordSys.type === "cartesian2d") { - isHorizontalOrRadial = baseAxis.isHorizontal(); - isCoordSysPolar = false; - } else if (coordSys.type === "polar") { - isHorizontalOrRadial = baseAxis.dim === "angle"; - isCoordSysPolar = true; - } - var seriesModel = data.hostModel; - var seriesDuration = seriesModel.get("animationDuration"); - if (isFunction(seriesDuration)) { - seriesDuration = seriesDuration(null); - } - var seriesDelay = seriesModel.get("animationDelay") || 0; - var seriesDelayValue = isFunction(seriesDelay) ? seriesDelay(null) : seriesDelay; - data.eachItemGraphicEl(function(symbol, idx) { - var el = symbol; - if (el) { - var point = [symbol.x, symbol.y]; - var start = void 0; - var end = void 0; - var current = void 0; - if (clipShape) { - if (isCoordSysPolar) { - var polarClip = clipShape; - var coord = coordSys.pointToCoord(point); - if (isHorizontalOrRadial) { - start = polarClip.startAngle; - end = polarClip.endAngle; - current = -coord[1] / 180 * Math.PI; - } else { - start = polarClip.r0; - end = polarClip.r; - current = coord[0]; - } - } else { - var gridClip = clipShape; - if (isHorizontalOrRadial) { - start = gridClip.x; - end = gridClip.x + gridClip.width; - current = symbol.x; - } else { - start = gridClip.y + gridClip.height; - end = gridClip.y; - current = symbol.y; - } - } - } - var ratio = end === start ? 0 : (current - start) / (end - start); - if (isAxisInverse) { - ratio = 1 - ratio; - } - var delay = isFunction(seriesDelay) ? seriesDelay(idx) : seriesDuration * ratio + seriesDelayValue; - var symbolPath = el.getSymbolPath(); - var text = symbolPath.getTextContent(); - el.attr({ - scaleX: 0, - scaleY: 0 - }); - el.animateTo({ - scaleX: 1, - scaleY: 1 - }, { - duration: 200, - setToFinal: true, - delay - }); - if (text) { - text.animateFrom({ - style: { - opacity: 0 - } - }, { - duration: 300, - delay - }); - } - symbolPath.disableLabelAnimation = true; - } - }); - }; - LineView2.prototype._initOrUpdateEndLabel = function(seriesModel, coordSys, inheritColor) { - var endLabelModel = seriesModel.getModel("endLabel"); - if (anyStateShowEndLabel(seriesModel)) { - var data_2 = seriesModel.getData(); - var polyline = this._polyline; - var points = data_2.getLayout("points"); - if (!points) { - polyline.removeTextContent(); - this._endLabel = null; - return; - } - var endLabel = this._endLabel; - if (!endLabel) { - endLabel = this._endLabel = new ZRText({ - z2: 200 - // should be higher than item symbol - }); - endLabel.ignoreClip = true; - polyline.setTextContent(this._endLabel); - polyline.disableLabelAnimation = true; - } - var dataIndex = getLastIndexNotNull(points); - if (dataIndex >= 0) { - setLabelStyle(polyline, getLabelStatesModels(seriesModel, "endLabel"), { - inheritColor, - labelFetcher: seriesModel, - labelDataIndex: dataIndex, - defaultText: function(dataIndex2, opt, interpolatedValue) { - return interpolatedValue != null ? getDefaultInterpolatedLabel(data_2, interpolatedValue) : getDefaultLabel(data_2, dataIndex2); - }, - enableTextSetter: true - }, getEndLabelStateSpecified(endLabelModel, coordSys)); - polyline.textConfig.position = null; - } - } else if (this._endLabel) { - this._polyline.removeTextContent(); - this._endLabel = null; - } - }; - LineView2.prototype._endLabelOnDuring = function(percent, clipRect, data, animationRecord, valueAnimation, endLabelModel, coordSys) { - var endLabel = this._endLabel; - var polyline = this._polyline; - if (endLabel) { - if (percent < 1 && animationRecord.originalX == null) { - animationRecord.originalX = endLabel.x; - animationRecord.originalY = endLabel.y; - } - var points = data.getLayout("points"); - var seriesModel = data.hostModel; - var connectNulls = seriesModel.get("connectNulls"); - var precision = endLabelModel.get("precision"); - var distance = endLabelModel.get("distance") || 0; - var baseAxis = coordSys.getBaseAxis(); - var isHorizontal = baseAxis.isHorizontal(); - var isBaseInversed = baseAxis.inverse; - var clipShape = clipRect.shape; - var xOrY = isBaseInversed ? isHorizontal ? clipShape.x : clipShape.y + clipShape.height : isHorizontal ? clipShape.x + clipShape.width : clipShape.y; - var distanceX = (isHorizontal ? distance : 0) * (isBaseInversed ? -1 : 1); - var distanceY = (isHorizontal ? 0 : -distance) * (isBaseInversed ? -1 : 1); - var dim = isHorizontal ? "x" : "y"; - var dataIndexRange = getIndexRange(points, xOrY, dim); - var indices = dataIndexRange.range; - var diff = indices[1] - indices[0]; - var value = void 0; - if (diff >= 1) { - if (diff > 1 && !connectNulls) { - var pt = getPointAtIndex(points, indices[0]); - endLabel.attr({ - x: pt[0] + distanceX, - y: pt[1] + distanceY - }); - valueAnimation && (value = seriesModel.getRawValue(indices[0])); - } else { - var pt = polyline.getPointOn(xOrY, dim); - pt && endLabel.attr({ - x: pt[0] + distanceX, - y: pt[1] + distanceY - }); - var startValue = seriesModel.getRawValue(indices[0]); - var endValue = seriesModel.getRawValue(indices[1]); - valueAnimation && (value = interpolateRawValues(data, precision, startValue, endValue, dataIndexRange.t)); - } - animationRecord.lastFrameIndex = indices[0]; - } else { - var idx = percent === 1 || animationRecord.lastFrameIndex > 0 ? indices[0] : 0; - var pt = getPointAtIndex(points, idx); - valueAnimation && (value = seriesModel.getRawValue(idx)); - endLabel.attr({ - x: pt[0] + distanceX, - y: pt[1] + distanceY - }); - } - if (valueAnimation) { - var inner = labelInner(endLabel); - if (typeof inner.setLabelText === "function") { - inner.setLabelText(value); - } - } - } - }; - LineView2.prototype._doUpdateAnimation = function(data, stackedOnPoints, coordSys, api, step, valueOrigin, connectNulls) { - var polyline = this._polyline; - var polygon = this._polygon; - var seriesModel = data.hostModel; - var diff = lineAnimationDiff(this._data, data, this._stackedOnPoints, stackedOnPoints, this._coordSys, coordSys, this._valueOrigin); - var current = diff.current; - var stackedOnCurrent = diff.stackedOnCurrent; - var next = diff.next; - var stackedOnNext = diff.stackedOnNext; - if (step) { - stackedOnCurrent = turnPointsIntoStep(diff.stackedOnCurrent, diff.current, coordSys, step, connectNulls); - current = turnPointsIntoStep(diff.current, null, coordSys, step, connectNulls); - stackedOnNext = turnPointsIntoStep(diff.stackedOnNext, diff.next, coordSys, step, connectNulls); - next = turnPointsIntoStep(diff.next, null, coordSys, step, connectNulls); - } - if (getBoundingDiff(current, next) > 3e3 || polygon && getBoundingDiff(stackedOnCurrent, stackedOnNext) > 3e3) { - polyline.stopAnimation(); - polyline.setShape({ - points: next - }); - if (polygon) { - polygon.stopAnimation(); - polygon.setShape({ - points: next, - stackedOnPoints: stackedOnNext - }); - } - return; - } - polyline.shape.__points = diff.current; - polyline.shape.points = current; - var target = { - shape: { - points: next - } - }; - if (diff.current !== current) { - target.shape.__points = diff.next; - } - polyline.stopAnimation(); - updateProps$1(polyline, target, seriesModel); - if (polygon) { - polygon.setShape({ - // Reuse the points with polyline. - points: current, - stackedOnPoints: stackedOnCurrent - }); - polygon.stopAnimation(); - updateProps$1(polygon, { - shape: { - stackedOnPoints: stackedOnNext - } - }, seriesModel); - if (polyline.shape.points !== polygon.shape.points) { - polygon.shape.points = polyline.shape.points; - } - } - var updatedDataInfo = []; - var diffStatus = diff.status; - for (var i = 0; i < diffStatus.length; i++) { - var cmd = diffStatus[i].cmd; - if (cmd === "=") { - var el = data.getItemGraphicEl(diffStatus[i].idx1); - if (el) { - updatedDataInfo.push({ - el, - ptIdx: i - // Index of points - }); - } - } - } - if (polyline.animators && polyline.animators.length) { - polyline.animators[0].during(function() { - polygon && polygon.dirtyShape(); - var points = polyline.shape.__points; - for (var i2 = 0; i2 < updatedDataInfo.length; i2++) { - var el2 = updatedDataInfo[i2].el; - var offset = updatedDataInfo[i2].ptIdx * 2; - el2.x = points[offset]; - el2.y = points[offset + 1]; - el2.markRedraw(); - } - }); - } - }; - LineView2.prototype.remove = function(ecModel) { - var group = this.group; - var oldData = this._data; - this._lineGroup.removeAll(); - this._symbolDraw.remove(true); - oldData && oldData.eachItemGraphicEl(function(el, idx) { - if (el.__temp) { - group.remove(el); - oldData.setItemGraphicEl(idx, null); - } - }); - this._polyline = this._polygon = this._coordSys = this._points = this._stackedOnPoints = this._endLabel = this._data = null; - }; - LineView2.type = "line"; - return LineView2; - }(ChartView) -); - -function pointsLayout(seriesType, forceStoreInTypedArray) { - return { - seriesType: seriesType, - plan: createRenderPlanner(), - reset: function (seriesModel) { - var data = seriesModel.getData(); - var coordSys = seriesModel.coordinateSystem; - seriesModel.pipelineContext; - if (!coordSys) { - return; - } - var dims = map$1(coordSys.dimensions, function (dim) { - return data.mapDimension(dim); - }).slice(0, 2); - var dimLen = dims.length; - var stackResultDim = data.getCalculationInfo('stackResultDimension'); - if (isDimensionStacked(data, dims[0])) { - dims[0] = stackResultDim; - } - if (isDimensionStacked(data, dims[1])) { - dims[1] = stackResultDim; - } - var store = data.getStore(); - var dimIdx0 = data.getDimensionIndex(dims[0]); - var dimIdx1 = data.getDimensionIndex(dims[1]); - return dimLen && { - progress: function (params, data) { - var segCount = params.end - params.start; - var points = createFloat32Array(segCount * dimLen); - var tmpIn = []; - var tmpOut = []; - for (var i = params.start, offset = 0; i < params.end; i++) { - var point = void 0; - if (dimLen === 1) { - var x = store.get(dimIdx0, i); - // NOTE: Make sure the second parameter is null to use default strategy. - point = coordSys.dataToPoint(x, null, tmpOut); - } else { - tmpIn[0] = store.get(dimIdx0, i); - tmpIn[1] = store.get(dimIdx1, i); - // Let coordinate system to handle the NaN data. - point = coordSys.dataToPoint(tmpIn, null, tmpOut); - } - { - points[offset++] = point[0]; - points[offset++] = point[1]; - } - } - data.setLayout('points', points); - } - }; - } - }; -} - -var samplers = { - average: function (frame) { - var sum = 0; - var count = 0; - for (var i = 0; i < frame.length; i++) { - if (!isNaN(frame[i])) { - sum += frame[i]; - count++; - } - } - // Return NaN if count is 0 - return count === 0 ? NaN : sum / count; - }, - sum: function (frame) { - var sum = 0; - for (var i = 0; i < frame.length; i++) { - // Ignore NaN - sum += frame[i] || 0; - } - return sum; - }, - max: function (frame) { - var max = -Infinity; - for (var i = 0; i < frame.length; i++) { - frame[i] > max && (max = frame[i]); - } - // NaN will cause illegal axis extent. - return isFinite(max) ? max : NaN; - }, - min: function (frame) { - var min = Infinity; - for (var i = 0; i < frame.length; i++) { - frame[i] < min && (min = frame[i]); - } - // NaN will cause illegal axis extent. - return isFinite(min) ? min : NaN; - }, - // TODO - // Median - nearest: function (frame) { - return frame[0]; - } -}; -var indexSampler = function (frame) { - return Math.round(frame.length / 2); -}; -function dataSample(seriesType) { - return { - seriesType: seriesType, - // FIXME:TS never used, so comment it - // modifyOutputEnd: true, - reset: function (seriesModel, ecModel, api) { - var data = seriesModel.getData(); - var sampling = seriesModel.get('sampling'); - var coordSys = seriesModel.coordinateSystem; - var count = data.count(); - // Only cartesian2d support down sampling. Disable it when there is few data. - if (count > 10 && coordSys.type === 'cartesian2d' && sampling) { - var baseAxis = coordSys.getBaseAxis(); - var valueAxis = coordSys.getOtherAxis(baseAxis); - var extent = baseAxis.getExtent(); - var dpr = api.getDevicePixelRatio(); - // Coordinste system has been resized - var size = Math.abs(extent[1] - extent[0]) * (dpr || 1); - var rate = Math.round(count / size); - if (isFinite(rate) && rate > 1) { - if (sampling === 'lttb') { - seriesModel.setData(data.lttbDownSample(data.mapDimension(valueAxis.dim), 1 / rate)); - } else if (sampling === 'minmax') { - seriesModel.setData(data.minmaxDownSample(data.mapDimension(valueAxis.dim), 1 / rate)); - } - var sampler = void 0; - if (isString(sampling)) { - sampler = samplers[sampling]; - } else if (isFunction(sampling)) { - sampler = sampling; - } - if (sampler) { - // Only support sample the first dim mapped from value axis. - seriesModel.setData(data.downSample(data.mapDimension(valueAxis.dim), 1 / rate, sampler, indexSampler)); - } - } - } - } - }; -} - -function install$9(registers) { - registers.registerChartView(LineView); - registers.registerSeriesModel(LineSeriesModel); - registers.registerLayout(pointsLayout('line')); - registers.registerVisual({ - seriesType: 'line', - reset: function (seriesModel) { - var data = seriesModel.getData(); - // Visual coding for legend - var lineStyle = seriesModel.getModel('lineStyle').getLineStyle(); - if (lineStyle && !lineStyle.stroke) { - // Fill in visual should be palette color if - // has color callback - lineStyle.stroke = data.getVisual('style').fill; - } - data.setVisual('legendLineStyle', lineStyle); - } - }); - // Down sample after filter - registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, dataSample('line')); -} - -function getSectorCornerRadius(model, shape, zeroIfNull) { - var cornerRadius = model.get('borderRadius'); - if (cornerRadius == null) { - return zeroIfNull ? { - cornerRadius: 0 - } : null; - } - if (!isArray(cornerRadius)) { - cornerRadius = [cornerRadius, cornerRadius, cornerRadius, cornerRadius]; - } - var dr = Math.abs(shape.r || 0 - shape.r0 || 0); - return { - cornerRadius: map$1(cornerRadius, function (cr) { - return parsePercent$1(cr, dr); - }) - }; -} - -var PI2 = Math.PI * 2; -var RADIAN$1 = Math.PI / 180; -function getViewRect(seriesModel, api) { - return getLayoutRect(seriesModel.getBoxLayoutParams(), { - width: api.getWidth(), - height: api.getHeight() - }); -} -function getBasicPieLayout(seriesModel, api) { - var viewRect = getViewRect(seriesModel, api); - // center can be string or number when coordinateSystem is specified - var center = seriesModel.get('center'); - var radius = seriesModel.get('radius'); - if (!isArray(radius)) { - radius = [0, radius]; - } - var width = parsePercent(viewRect.width, api.getWidth()); - var height = parsePercent(viewRect.height, api.getHeight()); - var size = Math.min(width, height); - var r0 = parsePercent(radius[0], size / 2); - var r = parsePercent(radius[1], size / 2); - var cx; - var cy; - var coordSys = seriesModel.coordinateSystem; - if (coordSys) { - // percentage is not allowed when coordinate system is specified - var point = coordSys.dataToPoint(center); - cx = point[0] || 0; - cy = point[1] || 0; - } else { - if (!isArray(center)) { - center = [center, center]; - } - cx = parsePercent(center[0], width) + viewRect.x; - cy = parsePercent(center[1], height) + viewRect.y; - } - return { - cx: cx, - cy: cy, - r0: r0, - r: r - }; -} -function pieLayout(seriesType, ecModel, api) { - ecModel.eachSeriesByType(seriesType, function (seriesModel) { - var data = seriesModel.getData(); - var valueDim = data.mapDimension('value'); - var viewRect = getViewRect(seriesModel, api); - var _a = getBasicPieLayout(seriesModel, api), - cx = _a.cx, - cy = _a.cy, - r = _a.r, - r0 = _a.r0; - var startAngle = -seriesModel.get('startAngle') * RADIAN$1; - var endAngle = seriesModel.get('endAngle'); - var padAngle = seriesModel.get('padAngle') * RADIAN$1; - endAngle = endAngle === 'auto' ? startAngle - PI2 : -endAngle * RADIAN$1; - var minAngle = seriesModel.get('minAngle') * RADIAN$1; - var minAndPadAngle = minAngle + padAngle; - var validDataCount = 0; - data.each(valueDim, function (value) { - !isNaN(value) && validDataCount++; - }); - var sum = data.getSum(valueDim); - // Sum may be 0 - var unitRadian = Math.PI / (sum || validDataCount) * 2; - var clockwise = seriesModel.get('clockwise'); - var roseType = seriesModel.get('roseType'); - var stillShowZeroSum = seriesModel.get('stillShowZeroSum'); - // [0...max] - var extent = data.getDataExtent(valueDim); - extent[0] = 0; - var dir = clockwise ? 1 : -1; - var angles = [startAngle, endAngle]; - var halfPadAngle = dir * padAngle / 2; - normalizeArcAngles(angles, !clockwise); - startAngle = angles[0], endAngle = angles[1]; - var layoutData = getSeriesLayoutData(seriesModel); - layoutData.startAngle = startAngle; - layoutData.endAngle = endAngle; - layoutData.clockwise = clockwise; - var angleRange = Math.abs(endAngle - startAngle); - // In the case some sector angle is smaller than minAngle - var restAngle = angleRange; - var valueSumLargerThanMinAngle = 0; - var currentAngle = startAngle; - data.setLayout({ - viewRect: viewRect, - r: r - }); - data.each(valueDim, function (value, idx) { - var angle; - if (isNaN(value)) { - data.setItemLayout(idx, { - angle: NaN, - startAngle: NaN, - endAngle: NaN, - clockwise: clockwise, - cx: cx, - cy: cy, - r0: r0, - r: roseType ? NaN : r - }); - return; - } - // FIXME 兼容 2.0 但是 roseType 是 area 的时候才是这样？ - if (roseType !== 'area') { - angle = sum === 0 && stillShowZeroSum ? unitRadian : value * unitRadian; - } else { - angle = angleRange / validDataCount; - } - if (angle < minAndPadAngle) { - angle = minAndPadAngle; - restAngle -= minAndPadAngle; - } else { - valueSumLargerThanMinAngle += value; - } - var endAngle = currentAngle + dir * angle; - // calculate display angle - var actualStartAngle = 0; - var actualEndAngle = 0; - if (padAngle > angle) { - actualStartAngle = currentAngle + dir * angle / 2; - actualEndAngle = actualStartAngle; - } else { - actualStartAngle = currentAngle + halfPadAngle; - actualEndAngle = endAngle - halfPadAngle; - } - data.setItemLayout(idx, { - angle: angle, - startAngle: actualStartAngle, - endAngle: actualEndAngle, - clockwise: clockwise, - cx: cx, - cy: cy, - r0: r0, - r: roseType ? linearMap(value, extent, [r0, r]) : r - }); - currentAngle = endAngle; - }); - // Some sector is constrained by minAngle and padAngle - // Rest sectors needs recalculate angle - if (restAngle < PI2 && validDataCount) { - // Average the angle if rest angle is not enough after all angles is - // Constrained by minAngle and padAngle - if (restAngle <= 1e-3) { - var angle_1 = angleRange / validDataCount; - data.each(valueDim, function (value, idx) { - if (!isNaN(value)) { - var layout_1 = data.getItemLayout(idx); - layout_1.angle = angle_1; - var actualStartAngle = 0; - var actualEndAngle = 0; - if (angle_1 < padAngle) { - actualStartAngle = startAngle + dir * (idx + 1 / 2) * angle_1; - actualEndAngle = actualStartAngle; - } else { - actualStartAngle = startAngle + dir * idx * angle_1 + halfPadAngle; - actualEndAngle = startAngle + dir * (idx + 1) * angle_1 - halfPadAngle; - } - layout_1.startAngle = actualStartAngle; - layout_1.endAngle = actualEndAngle; - } - }); - } else { - unitRadian = restAngle / valueSumLargerThanMinAngle; - currentAngle = startAngle; - data.each(valueDim, function (value, idx) { - if (!isNaN(value)) { - var layout_2 = data.getItemLayout(idx); - var angle = layout_2.angle === minAndPadAngle ? minAndPadAngle : value * unitRadian; - var actualStartAngle = 0; - var actualEndAngle = 0; - if (angle < padAngle) { - actualStartAngle = currentAngle + dir * angle / 2; - actualEndAngle = actualStartAngle; - } else { - actualStartAngle = currentAngle + halfPadAngle; - actualEndAngle = currentAngle + dir * angle - halfPadAngle; - } - layout_2.startAngle = actualStartAngle; - layout_2.endAngle = actualEndAngle; - currentAngle += dir * angle; - } - }); - } - } - }); -} -var getSeriesLayoutData = makeInner(); - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function dataFilter(seriesType) { - return { - seriesType: seriesType, - reset: function (seriesModel, ecModel) { - var legendModels = ecModel.findComponents({ - mainType: 'legend' - }); - if (!legendModels || !legendModels.length) { - return; - } - var data = seriesModel.getData(); - data.filterSelf(function (idx) { - var name = data.getName(idx); - // If in any legend component the status is not selected. - for (var i = 0; i < legendModels.length; i++) { - // @ts-ignore FIXME: LegendModel - if (!legendModels[i].isSelected(name)) { - return false; - } - } - return true; - }); - } - }; -} - -var RADIAN = Math.PI / 180; -function adjustSingleSide(list, cx, cy, r, dir, viewWidth, viewHeight, viewLeft, viewTop, farthestX) { - if (list.length < 2) { - return; - } - function recalculateXOnSemiToAlignOnEllipseCurve(semi) { - var rB = semi.rB; - var rB2 = rB * rB; - for (var i = 0; i < semi.list.length; i++) { - var item = semi.list[i]; - var dy = Math.abs(item.label.y - cy); - // horizontal r is always same with original r because x is not changed. - var rA = r + item.len; - var rA2 = rA * rA; - // Use ellipse implicit function to calculate x - var dx = Math.sqrt(Math.abs((1 - dy * dy / rB2) * rA2)); - var newX = cx + (dx + item.len2) * dir; - var deltaX = newX - item.label.x; - var newTargetWidth = item.targetTextWidth - deltaX * dir; - // text x is changed, so need to recalculate width. - constrainTextWidth(item, newTargetWidth, true); - item.label.x = newX; - } - } - // Adjust X based on the shifted y. Make tight labels aligned on an ellipse curve. - function recalculateX(items) { - // Extremes of - var topSemi = { - list: [], - maxY: 0 - }; - var bottomSemi = { - list: [], - maxY: 0 - }; - for (var i = 0; i < items.length; i++) { - if (items[i].labelAlignTo !== 'none') { - continue; - } - var item = items[i]; - var semi = item.label.y > cy ? bottomSemi : topSemi; - var dy = Math.abs(item.label.y - cy); - if (dy >= semi.maxY) { - var dx = item.label.x - cx - item.len2 * dir; - // horizontal r is always same with original r because x is not changed. - var rA = r + item.len; - // Canculate rB based on the topest / bottemest label. - var rB = Math.abs(dx) < rA ? Math.sqrt(dy * dy / (1 - dx * dx / rA / rA)) : rA; - semi.rB = rB; - semi.maxY = dy; - } - semi.list.push(item); - } - recalculateXOnSemiToAlignOnEllipseCurve(topSemi); - recalculateXOnSemiToAlignOnEllipseCurve(bottomSemi); - } - var len = list.length; - for (var i = 0; i < len; i++) { - if (list[i].position === 'outer' && list[i].labelAlignTo === 'labelLine') { - var dx = list[i].label.x - farthestX; - list[i].linePoints[1][0] += dx; - list[i].label.x = farthestX; - } - } - if (shiftLayoutOnY(list, viewTop, viewTop + viewHeight)) { - recalculateX(list); - } -} -function avoidOverlap(labelLayoutList, cx, cy, r, viewWidth, viewHeight, viewLeft, viewTop) { - var leftList = []; - var rightList = []; - var leftmostX = Number.MAX_VALUE; - var rightmostX = -Number.MAX_VALUE; - for (var i = 0; i < labelLayoutList.length; i++) { - var label = labelLayoutList[i].label; - if (isPositionCenter(labelLayoutList[i])) { - continue; - } - if (label.x < cx) { - leftmostX = Math.min(leftmostX, label.x); - leftList.push(labelLayoutList[i]); - } else { - rightmostX = Math.max(rightmostX, label.x); - rightList.push(labelLayoutList[i]); - } - } - for (var i = 0; i < labelLayoutList.length; i++) { - var layout = labelLayoutList[i]; - if (!isPositionCenter(layout) && layout.linePoints) { - if (layout.labelStyleWidth != null) { - continue; - } - var label = layout.label; - var linePoints = layout.linePoints; - var targetTextWidth = void 0; - if (layout.labelAlignTo === 'edge') { - if (label.x < cx) { - targetTextWidth = linePoints[2][0] - layout.labelDistance - viewLeft - layout.edgeDistance; - } else { - targetTextWidth = viewLeft + viewWidth - layout.edgeDistance - linePoints[2][0] - layout.labelDistance; - } - } else if (layout.labelAlignTo === 'labelLine') { - if (label.x < cx) { - targetTextWidth = leftmostX - viewLeft - layout.bleedMargin; - } else { - targetTextWidth = viewLeft + viewWidth - rightmostX - layout.bleedMargin; - } - } else { - if (label.x < cx) { - targetTextWidth = label.x - viewLeft - layout.bleedMargin; - } else { - targetTextWidth = viewLeft + viewWidth - label.x - layout.bleedMargin; - } - } - layout.targetTextWidth = targetTextWidth; - constrainTextWidth(layout, targetTextWidth); - } - } - adjustSingleSide(rightList, cx, cy, r, 1, viewWidth, viewHeight, viewLeft, viewTop, rightmostX); - adjustSingleSide(leftList, cx, cy, r, -1, viewWidth, viewHeight, viewLeft, viewTop, leftmostX); - for (var i = 0; i < labelLayoutList.length; i++) { - var layout = labelLayoutList[i]; - if (!isPositionCenter(layout) && layout.linePoints) { - var label = layout.label; - var linePoints = layout.linePoints; - var isAlignToEdge = layout.labelAlignTo === 'edge'; - var padding = label.style.padding; - var paddingH = padding ? padding[1] + padding[3] : 0; - // textRect.width already contains paddingH if bgColor is set - var extraPaddingH = label.style.backgroundColor ? 0 : paddingH; - var realTextWidth = layout.rect.width + extraPaddingH; - var dist = linePoints[1][0] - linePoints[2][0]; - if (isAlignToEdge) { - if (label.x < cx) { - linePoints[2][0] = viewLeft + layout.edgeDistance + realTextWidth + layout.labelDistance; - } else { - linePoints[2][0] = viewLeft + viewWidth - layout.edgeDistance - realTextWidth - layout.labelDistance; - } - } else { - if (label.x < cx) { - linePoints[2][0] = label.x + layout.labelDistance; - } else { - linePoints[2][0] = label.x - layout.labelDistance; - } - linePoints[1][0] = linePoints[2][0] + dist; - } - linePoints[1][1] = linePoints[2][1] = label.y; - } - } -} -/** - * Set max width of each label, and then wrap each label to the max width. - * - * @param layout label layout - * @param availableWidth max width for the label to display - * @param forceRecalculate recaculate the text layout even if the current width - * is smaller than `availableWidth`. This is useful when the text was previously - * wrapped by calling `constrainTextWidth` but now `availableWidth` changed, in - * which case, previous wrapping should be redo. - */ -function constrainTextWidth(layout, availableWidth, forceRecalculate) { - if (forceRecalculate === void 0) { - forceRecalculate = false; - } - if (layout.labelStyleWidth != null) { - // User-defined style.width has the highest priority. - return; - } - var label = layout.label; - var style = label.style; - var textRect = layout.rect; - var bgColor = style.backgroundColor; - var padding = style.padding; - var paddingH = padding ? padding[1] + padding[3] : 0; - var overflow = style.overflow; - // textRect.width already contains paddingH if bgColor is set - var oldOuterWidth = textRect.width + (bgColor ? 0 : paddingH); - if (availableWidth < oldOuterWidth || forceRecalculate) { - var oldHeight = textRect.height; - if (overflow && overflow.match('break')) { - // Temporarily set background to be null to calculate - // the bounding box without background. - label.setStyle('backgroundColor', null); - // Set constraining width - label.setStyle('width', availableWidth - paddingH); - // This is the real bounding box of the text without padding. - var innerRect = label.getBoundingRect(); - label.setStyle('width', Math.ceil(innerRect.width)); - label.setStyle('backgroundColor', bgColor); - } else { - var availableInnerWidth = availableWidth - paddingH; - var newWidth = availableWidth < oldOuterWidth - // Current text is too wide, use `availableWidth` as max width. - ? availableInnerWidth : - // Current available width is enough, but the text may have - // already been wrapped with a smaller available width. - forceRecalculate ? availableInnerWidth > layout.unconstrainedWidth - // Current available is larger than text width, - // so don't constrain width (otherwise it may have - // empty space in the background). - ? null - // Current available is smaller than text width, so - // use the current available width as constraining - // width. - : availableInnerWidth - // Current available width is enough, so no need to - // constrain. - : null; - label.setStyle('width', newWidth); - } - var newRect = label.getBoundingRect(); - textRect.width = newRect.width; - var margin = (label.style.margin || 0) + 2.1; - textRect.height = newRect.height + margin; - textRect.y -= (textRect.height - oldHeight) / 2; - } -} -function isPositionCenter(sectorShape) { - // Not change x for center label - return sectorShape.position === 'center'; -} -function pieLabelLayout(seriesModel) { - var data = seriesModel.getData(); - var labelLayoutList = []; - var cx; - var cy; - var hasLabelRotate = false; - var minShowLabelRadian = (seriesModel.get('minShowLabelAngle') || 0) * RADIAN; - var viewRect = data.getLayout('viewRect'); - var r = data.getLayout('r'); - var viewWidth = viewRect.width; - var viewLeft = viewRect.x; - var viewTop = viewRect.y; - var viewHeight = viewRect.height; - function setNotShow(el) { - el.ignore = true; - } - function isLabelShown(label) { - if (!label.ignore) { - return true; - } - for (var key in label.states) { - if (label.states[key].ignore === false) { - return true; - } - } - return false; - } - data.each(function (idx) { - var sector = data.getItemGraphicEl(idx); - var sectorShape = sector.shape; - var label = sector.getTextContent(); - var labelLine = sector.getTextGuideLine(); - var itemModel = data.getItemModel(idx); - var labelModel = itemModel.getModel('label'); - // Use position in normal or emphasis - var labelPosition = labelModel.get('position') || itemModel.get(['emphasis', 'label', 'position']); - var labelDistance = labelModel.get('distanceToLabelLine'); - var labelAlignTo = labelModel.get('alignTo'); - var edgeDistance = parsePercent(labelModel.get('edgeDistance'), viewWidth); - var bleedMargin = labelModel.get('bleedMargin'); - var labelLineModel = itemModel.getModel('labelLine'); - var labelLineLen = labelLineModel.get('length'); - labelLineLen = parsePercent(labelLineLen, viewWidth); - var labelLineLen2 = labelLineModel.get('length2'); - labelLineLen2 = parsePercent(labelLineLen2, viewWidth); - if (Math.abs(sectorShape.endAngle - sectorShape.startAngle) < minShowLabelRadian) { - each$4(label.states, setNotShow); - label.ignore = true; - if (labelLine) { - each$4(labelLine.states, setNotShow); - labelLine.ignore = true; - } - return; - } - if (!isLabelShown(label)) { - return; - } - var midAngle = (sectorShape.startAngle + sectorShape.endAngle) / 2; - var nx = Math.cos(midAngle); - var ny = Math.sin(midAngle); - var textX; - var textY; - var linePoints; - var textAlign; - cx = sectorShape.cx; - cy = sectorShape.cy; - var isLabelInside = labelPosition === 'inside' || labelPosition === 'inner'; - if (labelPosition === 'center') { - textX = sectorShape.cx; - textY = sectorShape.cy; - textAlign = 'center'; - } else { - var x1 = (isLabelInside ? (sectorShape.r + sectorShape.r0) / 2 * nx : sectorShape.r * nx) + cx; - var y1 = (isLabelInside ? (sectorShape.r + sectorShape.r0) / 2 * ny : sectorShape.r * ny) + cy; - textX = x1 + nx * 3; - textY = y1 + ny * 3; - if (!isLabelInside) { - // For roseType - var x2 = x1 + nx * (labelLineLen + r - sectorShape.r); - var y2 = y1 + ny * (labelLineLen + r - sectorShape.r); - var x3 = x2 + (nx < 0 ? -1 : 1) * labelLineLen2; - var y3 = y2; - if (labelAlignTo === 'edge') { - // Adjust textX because text align of edge is opposite - textX = nx < 0 ? viewLeft + edgeDistance : viewLeft + viewWidth - edgeDistance; - } else { - textX = x3 + (nx < 0 ? -labelDistance : labelDistance); - } - textY = y3; - linePoints = [[x1, y1], [x2, y2], [x3, y3]]; - } - textAlign = isLabelInside ? 'center' : labelAlignTo === 'edge' ? nx > 0 ? 'right' : 'left' : nx > 0 ? 'left' : 'right'; - } - var PI = Math.PI; - var labelRotate = 0; - var rotate = labelModel.get('rotate'); - if (isNumber(rotate)) { - labelRotate = rotate * (PI / 180); - } else if (labelPosition === 'center') { - labelRotate = 0; - } else if (rotate === 'radial' || rotate === true) { - var radialAngle = nx < 0 ? -midAngle + PI : -midAngle; - labelRotate = radialAngle; - } else if (rotate === 'tangential' && labelPosition !== 'outside' && labelPosition !== 'outer') { - var rad = Math.atan2(nx, ny); - if (rad < 0) { - rad = PI * 2 + rad; - } - var isDown = ny > 0; - if (isDown) { - rad = PI + rad; - } - labelRotate = rad - PI; - } - hasLabelRotate = !!labelRotate; - label.x = textX; - label.y = textY; - label.rotation = labelRotate; - label.setStyle({ - verticalAlign: 'middle' - }); - // Not sectorShape the inside label - if (!isLabelInside) { - var textRect = label.getBoundingRect().clone(); - textRect.applyTransform(label.getComputedTransform()); - // Text has a default 1px stroke. Exclude this. - var margin = (label.style.margin || 0) + 2.1; - textRect.y -= margin / 2; - textRect.height += margin; - labelLayoutList.push({ - label: label, - labelLine: labelLine, - position: labelPosition, - len: labelLineLen, - len2: labelLineLen2, - minTurnAngle: labelLineModel.get('minTurnAngle'), - maxSurfaceAngle: labelLineModel.get('maxSurfaceAngle'), - surfaceNormal: new Point(nx, ny), - linePoints: linePoints, - textAlign: textAlign, - labelDistance: labelDistance, - labelAlignTo: labelAlignTo, - edgeDistance: edgeDistance, - bleedMargin: bleedMargin, - rect: textRect, - unconstrainedWidth: textRect.width, - labelStyleWidth: label.style.width - }); - } else { - label.setStyle({ - align: textAlign - }); - var selectState = label.states.select; - if (selectState) { - selectState.x += label.x; - selectState.y += label.y; - } - } - sector.setTextConfig({ - inside: isLabelInside - }); - }); - if (!hasLabelRotate && seriesModel.get('avoidLabelOverlap')) { - avoidOverlap(labelLayoutList, cx, cy, r, viewWidth, viewHeight, viewLeft, viewTop); - } - for (var i = 0; i < labelLayoutList.length; i++) { - var layout = labelLayoutList[i]; - var label = layout.label; - var labelLine = layout.labelLine; - var notShowLabel = isNaN(label.x) || isNaN(label.y); - if (label) { - label.setStyle({ - align: layout.textAlign - }); - if (notShowLabel) { - each$4(label.states, setNotShow); - label.ignore = true; - } - var selectState = label.states.select; - if (selectState) { - selectState.x += label.x; - selectState.y += label.y; - } - } - if (labelLine) { - var linePoints = layout.linePoints; - if (notShowLabel || !linePoints) { - each$4(labelLine.states, setNotShow); - labelLine.ignore = true; - } else { - limitTurnAngle(linePoints, layout.minTurnAngle); - limitSurfaceAngle(linePoints, layout.surfaceNormal, layout.maxSurfaceAngle); - labelLine.setShape({ - points: linePoints - }); - // Set the anchor to the midpoint of sector - label.__hostTarget.textGuideLineConfig = { - anchor: new Point(linePoints[0][0], linePoints[0][1]) - }; - } - } - } -} - -/** - * Piece of pie including Sector, Label, LabelLine - */ -var PiePiece = /** @class */function (_super) { - __extends(PiePiece, _super); - function PiePiece(data, idx, startAngle) { - var _this = _super.call(this) || this; - _this.z2 = 2; - var text = new ZRText(); - _this.setTextContent(text); - _this.updateData(data, idx, startAngle, true); - return _this; - } - PiePiece.prototype.updateData = function (data, idx, startAngle, firstCreate) { - var sector = this; - var seriesModel = data.hostModel; - var itemModel = data.getItemModel(idx); - var emphasisModel = itemModel.getModel('emphasis'); - var layout = data.getItemLayout(idx); - // cornerRadius & innerCornerRadius doesn't exist in the item layout. Use `0` if null value is specified. - // see `setItemLayout` in `pieLayout.ts`. - var sectorShape = extend(getSectorCornerRadius(itemModel.getModel('itemStyle'), layout, true), layout); - // Ignore NaN data. - if (isNaN(sectorShape.startAngle)) { - // Use NaN shape to avoid drawing shape. - sector.setShape(sectorShape); - return; - } - if (firstCreate) { - sector.setShape(sectorShape); - var animationType = seriesModel.getShallow('animationType'); - if (seriesModel.ecModel.ssr) { - // Use scale animation in SSR mode(opacity?) - // Because CSS SVG animation doesn't support very customized shape animation. - initProps(sector, { - scaleX: 0, - scaleY: 0 - }, seriesModel, { - dataIndex: idx, - isFrom: true - }); - sector.originX = sectorShape.cx; - sector.originY = sectorShape.cy; - } else if (animationType === 'scale') { - sector.shape.r = layout.r0; - initProps(sector, { - shape: { - r: layout.r - } - }, seriesModel, idx); - } - // Expansion - else { - if (startAngle != null) { - sector.setShape({ - startAngle: startAngle, - endAngle: startAngle - }); - initProps(sector, { - shape: { - startAngle: layout.startAngle, - endAngle: layout.endAngle - } - }, seriesModel, idx); - } else { - sector.shape.endAngle = layout.startAngle; - updateProps$1(sector, { - shape: { - endAngle: layout.endAngle - } - }, seriesModel, idx); - } - } - } else { - saveOldStyle(sector); - // Transition animation from the old shape - updateProps$1(sector, { - shape: sectorShape - }, seriesModel, idx); - } - sector.useStyle(data.getItemVisual(idx, 'style')); - setStatesStylesFromModel(sector, itemModel); - var midAngle = (layout.startAngle + layout.endAngle) / 2; - var offset = seriesModel.get('selectedOffset'); - var dx = Math.cos(midAngle) * offset; - var dy = Math.sin(midAngle) * offset; - var cursorStyle = itemModel.getShallow('cursor'); - cursorStyle && sector.attr('cursor', cursorStyle); - this._updateLabel(seriesModel, data, idx); - sector.ensureState('emphasis').shape = extend({ - r: layout.r + (emphasisModel.get('scale') ? emphasisModel.get('scaleSize') || 0 : 0) - }, getSectorCornerRadius(emphasisModel.getModel('itemStyle'), layout)); - extend(sector.ensureState('select'), { - x: dx, - y: dy, - shape: getSectorCornerRadius(itemModel.getModel(['select', 'itemStyle']), layout) - }); - extend(sector.ensureState('blur'), { - shape: getSectorCornerRadius(itemModel.getModel(['blur', 'itemStyle']), layout) - }); - var labelLine = sector.getTextGuideLine(); - var labelText = sector.getTextContent(); - labelLine && extend(labelLine.ensureState('select'), { - x: dx, - y: dy - }); - // TODO: needs dx, dy in zrender? - extend(labelText.ensureState('select'), { - x: dx, - y: dy - }); - toggleHoverEmphasis(this, emphasisModel.get('focus'), emphasisModel.get('blurScope'), emphasisModel.get('disabled')); - }; - PiePiece.prototype._updateLabel = function (seriesModel, data, idx) { - var sector = this; - var itemModel = data.getItemModel(idx); - var labelLineModel = itemModel.getModel('labelLine'); - var style = data.getItemVisual(idx, 'style'); - var visualColor = style && style.fill; - var visualOpacity = style && style.opacity; - setLabelStyle(sector, getLabelStatesModels(itemModel), { - labelFetcher: data.hostModel, - labelDataIndex: idx, - inheritColor: visualColor, - defaultOpacity: visualOpacity, - defaultText: seriesModel.getFormattedLabel(idx, 'normal') || data.getName(idx) - }); - var labelText = sector.getTextContent(); - // Set textConfig on sector. - sector.setTextConfig({ - // reset position, rotation - position: null, - rotation: null - }); - // Make sure update style on labelText after setLabelStyle. - // Because setLabelStyle will replace a new style on it. - labelText.attr({ - z2: 10 - }); - var labelPosition = seriesModel.get(['label', 'position']); - if (labelPosition !== 'outside' && labelPosition !== 'outer') { - sector.removeTextGuideLine(); - } else { - var polyline = this.getTextGuideLine(); - if (!polyline) { - polyline = new Polyline(); - this.setTextGuideLine(polyline); - } - // Default use item visual color - setLabelLineStyle(this, getLabelLineStatesModels(itemModel), { - stroke: visualColor, - opacity: retrieve3(labelLineModel.get(['lineStyle', 'opacity']), visualOpacity, 1) - }); - } - }; - return PiePiece; -}(Sector); -// Pie view -var PieView = /** @class */function (_super) { - __extends(PieView, _super); - function PieView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.ignoreLabelLineUpdate = true; - return _this; - } - PieView.prototype.render = function (seriesModel, ecModel, api, payload) { - var data = seriesModel.getData(); - var oldData = this._data; - var group = this.group; - var startAngle; - // First render - if (!oldData && data.count() > 0) { - var shape = data.getItemLayout(0); - for (var s = 1; isNaN(shape && shape.startAngle) && s < data.count(); ++s) { - shape = data.getItemLayout(s); - } - if (shape) { - startAngle = shape.startAngle; - } - } - // remove empty-circle if it exists - if (this._emptyCircleSector) { - group.remove(this._emptyCircleSector); - } - // when all data are filtered, show lightgray empty circle - if (data.count() === 0 && seriesModel.get('showEmptyCircle')) { - var layoutData = getSeriesLayoutData(seriesModel); - var sector = new Sector({ - shape: extend(getBasicPieLayout(seriesModel, api), layoutData) - }); - sector.useStyle(seriesModel.getModel('emptyCircleStyle').getItemStyle()); - this._emptyCircleSector = sector; - group.add(sector); - } - data.diff(oldData).add(function (idx) { - var piePiece = new PiePiece(data, idx, startAngle); - data.setItemGraphicEl(idx, piePiece); - group.add(piePiece); - }).update(function (newIdx, oldIdx) { - var piePiece = oldData.getItemGraphicEl(oldIdx); - piePiece.updateData(data, newIdx, startAngle); - piePiece.off('click'); - group.add(piePiece); - data.setItemGraphicEl(newIdx, piePiece); - }).remove(function (idx) { - var piePiece = oldData.getItemGraphicEl(idx); - removeElementWithFadeOut(piePiece, seriesModel, idx); - }).execute(); - pieLabelLayout(seriesModel); - // Always use initial animation. - if (seriesModel.get('animationTypeUpdate') !== 'expansion') { - this._data = data; - } - }; - PieView.prototype.dispose = function () {}; - PieView.prototype.containPoint = function (point, seriesModel) { - var data = seriesModel.getData(); - var itemLayout = data.getItemLayout(0); - if (itemLayout) { - var dx = point[0] - itemLayout.cx; - var dy = point[1] - itemLayout.cy; - var radius = Math.sqrt(dx * dx + dy * dy); - return radius <= itemLayout.r && radius >= itemLayout.r0; - } - }; - PieView.type = 'pie'; - return PieView; -}(ChartView); - -/** - * [Usage]: - * (1) - * createListSimply(seriesModel, ['value']); - * (2) - * createListSimply(seriesModel, { - * coordDimensions: ['value'], - * dimensionsCount: 5 - * }); - */ -function createSeriesDataSimply(seriesModel, opt, nameList) { - opt = isArray(opt) && { - coordDimensions: opt - } || extend({ - encodeDefine: seriesModel.getEncode() - }, opt); - var source = seriesModel.getSource(); - var dimensions = prepareSeriesDataSchema(source, opt).dimensions; - var list = new SeriesData(dimensions, seriesModel); - list.initData(source, nameList); - return list; -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -/** - * LegendVisualProvider is an bridge that pick encoded color from data and - * provide to the legend component. - */ -var LegendVisualProvider = /** @class */function () { - function LegendVisualProvider( - // Function to get data after filtered. It stores all the encoding info - getDataWithEncodedVisual, - // Function to get raw data before filtered. - getRawData) { - this._getDataWithEncodedVisual = getDataWithEncodedVisual; - this._getRawData = getRawData; - } - LegendVisualProvider.prototype.getAllNames = function () { - var rawData = this._getRawData(); - // We find the name from the raw data. In case it's filtered by the legend component. - // Normally, the name can be found in rawData, but can't be found in filtered data will display as gray. - return rawData.mapArray(rawData.getName); - }; - LegendVisualProvider.prototype.containName = function (name) { - var rawData = this._getRawData(); - return rawData.indexOfName(name) >= 0; - }; - LegendVisualProvider.prototype.indexOfName = function (name) { - // Only get data when necessary. - // Because LegendVisualProvider constructor may be new in the stage that data is not prepared yet. - // Invoking Series#getData immediately will throw an error. - var dataWithEncodedVisual = this._getDataWithEncodedVisual(); - return dataWithEncodedVisual.indexOfName(name); - }; - LegendVisualProvider.prototype.getItemVisual = function (dataIndex, key) { - // Get encoded visual properties from final filtered data. - var dataWithEncodedVisual = this._getDataWithEncodedVisual(); - return dataWithEncodedVisual.getItemVisual(dataIndex, key); - }; - return LegendVisualProvider; -}(); - -var innerData = makeInner(); -var PieSeriesModel = /** @class */function (_super) { - __extends(PieSeriesModel, _super); - function PieSeriesModel() { - return _super !== null && _super.apply(this, arguments) || this; - } - /** - * @overwrite - */ - PieSeriesModel.prototype.init = function (option) { - _super.prototype.init.apply(this, arguments); - // Enable legend selection for each data item - // Use a function instead of direct access because data reference may changed - this.legendVisualProvider = new LegendVisualProvider(bind$1(this.getData, this), bind$1(this.getRawData, this)); - this._defaultLabelLine(option); - }; - /** - * @overwrite - */ - PieSeriesModel.prototype.mergeOption = function () { - _super.prototype.mergeOption.apply(this, arguments); - }; - /** - * @overwrite - */ - PieSeriesModel.prototype.getInitialData = function () { - return createSeriesDataSimply(this, { - coordDimensions: ['value'], - encodeDefaulter: curry$1(makeSeriesEncodeForNameBased, this) - }); - }; - /** - * @overwrite - */ - PieSeriesModel.prototype.getDataParams = function (dataIndex) { - var data = this.getData(); - // update seats when data is changed - var dataInner = innerData(data); - var seats = dataInner.seats; - if (!seats) { - var valueList_1 = []; - data.each(data.mapDimension('value'), function (value) { - valueList_1.push(value); - }); - seats = dataInner.seats = getPercentSeats(valueList_1, data.hostModel.get('percentPrecision')); - } - var params = _super.prototype.getDataParams.call(this, dataIndex); - // seats may be empty when sum is 0 - params.percent = seats[dataIndex] || 0; - params.$vars.push('percent'); - return params; - }; - PieSeriesModel.prototype._defaultLabelLine = function (option) { - // Extend labelLine emphasis - defaultEmphasis(option, 'labelLine', ['show']); - var labelLineNormalOpt = option.labelLine; - var labelLineEmphasisOpt = option.emphasis.labelLine; - // Not show label line if `label.normal.show = false` - labelLineNormalOpt.show = labelLineNormalOpt.show && option.label.show; - labelLineEmphasisOpt.show = labelLineEmphasisOpt.show && option.emphasis.label.show; - }; - PieSeriesModel.type = 'series.pie'; - PieSeriesModel.defaultOption = { - // zlevel: 0, - z: 2, - legendHoverLink: true, - colorBy: 'data', - // 默认全局居中 - center: ['50%', '50%'], - radius: [0, '75%'], - // 默认顺时针 - clockwise: true, - startAngle: 90, - endAngle: 'auto', - padAngle: 0, - // 最小角度改为0 - minAngle: 0, - // If the angle of a sector less than `minShowLabelAngle`, - // the label will not be displayed. - minShowLabelAngle: 0, - // 选中时扇区偏移量 - selectedOffset: 10, - // 选择模式，默认关闭，可选single，multiple - // selectedMode: false, - // 南丁格尔玫瑰图模式，'radius'（半径） | 'area'（面积） - // roseType: null, - percentPrecision: 2, - // If still show when all data zero. - stillShowZeroSum: true, - // cursor: null, - left: 0, - top: 0, - right: 0, - bottom: 0, - width: null, - height: null, - label: { - // color: 'inherit', - // If rotate around circle - rotate: 0, - show: true, - overflow: 'truncate', - // 'outer', 'inside', 'center' - position: 'outer', - // 'none', 'labelLine', 'edge'. Works only when position is 'outer' - alignTo: 'none', - // Closest distance between label and chart edge. - // Works only position is 'outer' and alignTo is 'edge'. - edgeDistance: '25%', - // Works only position is 'outer' and alignTo is not 'edge'. - bleedMargin: 10, - // Distance between text and label line. - distanceToLabelLine: 5 - // formatter: 标签文本格式器，同 tooltip.formatter，不支持异步回调 - // 默认使用全局文本样式，详见 textStyle - // distance: 当position为inner时有效，为label位置到圆心的距离与圆半径(环状图为内外半径和)的比例系数 - }, - // Enabled when label.normal.position is 'outer' - labelLine: { - show: true, - // 引导线两段中的第一段长度 - length: 15, - // 引导线两段中的第二段长度 - length2: 15, - smooth: false, - minTurnAngle: 90, - maxSurfaceAngle: 90, - lineStyle: { - // color: 各异, - width: 1, - type: 'solid' - } - }, - itemStyle: { - borderWidth: 1, - borderJoin: 'round' - }, - showEmptyCircle: true, - emptyCircleStyle: { - color: 'lightgray', - opacity: 1 - }, - labelLayout: { - // Hide the overlapped label. - hideOverlap: true - }, - emphasis: { - scale: true, - scaleSize: 5 - }, - // If use strategy to avoid label overlapping - avoidLabelOverlap: true, - // Animation type. Valid values: expansion, scale - animationType: 'expansion', - animationDuration: 1000, - // Animation type when update. Valid values: transition, expansion - animationTypeUpdate: 'transition', - animationEasingUpdate: 'cubicInOut', - animationDurationUpdate: 500, - animationEasing: 'cubicInOut' - }; - return PieSeriesModel; -}(SeriesModel); - -function negativeDataFilter(seriesType) { - return { - seriesType: seriesType, - reset: function (seriesModel, ecModel) { - var data = seriesModel.getData(); - data.filterSelf(function (idx) { - // handle negative value condition - var valueDim = data.mapDimension('value'); - var curValue = data.get(valueDim, idx); - if (isNumber(curValue) && !isNaN(curValue) && curValue < 0) { - return false; - } - return true; - }); - } - }; -} - -function install$8(registers) { - registers.registerChartView(PieView); - registers.registerSeriesModel(PieSeriesModel); - createLegacyDataSelectAction('pie', registers.registerAction); - registers.registerLayout(curry$1(pieLayout, 'pie')); - registers.registerProcessor(dataFilter('pie')); - registers.registerProcessor(negativeDataFilter('pie')); -} - -var GridModel = /** @class */function (_super) { - __extends(GridModel, _super); - function GridModel() { - return _super !== null && _super.apply(this, arguments) || this; - } - GridModel.type = 'grid'; - GridModel.dependencies = ['xAxis', 'yAxis']; - GridModel.layoutMode = 'box'; - GridModel.defaultOption = { - show: false, - // zlevel: 0, - z: 0, - left: '10%', - top: 60, - right: '10%', - bottom: 70, - // If grid size contain label - containLabel: false, - // width: {totalWidth} - left - right, - // height: {totalHeight} - top - bottom, - backgroundColor: 'rgba(0,0,0,0)', - borderWidth: 1, - borderColor: '#ccc' - }; - return GridModel; -}(ComponentModel); - -var CartesianAxisModel = /** @class */function (_super) { - __extends(CartesianAxisModel, _super); - function CartesianAxisModel() { - return _super !== null && _super.apply(this, arguments) || this; - } - CartesianAxisModel.prototype.getCoordSysModel = function () { - return this.getReferringComponents('grid', SINGLE_REFERRING).models[0]; - }; - CartesianAxisModel.type = 'cartesian2dAxis'; - return CartesianAxisModel; -}(ComponentModel); -mixin(CartesianAxisModel, AxisModelCommonMixin); - -var defaultOption = { - show: true, - // zlevel: 0, - z: 0, - // Inverse the axis. - inverse: false, - // Axis name displayed. - name: '', - // 'start' | 'middle' | 'end' - nameLocation: 'end', - // By degree. By default auto rotate by nameLocation. - nameRotate: null, - nameTruncate: { - maxWidth: null, - ellipsis: '...', - placeholder: '.' - }, - // Use global text style by default. - nameTextStyle: {}, - // The gap between axisName and axisLine. - nameGap: 15, - // Default `false` to support tooltip. - silent: false, - // Default `false` to avoid legacy user event listener fail. - triggerEvent: false, - tooltip: { - show: false - }, - axisPointer: {}, - axisLine: { - show: true, - onZero: true, - onZeroAxisIndex: null, - lineStyle: { - color: '#6E7079', - width: 1, - type: 'solid' - }, - // The arrow at both ends the the axis. - symbol: ['none', 'none'], - symbolSize: [10, 15] - }, - axisTick: { - show: true, - // Whether axisTick is inside the grid or outside the grid. - inside: false, - // The length of axisTick. - length: 5, - lineStyle: { - width: 1 - } - }, - axisLabel: { - show: true, - // Whether axisLabel is inside the grid or outside the grid. - inside: false, - rotate: 0, - // true | false | null/undefined (auto) - showMinLabel: null, - // true | false | null/undefined (auto) - showMaxLabel: null, - margin: 8, - // formatter: null, - fontSize: 12 - }, - splitLine: { - show: true, - showMinLine: true, - showMaxLine: true, - lineStyle: { - color: ['#E0E6F1'], - width: 1, - type: 'solid' - } - }, - splitArea: { - show: false, - areaStyle: { - color: ['rgba(250,250,250,0.2)', 'rgba(210,219,238,0.2)'] - } - } -}; -var categoryAxis = merge({ - // The gap at both ends of the axis. For categoryAxis, boolean. - boundaryGap: true, - // Set false to faster category collection. - deduplication: null, - // splitArea: { - // show: false - // }, - splitLine: { - show: false - }, - axisTick: { - // If tick is align with label when boundaryGap is true - alignWithLabel: false, - interval: 'auto' - }, - axisLabel: { - interval: 'auto' - } -}, defaultOption); -var valueAxis = merge({ - boundaryGap: [0, 0], - axisLine: { - // Not shown when other axis is categoryAxis in cartesian - show: 'auto' - }, - axisTick: { - // Not shown when other axis is categoryAxis in cartesian - show: 'auto' - }, - // TODO - // min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60] - splitNumber: 5, - minorTick: { - // Minor tick, not available for cateogry axis. - show: false, - // Split number of minor ticks. The value should be in range of (0, 100) - splitNumber: 5, - // Length of minor tick - length: 3, - // Line style - lineStyle: { - // Default to be same with axisTick - } - }, - minorSplitLine: { - show: false, - lineStyle: { - color: '#F4F7FD', - width: 1 - } - } -}, defaultOption); -var timeAxis = merge({ - splitNumber: 6, - axisLabel: { - // To eliminate labels that are not nice - showMinLabel: false, - showMaxLabel: false, - rich: { - primary: { - fontWeight: 'bold' - } - } - }, - splitLine: { - show: false - } -}, valueAxis); -var logAxis = defaults({ - logBase: 10 -}, valueAxis); -const axisDefault = { - category: categoryAxis, - value: valueAxis, - time: timeAxis, - log: logAxis -}; - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -var AXIS_TYPES = { - value: 1, - category: 1, - time: 1, - log: 1 -}; - -/** - * Generate sub axis model class - * @param axisName 'x' 'y' 'radius' 'angle' 'parallel' ... - */ -function axisModelCreator(registers, axisName, BaseAxisModelClass, extraDefaultOption) { - each$4(AXIS_TYPES, function (v, axisType) { - var defaultOption = merge(merge({}, axisDefault[axisType], true), extraDefaultOption, true); - var AxisModel = /** @class */function (_super) { - __extends(AxisModel, _super); - function AxisModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = axisName + 'Axis.' + axisType; - return _this; - } - AxisModel.prototype.mergeDefaultAndTheme = function (option, ecModel) { - var layoutMode = fetchLayoutMode(this); - var inputPositionParams = layoutMode ? getLayoutParams(option) : {}; - var themeModel = ecModel.getTheme(); - merge(option, themeModel.get(axisType + 'Axis')); - merge(option, this.getDefaultOption()); - option.type = getAxisType(option); - if (layoutMode) { - mergeLayoutParam(option, inputPositionParams, layoutMode); - } - }; - AxisModel.prototype.optionUpdated = function () { - var thisOption = this.option; - if (thisOption.type === 'category') { - this.__ordinalMeta = OrdinalMeta.createByAxisModel(this); - } - }; - /** - * Should not be called before all of 'getInitailData' finished. - * Because categories are collected during initializing data. - */ - AxisModel.prototype.getCategories = function (rawData) { - var option = this.option; - // FIXME - // warning if called before all of 'getInitailData' finished. - if (option.type === 'category') { - if (rawData) { - return option.data; - } - return this.__ordinalMeta.categories; - } - }; - AxisModel.prototype.getOrdinalMeta = function () { - return this.__ordinalMeta; - }; - AxisModel.type = axisName + 'Axis.' + axisType; - AxisModel.defaultOption = defaultOption; - return AxisModel; - }(BaseAxisModelClass); - registers.registerComponentModel(AxisModel); - }); - registers.registerSubTypeDefaulter(axisName + 'Axis', getAxisType); -} -function getAxisType(option) { - // Default axis with data is category axis - return option.type || (option.data ? 'category' : 'value'); -} - -var Cartesian = /** @class */function () { - function Cartesian(name) { - this.type = 'cartesian'; - this._dimList = []; - this._axes = {}; - this.name = name || ''; - } - Cartesian.prototype.getAxis = function (dim) { - return this._axes[dim]; - }; - Cartesian.prototype.getAxes = function () { - return map$1(this._dimList, function (dim) { - return this._axes[dim]; - }, this); - }; - Cartesian.prototype.getAxesByScale = function (scaleType) { - scaleType = scaleType.toLowerCase(); - return filter(this.getAxes(), function (axis) { - return axis.scale.type === scaleType; - }); - }; - Cartesian.prototype.addAxis = function (axis) { - var dim = axis.dim; - this._axes[dim] = axis; - this._dimList.push(dim); - }; - return Cartesian; -}(); - -var cartesian2DDimensions = ['x', 'y']; -function canCalculateAffineTransform(scale) { - return scale.type === 'interval' || scale.type === 'time'; -} -var Cartesian2D = /** @class */function (_super) { - __extends(Cartesian2D, _super); - function Cartesian2D() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = 'cartesian2d'; - _this.dimensions = cartesian2DDimensions; - return _this; - } - /** - * Calculate an affine transform matrix if two axes are time or value. - * It's mainly for accelartion on the large time series data. - */ - Cartesian2D.prototype.calcAffineTransform = function () { - this._transform = this._invTransform = null; - var xAxisScale = this.getAxis('x').scale; - var yAxisScale = this.getAxis('y').scale; - if (!canCalculateAffineTransform(xAxisScale) || !canCalculateAffineTransform(yAxisScale)) { - return; - } - var xScaleExtent = xAxisScale.getExtent(); - var yScaleExtent = yAxisScale.getExtent(); - var start = this.dataToPoint([xScaleExtent[0], yScaleExtent[0]]); - var end = this.dataToPoint([xScaleExtent[1], yScaleExtent[1]]); - var xScaleSpan = xScaleExtent[1] - xScaleExtent[0]; - var yScaleSpan = yScaleExtent[1] - yScaleExtent[0]; - if (!xScaleSpan || !yScaleSpan) { - return; - } - // Accelerate data to point calculation on the special large time series data. - var scaleX = (end[0] - start[0]) / xScaleSpan; - var scaleY = (end[1] - start[1]) / yScaleSpan; - var translateX = start[0] - xScaleExtent[0] * scaleX; - var translateY = start[1] - yScaleExtent[0] * scaleY; - var m = this._transform = [scaleX, 0, 0, scaleY, translateX, translateY]; - this._invTransform = invert([], m); - }; - /** - * Base axis will be used on stacking. - */ - Cartesian2D.prototype.getBaseAxis = function () { - return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAxis('x'); - }; - Cartesian2D.prototype.containPoint = function (point) { - var axisX = this.getAxis('x'); - var axisY = this.getAxis('y'); - return axisX.contain(axisX.toLocalCoord(point[0])) && axisY.contain(axisY.toLocalCoord(point[1])); - }; - Cartesian2D.prototype.containData = function (data) { - return this.getAxis('x').containData(data[0]) && this.getAxis('y').containData(data[1]); - }; - Cartesian2D.prototype.containZone = function (data1, data2) { - var zoneDiag1 = this.dataToPoint(data1); - var zoneDiag2 = this.dataToPoint(data2); - var area = this.getArea(); - var zone = new BoundingRect(zoneDiag1[0], zoneDiag1[1], zoneDiag2[0] - zoneDiag1[0], zoneDiag2[1] - zoneDiag1[1]); - return area.intersect(zone); - }; - Cartesian2D.prototype.dataToPoint = function (data, clamp, out) { - out = out || []; - var xVal = data[0]; - var yVal = data[1]; - // Fast path - if (this._transform - // It's supported that if data is like `[Inifity, 123]`, where only Y pixel calculated. - && xVal != null && isFinite(xVal) && yVal != null && isFinite(yVal)) { - return applyTransform$1(out, data, this._transform); - } - var xAxis = this.getAxis('x'); - var yAxis = this.getAxis('y'); - out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal, clamp)); - out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal, clamp)); - return out; - }; - Cartesian2D.prototype.clampData = function (data, out) { - var xScale = this.getAxis('x').scale; - var yScale = this.getAxis('y').scale; - var xAxisExtent = xScale.getExtent(); - var yAxisExtent = yScale.getExtent(); - var x = xScale.parse(data[0]); - var y = yScale.parse(data[1]); - out = out || []; - out[0] = Math.min(Math.max(Math.min(xAxisExtent[0], xAxisExtent[1]), x), Math.max(xAxisExtent[0], xAxisExtent[1])); - out[1] = Math.min(Math.max(Math.min(yAxisExtent[0], yAxisExtent[1]), y), Math.max(yAxisExtent[0], yAxisExtent[1])); - return out; - }; - Cartesian2D.prototype.pointToData = function (point, clamp) { - var out = []; - if (this._invTransform) { - return applyTransform$1(out, point, this._invTransform); - } - var xAxis = this.getAxis('x'); - var yAxis = this.getAxis('y'); - out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]), clamp); - out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]), clamp); - return out; - }; - Cartesian2D.prototype.getOtherAxis = function (axis) { - return this.getAxis(axis.dim === 'x' ? 'y' : 'x'); - }; - /** - * Get rect area of cartesian. - * Area will have a contain function to determine if a point is in the coordinate system. - */ - Cartesian2D.prototype.getArea = function (tolerance) { - tolerance = tolerance || 0; - var xExtent = this.getAxis('x').getGlobalExtent(); - var yExtent = this.getAxis('y').getGlobalExtent(); - var x = Math.min(xExtent[0], xExtent[1]) - tolerance; - var y = Math.min(yExtent[0], yExtent[1]) - tolerance; - var width = Math.max(xExtent[0], xExtent[1]) - x + tolerance; - var height = Math.max(yExtent[0], yExtent[1]) - y + tolerance; - return new BoundingRect(x, y, width, height); - }; - return Cartesian2D; -}(Cartesian); - -var Axis2D = /** @class */function (_super) { - __extends(Axis2D, _super); - function Axis2D(dim, scale, coordExtent, axisType, position) { - var _this = _super.call(this, dim, scale, coordExtent) || this; - /** - * Index of axis, can be used as key - * Injected outside. - */ - _this.index = 0; - _this.type = axisType || 'value'; - _this.position = position || 'bottom'; - return _this; - } - Axis2D.prototype.isHorizontal = function () { - var position = this.position; - return position === 'top' || position === 'bottom'; - }; - /** - * Each item cooresponds to this.getExtent(), which - * means globalExtent[0] may greater than globalExtent[1], - * unless `asc` is input. - * - * @param {boolean} [asc] - * @return {Array.} - */ - Axis2D.prototype.getGlobalExtent = function (asc) { - var ret = this.getExtent(); - ret[0] = this.toGlobalCoord(ret[0]); - ret[1] = this.toGlobalCoord(ret[1]); - asc && ret[0] > ret[1] && ret.reverse(); - return ret; - }; - Axis2D.prototype.pointToData = function (point, clamp) { - return this.coordToData(this.toLocalCoord(point[this.dim === 'x' ? 0 : 1]), clamp); - }; - /** - * Set ordinalSortInfo - * @param info new OrdinalSortInfo - */ - Axis2D.prototype.setCategorySortInfo = function (info) { - if (this.type !== 'category') { - return false; - } - this.model.option.categorySortInfo = info; - this.scale.setSortInfo(info); - }; - return Axis2D; -}(Axis); - -function layout(gridModel, axisModel, opt) { - opt = opt || {}; - var grid = gridModel.coordinateSystem; - var axis = axisModel.axis; - var layout2 = {}; - var otherAxisOnZeroOf = axis.getAxesOnZeroOf()[0]; - var rawAxisPosition = axis.position; - var axisPosition = otherAxisOnZeroOf ? "onZero" : rawAxisPosition; - var axisDim = axis.dim; - var rect = grid.getRect(); - var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height]; - var idx = { - left: 0, - right: 1, - top: 0, - bottom: 1, - onZero: 2 - }; - var axisOffset = axisModel.get("offset") || 0; - var posBound = axisDim === "x" ? [rectBound[2] - axisOffset, rectBound[3] + axisOffset] : [rectBound[0] - axisOffset, rectBound[1] + axisOffset]; - if (otherAxisOnZeroOf) { - var onZeroCoord = otherAxisOnZeroOf.toGlobalCoord(otherAxisOnZeroOf.dataToCoord(0)); - posBound[idx.onZero] = Math.max(Math.min(onZeroCoord, posBound[1]), posBound[0]); - } - layout2.position = [axisDim === "y" ? posBound[idx[axisPosition]] : rectBound[0], axisDim === "x" ? posBound[idx[axisPosition]] : rectBound[3]]; - layout2.rotation = Math.PI / 2 * (axisDim === "x" ? 0 : 1); - var dirMap = { - top: -1, - bottom: 1, - left: -1, - right: 1 - }; - layout2.labelDirection = layout2.tickDirection = layout2.nameDirection = dirMap[rawAxisPosition]; - layout2.labelOffset = otherAxisOnZeroOf ? posBound[idx[rawAxisPosition]] - posBound[idx.onZero] : 0; - if (axisModel.get(["axisTick", "inside"])) { - layout2.tickDirection = -layout2.tickDirection; - } - if (retrieve(opt.labelInside, axisModel.get(["axisLabel", "inside"]))) { - layout2.labelDirection = -layout2.labelDirection; - } - var labelRotate = axisModel.get(["axisLabel", "rotate"]); - layout2.labelRotate = axisPosition === "top" ? -labelRotate : labelRotate; - layout2.z2 = 1; - return layout2; -} -function isCartesian2DSeries(seriesModel) { - return seriesModel.get("coordinateSystem") === "cartesian2d"; -} -function findAxisModels(seriesModel) { - var axisModelMap = { - xAxisModel: null, - yAxisModel: null - }; - each$4(axisModelMap, function(v, key) { - var axisType = key.replace(/Model$/, ""); - var axisModel = seriesModel.getReferringComponents(axisType, SINGLE_REFERRING).models[0]; - axisModelMap[key] = axisModel; - }); - return axisModelMap; -} - -var mathLog = Math.log; -function alignScaleTicks(scale, axisModel, alignToScale) { - var intervalScaleProto = IntervalScale.prototype; - var alignToTicks = intervalScaleProto.getTicks.call(alignToScale); - var alignToNicedTicks = intervalScaleProto.getTicks.call(alignToScale, true); - var alignToSplitNumber = alignToTicks.length - 1; - var alignToInterval = intervalScaleProto.getInterval.call(alignToScale); - var scaleExtent = getScaleExtent(scale, axisModel); - var rawExtent = scaleExtent.extent; - var isMinFixed = scaleExtent.fixMin; - var isMaxFixed = scaleExtent.fixMax; - if (scale.type === "log") { - var logBase = mathLog(scale.base); - rawExtent = [mathLog(rawExtent[0]) / logBase, mathLog(rawExtent[1]) / logBase]; - } - scale.setExtent(rawExtent[0], rawExtent[1]); - scale.calcNiceExtent({ - splitNumber: alignToSplitNumber, - fixMin: isMinFixed, - fixMax: isMaxFixed - }); - var extent = intervalScaleProto.getExtent.call(scale); - if (isMinFixed) { - rawExtent[0] = extent[0]; - } - if (isMaxFixed) { - rawExtent[1] = extent[1]; - } - var interval = intervalScaleProto.getInterval.call(scale); - var min = rawExtent[0]; - var max = rawExtent[1]; - if (isMinFixed && isMaxFixed) { - interval = (max - min) / alignToSplitNumber; - } else if (isMinFixed) { - max = rawExtent[0] + interval * alignToSplitNumber; - while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1])) { - interval = increaseInterval(interval); - max = rawExtent[0] + interval * alignToSplitNumber; - } - } else if (isMaxFixed) { - min = rawExtent[1] - interval * alignToSplitNumber; - while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0])) { - interval = increaseInterval(interval); - min = rawExtent[1] - interval * alignToSplitNumber; - } - } else { - var nicedSplitNumber = scale.getTicks().length - 1; - if (nicedSplitNumber > alignToSplitNumber) { - interval = increaseInterval(interval); - } - var range = interval * alignToSplitNumber; - max = Math.ceil(rawExtent[1] / interval) * interval; - min = round$1(max - range); - if (min < 0 && rawExtent[0] >= 0) { - min = 0; - max = round$1(range); - } else if (max > 0 && rawExtent[1] <= 0) { - max = 0; - min = -round$1(range); - } - } - var t0 = (alignToTicks[0].value - alignToNicedTicks[0].value) / alignToInterval; - var t1 = (alignToTicks[alignToSplitNumber].value - alignToNicedTicks[alignToSplitNumber].value) / alignToInterval; - intervalScaleProto.setExtent.call(scale, min + interval * t0, max + interval * t1); - intervalScaleProto.setInterval.call(scale, interval); - if (t0 || t1) { - intervalScaleProto.setNiceExtent.call(scale, min + interval, max - interval); - } -} - -var Grid = ( - /** @class */ - function() { - function Grid2(gridModel, ecModel, api) { - this.type = "grid"; - this._coordsMap = {}; - this._coordsList = []; - this._axesMap = {}; - this._axesList = []; - this.axisPointerEnabled = true; - this.dimensions = cartesian2DDimensions; - this._initCartesian(gridModel, ecModel, api); - this.model = gridModel; - } - Grid2.prototype.getRect = function() { - return this._rect; - }; - Grid2.prototype.update = function(ecModel, api) { - var axesMap = this._axesMap; - this._updateScale(ecModel, this.model); - function updateAxisTicks(axes) { - var alignTo; - var axesIndices = keys(axes); - var len = axesIndices.length; - if (!len) { - return; - } - var axisNeedsAlign = []; - for (var i = len - 1; i >= 0; i--) { - var idx = +axesIndices[i]; - var axis = axes[idx]; - var model = axis.model; - var scale = axis.scale; - if ( - // Only value and log axis without interval support alignTicks. - isIntervalOrLogScale(scale) && model.get("alignTicks") && model.get("interval") == null - ) { - axisNeedsAlign.push(axis); - } else { - niceScaleExtent(scale, model); - if (isIntervalOrLogScale(scale)) { - alignTo = axis; - } - } - } - if (axisNeedsAlign.length) { - if (!alignTo) { - alignTo = axisNeedsAlign.pop(); - niceScaleExtent(alignTo.scale, alignTo.model); - } - each$4(axisNeedsAlign, function(axis2) { - alignScaleTicks(axis2.scale, axis2.model, alignTo.scale); - }); - } - } - updateAxisTicks(axesMap.x); - updateAxisTicks(axesMap.y); - var onZeroRecords = {}; - each$4(axesMap.x, function(xAxis) { - fixAxisOnZero(axesMap, "y", xAxis, onZeroRecords); - }); - each$4(axesMap.y, function(yAxis) { - fixAxisOnZero(axesMap, "x", yAxis, onZeroRecords); - }); - this.resize(this.model, api); - }; - Grid2.prototype.resize = function(gridModel, api, ignoreContainLabel) { - var boxLayoutParams = gridModel.getBoxLayoutParams(); - var isContainLabel = !ignoreContainLabel && gridModel.get("containLabel"); - var gridRect = getLayoutRect(boxLayoutParams, { - width: api.getWidth(), - height: api.getHeight() - }); - this._rect = gridRect; - var axesList = this._axesList; - adjustAxes(); - if (isContainLabel) { - each$4(axesList, function(axis) { - if (!axis.model.get(["axisLabel", "inside"])) { - var labelUnionRect = estimateLabelUnionRect(axis); - if (labelUnionRect) { - var dim = axis.isHorizontal() ? "height" : "width"; - var margin = axis.model.get(["axisLabel", "margin"]); - gridRect[dim] -= labelUnionRect[dim] + margin; - if (axis.position === "top") { - gridRect.y += labelUnionRect.height + margin; - } else if (axis.position === "left") { - gridRect.x += labelUnionRect.width + margin; - } - } - } - }); - adjustAxes(); - } - each$4(this._coordsList, function(coord) { - coord.calcAffineTransform(); - }); - function adjustAxes() { - each$4(axesList, function(axis) { - var isHorizontal = axis.isHorizontal(); - var extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height]; - var idx = axis.inverse ? 1 : 0; - axis.setExtent(extent[idx], extent[1 - idx]); - updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y); - }); - } - }; - Grid2.prototype.getAxis = function(dim, axisIndex) { - var axesMapOnDim = this._axesMap[dim]; - if (axesMapOnDim != null) { - return axesMapOnDim[axisIndex || 0]; - } - }; - Grid2.prototype.getAxes = function() { - return this._axesList.slice(); - }; - Grid2.prototype.getCartesian = function(xAxisIndex, yAxisIndex) { - if (xAxisIndex != null && yAxisIndex != null) { - var key = "x" + xAxisIndex + "y" + yAxisIndex; - return this._coordsMap[key]; - } - if (isObject$2(xAxisIndex)) { - yAxisIndex = xAxisIndex.yAxisIndex; - xAxisIndex = xAxisIndex.xAxisIndex; - } - for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) { - if (coordList[i].getAxis("x").index === xAxisIndex || coordList[i].getAxis("y").index === yAxisIndex) { - return coordList[i]; - } - } - }; - Grid2.prototype.getCartesians = function() { - return this._coordsList.slice(); - }; - Grid2.prototype.convertToPixel = function(ecModel, finder, value) { - var target = this._findConvertTarget(finder); - return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null; - }; - Grid2.prototype.convertFromPixel = function(ecModel, finder, value) { - var target = this._findConvertTarget(finder); - return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null; - }; - Grid2.prototype._findConvertTarget = function(finder) { - var seriesModel = finder.seriesModel; - var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0]; - var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0]; - var gridModel = finder.gridModel; - var coordsList = this._coordsList; - var cartesian; - var axis; - if (seriesModel) { - cartesian = seriesModel.coordinateSystem; - indexOf(coordsList, cartesian) < 0 && (cartesian = null); - } else if (xAxisModel && yAxisModel) { - cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex); - } else if (xAxisModel) { - axis = this.getAxis("x", xAxisModel.componentIndex); - } else if (yAxisModel) { - axis = this.getAxis("y", yAxisModel.componentIndex); - } else if (gridModel) { - var grid = gridModel.coordinateSystem; - if (grid === this) { - cartesian = this._coordsList[0]; - } - } - return { - cartesian, - axis - }; - }; - Grid2.prototype.containPoint = function(point) { - var coord = this._coordsList[0]; - if (coord) { - return coord.containPoint(point); - } - }; - Grid2.prototype._initCartesian = function(gridModel, ecModel, api) { - var _this = this; - var grid = this; - var axisPositionUsed = { - left: false, - right: false, - top: false, - bottom: false - }; - var axesMap = { - x: {}, - y: {} - }; - var axesCount = { - x: 0, - y: 0 - }; - ecModel.eachComponent("xAxis", createAxisCreator("x"), this); - ecModel.eachComponent("yAxis", createAxisCreator("y"), this); - if (!axesCount.x || !axesCount.y) { - this._axesMap = {}; - this._axesList = []; - return; - } - this._axesMap = axesMap; - each$4(axesMap.x, function(xAxis, xAxisIndex) { - each$4(axesMap.y, function(yAxis, yAxisIndex) { - var key = "x" + xAxisIndex + "y" + yAxisIndex; - var cartesian = new Cartesian2D(key); - cartesian.master = _this; - cartesian.model = gridModel; - _this._coordsMap[key] = cartesian; - _this._coordsList.push(cartesian); - cartesian.addAxis(xAxis); - cartesian.addAxis(yAxis); - }); - }); - function createAxisCreator(dimName) { - return function(axisModel, idx) { - if (!isAxisUsedInTheGrid(axisModel, gridModel)) { - return; - } - var axisPosition = axisModel.get("position"); - if (dimName === "x") { - if (axisPosition !== "top" && axisPosition !== "bottom") { - axisPosition = axisPositionUsed.bottom ? "top" : "bottom"; - } - } else { - if (axisPosition !== "left" && axisPosition !== "right") { - axisPosition = axisPositionUsed.left ? "right" : "left"; - } - } - axisPositionUsed[axisPosition] = true; - var axis = new Axis2D(dimName, createScaleByModel(axisModel), [0, 0], axisModel.get("type"), axisPosition); - var isCategory = axis.type === "category"; - axis.onBand = isCategory && axisModel.get("boundaryGap"); - axis.inverse = axisModel.get("inverse"); - axisModel.axis = axis; - axis.model = axisModel; - axis.grid = grid; - axis.index = idx; - grid._axesList.push(axis); - axesMap[dimName][idx] = axis; - axesCount[dimName]++; - }; - } - }; - Grid2.prototype._updateScale = function(ecModel, gridModel) { - each$4(this._axesList, function(axis) { - axis.scale.setExtent(Infinity, -Infinity); - if (axis.type === "category") { - var categorySortInfo = axis.model.get("categorySortInfo"); - axis.scale.setSortInfo(categorySortInfo); - } - }); - ecModel.eachSeries(function(seriesModel) { - if (isCartesian2DSeries(seriesModel)) { - var axesModelMap = findAxisModels(seriesModel); - var xAxisModel = axesModelMap.xAxisModel; - var yAxisModel = axesModelMap.yAxisModel; - if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) { - return; - } - var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex); - var data = seriesModel.getData(); - var xAxis = cartesian.getAxis("x"); - var yAxis = cartesian.getAxis("y"); - unionExtent(data, xAxis); - unionExtent(data, yAxis); - } - }, this); - function unionExtent(data, axis) { - each$4(getDataDimensionsOnAxis(data, axis.dim), function(dim) { - axis.scale.unionExtentFromData(data, dim); - }); - } - }; - Grid2.prototype.getTooltipAxes = function(dim) { - var baseAxes = []; - var otherAxes = []; - each$4(this.getCartesians(), function(cartesian) { - var baseAxis = dim != null && dim !== "auto" ? cartesian.getAxis(dim) : cartesian.getBaseAxis(); - var otherAxis = cartesian.getOtherAxis(baseAxis); - indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis); - indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis); - }); - return { - baseAxes, - otherAxes - }; - }; - Grid2.create = function(ecModel, api) { - var grids = []; - ecModel.eachComponent("grid", function(gridModel, idx) { - var grid = new Grid2(gridModel, ecModel, api); - grid.name = "grid_" + idx; - grid.resize(gridModel, api, true); - gridModel.coordinateSystem = grid; - grids.push(grid); - }); - ecModel.eachSeries(function(seriesModel) { - if (!isCartesian2DSeries(seriesModel)) { - return; - } - var axesModelMap = findAxisModels(seriesModel); - var xAxisModel = axesModelMap.xAxisModel; - var yAxisModel = axesModelMap.yAxisModel; - var gridModel = xAxisModel.getCoordSysModel(); - var grid = gridModel.coordinateSystem; - seriesModel.coordinateSystem = grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex); - }); - return grids; - }; - Grid2.dimensions = cartesian2DDimensions; - return Grid2; - }() -); -function isAxisUsedInTheGrid(axisModel, gridModel) { - return axisModel.getCoordSysModel() === gridModel; -} -function fixAxisOnZero(axesMap, otherAxisDim, axis, onZeroRecords) { - axis.getAxesOnZeroOf = function() { - return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : []; - }; - var otherAxes = axesMap[otherAxisDim]; - var otherAxisOnZeroOf; - var axisModel = axis.model; - var onZero = axisModel.get(["axisLine", "onZero"]); - var onZeroAxisIndex = axisModel.get(["axisLine", "onZeroAxisIndex"]); - if (!onZero) { - return; - } - if (onZeroAxisIndex != null) { - if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) { - otherAxisOnZeroOf = otherAxes[onZeroAxisIndex]; - } - } else { - for (var idx in otherAxes) { - if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx]) && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) { - otherAxisOnZeroOf = otherAxes[idx]; - break; - } - } - } - if (otherAxisOnZeroOf) { - onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true; - } - function getOnZeroRecordKey(axis2) { - return axis2.dim + "_" + axis2.index; - } -} -function canOnZeroToAxis(axis) { - return axis && axis.type !== "category" && axis.type !== "time" && ifAxisCrossZero(axis); -} -function updateAxisTransform(axis, coordBase) { - var axisExtent = axis.getExtent(); - var axisExtentSum = axisExtent[0] + axisExtent[1]; - axis.toGlobalCoord = axis.dim === "x" ? function(coord) { - return coord + coordBase; - } : function(coord) { - return axisExtentSum - coord + coordBase; - }; - axis.toLocalCoord = axis.dim === "x" ? function(coord) { - return coord - coordBase; - } : function(coord) { - return axisExtentSum - coord + coordBase; - }; -} - -var PI = Math.PI; -/** - * A final axis is translated and rotated from a "standard axis". - * So opt.position and opt.rotation is required. - * - * A standard axis is and axis from [0, 0] to [0, axisExtent[1]], - * for example: (0, 0) ------------> (0, 50) - * - * nameDirection or tickDirection or labelDirection is 1 means tick - * or label is below the standard axis, whereas is -1 means above - * the standard axis. labelOffset means offset between label and axis, - * which is useful when 'onZero', where axisLabel is in the grid and - * label in outside grid. - * - * Tips: like always, - * positive rotation represents anticlockwise, and negative rotation - * represents clockwise. - * The direction of position coordinate is the same as the direction - * of screen coordinate. - * - * Do not need to consider axis 'inverse', which is auto processed by - * axis extent. - */ -var AxisBuilder = /** @class */function () { - function AxisBuilder(axisModel, opt) { - this.group = new Group$2(); - this.opt = opt; - this.axisModel = axisModel; - // Default value - defaults(opt, { - labelOffset: 0, - nameDirection: 1, - tickDirection: 1, - labelDirection: 1, - silent: true, - handleAutoShown: function () { - return true; - } - }); - // FIXME Not use a separate text group? - var transformGroup = new Group$2({ - x: opt.position[0], - y: opt.position[1], - rotation: opt.rotation - }); - // this.group.add(transformGroup); - // this._transformGroup = transformGroup; - transformGroup.updateTransform(); - this._transformGroup = transformGroup; - } - AxisBuilder.prototype.hasBuilder = function (name) { - return !!builders[name]; - }; - AxisBuilder.prototype.add = function (name) { - builders[name](this.opt, this.axisModel, this.group, this._transformGroup); - }; - AxisBuilder.prototype.getGroup = function () { - return this.group; - }; - AxisBuilder.innerTextLayout = function (axisRotation, textRotation, direction) { - var rotationDiff = remRadian(textRotation - axisRotation); - var textAlign; - var textVerticalAlign; - if (isRadianAroundZero(rotationDiff)) { - // Label is parallel with axis line. - textVerticalAlign = direction > 0 ? 'top' : 'bottom'; - textAlign = 'center'; - } else if (isRadianAroundZero(rotationDiff - PI)) { - // Label is inverse parallel with axis line. - textVerticalAlign = direction > 0 ? 'bottom' : 'top'; - textAlign = 'center'; - } else { - textVerticalAlign = 'middle'; - if (rotationDiff > 0 && rotationDiff < PI) { - textAlign = direction > 0 ? 'right' : 'left'; - } else { - textAlign = direction > 0 ? 'left' : 'right'; - } - } - return { - rotation: rotationDiff, - textAlign: textAlign, - textVerticalAlign: textVerticalAlign - }; - }; - AxisBuilder.makeAxisEventDataBase = function (axisModel) { - var eventData = { - componentType: axisModel.mainType, - componentIndex: axisModel.componentIndex - }; - eventData[axisModel.mainType + 'Index'] = axisModel.componentIndex; - return eventData; - }; - AxisBuilder.isLabelSilent = function (axisModel) { - var tooltipOpt = axisModel.get('tooltip'); - return axisModel.get('silent') - // Consider mouse cursor, add these restrictions. - || !(axisModel.get('triggerEvent') || tooltipOpt && tooltipOpt.show); - }; - return AxisBuilder; -}(); -var builders = { - axisLine: function (opt, axisModel, group, transformGroup) { - var shown = axisModel.get(['axisLine', 'show']); - if (shown === 'auto' && opt.handleAutoShown) { - shown = opt.handleAutoShown('axisLine'); - } - if (!shown) { - return; - } - var extent = axisModel.axis.getExtent(); - var matrix = transformGroup.transform; - var pt1 = [extent[0], 0]; - var pt2 = [extent[1], 0]; - var inverse = pt1[0] > pt2[0]; - if (matrix) { - applyTransform$1(pt1, pt1, matrix); - applyTransform$1(pt2, pt2, matrix); - } - var lineStyle = extend({ - lineCap: 'round' - }, axisModel.getModel(['axisLine', 'lineStyle']).getLineStyle()); - var line = new Line({ - shape: { - x1: pt1[0], - y1: pt1[1], - x2: pt2[0], - y2: pt2[1] - }, - style: lineStyle, - strokeContainThreshold: opt.strokeContainThreshold || 5, - silent: true, - z2: 1 - }); - subPixelOptimizeLine(line.shape, line.style.lineWidth); - line.anid = 'line'; - group.add(line); - var arrows = axisModel.get(['axisLine', 'symbol']); - if (arrows != null) { - var arrowSize = axisModel.get(['axisLine', 'symbolSize']); - if (isString(arrows)) { - // Use the same arrow for start and end point - arrows = [arrows, arrows]; - } - if (isString(arrowSize) || isNumber(arrowSize)) { - // Use the same size for width and height - arrowSize = [arrowSize, arrowSize]; - } - var arrowOffset = normalizeSymbolOffset(axisModel.get(['axisLine', 'symbolOffset']) || 0, arrowSize); - var symbolWidth_1 = arrowSize[0]; - var symbolHeight_1 = arrowSize[1]; - each$4([{ - rotate: opt.rotation + Math.PI / 2, - offset: arrowOffset[0], - r: 0 - }, { - rotate: opt.rotation - Math.PI / 2, - offset: arrowOffset[1], - r: Math.sqrt((pt1[0] - pt2[0]) * (pt1[0] - pt2[0]) + (pt1[1] - pt2[1]) * (pt1[1] - pt2[1])) - }], function (point, index) { - if (arrows[index] !== 'none' && arrows[index] != null) { - var symbol = createSymbol(arrows[index], -symbolWidth_1 / 2, -symbolHeight_1 / 2, symbolWidth_1, symbolHeight_1, lineStyle.stroke, true); - // Calculate arrow position with offset - var r = point.r + point.offset; - var pt = inverse ? pt2 : pt1; - symbol.attr({ - rotation: point.rotate, - x: pt[0] + r * Math.cos(opt.rotation), - y: pt[1] - r * Math.sin(opt.rotation), - silent: true, - z2: 11 - }); - group.add(symbol); - } - }); - } - }, - axisTickLabel: function (opt, axisModel, group, transformGroup) { - var ticksEls = buildAxisMajorTicks(group, transformGroup, axisModel, opt); - var labelEls = buildAxisLabel(group, transformGroup, axisModel, opt); - fixMinMaxLabelShow(axisModel, labelEls, ticksEls); - buildAxisMinorTicks(group, transformGroup, axisModel, opt.tickDirection); - // This bit fixes the label overlap issue for the time chart. - // See https://github.com/apache/echarts/issues/14266 for more. - if (axisModel.get(['axisLabel', 'hideOverlap'])) { - var labelList = prepareLayoutList(map$1(labelEls, function (label) { - return { - label: label, - priority: label.z2, - defaultAttr: { - ignore: label.ignore - } - }; - })); - hideOverlap(labelList); - } - }, - axisName: function (opt, axisModel, group, transformGroup) { - var name = retrieve(opt.axisName, axisModel.get('name')); - if (!name) { - return; - } - var nameLocation = axisModel.get('nameLocation'); - var nameDirection = opt.nameDirection; - var textStyleModel = axisModel.getModel('nameTextStyle'); - var gap = axisModel.get('nameGap') || 0; - var extent = axisModel.axis.getExtent(); - var gapSignal = extent[0] > extent[1] ? -1 : 1; - var pos = [nameLocation === 'start' ? extent[0] - gapSignal * gap : nameLocation === 'end' ? extent[1] + gapSignal * gap : (extent[0] + extent[1]) / 2, - // Reuse labelOffset. - isNameLocationCenter(nameLocation) ? opt.labelOffset + nameDirection * gap : 0]; - var labelLayout; - var nameRotation = axisModel.get('nameRotate'); - if (nameRotation != null) { - nameRotation = nameRotation * PI / 180; // To radian. - } - var axisNameAvailableWidth; - if (isNameLocationCenter(nameLocation)) { - labelLayout = AxisBuilder.innerTextLayout(opt.rotation, nameRotation != null ? nameRotation : opt.rotation, - // Adapt to axis. - nameDirection); - } else { - labelLayout = endTextLayout(opt.rotation, nameLocation, nameRotation || 0, extent); - axisNameAvailableWidth = opt.axisNameAvailableWidth; - if (axisNameAvailableWidth != null) { - axisNameAvailableWidth = Math.abs(axisNameAvailableWidth / Math.sin(labelLayout.rotation)); - !isFinite(axisNameAvailableWidth) && (axisNameAvailableWidth = null); - } - } - var textFont = textStyleModel.getFont(); - var truncateOpt = axisModel.get('nameTruncate', true) || {}; - var ellipsis = truncateOpt.ellipsis; - var maxWidth = retrieve(opt.nameTruncateMaxWidth, truncateOpt.maxWidth, axisNameAvailableWidth); - var textEl = new ZRText({ - x: pos[0], - y: pos[1], - rotation: labelLayout.rotation, - silent: AxisBuilder.isLabelSilent(axisModel), - style: createTextStyle(textStyleModel, { - text: name, - font: textFont, - overflow: 'truncate', - width: maxWidth, - ellipsis: ellipsis, - fill: textStyleModel.getTextColor() || axisModel.get(['axisLine', 'lineStyle', 'color']), - align: textStyleModel.get('align') || labelLayout.textAlign, - verticalAlign: textStyleModel.get('verticalAlign') || labelLayout.textVerticalAlign - }), - z2: 1 - }); - setTooltipConfig({ - el: textEl, - componentModel: axisModel, - itemName: name - }); - textEl.__fullText = name; - // Id for animation - textEl.anid = 'name'; - if (axisModel.get('triggerEvent')) { - var eventData = AxisBuilder.makeAxisEventDataBase(axisModel); - eventData.targetType = 'axisName'; - eventData.name = name; - getECData(textEl).eventData = eventData; - } - // FIXME - transformGroup.add(textEl); - textEl.updateTransform(); - group.add(textEl); - textEl.decomposeTransform(); - } -}; -function endTextLayout(rotation, textPosition, textRotate, extent) { - var rotationDiff = remRadian(textRotate - rotation); - var textAlign; - var textVerticalAlign; - var inverse = extent[0] > extent[1]; - var onLeft = textPosition === 'start' && !inverse || textPosition !== 'start' && inverse; - if (isRadianAroundZero(rotationDiff - PI / 2)) { - textVerticalAlign = onLeft ? 'bottom' : 'top'; - textAlign = 'center'; - } else if (isRadianAroundZero(rotationDiff - PI * 1.5)) { - textVerticalAlign = onLeft ? 'top' : 'bottom'; - textAlign = 'center'; - } else { - textVerticalAlign = 'middle'; - if (rotationDiff < PI * 1.5 && rotationDiff > PI / 2) { - textAlign = onLeft ? 'left' : 'right'; - } else { - textAlign = onLeft ? 'right' : 'left'; - } - } - return { - rotation: rotationDiff, - textAlign: textAlign, - textVerticalAlign: textVerticalAlign - }; -} -function fixMinMaxLabelShow(axisModel, labelEls, tickEls) { - if (shouldShowAllLabels(axisModel.axis)) { - return; - } - // If min or max are user set, we need to check - // If the tick on min(max) are overlap on their neighbour tick - // If they are overlapped, we need to hide the min(max) tick label - var showMinLabel = axisModel.get(['axisLabel', 'showMinLabel']); - var showMaxLabel = axisModel.get(['axisLabel', 'showMaxLabel']); - // FIXME - // Have not consider onBand yet, where tick els is more than label els. - labelEls = labelEls || []; - tickEls = tickEls || []; - var firstLabel = labelEls[0]; - var nextLabel = labelEls[1]; - var lastLabel = labelEls[labelEls.length - 1]; - var prevLabel = labelEls[labelEls.length - 2]; - var firstTick = tickEls[0]; - var nextTick = tickEls[1]; - var lastTick = tickEls[tickEls.length - 1]; - var prevTick = tickEls[tickEls.length - 2]; - if (showMinLabel === false) { - ignoreEl(firstLabel); - ignoreEl(firstTick); - } else if (isTwoLabelOverlapped(firstLabel, nextLabel)) { - if (showMinLabel) { - ignoreEl(nextLabel); - ignoreEl(nextTick); - } else { - ignoreEl(firstLabel); - ignoreEl(firstTick); - } - } - if (showMaxLabel === false) { - ignoreEl(lastLabel); - ignoreEl(lastTick); - } else if (isTwoLabelOverlapped(prevLabel, lastLabel)) { - if (showMaxLabel) { - ignoreEl(prevLabel); - ignoreEl(prevTick); - } else { - ignoreEl(lastLabel); - ignoreEl(lastTick); - } - } -} -function ignoreEl(el) { - el && (el.ignore = true); -} -function isTwoLabelOverlapped(current, next) { - // current and next has the same rotation. - var firstRect = current && current.getBoundingRect().clone(); - var nextRect = next && next.getBoundingRect().clone(); - if (!firstRect || !nextRect) { - return; - } - // When checking intersect of two rotated labels, we use mRotationBack - // to avoid that boundingRect is enlarge when using `boundingRect.applyTransform`. - var mRotationBack = identity([]); - rotate(mRotationBack, mRotationBack, -current.rotation); - firstRect.applyTransform(mul([], mRotationBack, current.getLocalTransform())); - nextRect.applyTransform(mul([], mRotationBack, next.getLocalTransform())); - return firstRect.intersect(nextRect); -} -function isNameLocationCenter(nameLocation) { - return nameLocation === 'middle' || nameLocation === 'center'; -} -function createTicks(ticksCoords, tickTransform, tickEndCoord, tickLineStyle, anidPrefix) { - var tickEls = []; - var pt1 = []; - var pt2 = []; - for (var i = 0; i < ticksCoords.length; i++) { - var tickCoord = ticksCoords[i].coord; - pt1[0] = tickCoord; - pt1[1] = 0; - pt2[0] = tickCoord; - pt2[1] = tickEndCoord; - if (tickTransform) { - applyTransform$1(pt1, pt1, tickTransform); - applyTransform$1(pt2, pt2, tickTransform); - } - // Tick line, Not use group transform to have better line draw - var tickEl = new Line({ - shape: { - x1: pt1[0], - y1: pt1[1], - x2: pt2[0], - y2: pt2[1] - }, - style: tickLineStyle, - z2: 2, - autoBatch: true, - silent: true - }); - subPixelOptimizeLine(tickEl.shape, tickEl.style.lineWidth); - tickEl.anid = anidPrefix + '_' + ticksCoords[i].tickValue; - tickEls.push(tickEl); - } - return tickEls; -} -function buildAxisMajorTicks(group, transformGroup, axisModel, opt) { - var axis = axisModel.axis; - var tickModel = axisModel.getModel('axisTick'); - var shown = tickModel.get('show'); - if (shown === 'auto' && opt.handleAutoShown) { - shown = opt.handleAutoShown('axisTick'); - } - if (!shown || axis.scale.isBlank()) { - return; - } - var lineStyleModel = tickModel.getModel('lineStyle'); - var tickEndCoord = opt.tickDirection * tickModel.get('length'); - var ticksCoords = axis.getTicksCoords(); - var ticksEls = createTicks(ticksCoords, transformGroup.transform, tickEndCoord, defaults(lineStyleModel.getLineStyle(), { - stroke: axisModel.get(['axisLine', 'lineStyle', 'color']) - }), 'ticks'); - for (var i = 0; i < ticksEls.length; i++) { - group.add(ticksEls[i]); - } - return ticksEls; -} -function buildAxisMinorTicks(group, transformGroup, axisModel, tickDirection) { - var axis = axisModel.axis; - var minorTickModel = axisModel.getModel('minorTick'); - if (!minorTickModel.get('show') || axis.scale.isBlank()) { - return; - } - var minorTicksCoords = axis.getMinorTicksCoords(); - if (!minorTicksCoords.length) { - return; - } - var lineStyleModel = minorTickModel.getModel('lineStyle'); - var tickEndCoord = tickDirection * minorTickModel.get('length'); - var minorTickLineStyle = defaults(lineStyleModel.getLineStyle(), defaults(axisModel.getModel('axisTick').getLineStyle(), { - stroke: axisModel.get(['axisLine', 'lineStyle', 'color']) - })); - for (var i = 0; i < minorTicksCoords.length; i++) { - var minorTicksEls = createTicks(minorTicksCoords[i], transformGroup.transform, tickEndCoord, minorTickLineStyle, 'minorticks_' + i); - for (var k = 0; k < minorTicksEls.length; k++) { - group.add(minorTicksEls[k]); - } - } -} -function buildAxisLabel(group, transformGroup, axisModel, opt) { - var axis = axisModel.axis; - var show = retrieve(opt.axisLabelShow, axisModel.get(['axisLabel', 'show'])); - if (!show || axis.scale.isBlank()) { - return; - } - var labelModel = axisModel.getModel('axisLabel'); - var labelMargin = labelModel.get('margin'); - var labels = axis.getViewLabels(); - // Special label rotate. - var labelRotation = (retrieve(opt.labelRotate, labelModel.get('rotate')) || 0) * PI / 180; - var labelLayout = AxisBuilder.innerTextLayout(opt.rotation, labelRotation, opt.labelDirection); - var rawCategoryData = axisModel.getCategories && axisModel.getCategories(true); - var labelEls = []; - var silent = AxisBuilder.isLabelSilent(axisModel); - var triggerEvent = axisModel.get('triggerEvent'); - each$4(labels, function (labelItem, index) { - var tickValue = axis.scale.type === 'ordinal' ? axis.scale.getRawOrdinalNumber(labelItem.tickValue) : labelItem.tickValue; - var formattedLabel = labelItem.formattedLabel; - var rawLabel = labelItem.rawLabel; - var itemLabelModel = labelModel; - if (rawCategoryData && rawCategoryData[tickValue]) { - var rawCategoryItem = rawCategoryData[tickValue]; - if (isObject$2(rawCategoryItem) && rawCategoryItem.textStyle) { - itemLabelModel = new Model(rawCategoryItem.textStyle, labelModel, axisModel.ecModel); - } - } - var textColor = itemLabelModel.getTextColor() || axisModel.get(['axisLine', 'lineStyle', 'color']); - var tickCoord = axis.dataToCoord(tickValue); - var align = itemLabelModel.getShallow('align', true) || labelLayout.textAlign; - var alignMin = retrieve2(itemLabelModel.getShallow('alignMinLabel', true), align); - var alignMax = retrieve2(itemLabelModel.getShallow('alignMaxLabel', true), align); - var verticalAlign = itemLabelModel.getShallow('verticalAlign', true) || itemLabelModel.getShallow('baseline', true) || labelLayout.textVerticalAlign; - var verticalAlignMin = retrieve2(itemLabelModel.getShallow('verticalAlignMinLabel', true), verticalAlign); - var verticalAlignMax = retrieve2(itemLabelModel.getShallow('verticalAlignMaxLabel', true), verticalAlign); - var textEl = new ZRText({ - x: tickCoord, - y: opt.labelOffset + opt.labelDirection * labelMargin, - rotation: labelLayout.rotation, - silent: silent, - z2: 10 + (labelItem.level || 0), - style: createTextStyle(itemLabelModel, { - text: formattedLabel, - align: index === 0 ? alignMin : index === labels.length - 1 ? alignMax : align, - verticalAlign: index === 0 ? verticalAlignMin : index === labels.length - 1 ? verticalAlignMax : verticalAlign, - fill: isFunction(textColor) ? textColor( - // (1) In category axis with data zoom, tick is not the original - // index of axis.data. So tick should not be exposed to user - // in category axis. - // (2) Compatible with previous version, which always use formatted label as - // input. But in interval scale the formatted label is like '223,445', which - // maked user replace ','. So we modify it to return original val but remain - // it as 'string' to avoid error in replacing. - axis.type === 'category' ? rawLabel : axis.type === 'value' ? tickValue + '' : tickValue, index) : textColor - }) - }); - textEl.anid = 'label_' + tickValue; - setTooltipConfig({ - el: textEl, - componentModel: axisModel, - itemName: formattedLabel, - formatterParamsExtra: { - isTruncated: function () { - return textEl.isTruncated; - }, - value: rawLabel, - tickIndex: index - } - }); - // Pack data for mouse event - if (triggerEvent) { - var eventData = AxisBuilder.makeAxisEventDataBase(axisModel); - eventData.targetType = 'axisLabel'; - eventData.value = rawLabel; - eventData.tickIndex = index; - if (axis.type === 'category') { - eventData.dataIndex = tickValue; - } - getECData(textEl).eventData = eventData; - } - // FIXME - transformGroup.add(textEl); - textEl.updateTransform(); - labelEls.push(textEl); - group.add(textEl); - textEl.decomposeTransform(); - }); - return labelEls; -} - -// Build axisPointerModel, mergin tooltip.axisPointer model for each axis. -// allAxesInfo should be updated when setOption performed. -function collect(ecModel, api) { - var result = { - /** - * key: makeKey(axis.model) - * value: { - * axis, - * coordSys, - * axisPointerModel, - * triggerTooltip, - * triggerEmphasis, - * involveSeries, - * snap, - * seriesModels, - * seriesDataCount - * } - */ - axesInfo: {}, - seriesInvolved: false, - /** - * key: makeKey(coordSys.model) - * value: Object: key makeKey(axis.model), value: axisInfo - */ - coordSysAxesInfo: {}, - coordSysMap: {} - }; - collectAxesInfo(result, ecModel, api); - // Check seriesInvolved for performance, in case too many series in some chart. - result.seriesInvolved && collectSeriesInfo(result, ecModel); - return result; -} -function collectAxesInfo(result, ecModel, api) { - var globalTooltipModel = ecModel.getComponent('tooltip'); - var globalAxisPointerModel = ecModel.getComponent('axisPointer'); - // links can only be set on global. - var linksOption = globalAxisPointerModel.get('link', true) || []; - var linkGroups = []; - // Collect axes info. - each$4(api.getCoordinateSystems(), function (coordSys) { - // Some coordinate system do not support axes, like geo. - if (!coordSys.axisPointerEnabled) { - return; - } - var coordSysKey = makeKey(coordSys.model); - var axesInfoInCoordSys = result.coordSysAxesInfo[coordSysKey] = {}; - result.coordSysMap[coordSysKey] = coordSys; - // Set tooltip (like 'cross') is a convenient way to show axisPointer - // for user. So we enable setting tooltip on coordSys model. - var coordSysModel = coordSys.model; - var baseTooltipModel = coordSysModel.getModel('tooltip', globalTooltipModel); - each$4(coordSys.getAxes(), curry$1(saveTooltipAxisInfo, false, null)); - // If axis tooltip used, choose tooltip axis for each coordSys. - // Notice this case: coordSys is `grid` but not `cartesian2D` here. - if (coordSys.getTooltipAxes && globalTooltipModel - // If tooltip.showContent is set as false, tooltip will not - // show but axisPointer will show as normal. - && baseTooltipModel.get('show')) { - // Compatible with previous logic. But series.tooltip.trigger: 'axis' - // or series.data[n].tooltip.trigger: 'axis' are not support any more. - var triggerAxis = baseTooltipModel.get('trigger') === 'axis'; - var cross = baseTooltipModel.get(['axisPointer', 'type']) === 'cross'; - var tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(['axisPointer', 'axis'])); - if (triggerAxis || cross) { - each$4(tooltipAxes.baseAxes, curry$1(saveTooltipAxisInfo, cross ? 'cross' : true, triggerAxis)); - } - if (cross) { - each$4(tooltipAxes.otherAxes, curry$1(saveTooltipAxisInfo, 'cross', false)); - } - } - // fromTooltip: true | false | 'cross' - // triggerTooltip: true | false | null - function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) { - var axisPointerModel = axis.model.getModel('axisPointer', globalAxisPointerModel); - var axisPointerShow = axisPointerModel.get('show'); - if (!axisPointerShow || axisPointerShow === 'auto' && !fromTooltip && !isHandleTrigger(axisPointerModel)) { - return; - } - if (triggerTooltip == null) { - triggerTooltip = axisPointerModel.get('triggerTooltip'); - } - axisPointerModel = fromTooltip ? makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) : axisPointerModel; - var snap = axisPointerModel.get('snap'); - var triggerEmphasis = axisPointerModel.get('triggerEmphasis'); - var axisKey = makeKey(axis.model); - var involveSeries = triggerTooltip || snap || axis.type === 'category'; - // If result.axesInfo[key] exist, override it (tooltip has higher priority). - var axisInfo = result.axesInfo[axisKey] = { - key: axisKey, - axis: axis, - coordSys: coordSys, - axisPointerModel: axisPointerModel, - triggerTooltip: triggerTooltip, - triggerEmphasis: triggerEmphasis, - involveSeries: involveSeries, - snap: snap, - useHandle: isHandleTrigger(axisPointerModel), - seriesModels: [], - linkGroup: null - }; - axesInfoInCoordSys[axisKey] = axisInfo; - result.seriesInvolved = result.seriesInvolved || involveSeries; - var groupIndex = getLinkGroupIndex(linksOption, axis); - if (groupIndex != null) { - var linkGroup = linkGroups[groupIndex] || (linkGroups[groupIndex] = { - axesInfo: {} - }); - linkGroup.axesInfo[axisKey] = axisInfo; - linkGroup.mapper = linksOption[groupIndex].mapper; - axisInfo.linkGroup = linkGroup; - } - } - }); -} -function makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) { - var tooltipAxisPointerModel = baseTooltipModel.getModel('axisPointer'); - var fields = ['type', 'snap', 'lineStyle', 'shadowStyle', 'label', 'animation', 'animationDurationUpdate', 'animationEasingUpdate', 'z']; - var volatileOption = {}; - each$4(fields, function (field) { - volatileOption[field] = clone$2(tooltipAxisPointerModel.get(field)); - }); - // category axis do not auto snap, otherwise some tick that do not - // has value can not be hovered. value/time/log axis default snap if - // triggered from tooltip and trigger tooltip. - volatileOption.snap = axis.type !== 'category' && !!triggerTooltip; - // Compatible with previous behavior, tooltip axis does not show label by default. - // Only these properties can be overridden from tooltip to axisPointer. - if (tooltipAxisPointerModel.get('type') === 'cross') { - volatileOption.type = 'line'; - } - var labelOption = volatileOption.label || (volatileOption.label = {}); - // Follow the convention, do not show label when triggered by tooltip by default. - labelOption.show == null && (labelOption.show = false); - if (fromTooltip === 'cross') { - // When 'cross', both axes show labels. - var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(['label', 'show']); - labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true; - // If triggerTooltip, this is a base axis, which should better not use cross style - // (cross style is dashed by default) - if (!triggerTooltip) { - var crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get('crossStyle'); - crossStyle && defaults(labelOption, crossStyle.textStyle); - } - } - return axis.model.getModel('axisPointer', new Model(volatileOption, globalAxisPointerModel, ecModel)); -} -function collectSeriesInfo(result, ecModel) { - // Prepare data for axis trigger - ecModel.eachSeries(function (seriesModel) { - // Notice this case: this coordSys is `cartesian2D` but not `grid`. - var coordSys = seriesModel.coordinateSystem; - var seriesTooltipTrigger = seriesModel.get(['tooltip', 'trigger'], true); - var seriesTooltipShow = seriesModel.get(['tooltip', 'show'], true); - if (!coordSys || seriesTooltipTrigger === 'none' || seriesTooltipTrigger === false || seriesTooltipTrigger === 'item' || seriesTooltipShow === false || seriesModel.get(['axisPointer', 'show'], true) === false) { - return; - } - each$4(result.coordSysAxesInfo[makeKey(coordSys.model)], function (axisInfo) { - var axis = axisInfo.axis; - if (coordSys.getAxis(axis.dim) === axis) { - axisInfo.seriesModels.push(seriesModel); - axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0); - axisInfo.seriesDataCount += seriesModel.getData().count(); - } - }); - }); -} -/** - * For example: - * { - * axisPointer: { - * links: [{ - * xAxisIndex: [2, 4], - * yAxisIndex: 'all' - * }, { - * xAxisId: ['a5', 'a7'], - * xAxisName: 'xxx' - * }] - * } - * } - */ -function getLinkGroupIndex(linksOption, axis) { - var axisModel = axis.model; - var dim = axis.dim; - for (var i = 0; i < linksOption.length; i++) { - var linkOption = linksOption[i] || {}; - if (checkPropInLink(linkOption[dim + 'AxisId'], axisModel.id) || checkPropInLink(linkOption[dim + 'AxisIndex'], axisModel.componentIndex) || checkPropInLink(linkOption[dim + 'AxisName'], axisModel.name)) { - return i; - } - } -} -function checkPropInLink(linkPropValue, axisPropValue) { - return linkPropValue === 'all' || isArray(linkPropValue) && indexOf(linkPropValue, axisPropValue) >= 0 || linkPropValue === axisPropValue; -} -function fixValue(axisModel) { - var axisInfo = getAxisInfo(axisModel); - if (!axisInfo) { - return; - } - var axisPointerModel = axisInfo.axisPointerModel; - var scale = axisInfo.axis.scale; - var option = axisPointerModel.option; - var status = axisPointerModel.get('status'); - var value = axisPointerModel.get('value'); - // Parse init value for category and time axis. - if (value != null) { - value = scale.parse(value); - } - var useHandle = isHandleTrigger(axisPointerModel); - // If `handle` used, `axisPointer` will always be displayed, so value - // and status should be initialized. - if (status == null) { - option.status = useHandle ? 'show' : 'hide'; - } - var extent = scale.getExtent().slice(); - extent[0] > extent[1] && extent.reverse(); - if ( - // Pick a value on axis when initializing. - value == null - // If both `handle` and `dataZoom` are used, value may be out of axis extent, - // where we should re-pick a value to keep `handle` displaying normally. - || value > extent[1]) { - // Make handle displayed on the end of the axis when init, which looks better. - value = extent[1]; - } - if (value < extent[0]) { - value = extent[0]; - } - option.value = value; - if (useHandle) { - option.status = axisInfo.axis.scale.isBlank() ? 'hide' : 'show'; - } -} -function getAxisInfo(axisModel) { - var coordSysAxesInfo = (axisModel.ecModel.getComponent('axisPointer') || {}).coordSysAxesInfo; - return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)]; -} -function getAxisPointerModel(axisModel) { - var axisInfo = getAxisInfo(axisModel); - return axisInfo && axisInfo.axisPointerModel; -} -function isHandleTrigger(axisPointerModel) { - return !!axisPointerModel.get(['handle', 'show']); -} -/** - * @param {module:echarts/model/Model} model - * @return {string} unique key - */ -function makeKey(model) { - return model.type + '||' + model.id; -} - -var axisPointerClazz = {}; -var AxisView = ( - /** @class */ - function(_super) { - __extends(AxisView2, _super); - function AxisView2() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = AxisView2.type; - return _this; - } - AxisView2.prototype.render = function(axisModel, ecModel, api, payload) { - this.axisPointerClass && fixValue(axisModel); - _super.prototype.render.apply(this, arguments); - this._doUpdateAxisPointerClass(axisModel, api, true); - }; - AxisView2.prototype.updateAxisPointer = function(axisModel, ecModel, api, payload) { - this._doUpdateAxisPointerClass(axisModel, api, false); - }; - AxisView2.prototype.remove = function(ecModel, api) { - var axisPointer = this._axisPointer; - axisPointer && axisPointer.remove(api); - }; - AxisView2.prototype.dispose = function(ecModel, api) { - this._disposeAxisPointer(api); - _super.prototype.dispose.apply(this, arguments); - }; - AxisView2.prototype._doUpdateAxisPointerClass = function(axisModel, api, forceRender) { - var Clazz = AxisView2.getAxisPointerClass(this.axisPointerClass); - if (!Clazz) { - return; - } - var axisPointerModel = getAxisPointerModel(axisModel); - axisPointerModel ? (this._axisPointer || (this._axisPointer = new Clazz())).render(axisModel, axisPointerModel, api, forceRender) : this._disposeAxisPointer(api); - }; - AxisView2.prototype._disposeAxisPointer = function(api) { - this._axisPointer && this._axisPointer.dispose(api); - this._axisPointer = null; - }; - AxisView2.registerAxisPointerClass = function(type, clazz) { - axisPointerClazz[type] = clazz; - }; - AxisView2.getAxisPointerClass = function(type) { - return type && axisPointerClazz[type]; - }; - AxisView2.type = "axis"; - return AxisView2; - }(ComponentView) -); - -var inner$3 = makeInner(); -function rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel) { - var axis = axisModel.axis; - if (axis.scale.isBlank()) { - return; - } - // TODO: TYPE - var splitAreaModel = axisModel.getModel('splitArea'); - var areaStyleModel = splitAreaModel.getModel('areaStyle'); - var areaColors = areaStyleModel.get('color'); - var gridRect = gridModel.coordinateSystem.getRect(); - var ticksCoords = axis.getTicksCoords({ - tickModel: splitAreaModel, - clamp: true - }); - if (!ticksCoords.length) { - return; - } - // For Making appropriate splitArea animation, the color and anid - // should be corresponding to previous one if possible. - var areaColorsLen = areaColors.length; - var lastSplitAreaColors = inner$3(axisView).splitAreaColors; - var newSplitAreaColors = createHashMap(); - var colorIndex = 0; - if (lastSplitAreaColors) { - for (var i = 0; i < ticksCoords.length; i++) { - var cIndex = lastSplitAreaColors.get(ticksCoords[i].tickValue); - if (cIndex != null) { - colorIndex = (cIndex + (areaColorsLen - 1) * i) % areaColorsLen; - break; - } - } - } - var prev = axis.toGlobalCoord(ticksCoords[0].coord); - var areaStyle = areaStyleModel.getAreaStyle(); - areaColors = isArray(areaColors) ? areaColors : [areaColors]; - for (var i = 1; i < ticksCoords.length; i++) { - var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord); - var x = void 0; - var y = void 0; - var width = void 0; - var height = void 0; - if (axis.isHorizontal()) { - x = prev; - y = gridRect.y; - width = tickCoord - x; - height = gridRect.height; - prev = x + width; - } else { - x = gridRect.x; - y = prev; - width = gridRect.width; - height = tickCoord - y; - prev = y + height; - } - var tickValue = ticksCoords[i - 1].tickValue; - tickValue != null && newSplitAreaColors.set(tickValue, colorIndex); - axisGroup.add(new Rect({ - anid: tickValue != null ? 'area_' + tickValue : null, - shape: { - x: x, - y: y, - width: width, - height: height - }, - style: defaults({ - fill: areaColors[colorIndex] - }, areaStyle), - autoBatch: true, - silent: true - })); - colorIndex = (colorIndex + 1) % areaColorsLen; - } - inner$3(axisView).splitAreaColors = newSplitAreaColors; -} -function rectCoordAxisHandleRemove(axisView) { - inner$3(axisView).splitAreaColors = null; -} - -var axisBuilderAttrs = ['axisLine', 'axisTickLabel', 'axisName']; -var selfBuilderAttrs = ['splitArea', 'splitLine', 'minorSplitLine']; -var CartesianAxisView = /** @class */function (_super) { - __extends(CartesianAxisView, _super); - function CartesianAxisView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = CartesianAxisView.type; - _this.axisPointerClass = 'CartesianAxisPointer'; - return _this; - } - /** - * @override - */ - CartesianAxisView.prototype.render = function (axisModel, ecModel, api, payload) { - this.group.removeAll(); - var oldAxisGroup = this._axisGroup; - this._axisGroup = new Group$2(); - this.group.add(this._axisGroup); - if (!axisModel.get('show')) { - return; - } - var gridModel = axisModel.getCoordSysModel(); - var layout$1 = layout(gridModel, axisModel); - var axisBuilder = new AxisBuilder(axisModel, extend({ - handleAutoShown: function (elementType) { - var cartesians = gridModel.coordinateSystem.getCartesians(); - for (var i = 0; i < cartesians.length; i++) { - if (isIntervalOrLogScale(cartesians[i].getOtherAxis(axisModel.axis).scale)) { - // Still show axis tick or axisLine if other axis is value / log - return true; - } - } - // Not show axisTick or axisLine if other axis is category / time - return false; - } - }, layout$1)); - each$4(axisBuilderAttrs, axisBuilder.add, axisBuilder); - this._axisGroup.add(axisBuilder.getGroup()); - each$4(selfBuilderAttrs, function (name) { - if (axisModel.get([name, 'show'])) { - axisElementBuilders[name](this, this._axisGroup, axisModel, gridModel); - } - }, this); - // THIS is a special case for bar racing chart. - // Update the axis label from the natural initial layout to - // sorted layout should has no animation. - var isInitialSortFromBarRacing = payload && payload.type === 'changeAxisOrder' && payload.isInitSort; - if (!isInitialSortFromBarRacing) { - groupTransition(oldAxisGroup, this._axisGroup, axisModel); - } - _super.prototype.render.call(this, axisModel, ecModel, api, payload); - }; - CartesianAxisView.prototype.remove = function () { - rectCoordAxisHandleRemove(this); - }; - CartesianAxisView.type = 'cartesianAxis'; - return CartesianAxisView; -}(AxisView); -var axisElementBuilders = { - splitLine: function (axisView, axisGroup, axisModel, gridModel) { - var axis = axisModel.axis; - if (axis.scale.isBlank()) { - return; - } - var splitLineModel = axisModel.getModel('splitLine'); - var lineStyleModel = splitLineModel.getModel('lineStyle'); - var lineColors = lineStyleModel.get('color'); - var showMinLine = splitLineModel.get('showMinLine') !== false; - var showMaxLine = splitLineModel.get('showMaxLine') !== false; - lineColors = isArray(lineColors) ? lineColors : [lineColors]; - var gridRect = gridModel.coordinateSystem.getRect(); - var isHorizontal = axis.isHorizontal(); - var lineCount = 0; - var ticksCoords = axis.getTicksCoords({ - tickModel: splitLineModel - }); - var p1 = []; - var p2 = []; - var lineStyle = lineStyleModel.getLineStyle(); - for (var i = 0; i < ticksCoords.length; i++) { - var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord); - if (i === 0 && !showMinLine || i === ticksCoords.length - 1 && !showMaxLine) { - continue; - } - var tickValue = ticksCoords[i].tickValue; - if (isHorizontal) { - p1[0] = tickCoord; - p1[1] = gridRect.y; - p2[0] = tickCoord; - p2[1] = gridRect.y + gridRect.height; - } else { - p1[0] = gridRect.x; - p1[1] = tickCoord; - p2[0] = gridRect.x + gridRect.width; - p2[1] = tickCoord; - } - var colorIndex = lineCount++ % lineColors.length; - var line = new Line({ - anid: tickValue != null ? 'line_' + tickValue : null, - autoBatch: true, - shape: { - x1: p1[0], - y1: p1[1], - x2: p2[0], - y2: p2[1] - }, - style: defaults({ - stroke: lineColors[colorIndex] - }, lineStyle), - silent: true - }); - subPixelOptimizeLine(line.shape, lineStyle.lineWidth); - axisGroup.add(line); - } - }, - minorSplitLine: function (axisView, axisGroup, axisModel, gridModel) { - var axis = axisModel.axis; - var minorSplitLineModel = axisModel.getModel('minorSplitLine'); - var lineStyleModel = minorSplitLineModel.getModel('lineStyle'); - var gridRect = gridModel.coordinateSystem.getRect(); - var isHorizontal = axis.isHorizontal(); - var minorTicksCoords = axis.getMinorTicksCoords(); - if (!minorTicksCoords.length) { - return; - } - var p1 = []; - var p2 = []; - var lineStyle = lineStyleModel.getLineStyle(); - for (var i = 0; i < minorTicksCoords.length; i++) { - for (var k = 0; k < minorTicksCoords[i].length; k++) { - var tickCoord = axis.toGlobalCoord(minorTicksCoords[i][k].coord); - if (isHorizontal) { - p1[0] = tickCoord; - p1[1] = gridRect.y; - p2[0] = tickCoord; - p2[1] = gridRect.y + gridRect.height; - } else { - p1[0] = gridRect.x; - p1[1] = tickCoord; - p2[0] = gridRect.x + gridRect.width; - p2[1] = tickCoord; - } - var line = new Line({ - anid: 'minor_line_' + minorTicksCoords[i][k].tickValue, - autoBatch: true, - shape: { - x1: p1[0], - y1: p1[1], - x2: p2[0], - y2: p2[1] - }, - style: lineStyle, - silent: true - }); - subPixelOptimizeLine(line.shape, lineStyle.lineWidth); - axisGroup.add(line); - } - } - }, - splitArea: function (axisView, axisGroup, axisModel, gridModel) { - rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel); - } -}; -var CartesianXAxisView = /** @class */function (_super) { - __extends(CartesianXAxisView, _super); - function CartesianXAxisView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = CartesianXAxisView.type; - return _this; - } - CartesianXAxisView.type = 'xAxis'; - return CartesianXAxisView; -}(CartesianAxisView); -var CartesianYAxisView = /** @class */function (_super) { - __extends(CartesianYAxisView, _super); - function CartesianYAxisView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = CartesianXAxisView.type; - return _this; - } - CartesianYAxisView.type = 'yAxis'; - return CartesianYAxisView; -}(CartesianAxisView); - -// Grid view -var GridView = /** @class */function (_super) { - __extends(GridView, _super); - function GridView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = 'grid'; - return _this; - } - GridView.prototype.render = function (gridModel, ecModel) { - this.group.removeAll(); - if (gridModel.get('show')) { - this.group.add(new Rect({ - shape: gridModel.coordinateSystem.getRect(), - style: defaults({ - fill: gridModel.get('backgroundColor') - }, gridModel.getItemStyle()), - silent: true, - z2: -1 - })); - } - }; - GridView.type = 'grid'; - return GridView; -}(ComponentView); -var extraOption = { - // gridIndex: 0, - // gridId: '', - offset: 0 -}; -function install$7(registers) { - registers.registerComponentView(GridView); - registers.registerComponentModel(GridModel); - registers.registerCoordinateSystem('cartesian2d', Grid); - axisModelCreator(registers, 'x', CartesianAxisModel, extraOption); - axisModelCreator(registers, 'y', CartesianAxisModel, extraOption); - registers.registerComponentView(CartesianXAxisView); - registers.registerComponentView(CartesianYAxisView); - registers.registerPreprocessor(function (option) { - // Only create grid when need - if (option.xAxis && option.yAxis && !option.grid) { - option.grid = {}; - } - }); -} - -var inner$2 = makeInner(); -var clone = clone$2; -var bind = bind$1; -/** - * Base axis pointer class in 2D. - */ -var BaseAxisPointer = /** @class */function () { - function BaseAxisPointer() { - this._dragging = false; - /** - * In px, arbitrary value. Do not set too small, - * no animation is ok for most cases. - */ - this.animationThreshold = 15; - } - /** - * @implement - */ - BaseAxisPointer.prototype.render = function (axisModel, axisPointerModel, api, forceRender) { - var value = axisPointerModel.get('value'); - var status = axisPointerModel.get('status'); - // Bind them to `this`, not in closure, otherwise they will not - // be replaced when user calling setOption in not merge mode. - this._axisModel = axisModel; - this._axisPointerModel = axisPointerModel; - this._api = api; - // Optimize: `render` will be called repeatedly during mouse move. - // So it is power consuming if performing `render` each time, - // especially on mobile device. - if (!forceRender && this._lastValue === value && this._lastStatus === status) { - return; - } - this._lastValue = value; - this._lastStatus = status; - var group = this._group; - var handle = this._handle; - if (!status || status === 'hide') { - // Do not clear here, for animation better. - group && group.hide(); - handle && handle.hide(); - return; - } - group && group.show(); - handle && handle.show(); - // Otherwise status is 'show' - var elOption = {}; - this.makeElOption(elOption, value, axisModel, axisPointerModel, api); - // Enable change axis pointer type. - var graphicKey = elOption.graphicKey; - if (graphicKey !== this._lastGraphicKey) { - this.clear(api); - } - this._lastGraphicKey = graphicKey; - var moveAnimation = this._moveAnimation = this.determineAnimation(axisModel, axisPointerModel); - if (!group) { - group = this._group = new Group$2(); - this.createPointerEl(group, elOption, axisModel, axisPointerModel); - this.createLabelEl(group, elOption, axisModel, axisPointerModel); - api.getZr().add(group); - } else { - var doUpdateProps = curry$1(updateProps, axisPointerModel, moveAnimation); - this.updatePointerEl(group, elOption, doUpdateProps); - this.updateLabelEl(group, elOption, doUpdateProps, axisPointerModel); - } - updateMandatoryProps(group, axisPointerModel, true); - this._renderHandle(value); - }; - /** - * @implement - */ - BaseAxisPointer.prototype.remove = function (api) { - this.clear(api); - }; - /** - * @implement - */ - BaseAxisPointer.prototype.dispose = function (api) { - this.clear(api); - }; - /** - * @protected - */ - BaseAxisPointer.prototype.determineAnimation = function (axisModel, axisPointerModel) { - var animation = axisPointerModel.get('animation'); - var axis = axisModel.axis; - var isCategoryAxis = axis.type === 'category'; - var useSnap = axisPointerModel.get('snap'); - // Value axis without snap always do not snap. - if (!useSnap && !isCategoryAxis) { - return false; - } - if (animation === 'auto' || animation == null) { - var animationThreshold = this.animationThreshold; - if (isCategoryAxis && axis.getBandWidth() > animationThreshold) { - return true; - } - // It is important to auto animation when snap used. Consider if there is - // a dataZoom, animation will be disabled when too many points exist, while - // it will be enabled for better visual effect when little points exist. - if (useSnap) { - var seriesDataCount = getAxisInfo(axisModel).seriesDataCount; - var axisExtent = axis.getExtent(); - // Approximate band width - return Math.abs(axisExtent[0] - axisExtent[1]) / seriesDataCount > animationThreshold; - } - return false; - } - return animation === true; - }; - /** - * add {pointer, label, graphicKey} to elOption - * @protected - */ - BaseAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) { - // Should be implemenented by sub-class. - }; - /** - * @protected - */ - BaseAxisPointer.prototype.createPointerEl = function (group, elOption, axisModel, axisPointerModel) { - var pointerOption = elOption.pointer; - if (pointerOption) { - var pointerEl = inner$2(group).pointerEl = new graphic[pointerOption.type](clone(elOption.pointer)); - group.add(pointerEl); - } - }; - /** - * @protected - */ - BaseAxisPointer.prototype.createLabelEl = function (group, elOption, axisModel, axisPointerModel) { - if (elOption.label) { - var labelEl = inner$2(group).labelEl = new ZRText(clone(elOption.label)); - group.add(labelEl); - updateLabelShowHide(labelEl, axisPointerModel); - } - }; - /** - * @protected - */ - BaseAxisPointer.prototype.updatePointerEl = function (group, elOption, updateProps) { - var pointerEl = inner$2(group).pointerEl; - if (pointerEl && elOption.pointer) { - pointerEl.setStyle(elOption.pointer.style); - updateProps(pointerEl, { - shape: elOption.pointer.shape - }); - } - }; - /** - * @protected - */ - BaseAxisPointer.prototype.updateLabelEl = function (group, elOption, updateProps, axisPointerModel) { - var labelEl = inner$2(group).labelEl; - if (labelEl) { - labelEl.setStyle(elOption.label.style); - updateProps(labelEl, { - // Consider text length change in vertical axis, animation should - // be used on shape, otherwise the effect will be weird. - // TODOTODO - // shape: elOption.label.shape, - x: elOption.label.x, - y: elOption.label.y - }); - updateLabelShowHide(labelEl, axisPointerModel); - } - }; - /** - * @private - */ - BaseAxisPointer.prototype._renderHandle = function (value) { - if (this._dragging || !this.updateHandleTransform) { - return; - } - var axisPointerModel = this._axisPointerModel; - var zr = this._api.getZr(); - var handle = this._handle; - var handleModel = axisPointerModel.getModel('handle'); - var status = axisPointerModel.get('status'); - if (!handleModel.get('show') || !status || status === 'hide') { - handle && zr.remove(handle); - this._handle = null; - return; - } - var isInit; - if (!this._handle) { - isInit = true; - handle = this._handle = createIcon(handleModel.get('icon'), { - cursor: 'move', - draggable: true, - onmousemove: function (e) { - // For mobile device, prevent screen slider on the button. - stop(e.event); - }, - onmousedown: bind(this._onHandleDragMove, this, 0, 0), - drift: bind(this._onHandleDragMove, this), - ondragend: bind(this._onHandleDragEnd, this) - }); - zr.add(handle); - } - updateMandatoryProps(handle, axisPointerModel, false); - // update style - handle.setStyle(handleModel.getItemStyle(null, ['color', 'borderColor', 'borderWidth', 'opacity', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY'])); - // update position - var handleSize = handleModel.get('size'); - if (!isArray(handleSize)) { - handleSize = [handleSize, handleSize]; - } - handle.scaleX = handleSize[0] / 2; - handle.scaleY = handleSize[1] / 2; - createOrUpdate(this, '_doDispatchAxisPointer', handleModel.get('throttle') || 0, 'fixRate'); - this._moveHandleToValue(value, isInit); - }; - BaseAxisPointer.prototype._moveHandleToValue = function (value, isInit) { - updateProps(this._axisPointerModel, !isInit && this._moveAnimation, this._handle, getHandleTransProps(this.getHandleTransform(value, this._axisModel, this._axisPointerModel))); - }; - BaseAxisPointer.prototype._onHandleDragMove = function (dx, dy) { - var handle = this._handle; - if (!handle) { - return; - } - this._dragging = true; - // Persistent for throttle. - var trans = this.updateHandleTransform(getHandleTransProps(handle), [dx, dy], this._axisModel, this._axisPointerModel); - this._payloadInfo = trans; - handle.stopAnimation(); - handle.attr(getHandleTransProps(trans)); - inner$2(handle).lastProp = null; - this._doDispatchAxisPointer(); - }; - /** - * Throttled method. - */ - BaseAxisPointer.prototype._doDispatchAxisPointer = function () { - var handle = this._handle; - if (!handle) { - return; - } - var payloadInfo = this._payloadInfo; - var axisModel = this._axisModel; - this._api.dispatchAction({ - type: 'updateAxisPointer', - x: payloadInfo.cursorPoint[0], - y: payloadInfo.cursorPoint[1], - tooltipOption: payloadInfo.tooltipOption, - axesInfo: [{ - axisDim: axisModel.axis.dim, - axisIndex: axisModel.componentIndex - }] - }); - }; - BaseAxisPointer.prototype._onHandleDragEnd = function () { - this._dragging = false; - var handle = this._handle; - if (!handle) { - return; - } - var value = this._axisPointerModel.get('value'); - // Consider snap or categroy axis, handle may be not consistent with - // axisPointer. So move handle to align the exact value position when - // drag ended. - this._moveHandleToValue(value); - // For the effect: tooltip will be shown when finger holding on handle - // button, and will be hidden after finger left handle button. - this._api.dispatchAction({ - type: 'hideTip' - }); - }; - /** - * @private - */ - BaseAxisPointer.prototype.clear = function (api) { - this._lastValue = null; - this._lastStatus = null; - var zr = api.getZr(); - var group = this._group; - var handle = this._handle; - if (zr && group) { - this._lastGraphicKey = null; - group && zr.remove(group); - handle && zr.remove(handle); - this._group = null; - this._handle = null; - this._payloadInfo = null; - } - clear(this, '_doDispatchAxisPointer'); - }; - /** - * @protected - */ - BaseAxisPointer.prototype.doClear = function () { - // Implemented by sub-class if necessary. - }; - BaseAxisPointer.prototype.buildLabel = function (xy, wh, xDimIndex) { - xDimIndex = xDimIndex || 0; - return { - x: xy[xDimIndex], - y: xy[1 - xDimIndex], - width: wh[xDimIndex], - height: wh[1 - xDimIndex] - }; - }; - return BaseAxisPointer; -}(); -function updateProps(animationModel, moveAnimation, el, props) { - // Animation optimize. - if (!propsEqual(inner$2(el).lastProp, props)) { - inner$2(el).lastProp = props; - moveAnimation ? updateProps$1(el, props, animationModel) : (el.stopAnimation(), el.attr(props)); - } -} -function propsEqual(lastProps, newProps) { - if (isObject$2(lastProps) && isObject$2(newProps)) { - var equals_1 = true; - each$4(newProps, function (item, key) { - equals_1 = equals_1 && propsEqual(lastProps[key], item); - }); - return !!equals_1; - } else { - return lastProps === newProps; - } -} -function updateLabelShowHide(labelEl, axisPointerModel) { - labelEl[axisPointerModel.get(['label', 'show']) ? 'show' : 'hide'](); -} -function getHandleTransProps(trans) { - return { - x: trans.x || 0, - y: trans.y || 0, - rotation: trans.rotation || 0 - }; -} -function updateMandatoryProps(group, axisPointerModel, silent) { - var z = axisPointerModel.get('z'); - var zlevel = axisPointerModel.get('zlevel'); - group && group.traverse(function (el) { - if (el.type !== 'group') { - z != null && (el.z = z); - zlevel != null && (el.zlevel = zlevel); - el.silent = silent; - } - }); -} - -function buildElStyle(axisPointerModel) { - var axisPointerType = axisPointerModel.get('type'); - var styleModel = axisPointerModel.getModel(axisPointerType + 'Style'); - var style; - if (axisPointerType === 'line') { - style = styleModel.getLineStyle(); - style.fill = null; - } else if (axisPointerType === 'shadow') { - style = styleModel.getAreaStyle(); - style.stroke = null; - } - return style; -} -/** - * @param {Function} labelPos {align, verticalAlign, position} - */ -function buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos) { - var value = axisPointerModel.get('value'); - var text = getValueLabel(value, axisModel.axis, axisModel.ecModel, axisPointerModel.get('seriesDataIndices'), { - precision: axisPointerModel.get(['label', 'precision']), - formatter: axisPointerModel.get(['label', 'formatter']) - }); - var labelModel = axisPointerModel.getModel('label'); - var paddings = normalizeCssArray(labelModel.get('padding') || 0); - var font = labelModel.getFont(); - var textRect = getBoundingRect(text, font); - var position = labelPos.position; - var width = textRect.width + paddings[1] + paddings[3]; - var height = textRect.height + paddings[0] + paddings[2]; - // Adjust by align. - var align = labelPos.align; - align === 'right' && (position[0] -= width); - align === 'center' && (position[0] -= width / 2); - var verticalAlign = labelPos.verticalAlign; - verticalAlign === 'bottom' && (position[1] -= height); - verticalAlign === 'middle' && (position[1] -= height / 2); - // Not overflow ec container - confineInContainer(position, width, height, api); - var bgColor = labelModel.get('backgroundColor'); - if (!bgColor || bgColor === 'auto') { - bgColor = axisModel.get(['axisLine', 'lineStyle', 'color']); - } - elOption.label = { - // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')}, - x: position[0], - y: position[1], - style: createTextStyle(labelModel, { - text: text, - font: font, - fill: labelModel.getTextColor(), - padding: paddings, - backgroundColor: bgColor - }), - // Label should be over axisPointer. - z2: 10 - }; -} -// Do not overflow ec container -function confineInContainer(position, width, height, api) { - var viewWidth = api.getWidth(); - var viewHeight = api.getHeight(); - position[0] = Math.min(position[0] + width, viewWidth) - width; - position[1] = Math.min(position[1] + height, viewHeight) - height; - position[0] = Math.max(position[0], 0); - position[1] = Math.max(position[1], 0); -} -function getValueLabel(value, axis, ecModel, seriesDataIndices, opt) { - value = axis.scale.parse(value); - var text = axis.scale.getLabel({ - value: value - }, { - // If `precision` is set, width can be fixed (like '12.00500'), which - // helps to debounce when when moving label. - precision: opt.precision - }); - var formatter = opt.formatter; - if (formatter) { - var params_1 = { - value: getAxisRawValue(axis, { - value: value - }), - axisDimension: axis.dim, - axisIndex: axis.index, - seriesData: [] - }; - each$4(seriesDataIndices, function (idxItem) { - var series = ecModel.getSeriesByIndex(idxItem.seriesIndex); - var dataIndex = idxItem.dataIndexInside; - var dataParams = series && series.getDataParams(dataIndex); - dataParams && params_1.seriesData.push(dataParams); - }); - if (isString(formatter)) { - text = formatter.replace('{value}', text); - } else if (isFunction(formatter)) { - text = formatter(params_1); - } - } - return text; -} -function getTransformedPosition(axis, value, layoutInfo) { - var transform = create(); - rotate(transform, transform, layoutInfo.rotation); - translate(transform, transform, layoutInfo.position); - return applyTransform([axis.dataToCoord(value), (layoutInfo.labelOffset || 0) + (layoutInfo.labelDirection || 1) * (layoutInfo.labelMargin || 0)], transform); -} -function buildCartesianSingleLabelElOption(value, elOption, layoutInfo, axisModel, axisPointerModel, api) { - // @ts-ignore - var textLayout = AxisBuilder.innerTextLayout(layoutInfo.rotation, 0, layoutInfo.labelDirection); - layoutInfo.labelMargin = axisPointerModel.get(['label', 'margin']); - buildLabelElOption(elOption, axisModel, axisPointerModel, api, { - position: getTransformedPosition(axisModel.axis, value, layoutInfo), - align: textLayout.textAlign, - verticalAlign: textLayout.textVerticalAlign - }); -} -function makeLineShape(p1, p2, xDimIndex) { - xDimIndex = xDimIndex || 0; - return { - x1: p1[xDimIndex], - y1: p1[1 - xDimIndex], - x2: p2[xDimIndex], - y2: p2[1 - xDimIndex] - }; -} -function makeRectShape(xy, wh, xDimIndex) { - xDimIndex = xDimIndex || 0; - return { - x: xy[xDimIndex], - y: xy[1 - xDimIndex], - width: wh[xDimIndex], - height: wh[1 - xDimIndex] - }; -} - -var CartesianAxisPointer = /** @class */function (_super) { - __extends(CartesianAxisPointer, _super); - function CartesianAxisPointer() { - return _super !== null && _super.apply(this, arguments) || this; - } - /** - * @override - */ - CartesianAxisPointer.prototype.makeElOption = function (elOption, value, axisModel, axisPointerModel, api) { - var axis = axisModel.axis; - var grid = axis.grid; - var axisPointerType = axisPointerModel.get('type'); - var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent(); - var pixelValue = axis.toGlobalCoord(axis.dataToCoord(value, true)); - if (axisPointerType && axisPointerType !== 'none') { - var elStyle = buildElStyle(axisPointerModel); - var pointerOption = pointerShapeBuilder[axisPointerType](axis, pixelValue, otherExtent); - pointerOption.style = elStyle; - elOption.graphicKey = pointerOption.type; - elOption.pointer = pointerOption; - } - var layoutInfo = layout(grid.model, axisModel); - buildCartesianSingleLabelElOption( - // @ts-ignore - value, elOption, layoutInfo, axisModel, axisPointerModel, api); - }; - /** - * @override - */ - CartesianAxisPointer.prototype.getHandleTransform = function (value, axisModel, axisPointerModel) { - var layoutInfo = layout(axisModel.axis.grid.model, axisModel, { - labelInside: false - }); - // @ts-ignore - layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']); - var pos = getTransformedPosition(axisModel.axis, value, layoutInfo); - return { - x: pos[0], - y: pos[1], - rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0) - }; - }; - /** - * @override - */ - CartesianAxisPointer.prototype.updateHandleTransform = function (transform, delta, axisModel, axisPointerModel) { - var axis = axisModel.axis; - var grid = axis.grid; - var axisExtent = axis.getGlobalExtent(true); - var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent(); - var dimIndex = axis.dim === 'x' ? 0 : 1; - var currPosition = [transform.x, transform.y]; - currPosition[dimIndex] += delta[dimIndex]; - currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]); - currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]); - var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2; - var cursorPoint = [cursorOtherValue, cursorOtherValue]; - cursorPoint[dimIndex] = currPosition[dimIndex]; - // Make tooltip do not overlap axisPointer and in the middle of the grid. - var tooltipOptions = [{ - verticalAlign: 'middle' - }, { - align: 'center' - }]; - return { - x: currPosition[0], - y: currPosition[1], - rotation: transform.rotation, - cursorPoint: cursorPoint, - tooltipOption: tooltipOptions[dimIndex] - }; - }; - return CartesianAxisPointer; -}(BaseAxisPointer); -function getCartesian(grid, axis) { - var opt = {}; - opt[axis.dim + 'AxisIndex'] = axis.index; - return grid.getCartesian(opt); -} -var pointerShapeBuilder = { - line: function (axis, pixelValue, otherExtent) { - var targetShape = makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getAxisDimIndex(axis)); - return { - type: 'Line', - subPixelOptimize: true, - shape: targetShape - }; - }, - shadow: function (axis, pixelValue, otherExtent) { - var bandWidth = Math.max(1, axis.getBandWidth()); - var span = otherExtent[1] - otherExtent[0]; - return { - type: 'Rect', - shape: makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getAxisDimIndex(axis)) - }; - } -}; -function getAxisDimIndex(axis) { - return axis.dim === 'x' ? 0 : 1; -} - -var AxisPointerModel = /** @class */function (_super) { - __extends(AxisPointerModel, _super); - function AxisPointerModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = AxisPointerModel.type; - return _this; - } - AxisPointerModel.type = 'axisPointer'; - AxisPointerModel.defaultOption = { - // 'auto' means that show when triggered by tooltip or handle. - show: 'auto', - // zlevel: 0, - z: 50, - type: 'line', - // axispointer triggered by tootip determine snap automatically, - // see `modelHelper`. - snap: false, - triggerTooltip: true, - triggerEmphasis: true, - value: null, - status: null, - link: [], - // Do not set 'auto' here, otherwise global animation: false - // will not effect at this axispointer. - animation: null, - animationDurationUpdate: 200, - lineStyle: { - color: '#B9BEC9', - width: 1, - type: 'dashed' - }, - shadowStyle: { - color: 'rgba(210,219,238,0.2)' - }, - label: { - show: true, - formatter: null, - precision: 'auto', - margin: 3, - color: '#fff', - padding: [5, 7, 5, 7], - backgroundColor: 'auto', - borderColor: null, - borderWidth: 0, - borderRadius: 3 - }, - handle: { - show: false, - // eslint-disable-next-line - icon: 'M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z', - size: 45, - // handle margin is from symbol center to axis, which is stable when circular move. - margin: 50, - // color: '#1b8bbd' - // color: '#2f4554' - color: '#333', - shadowBlur: 3, - shadowColor: '#aaa', - shadowOffsetX: 0, - shadowOffsetY: 2, - // For mobile performance - throttle: 40 - } - }; - return AxisPointerModel; -}(ComponentModel); - -var inner$1 = makeInner(); -var each$1 = each$4; -/** - * @param {string} key - * @param {module:echarts/ExtensionAPI} api - * @param {Function} handler - * param: {string} currTrigger - * param: {Array.} point - */ -function register(key, api, handler) { - if (env.node) { - return; - } - var zr = api.getZr(); - inner$1(zr).records || (inner$1(zr).records = {}); - initGlobalListeners(zr, api); - var record = inner$1(zr).records[key] || (inner$1(zr).records[key] = {}); - record.handler = handler; -} -function initGlobalListeners(zr, api) { - if (inner$1(zr).initialized) { - return; - } - inner$1(zr).initialized = true; - useHandler('click', curry$1(doEnter, 'click')); - useHandler('mousemove', curry$1(doEnter, 'mousemove')); - // useHandler('mouseout', onLeave); - useHandler('globalout', onLeave); - function useHandler(eventType, cb) { - zr.on(eventType, function (e) { - var dis = makeDispatchAction$1(api); - each$1(inner$1(zr).records, function (record) { - record && cb(record, e, dis.dispatchAction); - }); - dispatchTooltipFinally(dis.pendings, api); - }); - } -} -function dispatchTooltipFinally(pendings, api) { - var showLen = pendings.showTip.length; - var hideLen = pendings.hideTip.length; - var actuallyPayload; - if (showLen) { - actuallyPayload = pendings.showTip[showLen - 1]; - } else if (hideLen) { - actuallyPayload = pendings.hideTip[hideLen - 1]; - } - if (actuallyPayload) { - actuallyPayload.dispatchAction = null; - api.dispatchAction(actuallyPayload); - } -} -function onLeave(record, e, dispatchAction) { - record.handler('leave', null, dispatchAction); -} -function doEnter(currTrigger, record, e, dispatchAction) { - record.handler(currTrigger, e, dispatchAction); -} -function makeDispatchAction$1(api) { - var pendings = { - showTip: [], - hideTip: [] - }; - // FIXME - // better approach? - // 'showTip' and 'hideTip' can be triggered by axisPointer and tooltip, - // which may be conflict, (axisPointer call showTip but tooltip call hideTip); - // So we have to add "final stage" to merge those dispatched actions. - var dispatchAction = function (payload) { - var pendingList = pendings[payload.type]; - if (pendingList) { - pendingList.push(payload); - } else { - payload.dispatchAction = dispatchAction; - api.dispatchAction(payload); - } - }; - return { - dispatchAction: dispatchAction, - pendings: pendings - }; -} -function unregister(key, api) { - if (env.node) { - return; - } - var zr = api.getZr(); - var record = (inner$1(zr).records || {})[key]; - if (record) { - inner$1(zr).records[key] = null; - } -} - -var AxisPointerView = /** @class */function (_super) { - __extends(AxisPointerView, _super); - function AxisPointerView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = AxisPointerView.type; - return _this; - } - AxisPointerView.prototype.render = function (globalAxisPointerModel, ecModel, api) { - var globalTooltipModel = ecModel.getComponent('tooltip'); - var triggerOn = globalAxisPointerModel.get('triggerOn') || globalTooltipModel && globalTooltipModel.get('triggerOn') || 'mousemove|click'; - // Register global listener in AxisPointerView to enable - // AxisPointerView to be independent to Tooltip. - register('axisPointer', api, function (currTrigger, e, dispatchAction) { - // If 'none', it is not controlled by mouse totally. - if (triggerOn !== 'none' && (currTrigger === 'leave' || triggerOn.indexOf(currTrigger) >= 0)) { - dispatchAction({ - type: 'updateAxisPointer', - currTrigger: currTrigger, - x: e && e.offsetX, - y: e && e.offsetY - }); - } - }); - }; - AxisPointerView.prototype.remove = function (ecModel, api) { - unregister('axisPointer', api); - }; - AxisPointerView.prototype.dispose = function (ecModel, api) { - unregister('axisPointer', api); - }; - AxisPointerView.type = 'axisPointer'; - return AxisPointerView; -}(ComponentView); - -/** - * @param finder contains {seriesIndex, dataIndex, dataIndexInside} - * @param ecModel - * @return {point: [x, y], el: ...} point Will not be null. - */ -function findPointFromSeries(finder, ecModel) { - var point = []; - var seriesIndex = finder.seriesIndex; - var seriesModel; - if (seriesIndex == null || !(seriesModel = ecModel.getSeriesByIndex(seriesIndex))) { - return { - point: [] - }; - } - var data = seriesModel.getData(); - var dataIndex = queryDataIndex(data, finder); - if (dataIndex == null || dataIndex < 0 || isArray(dataIndex)) { - return { - point: [] - }; - } - var el = data.getItemGraphicEl(dataIndex); - var coordSys = seriesModel.coordinateSystem; - if (seriesModel.getTooltipPosition) { - point = seriesModel.getTooltipPosition(dataIndex) || []; - } else if (coordSys && coordSys.dataToPoint) { - if (finder.isStacked) { - var baseAxis = coordSys.getBaseAxis(); - var valueAxis = coordSys.getOtherAxis(baseAxis); - var valueAxisDim = valueAxis.dim; - var baseAxisDim = baseAxis.dim; - var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0; - var baseDim = data.mapDimension(baseAxisDim); - var stackedData = []; - stackedData[baseDataOffset] = data.get(baseDim, dataIndex); - stackedData[1 - baseDataOffset] = data.get(data.getCalculationInfo('stackResultDimension'), dataIndex); - point = coordSys.dataToPoint(stackedData) || []; - } else { - point = coordSys.dataToPoint(data.getValues(map$1(coordSys.dimensions, function (dim) { - return data.mapDimension(dim); - }), dataIndex)) || []; - } - } else if (el) { - // Use graphic bounding rect - var rect = el.getBoundingRect().clone(); - rect.applyTransform(el.transform); - point = [rect.x + rect.width / 2, rect.y + rect.height / 2]; - } - return { - point: point, - el: el - }; -} - -var inner = makeInner(); -/** - * Basic logic: check all axis, if they do not demand show/highlight, - * then hide/downplay them. - * - * @return content of event obj for echarts.connect. - */ -function axisTrigger(payload, ecModel, api) { - var currTrigger = payload.currTrigger; - var point = [payload.x, payload.y]; - var finder = payload; - var dispatchAction = payload.dispatchAction || bind$1(api.dispatchAction, api); - var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo; - // Pending - // See #6121. But we are not able to reproduce it yet. - if (!coordSysAxesInfo) { - return; - } - if (illegalPoint(point)) { - // Used in the default behavior of `connection`: use the sample seriesIndex - // and dataIndex. And also used in the tooltipView trigger. - point = findPointFromSeries({ - seriesIndex: finder.seriesIndex, - // Do not use dataIndexInside from other ec instance. - // FIXME: auto detect it? - dataIndex: finder.dataIndex - }, ecModel).point; - } - var isIllegalPoint = illegalPoint(point); - // Axis and value can be specified when calling dispatchAction({type: 'updateAxisPointer'}). - // Notice: In this case, it is difficult to get the `point` (which is necessary to show - // tooltip, so if point is not given, we just use the point found by sample seriesIndex - // and dataIndex. - var inputAxesInfo = finder.axesInfo; - var axesInfo = coordSysAxesInfo.axesInfo; - var shouldHide = currTrigger === 'leave' || illegalPoint(point); - var outputPayload = {}; - var showValueMap = {}; - var dataByCoordSys = { - list: [], - map: {} - }; - var updaters = { - showPointer: curry$1(showPointer, showValueMap), - showTooltip: curry$1(showTooltip, dataByCoordSys) - }; - // Process for triggered axes. - each$4(coordSysAxesInfo.coordSysMap, function (coordSys, coordSysKey) { - // If a point given, it must be contained by the coordinate system. - var coordSysContainsPoint = isIllegalPoint || coordSys.containPoint(point); - each$4(coordSysAxesInfo.coordSysAxesInfo[coordSysKey], function (axisInfo, key) { - var axis = axisInfo.axis; - var inputAxisInfo = findInputAxisInfo(inputAxesInfo, axisInfo); - // If no inputAxesInfo, no axis is restricted. - if (!shouldHide && coordSysContainsPoint && (!inputAxesInfo || inputAxisInfo)) { - var val = inputAxisInfo && inputAxisInfo.value; - if (val == null && !isIllegalPoint) { - val = axis.pointToData(point); - } - val != null && processOnAxis(axisInfo, val, updaters, false, outputPayload); - } - }); - }); - // Process for linked axes. - var linkTriggers = {}; - each$4(axesInfo, function (tarAxisInfo, tarKey) { - var linkGroup = tarAxisInfo.linkGroup; - // If axis has been triggered in the previous stage, it should not be triggered by link. - if (linkGroup && !showValueMap[tarKey]) { - each$4(linkGroup.axesInfo, function (srcAxisInfo, srcKey) { - var srcValItem = showValueMap[srcKey]; - // If srcValItem exist, source axis is triggered, so link to target axis. - if (srcAxisInfo !== tarAxisInfo && srcValItem) { - var val = srcValItem.value; - linkGroup.mapper && (val = tarAxisInfo.axis.scale.parse(linkGroup.mapper(val, makeMapperParam(srcAxisInfo), makeMapperParam(tarAxisInfo)))); - linkTriggers[tarAxisInfo.key] = val; - } - }); - } - }); - each$4(linkTriggers, function (val, tarKey) { - processOnAxis(axesInfo[tarKey], val, updaters, true, outputPayload); - }); - updateModelActually(showValueMap, axesInfo, outputPayload); - dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction); - dispatchHighDownActually(axesInfo, dispatchAction, api); - return outputPayload; -} -function processOnAxis(axisInfo, newValue, updaters, noSnap, outputFinder) { - var axis = axisInfo.axis; - if (axis.scale.isBlank() || !axis.containData(newValue)) { - return; - } - if (!axisInfo.involveSeries) { - updaters.showPointer(axisInfo, newValue); - return; - } - // Heavy calculation. So put it after axis.containData checking. - var payloadInfo = buildPayloadsBySeries(newValue, axisInfo); - var payloadBatch = payloadInfo.payloadBatch; - var snapToValue = payloadInfo.snapToValue; - // Fill content of event obj for echarts.connect. - // By default use the first involved series data as a sample to connect. - if (payloadBatch[0] && outputFinder.seriesIndex == null) { - extend(outputFinder, payloadBatch[0]); - } - // If no linkSource input, this process is for collecting link - // target, where snap should not be accepted. - if (!noSnap && axisInfo.snap) { - if (axis.containData(snapToValue) && snapToValue != null) { - newValue = snapToValue; - } - } - updaters.showPointer(axisInfo, newValue, payloadBatch); - // Tooltip should always be snapToValue, otherwise there will be - // incorrect "axis value ~ series value" mapping displayed in tooltip. - updaters.showTooltip(axisInfo, payloadInfo, snapToValue); -} -function buildPayloadsBySeries(value, axisInfo) { - var axis = axisInfo.axis; - var dim = axis.dim; - var snapToValue = value; - var payloadBatch = []; - var minDist = Number.MAX_VALUE; - var minDiff = -1; - each$4(axisInfo.seriesModels, function (series, idx) { - var dataDim = series.getData().mapDimensionsAll(dim); - var seriesNestestValue; - var dataIndices; - if (series.getAxisTooltipData) { - var result = series.getAxisTooltipData(dataDim, value, axis); - dataIndices = result.dataIndices; - seriesNestestValue = result.nestestValue; - } else { - dataIndices = series.getData().indicesOfNearest(dataDim[0], value, - // Add a threshold to avoid find the wrong dataIndex - // when data length is not same. - // false, - axis.type === 'category' ? 0.5 : null); - if (!dataIndices.length) { - return; - } - seriesNestestValue = series.getData().get(dataDim[0], dataIndices[0]); - } - if (seriesNestestValue == null || !isFinite(seriesNestestValue)) { - return; - } - var diff = value - seriesNestestValue; - var dist = Math.abs(diff); - // Consider category case - if (dist <= minDist) { - if (dist < minDist || diff >= 0 && minDiff < 0) { - minDist = dist; - minDiff = diff; - snapToValue = seriesNestestValue; - payloadBatch.length = 0; - } - each$4(dataIndices, function (dataIndex) { - payloadBatch.push({ - seriesIndex: series.seriesIndex, - dataIndexInside: dataIndex, - dataIndex: series.getData().getRawIndex(dataIndex) - }); - }); - } - }); - return { - payloadBatch: payloadBatch, - snapToValue: snapToValue - }; -} -function showPointer(showValueMap, axisInfo, value, payloadBatch) { - showValueMap[axisInfo.key] = { - value: value, - payloadBatch: payloadBatch - }; -} -function showTooltip(dataByCoordSys, axisInfo, payloadInfo, value) { - var payloadBatch = payloadInfo.payloadBatch; - var axis = axisInfo.axis; - var axisModel = axis.model; - var axisPointerModel = axisInfo.axisPointerModel; - // If no data, do not create anything in dataByCoordSys, - // whose length will be used to judge whether dispatch action. - if (!axisInfo.triggerTooltip || !payloadBatch.length) { - return; - } - var coordSysModel = axisInfo.coordSys.model; - var coordSysKey = makeKey(coordSysModel); - var coordSysItem = dataByCoordSys.map[coordSysKey]; - if (!coordSysItem) { - coordSysItem = dataByCoordSys.map[coordSysKey] = { - coordSysId: coordSysModel.id, - coordSysIndex: coordSysModel.componentIndex, - coordSysType: coordSysModel.type, - coordSysMainType: coordSysModel.mainType, - dataByAxis: [] - }; - dataByCoordSys.list.push(coordSysItem); - } - coordSysItem.dataByAxis.push({ - axisDim: axis.dim, - axisIndex: axisModel.componentIndex, - axisType: axisModel.type, - axisId: axisModel.id, - value: value, - // Caustion: viewHelper.getValueLabel is actually on "view stage", which - // depends that all models have been updated. So it should not be performed - // here. Considering axisPointerModel used here is volatile, which is hard - // to be retrieve in TooltipView, we prepare parameters here. - valueLabelOpt: { - precision: axisPointerModel.get(['label', 'precision']), - formatter: axisPointerModel.get(['label', 'formatter']) - }, - seriesDataIndices: payloadBatch.slice() - }); -} -function updateModelActually(showValueMap, axesInfo, outputPayload) { - var outputAxesInfo = outputPayload.axesInfo = []; - // Basic logic: If no 'show' required, 'hide' this axisPointer. - each$4(axesInfo, function (axisInfo, key) { - var option = axisInfo.axisPointerModel.option; - var valItem = showValueMap[key]; - if (valItem) { - !axisInfo.useHandle && (option.status = 'show'); - option.value = valItem.value; - // For label formatter param and highlight. - option.seriesDataIndices = (valItem.payloadBatch || []).slice(); - } - // When always show (e.g., handle used), remain - // original value and status. - else { - // If hide, value still need to be set, consider - // click legend to toggle axis blank. - !axisInfo.useHandle && (option.status = 'hide'); - } - // If status is 'hide', should be no info in payload. - option.status === 'show' && outputAxesInfo.push({ - axisDim: axisInfo.axis.dim, - axisIndex: axisInfo.axis.model.componentIndex, - value: option.value - }); - }); -} -function dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction) { - // Basic logic: If no showTip required, hideTip will be dispatched. - if (illegalPoint(point) || !dataByCoordSys.list.length) { - dispatchAction({ - type: 'hideTip' - }); - return; - } - // In most case only one axis (or event one series is used). It is - // convenient to fetch payload.seriesIndex and payload.dataIndex - // directly. So put the first seriesIndex and dataIndex of the first - // axis on the payload. - var sampleItem = ((dataByCoordSys.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {}; - dispatchAction({ - type: 'showTip', - escapeConnect: true, - x: point[0], - y: point[1], - tooltipOption: payload.tooltipOption, - position: payload.position, - dataIndexInside: sampleItem.dataIndexInside, - dataIndex: sampleItem.dataIndex, - seriesIndex: sampleItem.seriesIndex, - dataByCoordSys: dataByCoordSys.list - }); -} -function dispatchHighDownActually(axesInfo, dispatchAction, api) { - // FIXME - // highlight status modification should be a stage of main process? - // (Consider confilct (e.g., legend and axisPointer) and setOption) - var zr = api.getZr(); - var highDownKey = 'axisPointerLastHighlights'; - var lastHighlights = inner(zr)[highDownKey] || {}; - var newHighlights = inner(zr)[highDownKey] = {}; - // Update highlight/downplay status according to axisPointer model. - // Build hash map and remove duplicate incidentally. - each$4(axesInfo, function (axisInfo, key) { - var option = axisInfo.axisPointerModel.option; - option.status === 'show' && axisInfo.triggerEmphasis && each$4(option.seriesDataIndices, function (batchItem) { - var key = batchItem.seriesIndex + ' | ' + batchItem.dataIndex; - newHighlights[key] = batchItem; - }); - }); - // Diff. - var toHighlight = []; - var toDownplay = []; - each$4(lastHighlights, function (batchItem, key) { - !newHighlights[key] && toDownplay.push(batchItem); - }); - each$4(newHighlights, function (batchItem, key) { - !lastHighlights[key] && toHighlight.push(batchItem); - }); - toDownplay.length && api.dispatchAction({ - type: 'downplay', - escapeConnect: true, - // Not blur others when highlight in axisPointer. - notBlur: true, - batch: toDownplay - }); - toHighlight.length && api.dispatchAction({ - type: 'highlight', - escapeConnect: true, - // Not blur others when highlight in axisPointer. - notBlur: true, - batch: toHighlight - }); -} -function findInputAxisInfo(inputAxesInfo, axisInfo) { - for (var i = 0; i < (inputAxesInfo || []).length; i++) { - var inputAxisInfo = inputAxesInfo[i]; - if (axisInfo.axis.dim === inputAxisInfo.axisDim && axisInfo.axis.model.componentIndex === inputAxisInfo.axisIndex) { - return inputAxisInfo; - } - } -} -function makeMapperParam(axisInfo) { - var axisModel = axisInfo.axis.model; - var item = {}; - var dim = item.axisDim = axisInfo.axis.dim; - item.axisIndex = item[dim + 'AxisIndex'] = axisModel.componentIndex; - item.axisName = item[dim + 'AxisName'] = axisModel.name; - item.axisId = item[dim + 'AxisId'] = axisModel.id; - return item; -} -function illegalPoint(point) { - return !point || point[0] == null || isNaN(point[0]) || point[1] == null || isNaN(point[1]); -} - -function install$6(registers) { - // CartesianAxisPointer is not supposed to be required here. But consider - // echarts.simple.js and online build tooltip, which only require gridSimple, - // CartesianAxisPointer should be able to required somewhere. - AxisView.registerAxisPointerClass('CartesianAxisPointer', CartesianAxisPointer); - registers.registerComponentModel(AxisPointerModel); - registers.registerComponentView(AxisPointerView); - registers.registerPreprocessor(function (option) { - // Always has a global axisPointerModel for default setting. - if (option) { - (!option.axisPointer || option.axisPointer.length === 0) && (option.axisPointer = {}); - var link = option.axisPointer.link; - // Normalize to array to avoid object mergin. But if link - // is not set, remain null/undefined, otherwise it will - // override existent link setting. - if (link && !isArray(link)) { - option.axisPointer.link = [link]; - } - } - }); - // This process should proformed after coordinate systems created - // and series data processed. So put it on statistic processing stage. - registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, function (ecModel, api) { - // Build axisPointerModel, mergin tooltip.axisPointer model for each axis. - // allAxesInfo should be updated when setOption performed. - ecModel.getComponent('axisPointer').coordSysAxesInfo = collect(ecModel, api); - }); - // Broadcast to all views. - registers.registerAction({ - type: 'updateAxisPointer', - event: 'updateAxisPointer', - update: ':updateAxisPointer' - }, axisTrigger); -} - -function install$5(registers) { - use(install$7); - use(install$6); -} - -function makeBackground(rect, componentModel) { - var padding = normalizeCssArray(componentModel.get('padding')); - var style = componentModel.getItemStyle(['color', 'opacity']); - style.fill = componentModel.get('backgroundColor'); - rect = new Rect({ - shape: { - x: rect.x - padding[3], - y: rect.y - padding[0], - width: rect.width + padding[1] + padding[3], - height: rect.height + padding[0] + padding[2], - r: componentModel.get('borderRadius') - }, - style: style, - silent: true, - z2: -1 - }); - // FIXME - // `subPixelOptimizeRect` may bring some gap between edge of viewpart - // and background rect when setting like `left: 0`, `top: 0`. - // graphic.subPixelOptimizeRect(rect); - return rect; -} - -var TooltipModel = /** @class */function (_super) { - __extends(TooltipModel, _super); - function TooltipModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = TooltipModel.type; - return _this; - } - TooltipModel.type = 'tooltip'; - TooltipModel.dependencies = ['axisPointer']; - TooltipModel.defaultOption = { - // zlevel: 0, - z: 60, - show: true, - // tooltip main content - showContent: true, - // 'trigger' only works on coordinate system. - // 'item' | 'axis' | 'none' - trigger: 'item', - // 'click' | 'mousemove' | 'none' - triggerOn: 'mousemove|click', - alwaysShowContent: false, - displayMode: 'single', - renderMode: 'auto', - // whether restraint content inside viewRect. - // If renderMode: 'richText', default true. - // If renderMode: 'html', defaut false (for backward compat). - confine: null, - showDelay: 0, - hideDelay: 100, - // Animation transition time, unit is second - transitionDuration: 0.4, - enterable: false, - backgroundColor: '#fff', - // box shadow - shadowBlur: 10, - shadowColor: 'rgba(0, 0, 0, .2)', - shadowOffsetX: 1, - shadowOffsetY: 2, - // tooltip border radius, unit is px, default is 4 - borderRadius: 4, - // tooltip border width, unit is px, default is 0 (no border) - borderWidth: 1, - // Tooltip inside padding, default is 5 for all direction - // Array is allowed to set up, right, bottom, left, same with css - // The default value: See `tooltip/tooltipMarkup.ts#getPaddingFromTooltipModel`. - padding: null, - // Extra css text - extraCssText: '', - // axis indicator, trigger by axis - axisPointer: { - // default is line - // legal values: 'line' | 'shadow' | 'cross' - type: 'line', - // Valid when type is line, appoint tooltip line locate on which line. Optional - // legal values: 'x' | 'y' | 'angle' | 'radius' | 'auto' - // default is 'auto', chose the axis which type is category. - // for multiply y axis, cartesian coord chose x axis, polar chose angle axis - axis: 'auto', - animation: 'auto', - animationDurationUpdate: 200, - animationEasingUpdate: 'exponentialOut', - crossStyle: { - color: '#999', - width: 1, - type: 'dashed', - // TODO formatter - textStyle: {} - } - // lineStyle and shadowStyle should not be specified here, - // otherwise it will always override those styles on option.axisPointer. - }, - textStyle: { - color: '#666', - fontSize: 14 - } - }; - return TooltipModel; -}(ComponentModel); - -/* global document */ -function shouldTooltipConfine(tooltipModel) { - var confineOption = tooltipModel.get('confine'); - return confineOption != null ? !!confineOption - // In richText mode, the outside part can not be visible. - : tooltipModel.get('renderMode') === 'richText'; -} -function testStyle(styleProps) { - if (!env.domSupported) { - return; - } - var style = document.documentElement.style; - for (var i = 0, len = styleProps.length; i < len; i++) { - if (styleProps[i] in style) { - return styleProps[i]; - } - } -} -var TRANSFORM_VENDOR = testStyle(['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform']); -var TRANSITION_VENDOR = testStyle(['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']); -function toCSSVendorPrefix(styleVendor, styleProp) { - if (!styleVendor) { - return styleProp; - } - styleProp = toCamelCase(styleProp, true); - var idx = styleVendor.indexOf(styleProp); - styleVendor = idx === -1 ? styleProp : "-" + styleVendor.slice(0, idx) + "-" + styleProp; - return styleVendor.toLowerCase(); -} -function getComputedStyle(el, style) { - var stl = el.currentStyle || document.defaultView && document.defaultView.getComputedStyle(el); - return stl ? stl[style] : null; -} - -/* global document, window */ -var CSS_TRANSITION_VENDOR = toCSSVendorPrefix(TRANSITION_VENDOR, 'transition'); -var CSS_TRANSFORM_VENDOR = toCSSVendorPrefix(TRANSFORM_VENDOR, 'transform'); -// eslint-disable-next-line -var gCssText = "position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;" + (env.transform3dSupported ? 'will-change:transform;' : ''); -function mirrorPos(pos) { - pos = pos === 'left' ? 'right' : pos === 'right' ? 'left' : pos === 'top' ? 'bottom' : 'top'; - return pos; -} -function assembleArrow(tooltipModel, borderColor, arrowPosition) { - if (!isString(arrowPosition) || arrowPosition === 'inside') { - return ''; - } - var backgroundColor = tooltipModel.get('backgroundColor'); - var borderWidth = tooltipModel.get('borderWidth'); - borderColor = convertToColorString(borderColor); - var arrowPos = mirrorPos(arrowPosition); - var arrowSize = Math.max(Math.round(borderWidth) * 1.5, 6); - var positionStyle = ''; - var transformStyle = CSS_TRANSFORM_VENDOR + ':'; - var rotateDeg; - if (indexOf(['left', 'right'], arrowPos) > -1) { - positionStyle += 'top:50%'; - transformStyle += "translateY(-50%) rotate(" + (rotateDeg = arrowPos === 'left' ? -225 : -45) + "deg)"; - } else { - positionStyle += 'left:50%'; - transformStyle += "translateX(-50%) rotate(" + (rotateDeg = arrowPos === 'top' ? 225 : 45) + "deg)"; - } - var rotateRadian = rotateDeg * Math.PI / 180; - var arrowWH = arrowSize + borderWidth; - var rotatedWH = arrowWH * Math.abs(Math.cos(rotateRadian)) + arrowWH * Math.abs(Math.sin(rotateRadian)); - var arrowOffset = Math.round(((rotatedWH - Math.SQRT2 * borderWidth) / 2 + Math.SQRT2 * borderWidth - (rotatedWH - arrowWH) / 2) * 100) / 100; - positionStyle += ";" + arrowPos + ":-" + arrowOffset + "px"; - var borderStyle = borderColor + " solid " + borderWidth + "px;"; - var styleCss = ["position:absolute;width:" + arrowSize + "px;height:" + arrowSize + "px;z-index:-1;", positionStyle + ";" + transformStyle + ";", "border-bottom:" + borderStyle, "border-right:" + borderStyle, "background-color:" + backgroundColor + ";"]; - return "
"; -} -function assembleTransition(duration, onlyFade) { - var transitionCurve = 'cubic-bezier(0.23,1,0.32,1)'; - var transitionOption = " " + duration / 2 + "s " + transitionCurve; - var transitionText = "opacity" + transitionOption + ",visibility" + transitionOption; - if (!onlyFade) { - transitionOption = " " + duration + "s " + transitionCurve; - transitionText += env.transformSupported ? "," + CSS_TRANSFORM_VENDOR + transitionOption : ",left" + transitionOption + ",top" + transitionOption; - } - return CSS_TRANSITION_VENDOR + ':' + transitionText; -} -function assembleTransform(x, y, toString) { - // If using float on style, the final width of the dom might - // keep changing slightly while mouse move. So `toFixed(0)` them. - var x0 = x.toFixed(0) + 'px'; - var y0 = y.toFixed(0) + 'px'; - // not support transform, use `left` and `top` instead. - if (!env.transformSupported) { - return toString ? "top:" + y0 + ";left:" + x0 + ";" : [['top', y0], ['left', x0]]; - } - // support transform - var is3d = env.transform3dSupported; - var translate = "translate" + (is3d ? '3d' : '') + "(" + x0 + "," + y0 + (is3d ? ',0' : '') + ")"; - return toString ? 'top:0;left:0;' + CSS_TRANSFORM_VENDOR + ':' + translate + ';' : [['top', 0], ['left', 0], [TRANSFORM_VENDOR, translate]]; -} -/** - * @param {Object} textStyle - * @return {string} - * @inner - */ -function assembleFont(textStyleModel) { - var cssText = []; - var fontSize = textStyleModel.get('fontSize'); - var color = textStyleModel.getTextColor(); - color && cssText.push('color:' + color); - cssText.push('font:' + textStyleModel.getFont()); - // @ts-ignore, leave it to the tooltip refactor. - var lineHeight = retrieve2(textStyleModel.get('lineHeight'), Math.round(fontSize * 3 / 2)); - fontSize && cssText.push('line-height:' + lineHeight + 'px'); - var shadowColor = textStyleModel.get('textShadowColor'); - var shadowBlur = textStyleModel.get('textShadowBlur') || 0; - var shadowOffsetX = textStyleModel.get('textShadowOffsetX') || 0; - var shadowOffsetY = textStyleModel.get('textShadowOffsetY') || 0; - shadowColor && shadowBlur && cssText.push('text-shadow:' + shadowOffsetX + 'px ' + shadowOffsetY + 'px ' + shadowBlur + 'px ' + shadowColor); - each$4(['decoration', 'align'], function (name) { - var val = textStyleModel.get(name); - val && cssText.push('text-' + name + ':' + val); - }); - return cssText.join(';'); -} -function assembleCssText(tooltipModel, enableTransition, onlyFade) { - var cssText = []; - var transitionDuration = tooltipModel.get('transitionDuration'); - var backgroundColor = tooltipModel.get('backgroundColor'); - var shadowBlur = tooltipModel.get('shadowBlur'); - var shadowColor = tooltipModel.get('shadowColor'); - var shadowOffsetX = tooltipModel.get('shadowOffsetX'); - var shadowOffsetY = tooltipModel.get('shadowOffsetY'); - var textStyleModel = tooltipModel.getModel('textStyle'); - var padding = getPaddingFromTooltipModel(tooltipModel, 'html'); - var boxShadow = shadowOffsetX + "px " + shadowOffsetY + "px " + shadowBlur + "px " + shadowColor; - cssText.push('box-shadow:' + boxShadow); - // Animation transition. Do not animate when transitionDuration is 0. - enableTransition && transitionDuration && cssText.push(assembleTransition(transitionDuration, onlyFade)); - if (backgroundColor) { - cssText.push('background-color:' + backgroundColor); - } - // Border style - each$4(['width', 'color', 'radius'], function (name) { - var borderName = 'border-' + name; - var camelCase = toCamelCase(borderName); - var val = tooltipModel.get(camelCase); - val != null && cssText.push(borderName + ':' + val + (name === 'color' ? '' : 'px')); - }); - // Text style - cssText.push(assembleFont(textStyleModel)); - // Padding - if (padding != null) { - cssText.push('padding:' + normalizeCssArray(padding).join('px ') + 'px'); - } - return cssText.join(';') + ';'; -} -// If not able to make, do not modify the input `out`. -function makeStyleCoord$1(out, zr, container, zrX, zrY) { - var zrPainter = zr && zr.painter; - if (container) { - var zrViewportRoot = zrPainter && zrPainter.getViewportRoot(); - if (zrViewportRoot) { - // Some APPs might use scale on body, so we support CSS transform here. - transformLocalCoord(out, zrViewportRoot, container, zrX, zrY); - } - } else { - out[0] = zrX; - out[1] = zrY; - // xy should be based on canvas root. But tooltipContent is - // the sibling of canvas root. So padding of ec container - // should be considered here. - var viewportRootOffset = zrPainter && zrPainter.getViewportRootOffset(); - if (viewportRootOffset) { - out[0] += viewportRootOffset.offsetLeft; - out[1] += viewportRootOffset.offsetTop; - } - } - out[2] = out[0] / zr.getWidth(); - out[3] = out[1] / zr.getHeight(); -} -var TooltipHTMLContent = /** @class */function () { - function TooltipHTMLContent(api, opt) { - this._show = false; - this._styleCoord = [0, 0, 0, 0]; - this._enterable = true; - this._alwaysShowContent = false; - this._firstShow = true; - this._longHide = true; - if (env.wxa) { - return null; - } - var el = document.createElement('div'); - // TODO: TYPE - el.domBelongToZr = true; - this.el = el; - var zr = this._zr = api.getZr(); - var appendTo = opt.appendTo; - var container = appendTo && (isString(appendTo) ? document.querySelector(appendTo) : isDom(appendTo) ? appendTo : isFunction(appendTo) && appendTo(api.getDom())); - makeStyleCoord$1(this._styleCoord, zr, container, api.getWidth() / 2, api.getHeight() / 2); - (container || api.getDom()).appendChild(el); - this._api = api; - this._container = container; - // FIXME - // Is it needed to trigger zr event manually if - // the browser do not support `pointer-events: none`. - var self = this; - el.onmouseenter = function () { - // clear the timeout in hideLater and keep showing tooltip - if (self._enterable) { - clearTimeout(self._hideTimeout); - self._show = true; - } - self._inContent = true; - }; - el.onmousemove = function (e) { - e = e || window.event; - if (!self._enterable) { - // `pointer-events: none` is set to tooltip content div - // if `enterable` is set as `false`, and `el.onmousemove` - // can not be triggered. But in browser that do not - // support `pointer-events`, we need to do this: - // Try trigger zrender event to avoid mouse - // in and out shape too frequently - var handler = zr.handler; - var zrViewportRoot = zr.painter.getViewportRoot(); - normalizeEvent(zrViewportRoot, e, true); - handler.dispatch('mousemove', e); - } - }; - el.onmouseleave = function () { - // set `_inContent` to `false` before `hideLater` - self._inContent = false; - if (self._enterable) { - if (self._show) { - self.hideLater(self._hideDelay); - } - } - }; - } - /** - * Update when tooltip is rendered - */ - TooltipHTMLContent.prototype.update = function (tooltipModel) { - // FIXME - // Move this logic to ec main? - if (!this._container) { - var container = this._api.getDom(); - var position = getComputedStyle(container, 'position'); - var domStyle = container.style; - if (domStyle.position !== 'absolute' && position !== 'absolute') { - domStyle.position = 'relative'; - } - } - // move tooltip if chart resized - var alwaysShowContent = tooltipModel.get('alwaysShowContent'); - alwaysShowContent && this._moveIfResized(); - // update alwaysShowContent - this._alwaysShowContent = alwaysShowContent; - // update className - this.el.className = tooltipModel.get('className') || ''; - // Hide the tooltip - // PENDING - // this.hide(); - }; - TooltipHTMLContent.prototype.show = function (tooltipModel, nearPointColor) { - clearTimeout(this._hideTimeout); - clearTimeout(this._longHideTimeout); - var el = this.el; - var style = el.style; - var styleCoord = this._styleCoord; - if (!el.innerHTML) { - style.display = 'none'; - } else { - style.cssText = gCssText + assembleCssText(tooltipModel, !this._firstShow, this._longHide) - // initial transform - + assembleTransform(styleCoord[0], styleCoord[1], true) + ("border-color:" + convertToColorString(nearPointColor) + ";") + (tooltipModel.get('extraCssText') || '') - // If mouse occasionally move over the tooltip, a mouseout event will be - // triggered by canvas, and cause some unexpectable result like dragging - // stop, "unfocusAdjacency". Here `pointer-events: none` is used to solve - // it. Although it is not supported by IE8~IE10, fortunately it is a rare - // scenario. - + (";pointer-events:" + (this._enterable ? 'auto' : 'none')); - } - this._show = true; - this._firstShow = false; - this._longHide = false; - }; - TooltipHTMLContent.prototype.setContent = function (content, markers, tooltipModel, borderColor, arrowPosition) { - var el = this.el; - if (content == null) { - el.innerHTML = ''; - return; - } - var arrow = ''; - if (isString(arrowPosition) && tooltipModel.get('trigger') === 'item' && !shouldTooltipConfine(tooltipModel)) { - arrow = assembleArrow(tooltipModel, borderColor, arrowPosition); - } - if (isString(content)) { - el.innerHTML = content + arrow; - } else if (content) { - // Clear previous - el.innerHTML = ''; - if (!isArray(content)) { - content = [content]; - } - for (var i = 0; i < content.length; i++) { - if (isDom(content[i]) && content[i].parentNode !== el) { - el.appendChild(content[i]); - } - } - // no arrow if empty - if (arrow && el.childNodes.length) { - // no need to create a new parent element, but it's not supported by IE 10 and older. - // const arrowEl = document.createRange().createContextualFragment(arrow); - var arrowEl = document.createElement('div'); - arrowEl.innerHTML = arrow; - el.appendChild(arrowEl); - } - } - }; - TooltipHTMLContent.prototype.setEnterable = function (enterable) { - this._enterable = enterable; - }; - TooltipHTMLContent.prototype.getSize = function () { - var el = this.el; - return el ? [el.offsetWidth, el.offsetHeight] : [0, 0]; - }; - TooltipHTMLContent.prototype.moveTo = function (zrX, zrY) { - if (!this.el) { - return; - } - var styleCoord = this._styleCoord; - makeStyleCoord$1(styleCoord, this._zr, this._container, zrX, zrY); - if (styleCoord[0] != null && styleCoord[1] != null) { - var style_1 = this.el.style; - var transforms = assembleTransform(styleCoord[0], styleCoord[1]); - each$4(transforms, function (transform) { - style_1[transform[0]] = transform[1]; - }); - } - }; - /** - * when `alwaysShowContent` is true, - * move the tooltip after chart resized - */ - TooltipHTMLContent.prototype._moveIfResized = function () { - // The ratio of left to width - var ratioX = this._styleCoord[2]; - // The ratio of top to height - var ratioY = this._styleCoord[3]; - this.moveTo(ratioX * this._zr.getWidth(), ratioY * this._zr.getHeight()); - }; - TooltipHTMLContent.prototype.hide = function () { - var _this = this; - var style = this.el.style; - style.visibility = 'hidden'; - style.opacity = '0'; - env.transform3dSupported && (style.willChange = ''); - this._show = false; - this._longHideTimeout = setTimeout(function () { - return _this._longHide = true; - }, 500); - }; - TooltipHTMLContent.prototype.hideLater = function (time) { - if (this._show && !(this._inContent && this._enterable) && !this._alwaysShowContent) { - if (time) { - this._hideDelay = time; - // Set show false to avoid invoke hideLater multiple times - this._show = false; - this._hideTimeout = setTimeout(bind$1(this.hide, this), time); - } else { - this.hide(); - } - } - }; - TooltipHTMLContent.prototype.isShow = function () { - return this._show; - }; - TooltipHTMLContent.prototype.dispose = function () { - clearTimeout(this._hideTimeout); - clearTimeout(this._longHideTimeout); - var parentNode = this.el.parentNode; - parentNode && parentNode.removeChild(this.el); - this.el = this._container = null; - }; - return TooltipHTMLContent; -}(); - -var TooltipRichContent = ( - /** @class */ - function() { - function TooltipRichContent2(api) { - this._show = false; - this._styleCoord = [0, 0, 0, 0]; - this._alwaysShowContent = false; - this._enterable = true; - this._zr = api.getZr(); - makeStyleCoord(this._styleCoord, this._zr, api.getWidth() / 2, api.getHeight() / 2); - } - TooltipRichContent2.prototype.update = function(tooltipModel) { - var alwaysShowContent = tooltipModel.get("alwaysShowContent"); - alwaysShowContent && this._moveIfResized(); - this._alwaysShowContent = alwaysShowContent; - }; - TooltipRichContent2.prototype.show = function() { - if (this._hideTimeout) { - clearTimeout(this._hideTimeout); - } - this.el.show(); - this._show = true; - }; - TooltipRichContent2.prototype.setContent = function(content, markupStyleCreator, tooltipModel, borderColor, arrowPosition) { - var _this = this; - if (isObject$2(content)) { - throwError(""); - } - if (this.el) { - this._zr.remove(this.el); - } - var textStyleModel = tooltipModel.getModel("textStyle"); - this.el = new ZRText({ - style: { - rich: markupStyleCreator.richTextStyles, - text: content, - lineHeight: 22, - borderWidth: 1, - borderColor, - textShadowColor: textStyleModel.get("textShadowColor"), - fill: tooltipModel.get(["textStyle", "color"]), - padding: getPaddingFromTooltipModel(tooltipModel, "richText"), - verticalAlign: "top", - align: "left" - }, - z: tooltipModel.get("z") - }); - each$4(["backgroundColor", "borderRadius", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"], function(propName) { - _this.el.style[propName] = tooltipModel.get(propName); - }); - each$4(["textShadowBlur", "textShadowOffsetX", "textShadowOffsetY"], function(propName) { - _this.el.style[propName] = textStyleModel.get(propName) || 0; - }); - this._zr.add(this.el); - var self = this; - this.el.on("mouseover", function() { - if (self._enterable) { - clearTimeout(self._hideTimeout); - self._show = true; - } - self._inContent = true; - }); - this.el.on("mouseout", function() { - if (self._enterable) { - if (self._show) { - self.hideLater(self._hideDelay); - } - } - self._inContent = false; - }); - }; - TooltipRichContent2.prototype.setEnterable = function(enterable) { - this._enterable = enterable; - }; - TooltipRichContent2.prototype.getSize = function() { - var el = this.el; - var bounding = this.el.getBoundingRect(); - var shadowOuterSize = calcShadowOuterSize(el.style); - return [bounding.width + shadowOuterSize.left + shadowOuterSize.right, bounding.height + shadowOuterSize.top + shadowOuterSize.bottom]; - }; - TooltipRichContent2.prototype.moveTo = function(x, y) { - var el = this.el; - if (el) { - var styleCoord = this._styleCoord; - makeStyleCoord(styleCoord, this._zr, x, y); - x = styleCoord[0]; - y = styleCoord[1]; - var style = el.style; - var borderWidth = mathMaxWith0(style.borderWidth || 0); - var shadowOuterSize = calcShadowOuterSize(style); - el.x = x + borderWidth + shadowOuterSize.left; - el.y = y + borderWidth + shadowOuterSize.top; - el.markRedraw(); - } - }; - TooltipRichContent2.prototype._moveIfResized = function() { - var ratioX = this._styleCoord[2]; - var ratioY = this._styleCoord[3]; - this.moveTo(ratioX * this._zr.getWidth(), ratioY * this._zr.getHeight()); - }; - TooltipRichContent2.prototype.hide = function() { - if (this.el) { - this.el.hide(); - } - this._show = false; - }; - TooltipRichContent2.prototype.hideLater = function(time) { - if (this._show && !(this._inContent && this._enterable) && !this._alwaysShowContent) { - if (time) { - this._hideDelay = time; - this._show = false; - this._hideTimeout = setTimeout(bind$1(this.hide, this), time); - } else { - this.hide(); - } - } - }; - TooltipRichContent2.prototype.isShow = function() { - return this._show; - }; - TooltipRichContent2.prototype.dispose = function() { - this._zr.remove(this.el); - }; - return TooltipRichContent2; - }() -); -function mathMaxWith0(val) { - return Math.max(0, val); -} -function calcShadowOuterSize(style) { - var shadowBlur = mathMaxWith0(style.shadowBlur || 0); - var shadowOffsetX = mathMaxWith0(style.shadowOffsetX || 0); - var shadowOffsetY = mathMaxWith0(style.shadowOffsetY || 0); - return { - left: mathMaxWith0(shadowBlur - shadowOffsetX), - right: mathMaxWith0(shadowBlur + shadowOffsetX), - top: mathMaxWith0(shadowBlur - shadowOffsetY), - bottom: mathMaxWith0(shadowBlur + shadowOffsetY) - }; -} -function makeStyleCoord(out, zr, zrX, zrY) { - out[0] = zrX; - out[1] = zrY; - out[2] = out[0] / zr.getWidth(); - out[3] = out[1] / zr.getHeight(); -} - -var proxyRect = new Rect({ - shape: { - x: -1, - y: -1, - width: 2, - height: 2 - } -}); -var TooltipView = /** @class */function (_super) { - __extends(TooltipView, _super); - function TooltipView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = TooltipView.type; - return _this; - } - TooltipView.prototype.init = function (ecModel, api) { - if (env.node || !api.getDom()) { - return; - } - var tooltipModel = ecModel.getComponent('tooltip'); - var renderMode = this._renderMode = getTooltipRenderMode(tooltipModel.get('renderMode')); - this._tooltipContent = renderMode === 'richText' ? new TooltipRichContent(api) : new TooltipHTMLContent(api, { - appendTo: tooltipModel.get('appendToBody', true) ? 'body' : tooltipModel.get('appendTo', true) - }); - }; - TooltipView.prototype.render = function (tooltipModel, ecModel, api) { - if (env.node || !api.getDom()) { - return; - } - // Reset - this.group.removeAll(); - this._tooltipModel = tooltipModel; - this._ecModel = ecModel; - this._api = api; - var tooltipContent = this._tooltipContent; - tooltipContent.update(tooltipModel); - tooltipContent.setEnterable(tooltipModel.get('enterable')); - this._initGlobalListener(); - this._keepShow(); - // PENDING - // `mousemove` event will be triggered very frequently when the mouse moves fast, - // which causes that the `updatePosition` function was also called frequently. - // In Chrome with devtools open and Firefox, tooltip looks laggy and shakes. See #14695 #16101 - // To avoid frequent triggering, - // consider throttling it in 50ms when transition is enabled - if (this._renderMode !== 'richText' && tooltipModel.get('transitionDuration')) { - createOrUpdate(this, '_updatePosition', 50, 'fixRate'); - } else { - clear(this, '_updatePosition'); - } - }; - TooltipView.prototype._initGlobalListener = function () { - var tooltipModel = this._tooltipModel; - var triggerOn = tooltipModel.get('triggerOn'); - register('itemTooltip', this._api, bind$1(function (currTrigger, e, dispatchAction) { - // If 'none', it is not controlled by mouse totally. - if (triggerOn !== 'none') { - if (triggerOn.indexOf(currTrigger) >= 0) { - this._tryShow(e, dispatchAction); - } else if (currTrigger === 'leave') { - this._hide(dispatchAction); - } - } - }, this)); - }; - TooltipView.prototype._keepShow = function () { - var tooltipModel = this._tooltipModel; - var ecModel = this._ecModel; - var api = this._api; - var triggerOn = tooltipModel.get('triggerOn'); - // Try to keep the tooltip show when refreshing - if (this._lastX != null && this._lastY != null - // When user is willing to control tooltip totally using API, - // self.manuallyShowTip({x, y}) might cause tooltip hide, - // which is not expected. - && triggerOn !== 'none' && triggerOn !== 'click') { - var self_1 = this; - clearTimeout(this._refreshUpdateTimeout); - this._refreshUpdateTimeout = setTimeout(function () { - // Show tip next tick after other charts are rendered - // In case highlight action has wrong result - // FIXME - !api.isDisposed() && self_1.manuallyShowTip(tooltipModel, ecModel, api, { - x: self_1._lastX, - y: self_1._lastY, - dataByCoordSys: self_1._lastDataByCoordSys - }); - }); - } - }; - /** - * Show tip manually by - * dispatchAction({ - * type: 'showTip', - * x: 10, - * y: 10 - * }); - * Or - * dispatchAction({ - * type: 'showTip', - * seriesIndex: 0, - * dataIndex or dataIndexInside or name - * }); - * - * TODO Batch - */ - TooltipView.prototype.manuallyShowTip = function (tooltipModel, ecModel, api, payload) { - if (payload.from === this.uid || env.node || !api.getDom()) { - return; - } - var dispatchAction = makeDispatchAction(payload, api); - // Reset ticket - this._ticket = ''; - // When triggered from axisPointer. - var dataByCoordSys = payload.dataByCoordSys; - var cmptRef = findComponentReference(payload, ecModel, api); - if (cmptRef) { - var rect = cmptRef.el.getBoundingRect().clone(); - rect.applyTransform(cmptRef.el.transform); - this._tryShow({ - offsetX: rect.x + rect.width / 2, - offsetY: rect.y + rect.height / 2, - target: cmptRef.el, - position: payload.position, - // When manully trigger, the mouse is not on the el, so we'd better to - // position tooltip on the bottom of the el and display arrow is possible. - positionDefault: 'bottom' - }, dispatchAction); - } else if (payload.tooltip && payload.x != null && payload.y != null) { - var el = proxyRect; - el.x = payload.x; - el.y = payload.y; - el.update(); - getECData(el).tooltipConfig = { - name: null, - option: payload.tooltip - }; - // Manually show tooltip while view is not using zrender elements. - this._tryShow({ - offsetX: payload.x, - offsetY: payload.y, - target: el - }, dispatchAction); - } else if (dataByCoordSys) { - this._tryShow({ - offsetX: payload.x, - offsetY: payload.y, - position: payload.position, - dataByCoordSys: dataByCoordSys, - tooltipOption: payload.tooltipOption - }, dispatchAction); - } else if (payload.seriesIndex != null) { - if (this._manuallyAxisShowTip(tooltipModel, ecModel, api, payload)) { - return; - } - var pointInfo = findPointFromSeries(payload, ecModel); - var cx = pointInfo.point[0]; - var cy = pointInfo.point[1]; - if (cx != null && cy != null) { - this._tryShow({ - offsetX: cx, - offsetY: cy, - target: pointInfo.el, - position: payload.position, - // When manully trigger, the mouse is not on the el, so we'd better to - // position tooltip on the bottom of the el and display arrow is possible. - positionDefault: 'bottom' - }, dispatchAction); - } - } else if (payload.x != null && payload.y != null) { - // FIXME - // should wrap dispatchAction like `axisPointer/globalListener` ? - api.dispatchAction({ - type: 'updateAxisPointer', - x: payload.x, - y: payload.y - }); - this._tryShow({ - offsetX: payload.x, - offsetY: payload.y, - position: payload.position, - target: api.getZr().findHover(payload.x, payload.y).target - }, dispatchAction); - } - }; - TooltipView.prototype.manuallyHideTip = function (tooltipModel, ecModel, api, payload) { - var tooltipContent = this._tooltipContent; - if (this._tooltipModel) { - tooltipContent.hideLater(this._tooltipModel.get('hideDelay')); - } - this._lastX = this._lastY = this._lastDataByCoordSys = null; - if (payload.from !== this.uid) { - this._hide(makeDispatchAction(payload, api)); - } - }; - // Be compatible with previous design, that is, when tooltip.type is 'axis' and - // dispatchAction 'showTip' with seriesIndex and dataIndex will trigger axis pointer - // and tooltip. - TooltipView.prototype._manuallyAxisShowTip = function (tooltipModel, ecModel, api, payload) { - var seriesIndex = payload.seriesIndex; - var dataIndex = payload.dataIndex; - // @ts-ignore - var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo; - if (seriesIndex == null || dataIndex == null || coordSysAxesInfo == null) { - return; - } - var seriesModel = ecModel.getSeriesByIndex(seriesIndex); - if (!seriesModel) { - return; - } - var data = seriesModel.getData(); - var tooltipCascadedModel = buildTooltipModel([data.getItemModel(dataIndex), seriesModel, (seriesModel.coordinateSystem || {}).model], this._tooltipModel); - if (tooltipCascadedModel.get('trigger') !== 'axis') { - return; - } - api.dispatchAction({ - type: 'updateAxisPointer', - seriesIndex: seriesIndex, - dataIndex: dataIndex, - position: payload.position - }); - return true; - }; - TooltipView.prototype._tryShow = function (e, dispatchAction) { - var el = e.target; - var tooltipModel = this._tooltipModel; - if (!tooltipModel) { - return; - } - // Save mouse x, mouse y. So we can try to keep showing the tip if chart is refreshed - this._lastX = e.offsetX; - this._lastY = e.offsetY; - var dataByCoordSys = e.dataByCoordSys; - if (dataByCoordSys && dataByCoordSys.length) { - this._showAxisTooltip(dataByCoordSys, e); - } else if (el) { - var ecData = getECData(el); - if (ecData.ssrType === 'legend') { - // Don't trigger tooltip for legend tooltip item - return; - } - this._lastDataByCoordSys = null; - var seriesDispatcher_1; - var cmptDispatcher_1; - findEventDispatcher(el, function (target) { - // Always show item tooltip if mouse is on the element with dataIndex - if (getECData(target).dataIndex != null) { - seriesDispatcher_1 = target; - return true; - } - // Tooltip provided directly. Like legend. - if (getECData(target).tooltipConfig != null) { - cmptDispatcher_1 = target; - return true; - } - }, true); - if (seriesDispatcher_1) { - this._showSeriesItemTooltip(e, seriesDispatcher_1, dispatchAction); - } else if (cmptDispatcher_1) { - this._showComponentItemTooltip(e, cmptDispatcher_1, dispatchAction); - } else { - this._hide(dispatchAction); - } - } else { - this._lastDataByCoordSys = null; - this._hide(dispatchAction); - } - }; - TooltipView.prototype._showOrMove = function (tooltipModel, cb) { - // showDelay is used in this case: tooltip.enterable is set - // as true. User intent to move mouse into tooltip and click - // something. `showDelay` makes it easier to enter the content - // but tooltip do not move immediately. - var delay = tooltipModel.get('showDelay'); - cb = bind$1(cb, this); - clearTimeout(this._showTimout); - delay > 0 ? this._showTimout = setTimeout(cb, delay) : cb(); - }; - TooltipView.prototype._showAxisTooltip = function (dataByCoordSys, e) { - var ecModel = this._ecModel; - var globalTooltipModel = this._tooltipModel; - var point = [e.offsetX, e.offsetY]; - var singleTooltipModel = buildTooltipModel([e.tooltipOption], globalTooltipModel); - var renderMode = this._renderMode; - var cbParamsList = []; - var articleMarkup = createTooltipMarkup('section', { - blocks: [], - noHeader: true - }); - // Only for legacy: `Serise['formatTooltip']` returns a string. - var markupTextArrLegacy = []; - var markupStyleCreator = new TooltipMarkupStyleCreator(); - each$4(dataByCoordSys, function (itemCoordSys) { - each$4(itemCoordSys.dataByAxis, function (axisItem) { - var axisModel = ecModel.getComponent(axisItem.axisDim + 'Axis', axisItem.axisIndex); - var axisValue = axisItem.value; - if (!axisModel || axisValue == null) { - return; - } - var axisValueLabel = getValueLabel(axisValue, axisModel.axis, ecModel, axisItem.seriesDataIndices, axisItem.valueLabelOpt); - var axisSectionMarkup = createTooltipMarkup('section', { - header: axisValueLabel, - noHeader: !trim(axisValueLabel), - sortBlocks: true, - blocks: [] - }); - articleMarkup.blocks.push(axisSectionMarkup); - each$4(axisItem.seriesDataIndices, function (idxItem) { - var series = ecModel.getSeriesByIndex(idxItem.seriesIndex); - var dataIndex = idxItem.dataIndexInside; - var cbParams = series.getDataParams(dataIndex); - // Can't find data. - if (cbParams.dataIndex < 0) { - return; - } - cbParams.axisDim = axisItem.axisDim; - cbParams.axisIndex = axisItem.axisIndex; - cbParams.axisType = axisItem.axisType; - cbParams.axisId = axisItem.axisId; - cbParams.axisValue = getAxisRawValue(axisModel.axis, { - value: axisValue - }); - cbParams.axisValueLabel = axisValueLabel; - // Pre-create marker style for makers. Users can assemble richText - // text in `formatter` callback and use those markers style. - cbParams.marker = markupStyleCreator.makeTooltipMarker('item', convertToColorString(cbParams.color), renderMode); - var seriesTooltipResult = normalizeTooltipFormatResult(series.formatTooltip(dataIndex, true, null)); - var frag = seriesTooltipResult.frag; - if (frag) { - var valueFormatter = buildTooltipModel([series], globalTooltipModel).get('valueFormatter'); - axisSectionMarkup.blocks.push(valueFormatter ? extend({ - valueFormatter: valueFormatter - }, frag) : frag); - } - if (seriesTooltipResult.text) { - markupTextArrLegacy.push(seriesTooltipResult.text); - } - cbParamsList.push(cbParams); - }); - }); - }); - // In most cases, the second axis is displays upper on the first one. - // So we reverse it to look better. - articleMarkup.blocks.reverse(); - markupTextArrLegacy.reverse(); - var positionExpr = e.position; - var orderMode = singleTooltipModel.get('order'); - var builtMarkupText = buildTooltipMarkup(articleMarkup, markupStyleCreator, renderMode, orderMode, ecModel.get('useUTC'), singleTooltipModel.get('textStyle')); - builtMarkupText && markupTextArrLegacy.unshift(builtMarkupText); - var blockBreak = renderMode === 'richText' ? '\n\n' : '
'; - var allMarkupText = markupTextArrLegacy.join(blockBreak); - this._showOrMove(singleTooltipModel, function () { - if (this._updateContentNotChangedOnAxis(dataByCoordSys, cbParamsList)) { - this._updatePosition(singleTooltipModel, positionExpr, point[0], point[1], this._tooltipContent, cbParamsList); - } else { - this._showTooltipContent(singleTooltipModel, allMarkupText, cbParamsList, Math.random() + '', point[0], point[1], positionExpr, null, markupStyleCreator); - } - }); - // Do not trigger events here, because this branch only be entered - // from dispatchAction. - }; - TooltipView.prototype._showSeriesItemTooltip = function (e, dispatcher, dispatchAction) { - var ecModel = this._ecModel; - var ecData = getECData(dispatcher); - // Use dataModel in element if possible - // Used when mouseover on a element like markPoint or edge - // In which case, the data is not main data in series. - var seriesIndex = ecData.seriesIndex; - var seriesModel = ecModel.getSeriesByIndex(seriesIndex); - // For example, graph link. - var dataModel = ecData.dataModel || seriesModel; - var dataIndex = ecData.dataIndex; - var dataType = ecData.dataType; - var data = dataModel.getData(dataType); - var renderMode = this._renderMode; - var positionDefault = e.positionDefault; - var tooltipModel = buildTooltipModel([data.getItemModel(dataIndex), dataModel, seriesModel && (seriesModel.coordinateSystem || {}).model], this._tooltipModel, positionDefault ? { - position: positionDefault - } : null); - var tooltipTrigger = tooltipModel.get('trigger'); - if (tooltipTrigger != null && tooltipTrigger !== 'item') { - return; - } - var params = dataModel.getDataParams(dataIndex, dataType); - var markupStyleCreator = new TooltipMarkupStyleCreator(); - // Pre-create marker style for makers. Users can assemble richText - // text in `formatter` callback and use those markers style. - params.marker = markupStyleCreator.makeTooltipMarker('item', convertToColorString(params.color), renderMode); - var seriesTooltipResult = normalizeTooltipFormatResult(dataModel.formatTooltip(dataIndex, false, dataType)); - var orderMode = tooltipModel.get('order'); - var valueFormatter = tooltipModel.get('valueFormatter'); - var frag = seriesTooltipResult.frag; - var markupText = frag ? buildTooltipMarkup(valueFormatter ? extend({ - valueFormatter: valueFormatter - }, frag) : frag, markupStyleCreator, renderMode, orderMode, ecModel.get('useUTC'), tooltipModel.get('textStyle')) : seriesTooltipResult.text; - var asyncTicket = 'item_' + dataModel.name + '_' + dataIndex; - this._showOrMove(tooltipModel, function () { - this._showTooltipContent(tooltipModel, markupText, params, asyncTicket, e.offsetX, e.offsetY, e.position, e.target, markupStyleCreator); - }); - // FIXME - // duplicated showtip if manuallyShowTip is called from dispatchAction. - dispatchAction({ - type: 'showTip', - dataIndexInside: dataIndex, - dataIndex: data.getRawIndex(dataIndex), - seriesIndex: seriesIndex, - from: this.uid - }); - }; - TooltipView.prototype._showComponentItemTooltip = function (e, el, dispatchAction) { - var isHTMLRenderMode = this._renderMode === 'html'; - var ecData = getECData(el); - var tooltipConfig = ecData.tooltipConfig; - var tooltipOpt = tooltipConfig.option || {}; - var encodeHTMLContent = tooltipOpt.encodeHTMLContent; - if (isString(tooltipOpt)) { - var content = tooltipOpt; - tooltipOpt = { - content: content, - // Fixed formatter - formatter: content - }; - // when `tooltipConfig.option` is a string rather than an object, - // we can't know if the content needs to be encoded - // for the sake of security, encode it by default. - encodeHTMLContent = true; - } - if (encodeHTMLContent && isHTMLRenderMode && tooltipOpt.content) { - // clone might be unnecessary? - tooltipOpt = clone$2(tooltipOpt); - tooltipOpt.content = encodeHTML(tooltipOpt.content); - } - var tooltipModelCascade = [tooltipOpt]; - var cmpt = this._ecModel.getComponent(ecData.componentMainType, ecData.componentIndex); - if (cmpt) { - tooltipModelCascade.push(cmpt); - } - // In most cases, component tooltip formatter has different params with series tooltip formatter, - // so that they cannot share the same formatter. Since the global tooltip formatter is used for series - // by convention, we do not use it as the default formatter for component. - tooltipModelCascade.push({ - formatter: tooltipOpt.content - }); - var positionDefault = e.positionDefault; - var subTooltipModel = buildTooltipModel(tooltipModelCascade, this._tooltipModel, positionDefault ? { - position: positionDefault - } : null); - var defaultHtml = subTooltipModel.get('content'); - var asyncTicket = Math.random() + ''; - // PENDING: this case do not support richText style yet. - var markupStyleCreator = new TooltipMarkupStyleCreator(); - // Do not check whether `trigger` is 'none' here, because `trigger` - // only works on coordinate system. In fact, we have not found case - // that requires setting `trigger` nothing on component yet. - this._showOrMove(subTooltipModel, function () { - // Use formatterParams from element defined in component - // Avoid users modify it. - var formatterParams = clone$2(subTooltipModel.get('formatterParams') || {}); - this._showTooltipContent(subTooltipModel, defaultHtml, formatterParams, asyncTicket, e.offsetX, e.offsetY, e.position, el, markupStyleCreator); - }); - // If not dispatch showTip, tip may be hide triggered by axis. - dispatchAction({ - type: 'showTip', - from: this.uid - }); - }; - TooltipView.prototype._showTooltipContent = function ( - // Use Model insteadof TooltipModel because this model may be from series or other options. - // Instead of top level tooltip. - tooltipModel, defaultHtml, params, asyncTicket, x, y, positionExpr, el, markupStyleCreator) { - // Reset ticket - this._ticket = ''; - if (!tooltipModel.get('showContent') || !tooltipModel.get('show')) { - return; - } - var tooltipContent = this._tooltipContent; - tooltipContent.setEnterable(tooltipModel.get('enterable')); - var formatter = tooltipModel.get('formatter'); - positionExpr = positionExpr || tooltipModel.get('position'); - var html = defaultHtml; - var nearPoint = this._getNearestPoint([x, y], params, tooltipModel.get('trigger'), tooltipModel.get('borderColor')); - var nearPointColor = nearPoint.color; - if (formatter) { - if (isString(formatter)) { - var useUTC = tooltipModel.ecModel.get('useUTC'); - var params0 = isArray(params) ? params[0] : params; - var isTimeAxis = params0 && params0.axisType && params0.axisType.indexOf('time') >= 0; - html = formatter; - if (isTimeAxis) { - html = format(params0.axisValue, html, useUTC); - } - html = formatTpl(html, params, true); - } else if (isFunction(formatter)) { - var callback = bind$1(function (cbTicket, html) { - if (cbTicket === this._ticket) { - tooltipContent.setContent(html, markupStyleCreator, tooltipModel, nearPointColor, positionExpr); - this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el); - } - }, this); - this._ticket = asyncTicket; - html = formatter(params, asyncTicket, callback); - } else { - html = formatter; - } - } - tooltipContent.setContent(html, markupStyleCreator, tooltipModel, nearPointColor, positionExpr); - tooltipContent.show(tooltipModel, nearPointColor); - this._updatePosition(tooltipModel, positionExpr, x, y, tooltipContent, params, el); - }; - TooltipView.prototype._getNearestPoint = function (point, tooltipDataParams, trigger, borderColor) { - if (trigger === 'axis' || isArray(tooltipDataParams)) { - return { - color: borderColor || (this._renderMode === 'html' ? '#fff' : 'none') - }; - } - if (!isArray(tooltipDataParams)) { - return { - color: borderColor || tooltipDataParams.color || tooltipDataParams.borderColor - }; - } - }; - TooltipView.prototype._updatePosition = function (tooltipModel, positionExpr, x, - // Mouse x - y, - // Mouse y - content, params, el) { - var viewWidth = this._api.getWidth(); - var viewHeight = this._api.getHeight(); - positionExpr = positionExpr || tooltipModel.get('position'); - var contentSize = content.getSize(); - var align = tooltipModel.get('align'); - var vAlign = tooltipModel.get('verticalAlign'); - var rect = el && el.getBoundingRect().clone(); - el && rect.applyTransform(el.transform); - if (isFunction(positionExpr)) { - // Callback of position can be an array or a string specify the position - positionExpr = positionExpr([x, y], params, content.el, rect, { - viewSize: [viewWidth, viewHeight], - contentSize: contentSize.slice() - }); - } - if (isArray(positionExpr)) { - x = parsePercent(positionExpr[0], viewWidth); - y = parsePercent(positionExpr[1], viewHeight); - } else if (isObject$2(positionExpr)) { - var boxLayoutPosition = positionExpr; - boxLayoutPosition.width = contentSize[0]; - boxLayoutPosition.height = contentSize[1]; - var layoutRect = getLayoutRect(boxLayoutPosition, { - width: viewWidth, - height: viewHeight - }); - x = layoutRect.x; - y = layoutRect.y; - align = null; - // When positionExpr is left/top/right/bottom, - // align and verticalAlign will not work. - vAlign = null; - } - // Specify tooltip position by string 'top' 'bottom' 'left' 'right' around graphic element - else if (isString(positionExpr) && el) { - var pos = calcTooltipPosition(positionExpr, rect, contentSize, tooltipModel.get('borderWidth')); - x = pos[0]; - y = pos[1]; - } else { - var pos = refixTooltipPosition(x, y, content, viewWidth, viewHeight, align ? null : 20, vAlign ? null : 20); - x = pos[0]; - y = pos[1]; - } - align && (x -= isCenterAlign(align) ? contentSize[0] / 2 : align === 'right' ? contentSize[0] : 0); - vAlign && (y -= isCenterAlign(vAlign) ? contentSize[1] / 2 : vAlign === 'bottom' ? contentSize[1] : 0); - if (shouldTooltipConfine(tooltipModel)) { - var pos = confineTooltipPosition(x, y, content, viewWidth, viewHeight); - x = pos[0]; - y = pos[1]; - } - content.moveTo(x, y); - }; - // FIXME - // Should we remove this but leave this to user? - TooltipView.prototype._updateContentNotChangedOnAxis = function (dataByCoordSys, cbParamsList) { - var lastCoordSys = this._lastDataByCoordSys; - var lastCbParamsList = this._cbParamsList; - var contentNotChanged = !!lastCoordSys && lastCoordSys.length === dataByCoordSys.length; - contentNotChanged && each$4(lastCoordSys, function (lastItemCoordSys, indexCoordSys) { - var lastDataByAxis = lastItemCoordSys.dataByAxis || []; - var thisItemCoordSys = dataByCoordSys[indexCoordSys] || {}; - var thisDataByAxis = thisItemCoordSys.dataByAxis || []; - contentNotChanged = contentNotChanged && lastDataByAxis.length === thisDataByAxis.length; - contentNotChanged && each$4(lastDataByAxis, function (lastItem, indexAxis) { - var thisItem = thisDataByAxis[indexAxis] || {}; - var lastIndices = lastItem.seriesDataIndices || []; - var newIndices = thisItem.seriesDataIndices || []; - contentNotChanged = contentNotChanged && lastItem.value === thisItem.value && lastItem.axisType === thisItem.axisType && lastItem.axisId === thisItem.axisId && lastIndices.length === newIndices.length; - contentNotChanged && each$4(lastIndices, function (lastIdxItem, j) { - var newIdxItem = newIndices[j]; - contentNotChanged = contentNotChanged && lastIdxItem.seriesIndex === newIdxItem.seriesIndex && lastIdxItem.dataIndex === newIdxItem.dataIndex; - }); - // check is cbParams data value changed - lastCbParamsList && each$4(lastItem.seriesDataIndices, function (idxItem) { - var seriesIdx = idxItem.seriesIndex; - var cbParams = cbParamsList[seriesIdx]; - var lastCbParams = lastCbParamsList[seriesIdx]; - if (cbParams && lastCbParams && lastCbParams.data !== cbParams.data) { - contentNotChanged = false; - } - }); - }); - }); - this._lastDataByCoordSys = dataByCoordSys; - this._cbParamsList = cbParamsList; - return !!contentNotChanged; - }; - TooltipView.prototype._hide = function (dispatchAction) { - // Do not directly hideLater here, because this behavior may be prevented - // in dispatchAction when showTip is dispatched. - // FIXME - // duplicated hideTip if manuallyHideTip is called from dispatchAction. - this._lastDataByCoordSys = null; - dispatchAction({ - type: 'hideTip', - from: this.uid - }); - }; - TooltipView.prototype.dispose = function (ecModel, api) { - if (env.node || !api.getDom()) { - return; - } - clear(this, '_updatePosition'); - this._tooltipContent.dispose(); - unregister('itemTooltip', api); - }; - TooltipView.type = 'tooltip'; - return TooltipView; -}(ComponentView); -/** - * From top to bottom. (the last one should be globalTooltipModel); - */ -function buildTooltipModel(modelCascade, globalTooltipModel, defaultTooltipOption) { - // Last is always tooltip model. - var ecModel = globalTooltipModel.ecModel; - var resultModel; - if (defaultTooltipOption) { - resultModel = new Model(defaultTooltipOption, ecModel, ecModel); - resultModel = new Model(globalTooltipModel.option, resultModel, ecModel); - } else { - resultModel = globalTooltipModel; - } - for (var i = modelCascade.length - 1; i >= 0; i--) { - var tooltipOpt = modelCascade[i]; - if (tooltipOpt) { - if (tooltipOpt instanceof Model) { - tooltipOpt = tooltipOpt.get('tooltip', true); - } - // In each data item tooltip can be simply write: - // { - // value: 10, - // tooltip: 'Something you need to know' - // } - if (isString(tooltipOpt)) { - tooltipOpt = { - formatter: tooltipOpt - }; - } - if (tooltipOpt) { - resultModel = new Model(tooltipOpt, resultModel, ecModel); - } - } - } - return resultModel; -} -function makeDispatchAction(payload, api) { - return payload.dispatchAction || bind$1(api.dispatchAction, api); -} -function refixTooltipPosition(x, y, content, viewWidth, viewHeight, gapH, gapV) { - var size = content.getSize(); - var width = size[0]; - var height = size[1]; - if (gapH != null) { - // Add extra 2 pixels for this case: - // At present the "values" in default tooltip are using CSS `float: right`. - // When the right edge of the tooltip box is on the right side of the - // viewport, the `float` layout might push the "values" to the second line. - if (x + width + gapH + 2 > viewWidth) { - x -= width + gapH; - } else { - x += gapH; - } - } - if (gapV != null) { - if (y + height + gapV > viewHeight) { - y -= height + gapV; - } else { - y += gapV; - } - } - return [x, y]; -} -function confineTooltipPosition(x, y, content, viewWidth, viewHeight) { - var size = content.getSize(); - var width = size[0]; - var height = size[1]; - x = Math.min(x + width, viewWidth) - width; - y = Math.min(y + height, viewHeight) - height; - x = Math.max(x, 0); - y = Math.max(y, 0); - return [x, y]; -} -function calcTooltipPosition(position, rect, contentSize, borderWidth) { - var domWidth = contentSize[0]; - var domHeight = contentSize[1]; - var offset = Math.ceil(Math.SQRT2 * borderWidth) + 8; - var x = 0; - var y = 0; - var rectWidth = rect.width; - var rectHeight = rect.height; - switch (position) { - case 'inside': - x = rect.x + rectWidth / 2 - domWidth / 2; - y = rect.y + rectHeight / 2 - domHeight / 2; - break; - case 'top': - x = rect.x + rectWidth / 2 - domWidth / 2; - y = rect.y - domHeight - offset; - break; - case 'bottom': - x = rect.x + rectWidth / 2 - domWidth / 2; - y = rect.y + rectHeight + offset; - break; - case 'left': - x = rect.x - domWidth - offset; - y = rect.y + rectHeight / 2 - domHeight / 2; - break; - case 'right': - x = rect.x + rectWidth + offset; - y = rect.y + rectHeight / 2 - domHeight / 2; - } - return [x, y]; -} -function isCenterAlign(align) { - return align === 'center' || align === 'middle'; -} -/** - * Find target component by payload like: - * ```js - * { legendId: 'some_id', name: 'xxx' } - * { toolboxIndex: 1, name: 'xxx' } - * { geoName: 'some_name', name: 'xxx' } - * ``` - * PENDING: at present only - * - * If not found, return null/undefined. - */ -function findComponentReference(payload, ecModel, api) { - var queryOptionMap = preParseFinder(payload).queryOptionMap; - var componentMainType = queryOptionMap.keys()[0]; - if (!componentMainType || componentMainType === 'series') { - return; - } - var queryResult = queryReferringComponents(ecModel, componentMainType, queryOptionMap.get(componentMainType), { - useDefault: false, - enableAll: false, - enableNone: false - }); - var model = queryResult.models[0]; - if (!model) { - return; - } - var view = api.getViewOfComponentModel(model); - var el; - view.group.traverse(function (subEl) { - var tooltipConfig = getECData(subEl).tooltipConfig; - if (tooltipConfig && tooltipConfig.name === payload.name) { - el = subEl; - return true; // stop - } - }); - if (el) { - return { - componentMainType: componentMainType, - componentIndex: model.componentIndex, - el: el - }; - } -} - -function install$4(registers) { - use(install$6); - registers.registerComponentModel(TooltipModel); - registers.registerComponentView(TooltipView); - /** - * @action - * @property {string} type - * @property {number} seriesIndex - * @property {number} dataIndex - * @property {number} [x] - * @property {number} [y] - */ - registers.registerAction({ - type: 'showTip', - event: 'showTip', - update: 'tooltip:manuallyShowTip' - }, noop); - registers.registerAction({ - type: 'hideTip', - event: 'hideTip', - update: 'tooltip:manuallyHideTip' - }, noop); -} - -var TitleModel = /** @class */function (_super) { - __extends(TitleModel, _super); - function TitleModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = TitleModel.type; - _this.layoutMode = { - type: 'box', - ignoreSize: true - }; - return _this; - } - TitleModel.type = 'title'; - TitleModel.defaultOption = { - // zlevel: 0, - z: 6, - show: true, - text: '', - target: 'blank', - subtext: '', - subtarget: 'blank', - left: 0, - top: 0, - backgroundColor: 'rgba(0,0,0,0)', - borderColor: '#ccc', - borderWidth: 0, - padding: 5, - itemGap: 10, - textStyle: { - fontSize: 18, - fontWeight: 'bold', - color: '#464646' - }, - subtextStyle: { - fontSize: 12, - color: '#6E7079' - } - }; - return TitleModel; -}(ComponentModel); -// View -var TitleView = /** @class */function (_super) { - __extends(TitleView, _super); - function TitleView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = TitleView.type; - return _this; - } - TitleView.prototype.render = function (titleModel, ecModel, api) { - this.group.removeAll(); - if (!titleModel.get('show')) { - return; - } - var group = this.group; - var textStyleModel = titleModel.getModel('textStyle'); - var subtextStyleModel = titleModel.getModel('subtextStyle'); - var textAlign = titleModel.get('textAlign'); - var textVerticalAlign = retrieve2(titleModel.get('textBaseline'), titleModel.get('textVerticalAlign')); - var textEl = new ZRText({ - style: createTextStyle(textStyleModel, { - text: titleModel.get('text'), - fill: textStyleModel.getTextColor() - }, { - disableBox: true - }), - z2: 10 - }); - var textRect = textEl.getBoundingRect(); - var subText = titleModel.get('subtext'); - var subTextEl = new ZRText({ - style: createTextStyle(subtextStyleModel, { - text: subText, - fill: subtextStyleModel.getTextColor(), - y: textRect.height + titleModel.get('itemGap'), - verticalAlign: 'top' - }, { - disableBox: true - }), - z2: 10 - }); - var link = titleModel.get('link'); - var sublink = titleModel.get('sublink'); - var triggerEvent = titleModel.get('triggerEvent', true); - textEl.silent = !link && !triggerEvent; - subTextEl.silent = !sublink && !triggerEvent; - if (link) { - textEl.on('click', function () { - windowOpen(link, '_' + titleModel.get('target')); - }); - } - if (sublink) { - subTextEl.on('click', function () { - windowOpen(sublink, '_' + titleModel.get('subtarget')); - }); - } - getECData(textEl).eventData = getECData(subTextEl).eventData = triggerEvent ? { - componentType: 'title', - componentIndex: titleModel.componentIndex - } : null; - group.add(textEl); - subText && group.add(subTextEl); - // If no subText, but add subTextEl, there will be an empty line. - var groupRect = group.getBoundingRect(); - var layoutOption = titleModel.getBoxLayoutParams(); - layoutOption.width = groupRect.width; - layoutOption.height = groupRect.height; - var layoutRect = getLayoutRect(layoutOption, { - width: api.getWidth(), - height: api.getHeight() - }, titleModel.get('padding')); - // Adjust text align based on position - if (!textAlign) { - // Align left if title is on the left. center and right is same - textAlign = titleModel.get('left') || titleModel.get('right'); - // @ts-ignore - if (textAlign === 'middle') { - textAlign = 'center'; - } - // Adjust layout by text align - if (textAlign === 'right') { - layoutRect.x += layoutRect.width; - } else if (textAlign === 'center') { - layoutRect.x += layoutRect.width / 2; - } - } - if (!textVerticalAlign) { - textVerticalAlign = titleModel.get('top') || titleModel.get('bottom'); - // @ts-ignore - if (textVerticalAlign === 'center') { - textVerticalAlign = 'middle'; - } - if (textVerticalAlign === 'bottom') { - layoutRect.y += layoutRect.height; - } else if (textVerticalAlign === 'middle') { - layoutRect.y += layoutRect.height / 2; - } - textVerticalAlign = textVerticalAlign || 'top'; - } - group.x = layoutRect.x; - group.y = layoutRect.y; - group.markRedraw(); - var alignStyle = { - align: textAlign, - verticalAlign: textVerticalAlign - }; - textEl.setStyle(alignStyle); - subTextEl.setStyle(alignStyle); - // Render background - // Get groupRect again because textAlign has been changed - groupRect = group.getBoundingRect(); - var padding = layoutRect.margin; - var style = titleModel.getItemStyle(['color', 'opacity']); - style.fill = titleModel.get('backgroundColor'); - var rect = new Rect({ - shape: { - x: groupRect.x - padding[3], - y: groupRect.y - padding[0], - width: groupRect.width + padding[1] + padding[3], - height: groupRect.height + padding[0] + padding[2], - r: titleModel.get('borderRadius') - }, - style: style, - subPixelOptimize: true, - silent: true - }); - group.add(rect); - }; - TitleView.type = 'title'; - return TitleView; -}(ComponentView); -function install$3(registers) { - registers.registerComponentModel(TitleModel); - registers.registerComponentView(TitleView); -} - -var getDefaultSelectorOptions = function (ecModel, type) { - if (type === 'all') { - return { - type: 'all', - title: ecModel.getLocaleModel().get(['legend', 'selector', 'all']) - }; - } else if (type === 'inverse') { - return { - type: 'inverse', - title: ecModel.getLocaleModel().get(['legend', 'selector', 'inverse']) - }; - } -}; -var LegendModel = /** @class */function (_super) { - __extends(LegendModel, _super); - function LegendModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = LegendModel.type; - _this.layoutMode = { - type: 'box', - // legend.width/height are maxWidth/maxHeight actually, - // whereas real width/height is calculated by its content. - // (Setting {left: 10, right: 10} does not make sense). - // So consider the case: - // `setOption({legend: {left: 10});` - // then `setOption({legend: {right: 10});` - // The previous `left` should be cleared by setting `ignoreSize`. - ignoreSize: true - }; - return _this; - } - LegendModel.prototype.init = function (option, parentModel, ecModel) { - this.mergeDefaultAndTheme(option, ecModel); - option.selected = option.selected || {}; - this._updateSelector(option); - }; - LegendModel.prototype.mergeOption = function (option, ecModel) { - _super.prototype.mergeOption.call(this, option, ecModel); - this._updateSelector(option); - }; - LegendModel.prototype._updateSelector = function (option) { - var selector = option.selector; - var ecModel = this.ecModel; - if (selector === true) { - selector = option.selector = ['all', 'inverse']; - } - if (isArray(selector)) { - each$4(selector, function (item, index) { - isString(item) && (item = { - type: item - }); - selector[index] = merge(item, getDefaultSelectorOptions(ecModel, item.type)); - }); - } - }; - LegendModel.prototype.optionUpdated = function () { - this._updateData(this.ecModel); - var legendData = this._data; - // If selectedMode is single, try to select one - if (legendData[0] && this.get('selectedMode') === 'single') { - var hasSelected = false; - // If has any selected in option.selected - for (var i = 0; i < legendData.length; i++) { - var name_1 = legendData[i].get('name'); - if (this.isSelected(name_1)) { - // Force to unselect others - this.select(name_1); - hasSelected = true; - break; - } - } - // Try select the first if selectedMode is single - !hasSelected && this.select(legendData[0].get('name')); - } - }; - LegendModel.prototype._updateData = function (ecModel) { - var potentialData = []; - var availableNames = []; - ecModel.eachRawSeries(function (seriesModel) { - var seriesName = seriesModel.name; - availableNames.push(seriesName); - var isPotential; - if (seriesModel.legendVisualProvider) { - var provider = seriesModel.legendVisualProvider; - var names = provider.getAllNames(); - if (!ecModel.isSeriesFiltered(seriesModel)) { - availableNames = availableNames.concat(names); - } - if (names.length) { - potentialData = potentialData.concat(names); - } else { - isPotential = true; - } - } else { - isPotential = true; - } - if (isPotential && isNameSpecified(seriesModel)) { - potentialData.push(seriesModel.name); - } - }); - /** - * @type {Array.} - * @private - */ - this._availableNames = availableNames; - // If legend.data is not specified in option, use availableNames as data, - // which is convenient for user preparing option. - var rawData = this.get('data') || potentialData; - var legendNameMap = createHashMap(); - var legendData = map$1(rawData, function (dataItem) { - // Can be string or number - if (isString(dataItem) || isNumber(dataItem)) { - dataItem = { - name: dataItem - }; - } - if (legendNameMap.get(dataItem.name)) { - // remove legend name duplicate - return null; - } - legendNameMap.set(dataItem.name, true); - return new Model(dataItem, this, this.ecModel); - }, this); - /** - * @type {Array.} - * @private - */ - this._data = filter(legendData, function (item) { - return !!item; - }); - }; - LegendModel.prototype.getData = function () { - return this._data; - }; - LegendModel.prototype.select = function (name) { - var selected = this.option.selected; - var selectedMode = this.get('selectedMode'); - if (selectedMode === 'single') { - var data = this._data; - each$4(data, function (dataItem) { - selected[dataItem.get('name')] = false; - }); - } - selected[name] = true; - }; - LegendModel.prototype.unSelect = function (name) { - if (this.get('selectedMode') !== 'single') { - this.option.selected[name] = false; - } - }; - LegendModel.prototype.toggleSelected = function (name) { - var selected = this.option.selected; - // Default is true - if (!selected.hasOwnProperty(name)) { - selected[name] = true; - } - this[selected[name] ? 'unSelect' : 'select'](name); - }; - LegendModel.prototype.allSelect = function () { - var data = this._data; - var selected = this.option.selected; - each$4(data, function (dataItem) { - selected[dataItem.get('name', true)] = true; - }); - }; - LegendModel.prototype.inverseSelect = function () { - var data = this._data; - var selected = this.option.selected; - each$4(data, function (dataItem) { - var name = dataItem.get('name', true); - // Initially, default value is true - if (!selected.hasOwnProperty(name)) { - selected[name] = true; - } - selected[name] = !selected[name]; - }); - }; - LegendModel.prototype.isSelected = function (name) { - var selected = this.option.selected; - return !(selected.hasOwnProperty(name) && !selected[name]) && indexOf(this._availableNames, name) >= 0; - }; - LegendModel.prototype.getOrient = function () { - return this.get('orient') === 'vertical' ? { - index: 1, - name: 'vertical' - } : { - index: 0, - name: 'horizontal' - }; - }; - LegendModel.type = 'legend.plain'; - LegendModel.dependencies = ['series']; - LegendModel.defaultOption = { - // zlevel: 0, - z: 4, - show: true, - orient: 'horizontal', - left: 'center', - // right: 'center', - top: 0, - // bottom: null, - align: 'auto', - backgroundColor: 'rgba(0,0,0,0)', - borderColor: '#ccc', - borderRadius: 0, - borderWidth: 0, - padding: 5, - itemGap: 10, - itemWidth: 25, - itemHeight: 14, - symbolRotate: 'inherit', - symbolKeepAspect: true, - inactiveColor: '#ccc', - inactiveBorderColor: '#ccc', - inactiveBorderWidth: 'auto', - itemStyle: { - color: 'inherit', - opacity: 'inherit', - borderColor: 'inherit', - borderWidth: 'auto', - borderCap: 'inherit', - borderJoin: 'inherit', - borderDashOffset: 'inherit', - borderMiterLimit: 'inherit' - }, - lineStyle: { - width: 'auto', - color: 'inherit', - inactiveColor: '#ccc', - inactiveWidth: 2, - opacity: 'inherit', - type: 'inherit', - cap: 'inherit', - join: 'inherit', - dashOffset: 'inherit', - miterLimit: 'inherit' - }, - textStyle: { - color: '#333' - }, - selectedMode: true, - selector: false, - selectorLabel: { - show: true, - borderRadius: 10, - padding: [3, 5, 3, 5], - fontSize: 12, - fontFamily: 'sans-serif', - color: '#666', - borderWidth: 1, - borderColor: '#666' - }, - emphasis: { - selectorLabel: { - show: true, - color: '#eee', - backgroundColor: '#666' - } - }, - selectorPosition: 'auto', - selectorItemGap: 7, - selectorButtonGap: 10, - tooltip: { - show: false - } - }; - return LegendModel; -}(ComponentModel); - -var curry = curry$1; -var each = each$4; -var Group$1 = Group$2; -var LegendView = ( - /** @class */ - function(_super) { - __extends(LegendView2, _super); - function LegendView2() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = LegendView2.type; - _this.newlineDisabled = false; - return _this; - } - LegendView2.prototype.init = function() { - this.group.add(this._contentGroup = new Group$1()); - this.group.add(this._selectorGroup = new Group$1()); - this._isFirstRender = true; - }; - LegendView2.prototype.getContentGroup = function() { - return this._contentGroup; - }; - LegendView2.prototype.getSelectorGroup = function() { - return this._selectorGroup; - }; - LegendView2.prototype.render = function(legendModel, ecModel, api) { - var isFirstRender = this._isFirstRender; - this._isFirstRender = false; - this.resetInner(); - if (!legendModel.get("show", true)) { - return; - } - var itemAlign = legendModel.get("align"); - var orient = legendModel.get("orient"); - if (!itemAlign || itemAlign === "auto") { - itemAlign = legendModel.get("left") === "right" && orient === "vertical" ? "right" : "left"; - } - var selector = legendModel.get("selector", true); - var selectorPosition = legendModel.get("selectorPosition", true); - if (selector && (!selectorPosition || selectorPosition === "auto")) { - selectorPosition = orient === "horizontal" ? "end" : "start"; - } - this.renderInner(itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition); - var positionInfo = legendModel.getBoxLayoutParams(); - var viewportSize = { - width: api.getWidth(), - height: api.getHeight() - }; - var padding = legendModel.get("padding"); - var maxSize = getLayoutRect(positionInfo, viewportSize, padding); - var mainRect = this.layoutInner(legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition); - var layoutRect = getLayoutRect(defaults({ - width: mainRect.width, - height: mainRect.height - }, positionInfo), viewportSize, padding); - this.group.x = layoutRect.x - mainRect.x; - this.group.y = layoutRect.y - mainRect.y; - this.group.markRedraw(); - this.group.add(this._backgroundEl = makeBackground(mainRect, legendModel)); - }; - LegendView2.prototype.resetInner = function() { - this.getContentGroup().removeAll(); - this._backgroundEl && this.group.remove(this._backgroundEl); - this.getSelectorGroup().removeAll(); - }; - LegendView2.prototype.renderInner = function(itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) { - var contentGroup = this.getContentGroup(); - var legendDrawnMap = createHashMap(); - var selectMode = legendModel.get("selectedMode"); - var excludeSeriesId = []; - ecModel.eachRawSeries(function(seriesModel) { - !seriesModel.get("legendHoverLink") && excludeSeriesId.push(seriesModel.id); - }); - each(legendModel.getData(), function(legendItemModel, dataIndex) { - var name = legendItemModel.get("name"); - if (!this.newlineDisabled && (name === "" || name === "\n")) { - var g = new Group$1(); - g.newline = true; - contentGroup.add(g); - return; - } - var seriesModel = ecModel.getSeriesByName(name)[0]; - if (legendDrawnMap.get(name)) { - return; - } - if (seriesModel) { - var data = seriesModel.getData(); - var lineVisualStyle = data.getVisual("legendLineStyle") || {}; - var legendIcon = data.getVisual("legendIcon"); - var style = data.getVisual("style"); - var itemGroup = this._createItem(seriesModel, name, dataIndex, legendItemModel, legendModel, itemAlign, lineVisualStyle, style, legendIcon, selectMode, api); - itemGroup.on("click", curry(dispatchSelectAction, name, null, api, excludeSeriesId)).on("mouseover", curry(dispatchHighlightAction, seriesModel.name, null, api, excludeSeriesId)).on("mouseout", curry(dispatchDownplayAction, seriesModel.name, null, api, excludeSeriesId)); - if (ecModel.ssr) { - itemGroup.eachChild(function(child) { - var ecData = getECData(child); - ecData.seriesIndex = seriesModel.seriesIndex; - ecData.dataIndex = dataIndex; - ecData.ssrType = "legend"; - }); - } - legendDrawnMap.set(name, true); - } else { - ecModel.eachRawSeries(function(seriesModel2) { - if (legendDrawnMap.get(name)) { - return; - } - if (seriesModel2.legendVisualProvider) { - var provider = seriesModel2.legendVisualProvider; - if (!provider.containName(name)) { - return; - } - var idx = provider.indexOfName(name); - var style2 = provider.getItemVisual(idx, "style"); - var legendIcon2 = provider.getItemVisual(idx, "legendIcon"); - var colorArr = parse(style2.fill); - if (colorArr && colorArr[3] === 0) { - colorArr[3] = 0.2; - style2 = extend(extend({}, style2), { - fill: stringify(colorArr, "rgba") - }); - } - var itemGroup2 = this._createItem(seriesModel2, name, dataIndex, legendItemModel, legendModel, itemAlign, {}, style2, legendIcon2, selectMode, api); - itemGroup2.on("click", curry(dispatchSelectAction, null, name, api, excludeSeriesId)).on("mouseover", curry(dispatchHighlightAction, null, name, api, excludeSeriesId)).on("mouseout", curry(dispatchDownplayAction, null, name, api, excludeSeriesId)); - if (ecModel.ssr) { - itemGroup2.eachChild(function(child) { - var ecData = getECData(child); - ecData.seriesIndex = seriesModel2.seriesIndex; - ecData.dataIndex = dataIndex; - ecData.ssrType = "legend"; - }); - } - legendDrawnMap.set(name, true); - } - }, this); - } - }, this); - if (selector) { - this._createSelector(selector, legendModel, api, orient, selectorPosition); - } - }; - LegendView2.prototype._createSelector = function(selector, legendModel, api, orient, selectorPosition) { - var selectorGroup = this.getSelectorGroup(); - each(selector, function createSelectorButton(selectorItem) { - var type = selectorItem.type; - var labelText = new ZRText({ - style: { - x: 0, - y: 0, - align: "center", - verticalAlign: "middle" - }, - onclick: function() { - api.dispatchAction({ - type: type === "all" ? "legendAllSelect" : "legendInverseSelect", - legendId: legendModel.id - }); - } - }); - selectorGroup.add(labelText); - var labelModel = legendModel.getModel("selectorLabel"); - var emphasisLabelModel = legendModel.getModel(["emphasis", "selectorLabel"]); - setLabelStyle(labelText, { - normal: labelModel, - emphasis: emphasisLabelModel - }, { - defaultText: selectorItem.title - }); - enableHoverEmphasis(labelText); - }); - }; - LegendView2.prototype._createItem = function(seriesModel, name, dataIndex, legendItemModel, legendModel, itemAlign, lineVisualStyle, itemVisualStyle, legendIcon, selectMode, api) { - var drawType = seriesModel.visualDrawType; - var itemWidth = legendModel.get("itemWidth"); - var itemHeight = legendModel.get("itemHeight"); - var isSelected = legendModel.isSelected(name); - var iconRotate = legendItemModel.get("symbolRotate"); - var symbolKeepAspect = legendItemModel.get("symbolKeepAspect"); - var legendIconType = legendItemModel.get("icon"); - legendIcon = legendIconType || legendIcon || "roundRect"; - var style = getLegendStyle(legendIcon, legendItemModel, lineVisualStyle, itemVisualStyle, drawType, isSelected, api); - var itemGroup = new Group$1(); - var textStyleModel = legendItemModel.getModel("textStyle"); - if (isFunction(seriesModel.getLegendIcon) && (!legendIconType || legendIconType === "inherit")) { - itemGroup.add(seriesModel.getLegendIcon({ - itemWidth, - itemHeight, - icon: legendIcon, - iconRotate, - itemStyle: style.itemStyle, - lineStyle: style.lineStyle, - symbolKeepAspect - })); - } else { - var rotate = legendIconType === "inherit" && seriesModel.getData().getVisual("symbol") ? iconRotate === "inherit" ? seriesModel.getData().getVisual("symbolRotate") : iconRotate : 0; - itemGroup.add(getDefaultLegendIcon({ - itemWidth, - itemHeight, - icon: legendIcon, - iconRotate: rotate, - itemStyle: style.itemStyle, - symbolKeepAspect - })); - } - var textX = itemAlign === "left" ? itemWidth + 5 : -5; - var textAlign = itemAlign; - var formatter = legendModel.get("formatter"); - var content = name; - if (isString(formatter) && formatter) { - content = formatter.replace("{name}", name != null ? name : ""); - } else if (isFunction(formatter)) { - content = formatter(name); - } - var textColor = isSelected ? textStyleModel.getTextColor() : legendItemModel.get("inactiveColor"); - itemGroup.add(new ZRText({ - style: createTextStyle(textStyleModel, { - text: content, - x: textX, - y: itemHeight / 2, - fill: textColor, - align: textAlign, - verticalAlign: "middle" - }, { - inheritColor: textColor - }) - })); - var hitRect = new Rect({ - shape: itemGroup.getBoundingRect(), - style: { - // Cannot use 'invisible' because SVG SSR will miss the node - fill: "transparent" - } - }); - var tooltipModel = legendItemModel.getModel("tooltip"); - if (tooltipModel.get("show")) { - setTooltipConfig({ - el: hitRect, - componentModel: legendModel, - itemName: name, - itemTooltipOption: tooltipModel.option - }); - } - itemGroup.add(hitRect); - itemGroup.eachChild(function(child) { - child.silent = true; - }); - hitRect.silent = !selectMode; - this.getContentGroup().add(itemGroup); - enableHoverEmphasis(itemGroup); - itemGroup.__legendDataIndex = dataIndex; - return itemGroup; - }; - LegendView2.prototype.layoutInner = function(legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) { - var contentGroup = this.getContentGroup(); - var selectorGroup = this.getSelectorGroup(); - box(legendModel.get("orient"), contentGroup, legendModel.get("itemGap"), maxSize.width, maxSize.height); - var contentRect = contentGroup.getBoundingRect(); - var contentPos = [-contentRect.x, -contentRect.y]; - selectorGroup.markRedraw(); - contentGroup.markRedraw(); - if (selector) { - box( - // Buttons in selectorGroup always layout horizontally - "horizontal", - selectorGroup, - legendModel.get("selectorItemGap", true) - ); - var selectorRect = selectorGroup.getBoundingRect(); - var selectorPos = [-selectorRect.x, -selectorRect.y]; - var selectorButtonGap = legendModel.get("selectorButtonGap", true); - var orientIdx = legendModel.getOrient().index; - var wh = orientIdx === 0 ? "width" : "height"; - var hw = orientIdx === 0 ? "height" : "width"; - var yx = orientIdx === 0 ? "y" : "x"; - if (selectorPosition === "end") { - selectorPos[orientIdx] += contentRect[wh] + selectorButtonGap; - } else { - contentPos[orientIdx] += selectorRect[wh] + selectorButtonGap; - } - selectorPos[1 - orientIdx] += contentRect[hw] / 2 - selectorRect[hw] / 2; - selectorGroup.x = selectorPos[0]; - selectorGroup.y = selectorPos[1]; - contentGroup.x = contentPos[0]; - contentGroup.y = contentPos[1]; - var mainRect = { - x: 0, - y: 0 - }; - mainRect[wh] = contentRect[wh] + selectorButtonGap + selectorRect[wh]; - mainRect[hw] = Math.max(contentRect[hw], selectorRect[hw]); - mainRect[yx] = Math.min(0, selectorRect[yx] + selectorPos[1 - orientIdx]); - return mainRect; - } else { - contentGroup.x = contentPos[0]; - contentGroup.y = contentPos[1]; - return this.group.getBoundingRect(); - } - }; - LegendView2.prototype.remove = function() { - this.getContentGroup().removeAll(); - this._isFirstRender = true; - }; - LegendView2.type = "legend.plain"; - return LegendView2; - }(ComponentView) -); -function getLegendStyle(iconType, legendItemModel, lineVisualStyle, itemVisualStyle, drawType, isSelected, api) { - function handleCommonProps(style, visualStyle) { - if (style.lineWidth === "auto") { - style.lineWidth = visualStyle.lineWidth > 0 ? 2 : 0; - } - each(style, function(propVal, propName) { - style[propName] === "inherit" && (style[propName] = visualStyle[propName]); - }); - } - var itemStyleModel = legendItemModel.getModel("itemStyle"); - var itemStyle = itemStyleModel.getItemStyle(); - var iconBrushType = iconType.lastIndexOf("empty", 0) === 0 ? "fill" : "stroke"; - var decalStyle = itemStyleModel.getShallow("decal"); - itemStyle.decal = !decalStyle || decalStyle === "inherit" ? itemVisualStyle.decal : createOrUpdatePatternFromDecal(decalStyle, api); - if (itemStyle.fill === "inherit") { - itemStyle.fill = itemVisualStyle[drawType]; - } - if (itemStyle.stroke === "inherit") { - itemStyle.stroke = itemVisualStyle[iconBrushType]; - } - if (itemStyle.opacity === "inherit") { - itemStyle.opacity = (drawType === "fill" ? itemVisualStyle : lineVisualStyle).opacity; - } - handleCommonProps(itemStyle, itemVisualStyle); - var legendLineModel = legendItemModel.getModel("lineStyle"); - var lineStyle = legendLineModel.getLineStyle(); - handleCommonProps(lineStyle, lineVisualStyle); - itemStyle.fill === "auto" && (itemStyle.fill = itemVisualStyle.fill); - itemStyle.stroke === "auto" && (itemStyle.stroke = itemVisualStyle.fill); - lineStyle.stroke === "auto" && (lineStyle.stroke = itemVisualStyle.fill); - if (!isSelected) { - var borderWidth = legendItemModel.get("inactiveBorderWidth"); - var visualHasBorder = itemStyle[iconBrushType]; - itemStyle.lineWidth = borderWidth === "auto" ? itemVisualStyle.lineWidth > 0 && visualHasBorder ? 2 : 0 : itemStyle.lineWidth; - itemStyle.fill = legendItemModel.get("inactiveColor"); - itemStyle.stroke = legendItemModel.get("inactiveBorderColor"); - lineStyle.stroke = legendLineModel.get("inactiveColor"); - lineStyle.lineWidth = legendLineModel.get("inactiveWidth"); - } - return { - itemStyle, - lineStyle - }; -} -function getDefaultLegendIcon(opt) { - var symboType = opt.icon || "roundRect"; - var icon = createSymbol(symboType, 0, 0, opt.itemWidth, opt.itemHeight, opt.itemStyle.fill, opt.symbolKeepAspect); - icon.setStyle(opt.itemStyle); - icon.rotation = (opt.iconRotate || 0) * Math.PI / 180; - icon.setOrigin([opt.itemWidth / 2, opt.itemHeight / 2]); - if (symboType.indexOf("empty") > -1) { - icon.style.stroke = icon.style.fill; - icon.style.fill = "#fff"; - icon.style.lineWidth = 2; - } - return icon; -} -function dispatchSelectAction(seriesName, dataName, api, excludeSeriesId) { - dispatchDownplayAction(seriesName, dataName, api, excludeSeriesId); - api.dispatchAction({ - type: "legendToggleSelect", - name: seriesName != null ? seriesName : dataName - }); - dispatchHighlightAction(seriesName, dataName, api, excludeSeriesId); -} -function isUseHoverLayer(api) { - var list = api.getZr().storage.getDisplayList(); - var emphasisState; - var i = 0; - var len = list.length; - while (i < len && !(emphasisState = list[i].states.emphasis)) { - i++; - } - return emphasisState && emphasisState.hoverLayer; -} -function dispatchHighlightAction(seriesName, dataName, api, excludeSeriesId) { - if (!isUseHoverLayer(api)) { - api.dispatchAction({ - type: "highlight", - seriesName, - name: dataName, - excludeSeriesId - }); - } -} -function dispatchDownplayAction(seriesName, dataName, api, excludeSeriesId) { - if (!isUseHoverLayer(api)) { - api.dispatchAction({ - type: "downplay", - seriesName, - name: dataName, - excludeSeriesId - }); - } -} - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function legendFilter(ecModel) { - var legendModels = ecModel.findComponents({ - mainType: 'legend' - }); - if (legendModels && legendModels.length) { - ecModel.filterSeries(function (series) { - // If in any legend component the status is not selected. - // Because in legend series is assumed selected when it is not in the legend data. - for (var i = 0; i < legendModels.length; i++) { - if (!legendModels[i].isSelected(series.name)) { - return false; - } - } - return true; - }); - } -} - -function legendSelectActionHandler(methodName, payload, ecModel) { - var isAllSelect = methodName === 'allSelect' || methodName === 'inverseSelect'; - var selectedMap = {}; - var actionLegendIndices = []; - ecModel.eachComponent({ - mainType: 'legend', - query: payload - }, function (legendModel) { - if (isAllSelect) { - legendModel[methodName](); - } else { - legendModel[methodName](payload.name); - } - makeSelectedMap(legendModel, selectedMap); - actionLegendIndices.push(legendModel.componentIndex); - }); - var allSelectedMap = {}; - // make selectedMap from all legend components - ecModel.eachComponent('legend', function (legendModel) { - each$4(selectedMap, function (isSelected, name) { - // Force other legend has same selected status - // Or the first is toggled to true and other are toggled to false - // In the case one legend has some item unSelected in option. And if other legend - // doesn't has the item, they will assume it is selected. - legendModel[isSelected ? 'select' : 'unSelect'](name); - }); - makeSelectedMap(legendModel, allSelectedMap); - }); - // Return the event explicitly - return isAllSelect ? { - selected: allSelectedMap, - // return legendIndex array to tell the developers which legends are allSelect / inverseSelect - legendIndex: actionLegendIndices - } : { - name: payload.name, - selected: allSelectedMap - }; -} -function makeSelectedMap(legendModel, out) { - var selectedMap = out || {}; - each$4(legendModel.getData(), function (model) { - var name = model.get('name'); - // Wrap element - if (name === '\n' || name === '') { - return; - } - var isItemSelected = legendModel.isSelected(name); - if (hasOwn(selectedMap, name)) { - // Unselected if any legend is unselected - selectedMap[name] = selectedMap[name] && isItemSelected; - } else { - selectedMap[name] = isItemSelected; - } - }); - return selectedMap; -} -function installLegendAction(registers) { - /** - * @event legendToggleSelect - * @type {Object} - * @property {string} type 'legendToggleSelect' - * @property {string} [from] - * @property {string} name Series name or data item name - */ - registers.registerAction('legendToggleSelect', 'legendselectchanged', curry$1(legendSelectActionHandler, 'toggleSelected')); - registers.registerAction('legendAllSelect', 'legendselectall', curry$1(legendSelectActionHandler, 'allSelect')); - registers.registerAction('legendInverseSelect', 'legendinverseselect', curry$1(legendSelectActionHandler, 'inverseSelect')); - /** - * @event legendSelect - * @type {Object} - * @property {string} type 'legendSelect' - * @property {string} name Series name or data item name - */ - registers.registerAction('legendSelect', 'legendselected', curry$1(legendSelectActionHandler, 'select')); - /** - * @event legendUnSelect - * @type {Object} - * @property {string} type 'legendUnSelect' - * @property {string} name Series name or data item name - */ - registers.registerAction('legendUnSelect', 'legendunselected', curry$1(legendSelectActionHandler, 'unSelect')); -} - -function install$2(registers) { - registers.registerComponentModel(LegendModel); - registers.registerComponentView(LegendView); - registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter); - registers.registerSubTypeDefaulter('legend', function () { - return 'plain'; - }); - installLegendAction(registers); -} - -var ScrollableLegendModel = /** @class */function (_super) { - __extends(ScrollableLegendModel, _super); - function ScrollableLegendModel() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = ScrollableLegendModel.type; - return _this; - } - /** - * @param {number} scrollDataIndex - */ - ScrollableLegendModel.prototype.setScrollDataIndex = function (scrollDataIndex) { - this.option.scrollDataIndex = scrollDataIndex; - }; - ScrollableLegendModel.prototype.init = function (option, parentModel, ecModel) { - var inputPositionParams = getLayoutParams(option); - _super.prototype.init.call(this, option, parentModel, ecModel); - mergeAndNormalizeLayoutParams(this, option, inputPositionParams); - }; - /** - * @override - */ - ScrollableLegendModel.prototype.mergeOption = function (option, ecModel) { - _super.prototype.mergeOption.call(this, option, ecModel); - mergeAndNormalizeLayoutParams(this, this.option, option); - }; - ScrollableLegendModel.type = 'legend.scroll'; - ScrollableLegendModel.defaultOption = inheritDefaultOption(LegendModel.defaultOption, { - scrollDataIndex: 0, - pageButtonItemGap: 5, - pageButtonGap: null, - pageButtonPosition: 'end', - pageFormatter: '{current}/{total}', - pageIcons: { - horizontal: ['M0,0L12,-10L12,10z', 'M0,0L-12,-10L-12,10z'], - vertical: ['M0,0L20,0L10,-20z', 'M0,0L20,0L10,20z'] - }, - pageIconColor: '#2f4554', - pageIconInactiveColor: '#aaa', - pageIconSize: 15, - pageTextStyle: { - color: '#333' - }, - animationDurationUpdate: 800 - }); - return ScrollableLegendModel; -}(LegendModel); -// Do not `ignoreSize` to enable setting {left: 10, right: 10}. -function mergeAndNormalizeLayoutParams(legendModel, target, raw) { - var orient = legendModel.getOrient(); - var ignoreSize = [1, 1]; - ignoreSize[orient.index] = 0; - mergeLayoutParam(target, raw, { - type: 'box', - ignoreSize: !!ignoreSize - }); -} - -var Group = Group$2; -var WH = ['width', 'height']; -var XY = ['x', 'y']; -var ScrollableLegendView = /** @class */function (_super) { - __extends(ScrollableLegendView, _super); - function ScrollableLegendView() { - var _this = _super !== null && _super.apply(this, arguments) || this; - _this.type = ScrollableLegendView.type; - _this.newlineDisabled = true; - _this._currentIndex = 0; - return _this; - } - ScrollableLegendView.prototype.init = function () { - _super.prototype.init.call(this); - this.group.add(this._containerGroup = new Group()); - this._containerGroup.add(this.getContentGroup()); - this.group.add(this._controllerGroup = new Group()); - }; - /** - * @override - */ - ScrollableLegendView.prototype.resetInner = function () { - _super.prototype.resetInner.call(this); - this._controllerGroup.removeAll(); - this._containerGroup.removeClipPath(); - this._containerGroup.__rectSize = null; - }; - /** - * @override - */ - ScrollableLegendView.prototype.renderInner = function (itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) { - var self = this; - // Render content items. - _super.prototype.renderInner.call(this, itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition); - var controllerGroup = this._controllerGroup; - // FIXME: support be 'auto' adapt to size number text length, - // e.g., '3/12345' should not overlap with the control arrow button. - var pageIconSize = legendModel.get('pageIconSize', true); - var pageIconSizeArr = isArray(pageIconSize) ? pageIconSize : [pageIconSize, pageIconSize]; - createPageButton('pagePrev', 0); - var pageTextStyleModel = legendModel.getModel('pageTextStyle'); - controllerGroup.add(new ZRText({ - name: 'pageText', - style: { - // Placeholder to calculate a proper layout. - text: 'xx/xx', - fill: pageTextStyleModel.getTextColor(), - font: pageTextStyleModel.getFont(), - verticalAlign: 'middle', - align: 'center' - }, - silent: true - })); - createPageButton('pageNext', 1); - function createPageButton(name, iconIdx) { - var pageDataIndexName = name + 'DataIndex'; - var icon = createIcon(legendModel.get('pageIcons', true)[legendModel.getOrient().name][iconIdx], { - // Buttons will be created in each render, so we do not need - // to worry about avoiding using legendModel kept in scope. - onclick: bind$1(self._pageGo, self, pageDataIndexName, legendModel, api) - }, { - x: -pageIconSizeArr[0] / 2, - y: -pageIconSizeArr[1] / 2, - width: pageIconSizeArr[0], - height: pageIconSizeArr[1] - }); - icon.name = name; - controllerGroup.add(icon); - } - }; - /** - * @override - */ - ScrollableLegendView.prototype.layoutInner = function (legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) { - var selectorGroup = this.getSelectorGroup(); - var orientIdx = legendModel.getOrient().index; - var wh = WH[orientIdx]; - var xy = XY[orientIdx]; - var hw = WH[1 - orientIdx]; - var yx = XY[1 - orientIdx]; - selector && box( - // Buttons in selectorGroup always layout horizontally - 'horizontal', selectorGroup, legendModel.get('selectorItemGap', true)); - var selectorButtonGap = legendModel.get('selectorButtonGap', true); - var selectorRect = selectorGroup.getBoundingRect(); - var selectorPos = [-selectorRect.x, -selectorRect.y]; - var processMaxSize = clone$2(maxSize); - selector && (processMaxSize[wh] = maxSize[wh] - selectorRect[wh] - selectorButtonGap); - var mainRect = this._layoutContentAndController(legendModel, isFirstRender, processMaxSize, orientIdx, wh, hw, yx, xy); - if (selector) { - if (selectorPosition === 'end') { - selectorPos[orientIdx] += mainRect[wh] + selectorButtonGap; - } else { - var offset = selectorRect[wh] + selectorButtonGap; - selectorPos[orientIdx] -= offset; - mainRect[xy] -= offset; - } - mainRect[wh] += selectorRect[wh] + selectorButtonGap; - selectorPos[1 - orientIdx] += mainRect[yx] + mainRect[hw] / 2 - selectorRect[hw] / 2; - mainRect[hw] = Math.max(mainRect[hw], selectorRect[hw]); - mainRect[yx] = Math.min(mainRect[yx], selectorRect[yx] + selectorPos[1 - orientIdx]); - selectorGroup.x = selectorPos[0]; - selectorGroup.y = selectorPos[1]; - selectorGroup.markRedraw(); - } - return mainRect; - }; - ScrollableLegendView.prototype._layoutContentAndController = function (legendModel, isFirstRender, maxSize, orientIdx, wh, hw, yx, xy) { - var contentGroup = this.getContentGroup(); - var containerGroup = this._containerGroup; - var controllerGroup = this._controllerGroup; - // Place items in contentGroup. - box(legendModel.get('orient'), contentGroup, legendModel.get('itemGap'), !orientIdx ? null : maxSize.width, orientIdx ? null : maxSize.height); - box( - // Buttons in controller are layout always horizontally. - 'horizontal', controllerGroup, legendModel.get('pageButtonItemGap', true)); - var contentRect = contentGroup.getBoundingRect(); - var controllerRect = controllerGroup.getBoundingRect(); - var showController = this._showController = contentRect[wh] > maxSize[wh]; - // In case that the inner elements of contentGroup layout do not based on [0, 0] - var contentPos = [-contentRect.x, -contentRect.y]; - // Remain contentPos when scroll animation perfroming. - // If first rendering, `contentGroup.position` is [0, 0], which - // does not make sense and may cause unexepcted animation if adopted. - if (!isFirstRender) { - contentPos[orientIdx] = contentGroup[xy]; - } - // Layout container group based on 0. - var containerPos = [0, 0]; - var controllerPos = [-controllerRect.x, -controllerRect.y]; - var pageButtonGap = retrieve2(legendModel.get('pageButtonGap', true), legendModel.get('itemGap', true)); - // Place containerGroup and controllerGroup and contentGroup. - if (showController) { - var pageButtonPosition = legendModel.get('pageButtonPosition', true); - // controller is on the right / bottom. - if (pageButtonPosition === 'end') { - controllerPos[orientIdx] += maxSize[wh] - controllerRect[wh]; - } - // controller is on the left / top. - else { - containerPos[orientIdx] += controllerRect[wh] + pageButtonGap; - } - } - // Always align controller to content as 'middle'. - controllerPos[1 - orientIdx] += contentRect[hw] / 2 - controllerRect[hw] / 2; - contentGroup.setPosition(contentPos); - containerGroup.setPosition(containerPos); - controllerGroup.setPosition(controllerPos); - // Calculate `mainRect` and set `clipPath`. - // mainRect should not be calculated by `this.group.getBoundingRect()` - // for sake of the overflow. - var mainRect = { - x: 0, - y: 0 - }; - // Consider content may be overflow (should be clipped). - mainRect[wh] = showController ? maxSize[wh] : contentRect[wh]; - mainRect[hw] = Math.max(contentRect[hw], controllerRect[hw]); - // `containerRect[yx] + containerPos[1 - orientIdx]` is 0. - mainRect[yx] = Math.min(0, controllerRect[yx] + controllerPos[1 - orientIdx]); - containerGroup.__rectSize = maxSize[wh]; - if (showController) { - var clipShape = { - x: 0, - y: 0 - }; - clipShape[wh] = Math.max(maxSize[wh] - controllerRect[wh] - pageButtonGap, 0); - clipShape[hw] = mainRect[hw]; - containerGroup.setClipPath(new Rect({ - shape: clipShape - })); - // Consider content may be larger than container, container rect - // can not be obtained from `containerGroup.getBoundingRect()`. - containerGroup.__rectSize = clipShape[wh]; - } else { - // Do not remove or ignore controller. Keep them set as placeholders. - controllerGroup.eachChild(function (child) { - child.attr({ - invisible: true, - silent: true - }); - }); - } - // Content translate animation. - var pageInfo = this._getPageInfo(legendModel); - pageInfo.pageIndex != null && updateProps$1(contentGroup, { - x: pageInfo.contentPosition[0], - y: pageInfo.contentPosition[1] - }, - // When switch from "show controller" to "not show controller", view should be - // updated immediately without animation, otherwise causes weird effect. - showController ? legendModel : null); - this._updatePageInfoView(legendModel, pageInfo); - return mainRect; - }; - ScrollableLegendView.prototype._pageGo = function (to, legendModel, api) { - var scrollDataIndex = this._getPageInfo(legendModel)[to]; - scrollDataIndex != null && api.dispatchAction({ - type: 'legendScroll', - scrollDataIndex: scrollDataIndex, - legendId: legendModel.id - }); - }; - ScrollableLegendView.prototype._updatePageInfoView = function (legendModel, pageInfo) { - var controllerGroup = this._controllerGroup; - each$4(['pagePrev', 'pageNext'], function (name) { - var key = name + 'DataIndex'; - var canJump = pageInfo[key] != null; - var icon = controllerGroup.childOfName(name); - if (icon) { - icon.setStyle('fill', canJump ? legendModel.get('pageIconColor', true) : legendModel.get('pageIconInactiveColor', true)); - icon.cursor = canJump ? 'pointer' : 'default'; - } - }); - var pageText = controllerGroup.childOfName('pageText'); - var pageFormatter = legendModel.get('pageFormatter'); - var pageIndex = pageInfo.pageIndex; - var current = pageIndex != null ? pageIndex + 1 : 0; - var total = pageInfo.pageCount; - pageText && pageFormatter && pageText.setStyle('text', isString(pageFormatter) ? pageFormatter.replace('{current}', current == null ? '' : current + '').replace('{total}', total == null ? '' : total + '') : pageFormatter({ - current: current, - total: total - })); - }; - /** - * contentPosition: Array., null when data item not found. - * pageIndex: number, null when data item not found. - * pageCount: number, always be a number, can be 0. - * pagePrevDataIndex: number, null when no previous page. - * pageNextDataIndex: number, null when no next page. - * } - */ - ScrollableLegendView.prototype._getPageInfo = function (legendModel) { - var scrollDataIndex = legendModel.get('scrollDataIndex', true); - var contentGroup = this.getContentGroup(); - var containerRectSize = this._containerGroup.__rectSize; - var orientIdx = legendModel.getOrient().index; - var wh = WH[orientIdx]; - var xy = XY[orientIdx]; - var targetItemIndex = this._findTargetItemIndex(scrollDataIndex); - var children = contentGroup.children(); - var targetItem = children[targetItemIndex]; - var itemCount = children.length; - var pCount = !itemCount ? 0 : 1; - var result = { - contentPosition: [contentGroup.x, contentGroup.y], - pageCount: pCount, - pageIndex: pCount - 1, - pagePrevDataIndex: null, - pageNextDataIndex: null - }; - if (!targetItem) { - return result; - } - var targetItemInfo = getItemInfo(targetItem); - result.contentPosition[orientIdx] = -targetItemInfo.s; - // Strategy: - // (1) Always align based on the left/top most item. - // (2) It is user-friendly that the last item shown in the - // current window is shown at the begining of next window. - // Otherwise if half of the last item is cut by the window, - // it will have no chance to display entirely. - // (3) Consider that item size probably be different, we - // have calculate pageIndex by size rather than item index, - // and we can not get page index directly by division. - // (4) The window is to narrow to contain more than - // one item, we should make sure that the page can be fliped. - for (var i = targetItemIndex + 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i <= itemCount; ++i) { - currItemInfo = getItemInfo(children[i]); - if ( - // Half of the last item is out of the window. - !currItemInfo && winEndItemInfo.e > winStartItemInfo.s + containerRectSize - // If the current item does not intersect with the window, the new page - // can be started at the current item or the last item. - || currItemInfo && !intersect(currItemInfo, winStartItemInfo.s)) { - if (winEndItemInfo.i > winStartItemInfo.i) { - winStartItemInfo = winEndItemInfo; - } else { - // e.g., when page size is smaller than item size. - winStartItemInfo = currItemInfo; - } - if (winStartItemInfo) { - if (result.pageNextDataIndex == null) { - result.pageNextDataIndex = winStartItemInfo.i; - } - ++result.pageCount; - } - } - winEndItemInfo = currItemInfo; - } - for (var i = targetItemIndex - 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i >= -1; --i) { - currItemInfo = getItemInfo(children[i]); - if ( - // If the the end item does not intersect with the window started - // from the current item, a page can be settled. - (!currItemInfo || !intersect(winEndItemInfo, currItemInfo.s) - // e.g., when page size is smaller than item size. - ) && winStartItemInfo.i < winEndItemInfo.i) { - winEndItemInfo = winStartItemInfo; - if (result.pagePrevDataIndex == null) { - result.pagePrevDataIndex = winStartItemInfo.i; - } - ++result.pageCount; - ++result.pageIndex; - } - winStartItemInfo = currItemInfo; - } - return result; - function getItemInfo(el) { - if (el) { - var itemRect = el.getBoundingRect(); - var start = itemRect[xy] + el[xy]; - return { - s: start, - e: start + itemRect[wh], - i: el.__legendDataIndex - }; - } - } - function intersect(itemInfo, winStart) { - return itemInfo.e >= winStart && itemInfo.s <= winStart + containerRectSize; - } - }; - ScrollableLegendView.prototype._findTargetItemIndex = function (targetDataIndex) { - if (!this._showController) { - return 0; - } - var index; - var contentGroup = this.getContentGroup(); - var defaultIndex; - contentGroup.eachChild(function (child, idx) { - var legendDataIdx = child.__legendDataIndex; - // FIXME - // If the given targetDataIndex (from model) is illegal, - // we use defaultIndex. But the index on the legend model and - // action payload is still illegal. That case will not be - // changed until some scenario requires. - if (defaultIndex == null && legendDataIdx != null) { - defaultIndex = idx; - } - if (legendDataIdx === targetDataIndex) { - index = idx; - } - }); - return index != null ? index : defaultIndex; - }; - ScrollableLegendView.type = 'legend.scroll'; - return ScrollableLegendView; -}(LegendView); - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - - -/** - * AUTO-GENERATED FILE. DO NOT MODIFY. - */ - -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ -function installScrollableLegendAction(registers) { - /** - * @event legendScroll - * @type {Object} - * @property {string} type 'legendScroll' - * @property {string} scrollDataIndex - */ - registers.registerAction('legendScroll', 'legendscroll', function (payload, ecModel) { - var scrollDataIndex = payload.scrollDataIndex; - scrollDataIndex != null && ecModel.eachComponent({ - mainType: 'legend', - subType: 'scroll', - query: payload - }, function (legendModel) { - legendModel.setScrollDataIndex(scrollDataIndex); - }); - }); -} - -function install$1(registers) { - use(install$2); - registers.registerComponentModel(ScrollableLegendModel); - registers.registerComponentView(ScrollableLegendView); - installScrollableLegendAction(registers); -} - -function install(registers) { - use(install$2); - use(install$1); -} - -const {resolveComponent:_resolveComponent,createVNode:_createVNode,openBlock:_openBlock,createElementBlock:_createElementBlock,createCommentVNode:_createCommentVNode,unref:_unref,renderList:_renderList,Fragment:_Fragment,toDisplayString:_toDisplayString,createTextVNode:_createTextVNode,withCtx:_withCtx,createElementVNode:_createElementVNode,createSlots:_createSlots,createBlock:_createBlock} = await importShared('vue'); - - -const _hoisted_1 = { class: "dashboard-widget" }; -const _hoisted_2 = { class: "dashboard-content" }; -const _hoisted_3 = { - key: 0, - class: "d-flex justify-center align-center py-4" -}; -const _hoisted_4 = { key: 1 }; -const _hoisted_5 = { - key: 0, - class: "chart-container" -}; -const _hoisted_6 = { class: "text-caption" }; -const _hoisted_7 = { - key: 0, - class: "d-flex justify-center align-center py-4" -}; -const _hoisted_8 = { key: 1 }; -const _hoisted_9 = { - key: 0, - class: "chart-container" -}; -const _hoisted_10 = { class: "text-caption" }; - -const {ref,computed,onMounted,onUnmounted} = await importShared('vue'); - -// 注册ECharts组件 - -const _sfc_main = { - __name: 'Dashboard', - props: { - config: { - type: Object, - default: () => ({}), - }, - allowRefresh: { - type: Boolean, - default: true, - }, -}, - setup(__props) { - -try { - use([install$a, install$9, install$8, install$5, install$4, install, install$3]); -} catch (e) { - console.warn('ECharts components registration failed', e); -} - -// 接收仪表板配置 -const props = __props; - -// 组件状态 -const loading = ref(true); -const items = ref([]); -const chartData = ref(null); -let refreshTimer = null; - -// 获取状态图标 -function getStatusIcon(status) { - const icons = { - 'success': 'mdi-check-circle', - 'warning': 'mdi-alert', - 'error': 'mdi-alert-circle', - 'info': 'mdi-information', - 'running': 'mdi-play-circle', - 'pending': 'mdi-clock-outline', - 'completed': 'mdi-check-circle-outline', - }; - return icons[status] || 'mdi-help-circle' -} - -// 获取状态颜色 -function getStatusColor(status) { - const colors = { - 'success': 'success', - 'warning': 'warning', - 'error': 'error', - 'info': 'info', - 'running': 'primary', - 'pending': 'secondary', - 'completed': 'success', - }; - return colors[status] || 'grey' -} - -// 图表选项 -const chartOptions = computed(() => { - if (!chartData.value) return {} - - const { type, data } = chartData.value; - - if (type === 'line') { - return { - tooltip: { - trigger: 'axis', - }, - xAxis: { - type: 'category', - data: data.xAxis, - axisLabel: { - color: '#888', - }, - }, - yAxis: { - type: 'value', - axisLabel: { - color: '#888', - }, - }, - series: data.series.map(series => ({ - name: series.name, - type: 'line', - smooth: true, - data: series.data, - areaStyle: { opacity: 0.1 }, - })), - } - } - - if (type === 'pie') { - return { - tooltip: { - trigger: 'item', - formatter: '{a}
{b}: {c} ({d}%)', - }, - series: [ - { - name: data.name, - type: 'pie', - radius: ['40%', '70%'], - avoidLabelOverlap: false, - itemStyle: { - borderRadius: 10, - borderColor: '#fff', - borderWidth: 2, - }, - label: { - show: false, - position: 'center', - }, - emphasis: { - label: { - show: true, - fontSize: '12', - fontWeight: 'bold', - }, - }, - labelLine: { - show: false, - }, - data: data.items, - }, - ], - } - } - - return {} -}); - -// 获取仪表板数据 -async function fetchDashboardData() { - if (!props.allowRefresh) return - - loading.value = true; - - try { - // 模拟API调用 - await new Promise(resolve => setTimeout(resolve, 1000)); - - // 随机决定显示饼图或折线图 - const showPie = Math.random() > 0.5; - - if (showPie) { - // 饼图数据 - chartData.value = { - type: 'pie', - data: { - name: '文件分布', - items: [ - { value: Math.floor(Math.random() * 50) + 30, name: '电影' }, - { value: Math.floor(Math.random() * 40) + 20, name: '电视剧' }, - { value: Math.floor(Math.random() * 30) + 10, name: '动漫' }, - { value: Math.floor(Math.random() * 20) + 5, name: '纪录片' }, - ], - }, - }; - } else { - // 折线图数据 - const days = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']; - chartData.value = { - type: 'line', - data: { - xAxis: days, - series: [ - { - name: '下载量', - data: days.map(() => Math.floor(Math.random() * 10) + 1), - }, - { - name: '完成量', - data: days.map(() => Math.floor(Math.random() * 8) + 1), - }, - ], - }, - }; - } - - // 生成列表数据 - const statuses = ['success', 'warning', 'error', 'info', 'running', 'pending', 'completed']; - items.value = Array.from({ length: 5 }, (_, i) => { - const status = statuses[Math.floor(Math.random() * statuses.length)]; - return { - title: `项目 ${i + 1}`, - subtitle: `上次更新: ${new Date().toLocaleTimeString()}`, - status, - value: Math.floor(Math.random() * 100) + '%', - } - }); - } catch (error) { - console.error('获取仪表板数据失败:', error); - } finally { - loading.value = false; - } -} - -// 设置定时刷新 -function setupRefreshTimer() { - if (props.allowRefresh) { - // 每30秒刷新一次 - refreshTimer = setInterval(() => { - fetchDashboardData(); - }, 30000); - } -} - -// 初始化 -onMounted(() => { - fetchDashboardData(); - setupRefreshTimer(); -}); - -// 清理 -onUnmounted(() => { - if (refreshTimer) { - clearInterval(refreshTimer); - } -}); - -return (_ctx, _cache) => { - const _component_v_progress_circular = _resolveComponent("v-progress-circular"); - const _component_v_icon = _resolveComponent("v-icon"); - const _component_v_avatar = _resolveComponent("v-avatar"); - const _component_v_list_item = _resolveComponent("v-list-item"); - const _component_v_list = _resolveComponent("v-list"); - const _component_v_card_text = _resolveComponent("v-card-text"); - const _component_v_card = _resolveComponent("v-card"); - const _component_v_card_title = _resolveComponent("v-card-title"); - const _component_v_card_subtitle = _resolveComponent("v-card-subtitle"); - const _component_v_card_item = _resolveComponent("v-card-item"); - - return (_openBlock(), _createElementBlock("div", _hoisted_1, [ - (!__props.config?.attrs?.border) - ? (_openBlock(), _createBlock(_component_v_card, { - key: 0, - flat: "" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_card_text, { class: "pa-0" }, { - default: _withCtx(() => [ - _createElementVNode("div", _hoisted_2, [ - (loading.value) - ? (_openBlock(), _createElementBlock("div", _hoisted_3, [ - _createVNode(_component_v_progress_circular, { - indeterminate: "", - color: "primary" - }) - ])) - : (_openBlock(), _createElementBlock("div", _hoisted_4, [ - (chartData.value) - ? (_openBlock(), _createElementBlock("div", _hoisted_5, [ - _createVNode(_unref(H), { - class: "chart", - option: chartOptions.value, - autoresize: "" - }, null, 8, ["option"]) - ])) - : _createCommentVNode("", true), - (items.value.length) - ? (_openBlock(), _createBlock(_component_v_list, { - key: 1, - density: "compact", - class: "py-0" - }, { - default: _withCtx(() => [ - (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(items.value, (item, index) => { - return (_openBlock(), _createBlock(_component_v_list_item, { - key: index, - title: item.title, - subtitle: item.subtitle - }, _createSlots({ - prepend: _withCtx(() => [ - _createVNode(_component_v_avatar, { - color: getStatusColor(item.status), - size: "small" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { - size: "small", - color: "white" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(getStatusIcon(item.status)), 1) - ]), - _: 2 - }, 1024) - ]), - _: 2 - }, 1032, ["color"]) - ]), - _: 2 - }, [ - (item.value) - ? { - name: "append", - fn: _withCtx(() => [ - _createElementVNode("span", _hoisted_6, _toDisplayString(item.value), 1) - ]), - key: "0" - } - : undefined - ]), 1032, ["title", "subtitle"])) - }), 128)) - ]), - _: 1 - })) - : _createCommentVNode("", true) - ])) - ]) - ]), - _: 1 - }) - ]), - _: 1 - })) - : (_openBlock(), _createBlock(_component_v_card, { key: 1 }, { - default: _withCtx(() => [ - _createVNode(_component_v_card_item, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card_title, null, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(__props.config?.attrs?.title || '仪表板组件'), 1) - ]), - _: 1 - }), - (__props.config?.attrs?.subtitle) - ? (_openBlock(), _createBlock(_component_v_card_subtitle, { key: 0 }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(__props.config.attrs.subtitle), 1) - ]), - _: 1 - })) - : _createCommentVNode("", true) - ]), - _: 1 - }), - _createVNode(_component_v_card_text, null, { - default: _withCtx(() => [ - (loading.value) - ? (_openBlock(), _createElementBlock("div", _hoisted_7, [ - _createVNode(_component_v_progress_circular, { - indeterminate: "", - color: "primary" - }) - ])) - : (_openBlock(), _createElementBlock("div", _hoisted_8, [ - (chartData.value) - ? (_openBlock(), _createElementBlock("div", _hoisted_9, [ - _createVNode(_unref(H), { - class: "chart", - option: chartOptions.value, - autoresize: "" - }, null, 8, ["option"]) - ])) - : _createCommentVNode("", true), - (items.value.length) - ? (_openBlock(), _createBlock(_component_v_list, { - key: 1, - density: "compact", - class: "rounded pa-0" - }, { - default: _withCtx(() => [ - (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(items.value, (item, index) => { - return (_openBlock(), _createBlock(_component_v_list_item, { - key: index, - title: item.title, - subtitle: item.subtitle - }, _createSlots({ - prepend: _withCtx(() => [ - _createVNode(_component_v_avatar, { - color: getStatusColor(item.status), - size: "small" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { - size: "small", - color: "white" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(getStatusIcon(item.status)), 1) - ]), - _: 2 - }, 1024) - ]), - _: 2 - }, 1032, ["color"]) - ]), - _: 2 - }, [ - (item.value) - ? { - name: "append", - fn: _withCtx(() => [ - _createElementVNode("span", _hoisted_10, _toDisplayString(item.value), 1) - ]), - key: "0" - } - : undefined - ]), 1032, ["title", "subtitle"])) - }), 128)) - ]), - _: 1 - })) - : _createCommentVNode("", true) - ])) - ]), - _: 1 - }) - ]), - _: 1 - })) - ])) -} -} - -}; - -export { _sfc_main as default }; diff --git a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-Bl7XNZ7k.css b/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-Bl7XNZ7k.css deleted file mode 100644 index e359222..0000000 --- a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-Bl7XNZ7k.css +++ /dev/null @@ -1,48 +0,0 @@ - -.plugin-page[data-v-d5e502a5] { - max-width: 1200px; - margin: 0 auto; -} - -/* 使卡片等宽并适应移动端 */ -.d-flex.flex-wrap[data-v-d5e502a5] { - gap: 16px; -} -.url-display[data-v-d5e502a5] { - word-break: break-all; - padding: 8px; - background: rgba(0, 0, 0, 0.05); - border-radius: 4px; -} - -/* 移动端堆叠布局 */ -@media (max-width: 768px) { -.d-flex.flex-wrap[data-v-d5e502a5] { - flex-direction: column; -} -} - -/* Add visual distinction between sections */ -.ruleset-section[data-v-d5e502a5] { - border: 1px solid #e0e0e0; - border-radius: 4px; - padding: 16px; - background-color: #f5f5f5; -} -.top-section[data-v-d5e502a5] { - border: 1px solid #e0e0e0; - border-radius: 4px; - padding: 16px; - background-color: #f9f9f9; -} - -/* Optional: Add different border colors to further distinguish */ -.ruleset-section[data-v-d5e502a5] { - border-left: 4px solid #2196F3; /* Blue accent */ -} -.top-section[data-v-d5e502a5] { - border-left: 4px solid #4CAF50; /* Green accent */ -} -.drag-handle[data-v-d5e502a5] { - cursor: move; -} diff --git a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-DlQgf7u6.js b/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-DlQgf7u6.js deleted file mode 100644 index 594a5fd..0000000 --- a/plugins.v2/clashruleprovider/dist/assets/__federation_expose_Page-DlQgf7u6.js +++ /dev/null @@ -1,1118 +0,0 @@ -import { importShared } from './__federation_fn_import-JrT3xvdd.js'; -import { _ as _export_sfc } from './_plugin-vue_export-helper-pcqpp-6-.js'; - -const {createTextVNode:_createTextVNode,resolveComponent:_resolveComponent,withCtx:_withCtx,createVNode:_createVNode,toDisplayString:_toDisplayString,openBlock:_openBlock,createBlock:_createBlock,createCommentVNode:_createCommentVNode,createElementVNode:_createElementVNode,renderList:_renderList,Fragment:_Fragment,createElementBlock:_createElementBlock,withModifiers:_withModifiers,normalizeClass:_normalizeClass} = await importShared('vue'); - - -const _hoisted_1 = { class: "plugin-page" }; -const _hoisted_2 = { key: 2 }; -const _hoisted_3 = { class: "mb-6" }; -const _hoisted_4 = { class: "d-flex justify-space-between align-center mb-4" }; -const _hoisted_5 = ["onDragstart", "onDragover", "onDrop"]; -const _hoisted_6 = { class: "mb-6" }; -const _hoisted_7 = { class: "d-flex justify-space-between align-center mb-4" }; -const _hoisted_8 = ["onDragstart", "onDragover", "onDrop"]; -const _hoisted_9 = { class: "d-flex justify-space-between mb-2" }; -const _hoisted_10 = { class: "d-flex justify-space-between mb-2" }; -const _hoisted_11 = { class: "d-flex justify-space-between text-caption text-grey" }; -const _hoisted_12 = { class: "d-flex justify-space-between align-center mb-2" }; -const _hoisted_13 = { - key: 0, - class: "url-display" -}; -const _hoisted_14 = ["href"]; -const _hoisted_15 = { - key: 1, - class: "text-grey" -}; - -const {ref,onMounted,computed} = await importShared('vue'); - - - -const _sfc_main = { - __name: 'Page', - props: { - model: { - type: Object, - default: () => { - }, - }, - api: { - type: Object, - default: () => { - }, - }, -}, - emits: ['action', 'switch', 'close'], - setup(__props, { emit: __emit }) { - -const expansionPanels = ref(null); -const snackbar = ref({ - show: false, - message: '', - color: 'success' -}); -const dragItem = ref(null); -// 添加自定义出站状态 -const customOutbounds = ref([]); -const additionalParamOptions = ref([ - {title: '无', value: ''}, - {title: 'no-resolve', value: 'no-resolve'}, - {title: 'src', value: 'src'} -]); -// 新增状态变量 -const subUrl = ref(''); - -function dragStart(event, priority, type = 'top') { - dragItem.value = {priority, type}; - event.dataTransfer.effectAllowed = 'move'; -} - -function dragOver(event, priority, type = 'top') { - event.preventDefault(); - const currentRules = type === 'top' ? rules.value : ruleset_rules.value; - // 高亮当前悬停行 - currentRules.forEach(rule => { - rule._isHovered = (rule.priority === priority); - }); -} - -async function drop(event, targetPriority, type = 'top') { - // 5. 调用 API 提交 - await props.api.put('/plugin/ClashRuleProvider/reorder-rules', { - moved_priority: dragItem.value.priority, - target_priority: targetPriority, - rule_data: dragItem.value, - type: type - }); - await refreshData(); // 失败时恢复数据 - dragItem.value = null; -} - -// 接收初始配置 -const props = __props; - -// 组件状态 -const loading = ref(true); -const error = ref(null); -const rules = ref([]); -const ruleset_rules = ref([]); -const status = ref('running'); -const rulesetPrefix = ref('Custom_'); -const lastUpdated = ref(''); -const updatingSubscription = ref(false); -const subscriptionUrl = ref(''); - -// 规则编辑相关状态 -const ruleDialog = ref(false); -const editingPriority = ref(null); -const editingType = ref('top'); // 记录当前编辑的规则类型（'top' 或 'ruleset'） -const newRule = ref({ - type: 'DOMAIN-SUFFIX', - payload: '', - action: 'DIRECT', - additional_params: '', - priority: 0 -}); - -// 排序后的规则 -const sortedRules = computed(() => [...rules.value].sort((a, b) => a.priority - b.priority)); -const sortedRulesetRules = computed(() => [...ruleset_rules.value].sort((a, b) => a.priority - b.priority)); -const showAdditionalParams = computed(() => { - return ['IP-CIDR', 'IP-CIDR6', 'IP-ASN', 'GEOIP'].includes(newRule.value.type); -}); -const ruleProviders = ref([]); -const ruleProviderNames = computed(() => Object.keys(ruleProviders.value)); -// 规则类型和动作选项 -const ruleTypes = computed(() => { - const allTypes = [ - 'DOMAIN', 'DOMAIN-SUFFIX', 'DOMAIN-KEYWORD', 'DOMAIN-REGEX', 'GEOSITE', - 'IP-CIDR', 'IP-CIDR6', 'IP-SUFFIX', 'IP-ASN', 'GEOIP', - 'SRC-GEOIP', 'SRC-IP-ASN', 'SRC-IP-CIDR', 'SRC-IP-SUFFIX', - 'DST-PORT', 'SRC-PORT', 'IN-PORT', 'IN-TYPE', 'IN-USER', 'IN-NAME', - 'PROCESS-PATH', 'PROCESS-PATH-REGEX', 'PROCESS-NAME', 'PROCESS-NAME-REGEX', - 'UID', 'NETWORK', 'DSCP', 'RULE-SET', 'AND', 'OR', 'NOT', 'SUB-RULE', 'MATCH' - ]; - - // 如果是 ruleset 规则，过滤掉 SUB-RULE 和 RULE-SET - if (editingType.value === 'ruleset') { - return allTypes.filter(type => !['SUB-RULE', 'RULE-SET'].includes(type)); - } - - return allTypes; -}); -// 修改actions为计算属性，合并内置动作和自定义出站 -const actions = computed(() => [ - 'DIRECT', 'REJECT', 'REJECT-DROP', 'PASS', 'COMPATIBLE', - ...customOutbounds.value.map(outbound => outbound.name) -]); -const subscriptionInfo = ref({ - download: 0, - upload: 0, - total: 0, - expire: 0, - last_update: 0, - used_percentage: 0, - rule_size: 0 -}); -// 自定义事件，用于通知主应用刷新数据 -const emit = __emit; - -// 格式化字节为易读单位（如 1.5 GB） -function formatBytes(bytes) { - if (bytes === 0) return '0 B'; - const k = 1024; - const sizes = ['B', 'KB', 'MB', 'GB', 'TB']; - const i = Math.floor(Math.log(bytes) / Math.log(k)); - return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]; -} - -// 在工具函数中添加时间戳转换 -function formatTimestamp(timestamp) { - if (!timestamp) return 'N/A'; - const date = new Date(timestamp * 1000); // 注意：JS时间戳是毫秒，需乘以1000 - return date.toLocaleString(); // 或使用其他格式如 date.toISOString().split('T')[0] -} - -// 更新过期时间颜色判断（基于时间戳） -function getExpireColor(timestamp) { - if (!timestamp) return 'grey'; - const secondsLeft = timestamp - Math.floor(Date.now() / 1000); - const daysLeft = secondsLeft / 86400; - return daysLeft < 7 ? 'error' : daysLeft < 30 ? 'warning' : 'success'; -} - -// 复制功能 -function copyToClipboard(text) { - navigator.clipboard.writeText(text).then(() => { - snackbar.value = { - show: true, - message: '已复制到剪贴板', - color: 'success' - }; - }).catch(() => { - snackbar.value = { - show: true, - message: '复制失败', - color: 'error' - }; - }); -} - -// 计算已用流量百分比 -function calculatePercentage(download, total) { - return total > 0 ? Math.round((download / total) * 100) : 0; -} - -// 根据流量百分比获取颜色 -function getUsageColor(percentage) { - return percentage > 90 ? 'error' : percentage > 70 ? 'warning' : 'success'; -} - -// 获取动作对应的颜色 -function getActionColor(action) { - const colors = { - 'DIRECT': 'success', - 'REJECT': 'error', - 'REJECT-DROP': 'error', - 'PASS': 'warning', - 'COMPATIBLE': 'info' - }; - return colors[action] || 'primary' -} - -function isSystemRule(rule) { - return rule.payload?.startsWith(rulesetPrefix.value); -} - -// 打开添加规则对话框 -function openAddRuleDialog(type = 'top') { - editingPriority.value = null; - editingType.value = type; - const currentRules = type === 'top' ? sortedRules.value : sortedRulesetRules.value; - const nextPriority = currentRules.length > 0 - ? Math.max(...currentRules.map(r => r.priority)) + 1 - : 0; - - newRule.value = { - type: 'DOMAIN-SUFFIX', - payload: '', - action: 'DIRECT', - additional_params: '', - priority: nextPriority - }; - - ruleDialog.value = true; -} - -// 编辑规则 -function editRule(priority, type = 'top') { - editingType.value = type; // 记录当前编辑的类型 - const currentRules = type === 'top' ? sortedRules.value : sortedRulesetRules.value; - const rule = currentRules.find(r => r.priority === priority); - - if (rule) { - editingPriority.value = priority; - newRule.value = { - type: rule.type, - payload: rule.payload, - action: rule.action, - additional_params: rule.additional_params?.join(', ') || '', - priority: rule.priority - }; - ruleDialog.value = true; - } -} - -// 保存规则 -async function saveRule() { - try { - const requestData = { - type: editingType.value, // "top" 或 "ruleset" - rule_data: { - ...newRule.value, - additional_params: newRule.value.additional_params - ? newRule.value.additional_params.split(',').map(param => param.trim()).filter(param => param) - : [] - } - }; - - const method = editingPriority.value === null ? 'post' : 'put'; - await props.api[method]('/plugin/ClashRuleProvider/rule', requestData); - - ruleDialog.value = false; - await refreshData(); - - // 显示成功提示 - snackbar.value = { - show: true, - message: editingPriority.value === null ? '规则添加成功' : '规则更新成功', - color: 'success' - }; - } catch (err) { - console.error('保存规则失败:', err); - error.value = err.message || '保存规则失败'; - snackbar.value = { - show: true, - message: '保存规则失败: ' + (err.message || '未知错误'), - color: 'error' - }; - } -} - -// 删除规则 -async function deleteRule(priority, type = 'top') { - try { - await props.api.delete('/plugin/ClashRuleProvider/rule', { - data: { - type: type, // 规则类型 - priority: priority // 要删除的规则优先级 - } - }); - await refreshData(); - } catch (err) { - error.value = err.message || '删除规则失败'; - } -} - - -// 更新订阅 -async function updateSubscription() { - if (!subscriptionUrl.value) { - error.value = '请先输入订阅URL'; - return - } - - updatingSubscription.value = true; - try { - await props.api.put('plugin/ClashRuleProvider/subscription', { - url: subscriptionUrl.value - }); - // 显示成功提示 - snackbar.value = { - show: true, - message: '订阅更新成功', - color: 'success' - }; - await refreshData(); - } catch (err) { - console.error('更新订阅失败:', err); - error.value = err.message; - } finally { - updatingSubscription.value = false; - } -} - - -// 获取和刷新数据 -async function refreshData() { - loading.value = true; - error.value = null; - const wasPanelOpen = expansionPanels.value === (0); // 检查订阅面板是否展开 - try { - const state = await props.api.get('/plugin/ClashRuleProvider/status'); - status.value = state?.data?.state ? 'running' : 'disabled'; - subUrl.value = state?.data?.sub_url || ''; // 从API获取订阅URL - // 更新订阅信息 - if (state?.data?.subscription_info) { - subscriptionInfo.value = { - ...state.data.subscription_info, - used_percentage: calculatePercentage( - state.data.subscription_info.download, - state.data.subscription_info.total - ), - rule_size: state?.data?.clash?.rule_size - }; - } - rulesetPrefix.value = state?.data?.ruleset_prefix || 'Custom_'; - // 直接从响应中获取规则数组 - const response = await props.api.get('/plugin/ClashRuleProvider/rules?rule_type=top'); - rules.value = response?.data.rules || []; - - const response_ruleset = await props.api.get('/plugin/ClashRuleProvider/rules?rule_type=ruleset'); - ruleset_rules.value = response_ruleset?.data.rules || []; - - // 获取订阅信息 - const subscription = await props.api.get('/plugin/ClashRuleProvider/subscription'); - subscriptionUrl.value = subscription?.data.url; - // 获取自定义出站 - const outboundsResponse = await props.api.get('/plugin/ClashRuleProvider/clash_outbound'); - customOutbounds.value = outboundsResponse?.data.outbound || []; - - const providersResponse = await props.api.get('/plugin/ClashRuleProvider/rule_providers'); - ruleProviders.value = providersResponse?.data || {}; - - lastUpdated.value = new Date().toLocaleString(); - // 刷新后恢复面板状态 - if (wasPanelOpen && !(expansionPanels.value === 0)) { - expansionPanels.value = 0; - } - } catch (err) { - console.error('获取数据失败:', err); - error.value = err.message || '获取数据失败'; - status.value = 'error'; - } finally { - loading.value = false; - emit('action'); - } -} - -// 通知主应用切换到配置页面 -function notifySwitch() { - emit('switch'); -} - -// 通知主应用关闭组件 -function notifyClose() { - emit('close'); -} - -// 组件挂载时加载数据 -onMounted(() => { - refreshData(); -}); - -return (_ctx, _cache) => { - const _component_v_card_title = _resolveComponent("v-card-title"); - const _component_v_icon = _resolveComponent("v-icon"); - const _component_v_btn = _resolveComponent("v-btn"); - const _component_v_card_item = _resolveComponent("v-card-item"); - const _component_v_alert = _resolveComponent("v-alert"); - const _component_v_skeleton_loader = _resolveComponent("v-skeleton-loader"); - const _component_v_chip = _resolveComponent("v-chip"); - const _component_v_table = _resolveComponent("v-table"); - const _component_v_tooltip = _resolveComponent("v-tooltip"); - const _component_v_expansion_panel_title = _resolveComponent("v-expansion-panel-title"); - const _component_v_text_field = _resolveComponent("v-text-field"); - const _component_v_progress_linear = _resolveComponent("v-progress-linear"); - const _component_v_card_text = _resolveComponent("v-card-text"); - const _component_v_card = _resolveComponent("v-card"); - const _component_v_expansion_panel_text = _resolveComponent("v-expansion-panel-text"); - const _component_v_expansion_panel = _resolveComponent("v-expansion-panel"); - const _component_v_expansion_panels = _resolveComponent("v-expansion-panels"); - const _component_v_col = _resolveComponent("v-col"); - const _component_v_row = _resolveComponent("v-row"); - const _component_v_spacer = _resolveComponent("v-spacer"); - const _component_v_card_actions = _resolveComponent("v-card-actions"); - const _component_v_snackbar = _resolveComponent("v-snackbar"); - const _component_v_select = _resolveComponent("v-select"); - const _component_v_dialog = _resolveComponent("v-dialog"); - - return (_openBlock(), _createElementBlock("div", _hoisted_1, [ - _createVNode(_component_v_card, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card_item, null, { - append: _withCtx(() => [ - _createVNode(_component_v_btn, { - icon: "", - color: "primary", - variant: "text", - onClick: notifyClose - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[15] || (_cache[15] = [ - _createTextVNode("mdi-close") - ])), - _: 1 - }) - ]), - _: 1 - }) - ]), - default: _withCtx(() => [ - _createVNode(_component_v_card_title, null, { - default: _withCtx(() => _cache[14] || (_cache[14] = [ - _createTextVNode("Clash Rule Provider") - ])), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_card_text, null, { - default: _withCtx(() => [ - (error.value) - ? (_openBlock(), _createBlock(_component_v_alert, { - key: 0, - type: "error", - class: "mb-4" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(error.value), 1) - ]), - _: 1 - })) - : _createCommentVNode("", true), - (loading.value) - ? (_openBlock(), _createBlock(_component_v_skeleton_loader, { - key: 1, - type: "card" - })) - : (_openBlock(), _createElementBlock("div", _hoisted_2, [ - _createElementVNode("div", _hoisted_3, [ - _createElementVNode("div", _hoisted_4, [ - _cache[18] || (_cache[18] = _createElementVNode("div", { class: "text-h6" }, "规则集规则", -1)), - _createVNode(_component_v_btn, { - color: "primary", - onClick: _cache[0] || (_cache[0] = $event => (openAddRuleDialog('ruleset'))) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[16] || (_cache[16] = [ - _createTextVNode("mdi-plus") - ])), - _: 1 - }), - _cache[17] || (_cache[17] = _createTextVNode(" 添加规则 ")) - ]), - _: 1 - }) - ]), - _createVNode(_component_v_table, { - density: "compact", - hover: "" - }, { - default: _withCtx(() => [ - _cache[22] || (_cache[22] = _createElementVNode("thead", null, [ - _createElementVNode("tr", null, [ - _createElementVNode("th", null, "优先级"), - _createElementVNode("th", null, "类型"), - _createElementVNode("th", null, "内容"), - _createElementVNode("th", null, "出站"), - _createElementVNode("th", null, "规则集"), - _createElementVNode("th", null, "操作") - ]) - ], -1)), - _createElementVNode("tbody", null, [ - (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(sortedRulesetRules.value, (rule) => { - return (_openBlock(), _createElementBlock("tr", { - key: rule.priority, - class: _normalizeClass({ 'bg-blue-lighten-5': rule._isHovered }), - draggable: "true", - onDragstart: $event => (dragStart($event, rule.priority, 'ruleset')), - onDragover: _withModifiers($event => (dragOver($event, rule.priority, 'ruleset')), ["prevent"]), - onDrop: $event => (drop($event, rule.priority, 'ruleset')) - }, [ - _createElementVNode("td", null, [ - _createVNode(_component_v_icon, { class: "drag-handle" }, { - default: _withCtx(() => _cache[19] || (_cache[19] = [ - _createTextVNode("mdi-drag") - ])), - _: 1 - }), - _createTextVNode(" " + _toDisplayString(rule.priority), 1) - ]), - _createElementVNode("td", null, _toDisplayString(rule.type), 1), - _createElementVNode("td", null, _toDisplayString(rule.payload), 1), - _createElementVNode("td", null, [ - _createVNode(_component_v_chip, { - color: getActionColor(rule.action), - size: "small" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(rule.action), 1) - ]), - _: 2 - }, 1032, ["color"]) - ]), - _createElementVNode("td", null, _toDisplayString(rulesetPrefix.value) + _toDisplayString(rule.action), 1), - _createElementVNode("td", null, [ - _createVNode(_component_v_btn, { - icon: "", - size: "small", - color: "primary", - variant: "text", - onClick: $event => (editRule(rule.priority, 'ruleset')) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, null, { - default: _withCtx(() => _cache[20] || (_cache[20] = [ - _createTextVNode("mdi-pencil") - ])), - _: 1 - }) - ]), - _: 2 - }, 1032, ["onClick"]), - _createVNode(_component_v_btn, { - icon: "", - size: "small", - color: "error", - variant: "text", - onClick: $event => (deleteRule(rule.priority, 'ruleset')) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, null, { - default: _withCtx(() => _cache[21] || (_cache[21] = [ - _createTextVNode("mdi-delete") - ])), - _: 1 - }) - ]), - _: 2 - }, 1032, ["onClick"]) - ]) - ], 42, _hoisted_5)) - }), 128)) - ]) - ]), - _: 1 - }), - _cache[23] || (_cache[23] = _createElementVNode("div", { class: "text-caption text-grey mt-2" }, " *对规则集中规则的修改可以在Clash中立即生效。 ", -1)) - ]), - _createElementVNode("div", _hoisted_6, [ - _createElementVNode("div", _hoisted_7, [ - _cache[26] || (_cache[26] = _createElementVNode("div", { class: "text-h6" }, "置顶规则", -1)), - _createVNode(_component_v_btn, { - color: "primary", - onClick: _cache[1] || (_cache[1] = $event => (openAddRuleDialog('top'))) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[24] || (_cache[24] = [ - _createTextVNode("mdi-plus") - ])), - _: 1 - }), - _cache[25] || (_cache[25] = _createTextVNode(" 添加规则 ")) - ]), - _: 1 - }) - ]), - _createVNode(_component_v_table, { - density: "compact", - hover: "" - }, { - default: _withCtx(() => [ - _cache[31] || (_cache[31] = _createElementVNode("thead", null, [ - _createElementVNode("tr", null, [ - _createElementVNode("th", null, "优先级"), - _createElementVNode("th", null, "类型"), - _createElementVNode("th", null, "内容"), - _createElementVNode("th", null, "出站"), - _createElementVNode("th", null, "操作") - ]) - ], -1)), - _createElementVNode("tbody", null, [ - (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(sortedRules.value, (rule) => { - return (_openBlock(), _createElementBlock("tr", { - key: rule.priority, - class: _normalizeClass({ 'bg-blue-lighten-5': rule._isHovered }), - draggable: "true", - onDragstart: $event => (dragStart($event, rule.priority, 'top')), - onDragover: _withModifiers($event => (dragOver($event, rule.priority, 'top')), ["prevent"]), - onDrop: $event => (drop($event, rule.priority, 'top')) - }, [ - _createElementVNode("td", null, [ - _createVNode(_component_v_icon, { class: "drag-handle" }, { - default: _withCtx(() => _cache[27] || (_cache[27] = [ - _createTextVNode("mdi-drag") - ])), - _: 1 - }), - _createTextVNode(" " + _toDisplayString(rule.priority), 1) - ]), - _createElementVNode("td", null, _toDisplayString(rule.type), 1), - _createElementVNode("td", null, _toDisplayString(rule.payload), 1), - _createElementVNode("td", null, [ - _createVNode(_component_v_chip, { - color: getActionColor(rule.action), - size: "small" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(rule.action), 1) - ]), - _: 2 - }, 1032, ["color"]) - ]), - _createElementVNode("td", null, [ - _createVNode(_component_v_btn, { - icon: "", - size: "small", - color: "primary", - variant: "text", - onClick: $event => (editRule(rule.priority, 'top')), - disabled: isSystemRule(rule) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, null, { - default: _withCtx(() => _cache[28] || (_cache[28] = [ - _createTextVNode("mdi-pencil") - ])), - _: 1 - }) - ]), - _: 2 - }, 1032, ["onClick", "disabled"]), - _createVNode(_component_v_btn, { - icon: "", - size: "small", - color: "error", - variant: "text", - onClick: $event => (deleteRule(rule.priority, 'top')), - disabled: isSystemRule(rule) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, null, { - default: _withCtx(() => _cache[29] || (_cache[29] = [ - _createTextVNode("mdi-delete") - ])), - _: 1 - }) - ]), - _: 2 - }, 1032, ["onClick", "disabled"]), - (isSystemRule(rule)) - ? (_openBlock(), _createBlock(_component_v_tooltip, { - key: 0, - activator: "parent", - location: "top" - }, { - default: _withCtx(() => _cache[30] || (_cache[30] = [ - _createTextVNode(" 根据规则集自动添加 ") - ])), - _: 1 - })) - : _createCommentVNode("", true) - ]) - ], 42, _hoisted_8)) - }), 128)) - ]) - ]), - _: 1 - }), - _cache[32] || (_cache[32] = _createElementVNode("div", { class: "text-caption text-grey mt-2" }, " *置顶规则用于管理来自规则集的匹配规则，这些规则会动态更新。 ", -1)), - _cache[33] || (_cache[33] = _createElementVNode("div", { class: "text-caption text-grey mt-2" }, " *对置顶规则的修改只有Clash更新配置后才会生效。 ", -1)) - ]), - _createVNode(_component_v_expansion_panels, { - modelValue: expansionPanels.value, - "onUpdate:modelValue": _cache[3] || (_cache[3] = $event => ((expansionPanels).value = $event)) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_expansion_panel, null, { - default: _withCtx(() => [ - _createVNode(_component_v_expansion_panel_title, null, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[34] || (_cache[34] = [ - _createTextVNode("mdi-cloud-download") - ])), - _: 1 - }), - _cache[35] || (_cache[35] = _createElementVNode("span", null, "订阅管理", -1)), - (subscriptionInfo.value.last_update) - ? (_openBlock(), _createBlock(_component_v_chip, { - key: 0, - size: "small", - color: "light-blue", - class: "ml-2" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(formatTimestamp(subscriptionInfo.value.last_update)), 1) - ]), - _: 1 - })) - : _createCommentVNode("", true), - (subscriptionInfo.value.expire) - ? (_openBlock(), _createBlock(_component_v_chip, { - key: 1, - size: "small", - color: getExpireColor(subscriptionInfo.value.expire), - class: "ml-2" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(formatTimestamp(subscriptionInfo.value.expire)), 1) - ]), - _: 1 - }, 8, ["color"])) - : _createCommentVNode("", true) - ]), - _: 1 - }), - _createVNode(_component_v_expansion_panel_text, null, { - default: _withCtx(() => [ - _createVNode(_component_v_text_field, { - modelValue: subscriptionUrl.value, - "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => ((subscriptionUrl).value = $event)), - label: "订阅URL", - placeholder: "https://example.com/clash-rules.txt", - class: "mb-4", - readonly: "", - loading: loading.value - }, null, 8, ["modelValue", "loading"]), - _createVNode(_component_v_card, { - variant: "outlined", - class: "mb-4" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_card_text, null, { - default: _withCtx(() => [ - _createElementVNode("div", _hoisted_9, [ - _cache[36] || (_cache[36] = _createElementVNode("span", null, "已用流量：", -1)), - _createElementVNode("strong", null, _toDisplayString(formatBytes(subscriptionInfo.value.download + subscriptionInfo.value.upload)), 1) - ]), - _createElementVNode("div", _hoisted_10, [ - _cache[37] || (_cache[37] = _createElementVNode("span", null, "剩余流量：", -1)), - _createElementVNode("strong", null, _toDisplayString(formatBytes(subscriptionInfo.value.total - subscriptionInfo.value.download)), 1) - ]), - _createVNode(_component_v_progress_linear, { - "model-value": subscriptionInfo.value.used_percentage, - color: getUsageColor(subscriptionInfo.value.used_percentage), - height: "10", - class: "mb-2" - }, null, 8, ["model-value", "color"]), - _createElementVNode("div", _hoisted_11, [ - _createElementVNode("span", null, "下载：" + _toDisplayString(formatBytes(subscriptionInfo.value.download)), 1), - _createElementVNode("span", null, "上传：" + _toDisplayString(formatBytes(subscriptionInfo.value.upload)), 1), - _createElementVNode("span", null, "总量：" + _toDisplayString(formatBytes(subscriptionInfo.value.total)), 1) - ]) - ]), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_btn, { - color: "primary", - onClick: updateSubscription, - loading: updatingSubscription.value - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[38] || (_cache[38] = [ - _createTextVNode("mdi-cloud-sync") - ])), - _: 1 - }), - _cache[39] || (_cache[39] = _createTextVNode(" 更新订阅 ")) - ]), - _: 1 - }, 8, ["loading"]) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue"]), - _createVNode(_component_v_row, null, { - default: _withCtx(() => [ - _createVNode(_component_v_col, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card, { class: "flex-grow-1" }, { - default: _withCtx(() => [ - _createVNode(_component_v_card_text, { class: "text-subtitle-2" }, { - default: _withCtx(() => [ - _cache[45] || (_cache[45] = _createElementVNode("div", { class: "text-h6 mb-2" }, "状态信息", -1)), - _createElementVNode("div", null, [ - _cache[40] || (_cache[40] = _createElementVNode("strong", null, "状态: ", -1)), - _createVNode(_component_v_chip, { - size: "small", - color: status.value === 'running' ? 'success' : 'warning' - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(status.value), 1) - ]), - _: 1 - }, 8, ["color"]) - ]), - _createElementVNode("div", null, [ - _cache[41] || (_cache[41] = _createElementVNode("strong", null, "订阅配置规则数量:", -1)), - _createTextVNode(" " + _toDisplayString(subscriptionInfo.value.rule_size), 1) - ]), - _createElementVNode("div", null, [ - _cache[42] || (_cache[42] = _createElementVNode("strong", null, "置顶规则数量:", -1)), - _createTextVNode(" " + _toDisplayString(sortedRules.value.length), 1) - ]), - _createElementVNode("div", null, [ - _cache[43] || (_cache[43] = _createElementVNode("strong", null, "规则集规则数量:", -1)), - _createTextVNode(" " + _toDisplayString(sortedRulesetRules.value.length), 1) - ]), - _createElementVNode("div", null, [ - _cache[44] || (_cache[44] = _createElementVNode("strong", null, "最后更新:", -1)), - _createTextVNode(" " + _toDisplayString(lastUpdated.value), 1) - ]) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_col, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card, { class: "flex-grow-1" }, { - default: _withCtx(() => [ - _createVNode(_component_v_card_text, { class: "text-subtitle-2" }, { - default: _withCtx(() => [ - _createElementVNode("div", _hoisted_12, [ - _cache[48] || (_cache[48] = _createElementVNode("div", { class: "text-h6" }, "订阅链接", -1)), - (subUrl.value) - ? (_openBlock(), _createBlock(_component_v_btn, { - key: 0, - icon: "", - size: "small", - variant: "text", - color: "primary", - onClick: _cache[4] || (_cache[4] = $event => (copyToClipboard(subUrl.value))) - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, null, { - default: _withCtx(() => _cache[46] || (_cache[46] = [ - _createTextVNode("mdi-content-copy") - ])), - _: 1 - }), - _createVNode(_component_v_tooltip, { - activator: "parent", - location: "top" - }, { - default: _withCtx(() => _cache[47] || (_cache[47] = [ - _createTextVNode("复制链接") - ])), - _: 1 - }) - ]), - _: 1 - })) - : _createCommentVNode("", true) - ]), - (subUrl.value) - ? (_openBlock(), _createElementBlock("div", _hoisted_13, [ - _createElementVNode("a", { - href: subUrl.value, - target: "_blank", - class: "text-primary" - }, _toDisplayString(subUrl.value), 9, _hoisted_14) - ])) - : (_openBlock(), _createElementBlock("div", _hoisted_15, "未配置订阅URL")) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ])) - ]), - _: 1 - }), - _createVNode(_component_v_card_actions, null, { - default: _withCtx(() => [ - _createVNode(_component_v_btn, { - color: "primary", - onClick: refreshData, - loading: loading.value - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[49] || (_cache[49] = [ - _createTextVNode("mdi-refresh") - ])), - _: 1 - }), - _cache[50] || (_cache[50] = _createTextVNode(" 刷新数据 ")) - ]), - _: 1 - }, 8, ["loading"]), - _createVNode(_component_v_spacer), - _createVNode(_component_v_btn, { - color: "primary", - onClick: notifySwitch - }, { - default: _withCtx(() => [ - _createVNode(_component_v_icon, { left: "" }, { - default: _withCtx(() => _cache[51] || (_cache[51] = [ - _createTextVNode("mdi-cog") - ])), - _: 1 - }), - _cache[52] || (_cache[52] = _createTextVNode(" 配置 ")) - ]), - _: 1 - }) - ]), - _: 1 - }), - _createVNode(_component_v_snackbar, { - modelValue: snackbar.value.show, - "onUpdate:modelValue": _cache[5] || (_cache[5] = $event => ((snackbar.value.show) = $event)), - color: snackbar.value.color, - location: "bottom", - class: "mb-2" - }, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(snackbar.value.message), 1) - ]), - _: 1 - }, 8, ["modelValue", "color"]) - ]), - _: 1 - }), - _createVNode(_component_v_dialog, { - modelValue: ruleDialog.value, - "onUpdate:modelValue": _cache[13] || (_cache[13] = $event => ((ruleDialog).value = $event)), - "max-width": "600" - }, { - default: _withCtx(() => [ - _createVNode(_component_v_card, null, { - default: _withCtx(() => [ - _createVNode(_component_v_card_title, null, { - default: _withCtx(() => [ - _createTextVNode(_toDisplayString(editingPriority.value === null ? '添加规则' : '编辑规则'), 1) - ]), - _: 1 - }), - _createVNode(_component_v_card_text, null, { - default: _withCtx(() => [ - _createVNode(_component_v_select, { - modelValue: newRule.value.type, - "onUpdate:modelValue": _cache[6] || (_cache[6] = $event => ((newRule.value.type) = $event)), - items: ruleTypes.value, - label: "规则类型", - required: "", - class: "mb-4" - }, null, 8, ["modelValue", "items"]), - (newRule.value.type !== 'RULE-SET') - ? (_openBlock(), _createBlock(_component_v_text_field, { - key: 0, - modelValue: newRule.value.payload, - "onUpdate:modelValue": _cache[7] || (_cache[7] = $event => ((newRule.value.payload) = $event)), - label: "内容", - required: "", - class: "mb-4" - }, null, 8, ["modelValue"])) - : (_openBlock(), _createBlock(_component_v_select, { - key: 1, - modelValue: newRule.value.payload, - "onUpdate:modelValue": _cache[8] || (_cache[8] = $event => ((newRule.value.payload) = $event)), - items: ruleProviderNames.value, - label: "选择规则集", - required: "", - class: "mb-4" - }, null, 8, ["modelValue", "items"])), - _createVNode(_component_v_select, { - modelValue: newRule.value.action, - "onUpdate:modelValue": _cache[9] || (_cache[9] = $event => ((newRule.value.action) = $event)), - items: actions.value, - label: "出站", - required: "", - class: "mb-4" - }, null, 8, ["modelValue", "items"]), - (showAdditionalParams.value) - ? (_openBlock(), _createBlock(_component_v_select, { - key: 2, - modelValue: newRule.value.additional_params, - "onUpdate:modelValue": _cache[10] || (_cache[10] = $event => ((newRule.value.additional_params) = $event)), - label: "附加参数", - items: additionalParamOptions.value, - clearable: "", - hint: "可选参数", - "persistent-hint": "", - class: "mb-4" - }, null, 8, ["modelValue", "items"])) - : _createCommentVNode("", true), - (editingPriority.value !== null) - ? (_openBlock(), _createBlock(_component_v_text_field, { - key: 3, - modelValue: newRule.value.priority, - "onUpdate:modelValue": _cache[11] || (_cache[11] = $event => ((newRule.value.priority) = $event)), - modelModifiers: { number: true }, - type: "number", - label: "优先级", - hint: "数字越小优先级越高", - "persistent-hint": "" - }, null, 8, ["modelValue"])) - : _createCommentVNode("", true) - ]), - _: 1 - }), - _createVNode(_component_v_card_actions, null, { - default: _withCtx(() => [ - _createVNode(_component_v_spacer), - _createVNode(_component_v_btn, { - color: "secondary", - onClick: _cache[12] || (_cache[12] = $event => (ruleDialog.value = false)) - }, { - default: _withCtx(() => _cache[53] || (_cache[53] = [ - _createTextVNode("取消") - ])), - _: 1 - }), - _createVNode(_component_v_btn, { - color: "primary", - onClick: saveRule - }, { - default: _withCtx(() => _cache[54] || (_cache[54] = [ - _createTextVNode("保存") - ])), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }) - ]), - _: 1 - }, 8, ["modelValue"]) - ])) -} -} - -}; -const PageComponent = /*#__PURE__*/_export_sfc(_sfc_main, [['__scopeId',"data-v-d5e502a5"]]); - -export { PageComponent as default }; diff --git a/plugins.v2/clashruleprovider/dist/assets/remoteEntry.js b/plugins.v2/clashruleprovider/dist/assets/remoteEntry.js index 015521f..030bd60 100644 --- a/plugins.v2/clashruleprovider/dist/assets/remoteEntry.js +++ b/plugins.v2/clashruleprovider/dist/assets/remoteEntry.js @@ -2,14 +2,14 @@ const currentImports = {}; const exportSet = new Set(['Module', '__esModule', 'default', '_export_sfc']); let moduleMap = { "./Page":()=>{ - dynamicLoadingCss(["__federation_expose_Page-Bl7XNZ7k.css"], false, './Page'); - return __federation_import('./__federation_expose_Page-DlQgf7u6.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)}, + dynamicLoadingCss(["__federation_expose_Page-BiV11X52.css"], false, './Page'); + return __federation_import('./__federation_expose_Page-DSmFC_QV.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)}, "./Config":()=>{ - dynamicLoadingCss(["__federation_expose_Config-DXzIavcD.css"], false, './Config'); - return __federation_import('./__federation_expose_Config-C3BpNVeC.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)}, + dynamicLoadingCss(["__federation_expose_Config-C_eVGIzn.css"], false, './Config'); + return __federation_import('./__federation_expose_Config-BK6LRC9E.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)}, "./Dashboard":()=>{ dynamicLoadingCss([], false, './Dashboard'); - return __federation_import('./__federation_expose_Dashboard-BkyO-3pr.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)},}; + return __federation_import('./__federation_expose_Dashboard-DKtydfsT.js').then(module =>Object.keys(module).every(item => exportSet.has(item)) ? () => module.default : () => module)},}; const seen = {}; const dynamicLoadingCss = (cssFilePaths, dontAppendStylesToHead, exposeItemName) => { const metaUrl = import.meta.url;