@carbon/charts-svelte 0.54.8 → 0.54.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +11 -0
- package/package.json +4 -4
- package/bundle.js +0 -1
- package/index.js +0 -3769
package/index.js
DELETED
|
@@ -1,3769 +0,0 @@
|
|
|
1
|
-
import { AreaChart, StackedAreaChart, GroupedBarChart, SimpleBarChart, StackedBarChart, BoxplotChart, BubbleChart, BulletChart, ComboChart, DonutChart, LineChart, LollipopChart, PieChart, ScatterChart, RadarChart, GaugeChart, HistogramChart, MeterChart, TreeChart, TreemapChart, CirclePackChart, WordCloudChart, AlluvialChart, HeatmapChart } from '@carbon/charts';
|
|
2
|
-
import { createEventDispatcher, onMount } from 'svelte';
|
|
3
|
-
|
|
4
|
-
function noop() { }
|
|
5
|
-
function assign(tar, src) {
|
|
6
|
-
// @ts-ignore
|
|
7
|
-
for (const k in src)
|
|
8
|
-
tar[k] = src[k];
|
|
9
|
-
return tar;
|
|
10
|
-
}
|
|
11
|
-
function run(fn) {
|
|
12
|
-
return fn();
|
|
13
|
-
}
|
|
14
|
-
function blank_object() {
|
|
15
|
-
return Object.create(null);
|
|
16
|
-
}
|
|
17
|
-
function run_all(fns) {
|
|
18
|
-
fns.forEach(run);
|
|
19
|
-
}
|
|
20
|
-
function is_function(thing) {
|
|
21
|
-
return typeof thing === 'function';
|
|
22
|
-
}
|
|
23
|
-
function safe_not_equal(a, b) {
|
|
24
|
-
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
|
|
25
|
-
}
|
|
26
|
-
function is_empty(obj) {
|
|
27
|
-
return Object.keys(obj).length === 0;
|
|
28
|
-
}
|
|
29
|
-
function exclude_internal_props(props) {
|
|
30
|
-
const result = {};
|
|
31
|
-
for (const k in props)
|
|
32
|
-
if (k[0] !== '$')
|
|
33
|
-
result[k] = props[k];
|
|
34
|
-
return result;
|
|
35
|
-
}
|
|
36
|
-
function compute_rest_props(props, keys) {
|
|
37
|
-
const rest = {};
|
|
38
|
-
keys = new Set(keys);
|
|
39
|
-
for (const k in props)
|
|
40
|
-
if (!keys.has(k) && k[0] !== '$')
|
|
41
|
-
rest[k] = props[k];
|
|
42
|
-
return rest;
|
|
43
|
-
}
|
|
44
|
-
function insert(target, node, anchor) {
|
|
45
|
-
target.insertBefore(node, anchor || null);
|
|
46
|
-
}
|
|
47
|
-
function detach(node) {
|
|
48
|
-
node.parentNode.removeChild(node);
|
|
49
|
-
}
|
|
50
|
-
function element(name) {
|
|
51
|
-
return document.createElement(name);
|
|
52
|
-
}
|
|
53
|
-
function attr(node, attribute, value) {
|
|
54
|
-
if (value == null)
|
|
55
|
-
node.removeAttribute(attribute);
|
|
56
|
-
else if (node.getAttribute(attribute) !== value)
|
|
57
|
-
node.setAttribute(attribute, value);
|
|
58
|
-
}
|
|
59
|
-
function set_attributes(node, attributes) {
|
|
60
|
-
// @ts-ignore
|
|
61
|
-
const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
|
|
62
|
-
for (const key in attributes) {
|
|
63
|
-
if (attributes[key] == null) {
|
|
64
|
-
node.removeAttribute(key);
|
|
65
|
-
}
|
|
66
|
-
else if (key === 'style') {
|
|
67
|
-
node.style.cssText = attributes[key];
|
|
68
|
-
}
|
|
69
|
-
else if (key === '__value') {
|
|
70
|
-
node.value = node[key] = attributes[key];
|
|
71
|
-
}
|
|
72
|
-
else if (descriptors[key] && descriptors[key].set) {
|
|
73
|
-
node[key] = attributes[key];
|
|
74
|
-
}
|
|
75
|
-
else {
|
|
76
|
-
attr(node, key, attributes[key]);
|
|
77
|
-
}
|
|
78
|
-
}
|
|
79
|
-
}
|
|
80
|
-
function children(element) {
|
|
81
|
-
return Array.from(element.childNodes);
|
|
82
|
-
}
|
|
83
|
-
|
|
84
|
-
let current_component;
|
|
85
|
-
function set_current_component(component) {
|
|
86
|
-
current_component = component;
|
|
87
|
-
}
|
|
88
|
-
// TODO figure out if we still want to support
|
|
89
|
-
// shorthand events, or if we want to implement
|
|
90
|
-
// a real bubbling mechanism
|
|
91
|
-
function bubble(component, event) {
|
|
92
|
-
const callbacks = component.$$.callbacks[event.type];
|
|
93
|
-
if (callbacks) {
|
|
94
|
-
// @ts-ignore
|
|
95
|
-
callbacks.slice().forEach(fn => fn.call(this, event));
|
|
96
|
-
}
|
|
97
|
-
}
|
|
98
|
-
|
|
99
|
-
const dirty_components = [];
|
|
100
|
-
const binding_callbacks = [];
|
|
101
|
-
const render_callbacks = [];
|
|
102
|
-
const flush_callbacks = [];
|
|
103
|
-
const resolved_promise = Promise.resolve();
|
|
104
|
-
let update_scheduled = false;
|
|
105
|
-
function schedule_update() {
|
|
106
|
-
if (!update_scheduled) {
|
|
107
|
-
update_scheduled = true;
|
|
108
|
-
resolved_promise.then(flush);
|
|
109
|
-
}
|
|
110
|
-
}
|
|
111
|
-
function add_render_callback(fn) {
|
|
112
|
-
render_callbacks.push(fn);
|
|
113
|
-
}
|
|
114
|
-
function add_flush_callback(fn) {
|
|
115
|
-
flush_callbacks.push(fn);
|
|
116
|
-
}
|
|
117
|
-
let flushing = false;
|
|
118
|
-
const seen_callbacks = new Set();
|
|
119
|
-
function flush() {
|
|
120
|
-
if (flushing)
|
|
121
|
-
return;
|
|
122
|
-
flushing = true;
|
|
123
|
-
do {
|
|
124
|
-
// first, call beforeUpdate functions
|
|
125
|
-
// and update components
|
|
126
|
-
for (let i = 0; i < dirty_components.length; i += 1) {
|
|
127
|
-
const component = dirty_components[i];
|
|
128
|
-
set_current_component(component);
|
|
129
|
-
update(component.$$);
|
|
130
|
-
}
|
|
131
|
-
set_current_component(null);
|
|
132
|
-
dirty_components.length = 0;
|
|
133
|
-
while (binding_callbacks.length)
|
|
134
|
-
binding_callbacks.pop()();
|
|
135
|
-
// then, once components are updated, call
|
|
136
|
-
// afterUpdate functions. This may cause
|
|
137
|
-
// subsequent updates...
|
|
138
|
-
for (let i = 0; i < render_callbacks.length; i += 1) {
|
|
139
|
-
const callback = render_callbacks[i];
|
|
140
|
-
if (!seen_callbacks.has(callback)) {
|
|
141
|
-
// ...so guard against infinite loops
|
|
142
|
-
seen_callbacks.add(callback);
|
|
143
|
-
callback();
|
|
144
|
-
}
|
|
145
|
-
}
|
|
146
|
-
render_callbacks.length = 0;
|
|
147
|
-
} while (dirty_components.length);
|
|
148
|
-
while (flush_callbacks.length) {
|
|
149
|
-
flush_callbacks.pop()();
|
|
150
|
-
}
|
|
151
|
-
update_scheduled = false;
|
|
152
|
-
flushing = false;
|
|
153
|
-
seen_callbacks.clear();
|
|
154
|
-
}
|
|
155
|
-
function update($$) {
|
|
156
|
-
if ($$.fragment !== null) {
|
|
157
|
-
$$.update();
|
|
158
|
-
run_all($$.before_update);
|
|
159
|
-
const dirty = $$.dirty;
|
|
160
|
-
$$.dirty = [-1];
|
|
161
|
-
$$.fragment && $$.fragment.p($$.ctx, dirty);
|
|
162
|
-
$$.after_update.forEach(add_render_callback);
|
|
163
|
-
}
|
|
164
|
-
}
|
|
165
|
-
const outroing = new Set();
|
|
166
|
-
let outros;
|
|
167
|
-
function transition_in(block, local) {
|
|
168
|
-
if (block && block.i) {
|
|
169
|
-
outroing.delete(block);
|
|
170
|
-
block.i(local);
|
|
171
|
-
}
|
|
172
|
-
}
|
|
173
|
-
function transition_out(block, local, detach, callback) {
|
|
174
|
-
if (block && block.o) {
|
|
175
|
-
if (outroing.has(block))
|
|
176
|
-
return;
|
|
177
|
-
outroing.add(block);
|
|
178
|
-
outros.c.push(() => {
|
|
179
|
-
outroing.delete(block);
|
|
180
|
-
if (callback) {
|
|
181
|
-
if (detach)
|
|
182
|
-
block.d(1);
|
|
183
|
-
callback();
|
|
184
|
-
}
|
|
185
|
-
});
|
|
186
|
-
block.o(local);
|
|
187
|
-
}
|
|
188
|
-
}
|
|
189
|
-
|
|
190
|
-
function get_spread_update(levels, updates) {
|
|
191
|
-
const update = {};
|
|
192
|
-
const to_null_out = {};
|
|
193
|
-
const accounted_for = { $$scope: 1 };
|
|
194
|
-
let i = levels.length;
|
|
195
|
-
while (i--) {
|
|
196
|
-
const o = levels[i];
|
|
197
|
-
const n = updates[i];
|
|
198
|
-
if (n) {
|
|
199
|
-
for (const key in o) {
|
|
200
|
-
if (!(key in n))
|
|
201
|
-
to_null_out[key] = 1;
|
|
202
|
-
}
|
|
203
|
-
for (const key in n) {
|
|
204
|
-
if (!accounted_for[key]) {
|
|
205
|
-
update[key] = n[key];
|
|
206
|
-
accounted_for[key] = 1;
|
|
207
|
-
}
|
|
208
|
-
}
|
|
209
|
-
levels[i] = n;
|
|
210
|
-
}
|
|
211
|
-
else {
|
|
212
|
-
for (const key in o) {
|
|
213
|
-
accounted_for[key] = 1;
|
|
214
|
-
}
|
|
215
|
-
}
|
|
216
|
-
}
|
|
217
|
-
for (const key in to_null_out) {
|
|
218
|
-
if (!(key in update))
|
|
219
|
-
update[key] = undefined;
|
|
220
|
-
}
|
|
221
|
-
return update;
|
|
222
|
-
}
|
|
223
|
-
function get_spread_object(spread_props) {
|
|
224
|
-
return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};
|
|
225
|
-
}
|
|
226
|
-
|
|
227
|
-
function bind(component, name, callback) {
|
|
228
|
-
const index = component.$$.props[name];
|
|
229
|
-
if (index !== undefined) {
|
|
230
|
-
component.$$.bound[index] = callback;
|
|
231
|
-
callback(component.$$.ctx[index]);
|
|
232
|
-
}
|
|
233
|
-
}
|
|
234
|
-
function create_component(block) {
|
|
235
|
-
block && block.c();
|
|
236
|
-
}
|
|
237
|
-
function mount_component(component, target, anchor, customElement) {
|
|
238
|
-
const { fragment, on_mount, on_destroy, after_update } = component.$$;
|
|
239
|
-
fragment && fragment.m(target, anchor);
|
|
240
|
-
if (!customElement) {
|
|
241
|
-
// onMount happens before the initial afterUpdate
|
|
242
|
-
add_render_callback(() => {
|
|
243
|
-
const new_on_destroy = on_mount.map(run).filter(is_function);
|
|
244
|
-
if (on_destroy) {
|
|
245
|
-
on_destroy.push(...new_on_destroy);
|
|
246
|
-
}
|
|
247
|
-
else {
|
|
248
|
-
// Edge case - component was destroyed immediately,
|
|
249
|
-
// most likely as a result of a binding initialising
|
|
250
|
-
run_all(new_on_destroy);
|
|
251
|
-
}
|
|
252
|
-
component.$$.on_mount = [];
|
|
253
|
-
});
|
|
254
|
-
}
|
|
255
|
-
after_update.forEach(add_render_callback);
|
|
256
|
-
}
|
|
257
|
-
function destroy_component(component, detaching) {
|
|
258
|
-
const $$ = component.$$;
|
|
259
|
-
if ($$.fragment !== null) {
|
|
260
|
-
run_all($$.on_destroy);
|
|
261
|
-
$$.fragment && $$.fragment.d(detaching);
|
|
262
|
-
// TODO null out other refs, including component.$$ (but need to
|
|
263
|
-
// preserve final state?)
|
|
264
|
-
$$.on_destroy = $$.fragment = null;
|
|
265
|
-
$$.ctx = [];
|
|
266
|
-
}
|
|
267
|
-
}
|
|
268
|
-
function make_dirty(component, i) {
|
|
269
|
-
if (component.$$.dirty[0] === -1) {
|
|
270
|
-
dirty_components.push(component);
|
|
271
|
-
schedule_update();
|
|
272
|
-
component.$$.dirty.fill(0);
|
|
273
|
-
}
|
|
274
|
-
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
|
|
275
|
-
}
|
|
276
|
-
function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
|
|
277
|
-
const parent_component = current_component;
|
|
278
|
-
set_current_component(component);
|
|
279
|
-
const $$ = component.$$ = {
|
|
280
|
-
fragment: null,
|
|
281
|
-
ctx: null,
|
|
282
|
-
// state
|
|
283
|
-
props,
|
|
284
|
-
update: noop,
|
|
285
|
-
not_equal,
|
|
286
|
-
bound: blank_object(),
|
|
287
|
-
// lifecycle
|
|
288
|
-
on_mount: [],
|
|
289
|
-
on_destroy: [],
|
|
290
|
-
on_disconnect: [],
|
|
291
|
-
before_update: [],
|
|
292
|
-
after_update: [],
|
|
293
|
-
context: new Map(parent_component ? parent_component.$$.context : options.context || []),
|
|
294
|
-
// everything else
|
|
295
|
-
callbacks: blank_object(),
|
|
296
|
-
dirty,
|
|
297
|
-
skip_bound: false,
|
|
298
|
-
root: options.target || parent_component.$$.root
|
|
299
|
-
};
|
|
300
|
-
append_styles && append_styles($$.root);
|
|
301
|
-
let ready = false;
|
|
302
|
-
$$.ctx = instance
|
|
303
|
-
? instance(component, options.props || {}, (i, ret, ...rest) => {
|
|
304
|
-
const value = rest.length ? rest[0] : ret;
|
|
305
|
-
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
|
|
306
|
-
if (!$$.skip_bound && $$.bound[i])
|
|
307
|
-
$$.bound[i](value);
|
|
308
|
-
if (ready)
|
|
309
|
-
make_dirty(component, i);
|
|
310
|
-
}
|
|
311
|
-
return ret;
|
|
312
|
-
})
|
|
313
|
-
: [];
|
|
314
|
-
$$.update();
|
|
315
|
-
ready = true;
|
|
316
|
-
run_all($$.before_update);
|
|
317
|
-
// `false` as a special case of no DOM component
|
|
318
|
-
$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
|
|
319
|
-
if (options.target) {
|
|
320
|
-
if (options.hydrate) {
|
|
321
|
-
const nodes = children(options.target);
|
|
322
|
-
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
323
|
-
$$.fragment && $$.fragment.l(nodes);
|
|
324
|
-
nodes.forEach(detach);
|
|
325
|
-
}
|
|
326
|
-
else {
|
|
327
|
-
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
328
|
-
$$.fragment && $$.fragment.c();
|
|
329
|
-
}
|
|
330
|
-
if (options.intro)
|
|
331
|
-
transition_in(component.$$.fragment);
|
|
332
|
-
mount_component(component, options.target, options.anchor, options.customElement);
|
|
333
|
-
flush();
|
|
334
|
-
}
|
|
335
|
-
set_current_component(parent_component);
|
|
336
|
-
}
|
|
337
|
-
/**
|
|
338
|
-
* Base class for Svelte components. Used when dev=false.
|
|
339
|
-
*/
|
|
340
|
-
class SvelteComponent {
|
|
341
|
-
$destroy() {
|
|
342
|
-
destroy_component(this, 1);
|
|
343
|
-
this.$destroy = noop;
|
|
344
|
-
}
|
|
345
|
-
$on(type, callback) {
|
|
346
|
-
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
|
|
347
|
-
callbacks.push(callback);
|
|
348
|
-
return () => {
|
|
349
|
-
const index = callbacks.indexOf(callback);
|
|
350
|
-
if (index !== -1)
|
|
351
|
-
callbacks.splice(index, 1);
|
|
352
|
-
};
|
|
353
|
-
}
|
|
354
|
-
$set($$props) {
|
|
355
|
-
if (this.$$set && !is_empty($$props)) {
|
|
356
|
-
this.$$.skip_bound = true;
|
|
357
|
-
this.$$set($$props);
|
|
358
|
-
this.$$.skip_bound = false;
|
|
359
|
-
}
|
|
360
|
-
}
|
|
361
|
-
}
|
|
362
|
-
|
|
363
|
-
/* src/BaseChart.svelte generated by Svelte v3.42.1 */
|
|
364
|
-
|
|
365
|
-
function create_fragment(ctx) {
|
|
366
|
-
let div;
|
|
367
|
-
let div_levels = [/*$$restProps*/ ctx[2], { id: /*id*/ ctx[1] }];
|
|
368
|
-
let div_data = {};
|
|
369
|
-
|
|
370
|
-
for (let i = 0; i < div_levels.length; i += 1) {
|
|
371
|
-
div_data = assign(div_data, div_levels[i]);
|
|
372
|
-
}
|
|
373
|
-
|
|
374
|
-
return {
|
|
375
|
-
c() {
|
|
376
|
-
div = element("div");
|
|
377
|
-
set_attributes(div, div_data);
|
|
378
|
-
},
|
|
379
|
-
m(target, anchor) {
|
|
380
|
-
insert(target, div, anchor);
|
|
381
|
-
/*div_binding*/ ctx[7](div);
|
|
382
|
-
},
|
|
383
|
-
p(ctx, [dirty]) {
|
|
384
|
-
set_attributes(div, div_data = get_spread_update(div_levels, [
|
|
385
|
-
dirty & /*$$restProps*/ 4 && /*$$restProps*/ ctx[2],
|
|
386
|
-
dirty & /*id*/ 2 && { id: /*id*/ ctx[1] }
|
|
387
|
-
]));
|
|
388
|
-
},
|
|
389
|
-
i: noop,
|
|
390
|
-
o: noop,
|
|
391
|
-
d(detaching) {
|
|
392
|
-
if (detaching) detach(div);
|
|
393
|
-
/*div_binding*/ ctx[7](null);
|
|
394
|
-
}
|
|
395
|
-
};
|
|
396
|
-
}
|
|
397
|
-
|
|
398
|
-
function instance($$self, $$props, $$invalidate) {
|
|
399
|
-
const omit_props_names = ["Chart","chart","data","options","id","ref"];
|
|
400
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
401
|
-
let { Chart = undefined } = $$props;
|
|
402
|
-
let { chart = null } = $$props;
|
|
403
|
-
let { data = [] } = $$props;
|
|
404
|
-
let { options = {} } = $$props;
|
|
405
|
-
let { id = "chart-" + Math.random().toString(36) } = $$props;
|
|
406
|
-
let { ref = null } = $$props;
|
|
407
|
-
const dispatch = createEventDispatcher();
|
|
408
|
-
|
|
409
|
-
onMount(() => {
|
|
410
|
-
/**
|
|
411
|
-
* CodeSandbox does not resolve Svelte components from the `svelte` package.json entry.
|
|
412
|
-
* This causes `bind:ref` to be `undefined`; the chart can't mount to the element.
|
|
413
|
-
*
|
|
414
|
-
* We fallback to manually querying the DOM for the chart holder element because
|
|
415
|
-
* CodeSandbox does not use uncompiled Svelte source code.
|
|
416
|
-
*
|
|
417
|
-
* See https://github.com/sveltejs/svelte/issues/2937
|
|
418
|
-
*/
|
|
419
|
-
const element = ref || document.getElementById(id);
|
|
420
|
-
|
|
421
|
-
if (element) {
|
|
422
|
-
$$invalidate(3, chart = new Chart(element, { data, options }));
|
|
423
|
-
dispatch("load", chart);
|
|
424
|
-
}
|
|
425
|
-
|
|
426
|
-
return () => {
|
|
427
|
-
if (chart) {
|
|
428
|
-
chart.components.forEach(component => component.destroy());
|
|
429
|
-
$$invalidate(3, chart = null);
|
|
430
|
-
dispatch("destroy");
|
|
431
|
-
}
|
|
432
|
-
};
|
|
433
|
-
});
|
|
434
|
-
|
|
435
|
-
function div_binding($$value) {
|
|
436
|
-
binding_callbacks[$$value ? 'unshift' : 'push'](() => {
|
|
437
|
-
ref = $$value;
|
|
438
|
-
$$invalidate(0, ref);
|
|
439
|
-
});
|
|
440
|
-
}
|
|
441
|
-
|
|
442
|
-
$$self.$$set = $$new_props => {
|
|
443
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
444
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
445
|
-
if ('Chart' in $$new_props) $$invalidate(4, Chart = $$new_props.Chart);
|
|
446
|
-
if ('chart' in $$new_props) $$invalidate(3, chart = $$new_props.chart);
|
|
447
|
-
if ('data' in $$new_props) $$invalidate(5, data = $$new_props.data);
|
|
448
|
-
if ('options' in $$new_props) $$invalidate(6, options = $$new_props.options);
|
|
449
|
-
if ('id' in $$new_props) $$invalidate(1, id = $$new_props.id);
|
|
450
|
-
if ('ref' in $$new_props) $$invalidate(0, ref = $$new_props.ref);
|
|
451
|
-
};
|
|
452
|
-
|
|
453
|
-
$$self.$$.update = () => {
|
|
454
|
-
if ($$self.$$.dirty & /*chart, data, options*/ 104) {
|
|
455
|
-
if (chart) {
|
|
456
|
-
chart.model.setData(data);
|
|
457
|
-
chart.model.setOptions(options);
|
|
458
|
-
dispatch("update", { data, options });
|
|
459
|
-
}
|
|
460
|
-
}
|
|
461
|
-
};
|
|
462
|
-
|
|
463
|
-
return [ref, id, $$restProps, chart, Chart, data, options, div_binding];
|
|
464
|
-
}
|
|
465
|
-
|
|
466
|
-
class BaseChart extends SvelteComponent {
|
|
467
|
-
constructor(options) {
|
|
468
|
-
super();
|
|
469
|
-
|
|
470
|
-
init(this, options, instance, create_fragment, safe_not_equal, {
|
|
471
|
-
Chart: 4,
|
|
472
|
-
chart: 3,
|
|
473
|
-
data: 5,
|
|
474
|
-
options: 6,
|
|
475
|
-
id: 1,
|
|
476
|
-
ref: 0
|
|
477
|
-
});
|
|
478
|
-
}
|
|
479
|
-
}
|
|
480
|
-
|
|
481
|
-
/* src/AreaChart.svelte generated by Svelte v3.42.1 */
|
|
482
|
-
|
|
483
|
-
function create_fragment$1(ctx) {
|
|
484
|
-
let basechart;
|
|
485
|
-
let updating_ref;
|
|
486
|
-
let updating_chart;
|
|
487
|
-
let current;
|
|
488
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: AreaChart }];
|
|
489
|
-
|
|
490
|
-
function basechart_ref_binding(value) {
|
|
491
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
492
|
-
}
|
|
493
|
-
|
|
494
|
-
function basechart_chart_binding(value) {
|
|
495
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
496
|
-
}
|
|
497
|
-
|
|
498
|
-
let basechart_props = {};
|
|
499
|
-
|
|
500
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
501
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
502
|
-
}
|
|
503
|
-
|
|
504
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
505
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
506
|
-
}
|
|
507
|
-
|
|
508
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
509
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
510
|
-
}
|
|
511
|
-
|
|
512
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
513
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
514
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
515
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
516
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
517
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
518
|
-
|
|
519
|
-
return {
|
|
520
|
-
c() {
|
|
521
|
-
create_component(basechart.$$.fragment);
|
|
522
|
-
},
|
|
523
|
-
m(target, anchor) {
|
|
524
|
-
mount_component(basechart, target, anchor);
|
|
525
|
-
current = true;
|
|
526
|
-
},
|
|
527
|
-
p(ctx, [dirty]) {
|
|
528
|
-
const basechart_changes = (dirty & /*$$restProps, AreaChart*/ 4)
|
|
529
|
-
? get_spread_update(basechart_spread_levels, [
|
|
530
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
531
|
-
dirty & /*AreaChart*/ 0 && { Chart: AreaChart }
|
|
532
|
-
])
|
|
533
|
-
: {};
|
|
534
|
-
|
|
535
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
536
|
-
updating_ref = true;
|
|
537
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
538
|
-
add_flush_callback(() => updating_ref = false);
|
|
539
|
-
}
|
|
540
|
-
|
|
541
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
542
|
-
updating_chart = true;
|
|
543
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
544
|
-
add_flush_callback(() => updating_chart = false);
|
|
545
|
-
}
|
|
546
|
-
|
|
547
|
-
basechart.$set(basechart_changes);
|
|
548
|
-
},
|
|
549
|
-
i(local) {
|
|
550
|
-
if (current) return;
|
|
551
|
-
transition_in(basechart.$$.fragment, local);
|
|
552
|
-
current = true;
|
|
553
|
-
},
|
|
554
|
-
o(local) {
|
|
555
|
-
transition_out(basechart.$$.fragment, local);
|
|
556
|
-
current = false;
|
|
557
|
-
},
|
|
558
|
-
d(detaching) {
|
|
559
|
-
destroy_component(basechart, detaching);
|
|
560
|
-
}
|
|
561
|
-
};
|
|
562
|
-
}
|
|
563
|
-
|
|
564
|
-
function instance$1($$self, $$props, $$invalidate) {
|
|
565
|
-
const omit_props_names = ["chart","ref"];
|
|
566
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
567
|
-
let { chart = null } = $$props;
|
|
568
|
-
let { ref = null } = $$props;
|
|
569
|
-
|
|
570
|
-
function basechart_ref_binding(value) {
|
|
571
|
-
ref = value;
|
|
572
|
-
$$invalidate(1, ref);
|
|
573
|
-
}
|
|
574
|
-
|
|
575
|
-
function basechart_chart_binding(value) {
|
|
576
|
-
chart = value;
|
|
577
|
-
$$invalidate(0, chart);
|
|
578
|
-
}
|
|
579
|
-
|
|
580
|
-
function load_handler(event) {
|
|
581
|
-
bubble.call(this, $$self, event);
|
|
582
|
-
}
|
|
583
|
-
|
|
584
|
-
function update_handler(event) {
|
|
585
|
-
bubble.call(this, $$self, event);
|
|
586
|
-
}
|
|
587
|
-
|
|
588
|
-
function destroy_handler(event) {
|
|
589
|
-
bubble.call(this, $$self, event);
|
|
590
|
-
}
|
|
591
|
-
|
|
592
|
-
$$self.$$set = $$new_props => {
|
|
593
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
594
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
595
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
596
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
597
|
-
};
|
|
598
|
-
|
|
599
|
-
return [
|
|
600
|
-
chart,
|
|
601
|
-
ref,
|
|
602
|
-
$$restProps,
|
|
603
|
-
basechart_ref_binding,
|
|
604
|
-
basechart_chart_binding,
|
|
605
|
-
load_handler,
|
|
606
|
-
update_handler,
|
|
607
|
-
destroy_handler
|
|
608
|
-
];
|
|
609
|
-
}
|
|
610
|
-
|
|
611
|
-
class AreaChart_1 extends SvelteComponent {
|
|
612
|
-
constructor(options) {
|
|
613
|
-
super();
|
|
614
|
-
init(this, options, instance$1, create_fragment$1, safe_not_equal, { chart: 0, ref: 1 });
|
|
615
|
-
}
|
|
616
|
-
}
|
|
617
|
-
|
|
618
|
-
/* src/StackedAreaChart.svelte generated by Svelte v3.42.1 */
|
|
619
|
-
|
|
620
|
-
function create_fragment$2(ctx) {
|
|
621
|
-
let basechart;
|
|
622
|
-
let updating_ref;
|
|
623
|
-
let updating_chart;
|
|
624
|
-
let current;
|
|
625
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: StackedAreaChart }];
|
|
626
|
-
|
|
627
|
-
function basechart_ref_binding(value) {
|
|
628
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
629
|
-
}
|
|
630
|
-
|
|
631
|
-
function basechart_chart_binding(value) {
|
|
632
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
633
|
-
}
|
|
634
|
-
|
|
635
|
-
let basechart_props = {};
|
|
636
|
-
|
|
637
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
638
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
639
|
-
}
|
|
640
|
-
|
|
641
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
642
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
643
|
-
}
|
|
644
|
-
|
|
645
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
646
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
647
|
-
}
|
|
648
|
-
|
|
649
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
650
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
651
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
652
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
653
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
654
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
655
|
-
|
|
656
|
-
return {
|
|
657
|
-
c() {
|
|
658
|
-
create_component(basechart.$$.fragment);
|
|
659
|
-
},
|
|
660
|
-
m(target, anchor) {
|
|
661
|
-
mount_component(basechart, target, anchor);
|
|
662
|
-
current = true;
|
|
663
|
-
},
|
|
664
|
-
p(ctx, [dirty]) {
|
|
665
|
-
const basechart_changes = (dirty & /*$$restProps, StackedAreaChart*/ 4)
|
|
666
|
-
? get_spread_update(basechart_spread_levels, [
|
|
667
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
668
|
-
dirty & /*StackedAreaChart*/ 0 && { Chart: StackedAreaChart }
|
|
669
|
-
])
|
|
670
|
-
: {};
|
|
671
|
-
|
|
672
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
673
|
-
updating_ref = true;
|
|
674
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
675
|
-
add_flush_callback(() => updating_ref = false);
|
|
676
|
-
}
|
|
677
|
-
|
|
678
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
679
|
-
updating_chart = true;
|
|
680
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
681
|
-
add_flush_callback(() => updating_chart = false);
|
|
682
|
-
}
|
|
683
|
-
|
|
684
|
-
basechart.$set(basechart_changes);
|
|
685
|
-
},
|
|
686
|
-
i(local) {
|
|
687
|
-
if (current) return;
|
|
688
|
-
transition_in(basechart.$$.fragment, local);
|
|
689
|
-
current = true;
|
|
690
|
-
},
|
|
691
|
-
o(local) {
|
|
692
|
-
transition_out(basechart.$$.fragment, local);
|
|
693
|
-
current = false;
|
|
694
|
-
},
|
|
695
|
-
d(detaching) {
|
|
696
|
-
destroy_component(basechart, detaching);
|
|
697
|
-
}
|
|
698
|
-
};
|
|
699
|
-
}
|
|
700
|
-
|
|
701
|
-
function instance$2($$self, $$props, $$invalidate) {
|
|
702
|
-
const omit_props_names = ["chart","ref"];
|
|
703
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
704
|
-
let { chart = null } = $$props;
|
|
705
|
-
let { ref = null } = $$props;
|
|
706
|
-
|
|
707
|
-
function basechart_ref_binding(value) {
|
|
708
|
-
ref = value;
|
|
709
|
-
$$invalidate(1, ref);
|
|
710
|
-
}
|
|
711
|
-
|
|
712
|
-
function basechart_chart_binding(value) {
|
|
713
|
-
chart = value;
|
|
714
|
-
$$invalidate(0, chart);
|
|
715
|
-
}
|
|
716
|
-
|
|
717
|
-
function load_handler(event) {
|
|
718
|
-
bubble.call(this, $$self, event);
|
|
719
|
-
}
|
|
720
|
-
|
|
721
|
-
function update_handler(event) {
|
|
722
|
-
bubble.call(this, $$self, event);
|
|
723
|
-
}
|
|
724
|
-
|
|
725
|
-
function destroy_handler(event) {
|
|
726
|
-
bubble.call(this, $$self, event);
|
|
727
|
-
}
|
|
728
|
-
|
|
729
|
-
$$self.$$set = $$new_props => {
|
|
730
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
731
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
732
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
733
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
734
|
-
};
|
|
735
|
-
|
|
736
|
-
return [
|
|
737
|
-
chart,
|
|
738
|
-
ref,
|
|
739
|
-
$$restProps,
|
|
740
|
-
basechart_ref_binding,
|
|
741
|
-
basechart_chart_binding,
|
|
742
|
-
load_handler,
|
|
743
|
-
update_handler,
|
|
744
|
-
destroy_handler
|
|
745
|
-
];
|
|
746
|
-
}
|
|
747
|
-
|
|
748
|
-
class StackedAreaChart_1 extends SvelteComponent {
|
|
749
|
-
constructor(options) {
|
|
750
|
-
super();
|
|
751
|
-
init(this, options, instance$2, create_fragment$2, safe_not_equal, { chart: 0, ref: 1 });
|
|
752
|
-
}
|
|
753
|
-
}
|
|
754
|
-
|
|
755
|
-
/* src/BarChartGrouped.svelte generated by Svelte v3.42.1 */
|
|
756
|
-
|
|
757
|
-
function create_fragment$3(ctx) {
|
|
758
|
-
let basechart;
|
|
759
|
-
let updating_ref;
|
|
760
|
-
let updating_chart;
|
|
761
|
-
let current;
|
|
762
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: GroupedBarChart }];
|
|
763
|
-
|
|
764
|
-
function basechart_ref_binding(value) {
|
|
765
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
766
|
-
}
|
|
767
|
-
|
|
768
|
-
function basechart_chart_binding(value) {
|
|
769
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
770
|
-
}
|
|
771
|
-
|
|
772
|
-
let basechart_props = {};
|
|
773
|
-
|
|
774
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
775
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
776
|
-
}
|
|
777
|
-
|
|
778
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
779
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
780
|
-
}
|
|
781
|
-
|
|
782
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
783
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
784
|
-
}
|
|
785
|
-
|
|
786
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
787
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
788
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
789
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
790
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
791
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
792
|
-
|
|
793
|
-
return {
|
|
794
|
-
c() {
|
|
795
|
-
create_component(basechart.$$.fragment);
|
|
796
|
-
},
|
|
797
|
-
m(target, anchor) {
|
|
798
|
-
mount_component(basechart, target, anchor);
|
|
799
|
-
current = true;
|
|
800
|
-
},
|
|
801
|
-
p(ctx, [dirty]) {
|
|
802
|
-
const basechart_changes = (dirty & /*$$restProps, GroupedBarChart*/ 4)
|
|
803
|
-
? get_spread_update(basechart_spread_levels, [
|
|
804
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
805
|
-
dirty & /*GroupedBarChart*/ 0 && { Chart: GroupedBarChart }
|
|
806
|
-
])
|
|
807
|
-
: {};
|
|
808
|
-
|
|
809
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
810
|
-
updating_ref = true;
|
|
811
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
812
|
-
add_flush_callback(() => updating_ref = false);
|
|
813
|
-
}
|
|
814
|
-
|
|
815
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
816
|
-
updating_chart = true;
|
|
817
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
818
|
-
add_flush_callback(() => updating_chart = false);
|
|
819
|
-
}
|
|
820
|
-
|
|
821
|
-
basechart.$set(basechart_changes);
|
|
822
|
-
},
|
|
823
|
-
i(local) {
|
|
824
|
-
if (current) return;
|
|
825
|
-
transition_in(basechart.$$.fragment, local);
|
|
826
|
-
current = true;
|
|
827
|
-
},
|
|
828
|
-
o(local) {
|
|
829
|
-
transition_out(basechart.$$.fragment, local);
|
|
830
|
-
current = false;
|
|
831
|
-
},
|
|
832
|
-
d(detaching) {
|
|
833
|
-
destroy_component(basechart, detaching);
|
|
834
|
-
}
|
|
835
|
-
};
|
|
836
|
-
}
|
|
837
|
-
|
|
838
|
-
function instance$3($$self, $$props, $$invalidate) {
|
|
839
|
-
const omit_props_names = ["chart","ref"];
|
|
840
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
841
|
-
let { chart = null } = $$props;
|
|
842
|
-
let { ref = null } = $$props;
|
|
843
|
-
|
|
844
|
-
function basechart_ref_binding(value) {
|
|
845
|
-
ref = value;
|
|
846
|
-
$$invalidate(1, ref);
|
|
847
|
-
}
|
|
848
|
-
|
|
849
|
-
function basechart_chart_binding(value) {
|
|
850
|
-
chart = value;
|
|
851
|
-
$$invalidate(0, chart);
|
|
852
|
-
}
|
|
853
|
-
|
|
854
|
-
function load_handler(event) {
|
|
855
|
-
bubble.call(this, $$self, event);
|
|
856
|
-
}
|
|
857
|
-
|
|
858
|
-
function update_handler(event) {
|
|
859
|
-
bubble.call(this, $$self, event);
|
|
860
|
-
}
|
|
861
|
-
|
|
862
|
-
function destroy_handler(event) {
|
|
863
|
-
bubble.call(this, $$self, event);
|
|
864
|
-
}
|
|
865
|
-
|
|
866
|
-
$$self.$$set = $$new_props => {
|
|
867
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
868
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
869
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
870
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
871
|
-
};
|
|
872
|
-
|
|
873
|
-
return [
|
|
874
|
-
chart,
|
|
875
|
-
ref,
|
|
876
|
-
$$restProps,
|
|
877
|
-
basechart_ref_binding,
|
|
878
|
-
basechart_chart_binding,
|
|
879
|
-
load_handler,
|
|
880
|
-
update_handler,
|
|
881
|
-
destroy_handler
|
|
882
|
-
];
|
|
883
|
-
}
|
|
884
|
-
|
|
885
|
-
class BarChartGrouped extends SvelteComponent {
|
|
886
|
-
constructor(options) {
|
|
887
|
-
super();
|
|
888
|
-
init(this, options, instance$3, create_fragment$3, safe_not_equal, { chart: 0, ref: 1 });
|
|
889
|
-
}
|
|
890
|
-
}
|
|
891
|
-
|
|
892
|
-
/* src/BarChartSimple.svelte generated by Svelte v3.42.1 */
|
|
893
|
-
|
|
894
|
-
function create_fragment$4(ctx) {
|
|
895
|
-
let basechart;
|
|
896
|
-
let updating_ref;
|
|
897
|
-
let updating_chart;
|
|
898
|
-
let current;
|
|
899
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: SimpleBarChart }];
|
|
900
|
-
|
|
901
|
-
function basechart_ref_binding(value) {
|
|
902
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
903
|
-
}
|
|
904
|
-
|
|
905
|
-
function basechart_chart_binding(value) {
|
|
906
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
907
|
-
}
|
|
908
|
-
|
|
909
|
-
let basechart_props = {};
|
|
910
|
-
|
|
911
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
912
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
913
|
-
}
|
|
914
|
-
|
|
915
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
916
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
917
|
-
}
|
|
918
|
-
|
|
919
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
920
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
921
|
-
}
|
|
922
|
-
|
|
923
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
924
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
925
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
926
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
927
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
928
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
929
|
-
|
|
930
|
-
return {
|
|
931
|
-
c() {
|
|
932
|
-
create_component(basechart.$$.fragment);
|
|
933
|
-
},
|
|
934
|
-
m(target, anchor) {
|
|
935
|
-
mount_component(basechart, target, anchor);
|
|
936
|
-
current = true;
|
|
937
|
-
},
|
|
938
|
-
p(ctx, [dirty]) {
|
|
939
|
-
const basechart_changes = (dirty & /*$$restProps, SimpleBarChart*/ 4)
|
|
940
|
-
? get_spread_update(basechart_spread_levels, [
|
|
941
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
942
|
-
dirty & /*SimpleBarChart*/ 0 && { Chart: SimpleBarChart }
|
|
943
|
-
])
|
|
944
|
-
: {};
|
|
945
|
-
|
|
946
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
947
|
-
updating_ref = true;
|
|
948
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
949
|
-
add_flush_callback(() => updating_ref = false);
|
|
950
|
-
}
|
|
951
|
-
|
|
952
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
953
|
-
updating_chart = true;
|
|
954
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
955
|
-
add_flush_callback(() => updating_chart = false);
|
|
956
|
-
}
|
|
957
|
-
|
|
958
|
-
basechart.$set(basechart_changes);
|
|
959
|
-
},
|
|
960
|
-
i(local) {
|
|
961
|
-
if (current) return;
|
|
962
|
-
transition_in(basechart.$$.fragment, local);
|
|
963
|
-
current = true;
|
|
964
|
-
},
|
|
965
|
-
o(local) {
|
|
966
|
-
transition_out(basechart.$$.fragment, local);
|
|
967
|
-
current = false;
|
|
968
|
-
},
|
|
969
|
-
d(detaching) {
|
|
970
|
-
destroy_component(basechart, detaching);
|
|
971
|
-
}
|
|
972
|
-
};
|
|
973
|
-
}
|
|
974
|
-
|
|
975
|
-
function instance$4($$self, $$props, $$invalidate) {
|
|
976
|
-
const omit_props_names = ["chart","ref"];
|
|
977
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
978
|
-
let { chart = null } = $$props;
|
|
979
|
-
let { ref = null } = $$props;
|
|
980
|
-
|
|
981
|
-
function basechart_ref_binding(value) {
|
|
982
|
-
ref = value;
|
|
983
|
-
$$invalidate(1, ref);
|
|
984
|
-
}
|
|
985
|
-
|
|
986
|
-
function basechart_chart_binding(value) {
|
|
987
|
-
chart = value;
|
|
988
|
-
$$invalidate(0, chart);
|
|
989
|
-
}
|
|
990
|
-
|
|
991
|
-
function load_handler(event) {
|
|
992
|
-
bubble.call(this, $$self, event);
|
|
993
|
-
}
|
|
994
|
-
|
|
995
|
-
function update_handler(event) {
|
|
996
|
-
bubble.call(this, $$self, event);
|
|
997
|
-
}
|
|
998
|
-
|
|
999
|
-
function destroy_handler(event) {
|
|
1000
|
-
bubble.call(this, $$self, event);
|
|
1001
|
-
}
|
|
1002
|
-
|
|
1003
|
-
$$self.$$set = $$new_props => {
|
|
1004
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1005
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1006
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1007
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1008
|
-
};
|
|
1009
|
-
|
|
1010
|
-
return [
|
|
1011
|
-
chart,
|
|
1012
|
-
ref,
|
|
1013
|
-
$$restProps,
|
|
1014
|
-
basechart_ref_binding,
|
|
1015
|
-
basechart_chart_binding,
|
|
1016
|
-
load_handler,
|
|
1017
|
-
update_handler,
|
|
1018
|
-
destroy_handler
|
|
1019
|
-
];
|
|
1020
|
-
}
|
|
1021
|
-
|
|
1022
|
-
class BarChartSimple extends SvelteComponent {
|
|
1023
|
-
constructor(options) {
|
|
1024
|
-
super();
|
|
1025
|
-
init(this, options, instance$4, create_fragment$4, safe_not_equal, { chart: 0, ref: 1 });
|
|
1026
|
-
}
|
|
1027
|
-
}
|
|
1028
|
-
|
|
1029
|
-
/* src/BarChartStacked.svelte generated by Svelte v3.42.1 */
|
|
1030
|
-
|
|
1031
|
-
function create_fragment$5(ctx) {
|
|
1032
|
-
let basechart;
|
|
1033
|
-
let updating_ref;
|
|
1034
|
-
let updating_chart;
|
|
1035
|
-
let current;
|
|
1036
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: StackedBarChart }];
|
|
1037
|
-
|
|
1038
|
-
function basechart_ref_binding(value) {
|
|
1039
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1040
|
-
}
|
|
1041
|
-
|
|
1042
|
-
function basechart_chart_binding(value) {
|
|
1043
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1044
|
-
}
|
|
1045
|
-
|
|
1046
|
-
let basechart_props = {};
|
|
1047
|
-
|
|
1048
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1049
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1050
|
-
}
|
|
1051
|
-
|
|
1052
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1053
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1054
|
-
}
|
|
1055
|
-
|
|
1056
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1057
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1058
|
-
}
|
|
1059
|
-
|
|
1060
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1061
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1062
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1063
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1064
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1065
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1066
|
-
|
|
1067
|
-
return {
|
|
1068
|
-
c() {
|
|
1069
|
-
create_component(basechart.$$.fragment);
|
|
1070
|
-
},
|
|
1071
|
-
m(target, anchor) {
|
|
1072
|
-
mount_component(basechart, target, anchor);
|
|
1073
|
-
current = true;
|
|
1074
|
-
},
|
|
1075
|
-
p(ctx, [dirty]) {
|
|
1076
|
-
const basechart_changes = (dirty & /*$$restProps, StackedBarChart*/ 4)
|
|
1077
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1078
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1079
|
-
dirty & /*StackedBarChart*/ 0 && { Chart: StackedBarChart }
|
|
1080
|
-
])
|
|
1081
|
-
: {};
|
|
1082
|
-
|
|
1083
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1084
|
-
updating_ref = true;
|
|
1085
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1086
|
-
add_flush_callback(() => updating_ref = false);
|
|
1087
|
-
}
|
|
1088
|
-
|
|
1089
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1090
|
-
updating_chart = true;
|
|
1091
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1092
|
-
add_flush_callback(() => updating_chart = false);
|
|
1093
|
-
}
|
|
1094
|
-
|
|
1095
|
-
basechart.$set(basechart_changes);
|
|
1096
|
-
},
|
|
1097
|
-
i(local) {
|
|
1098
|
-
if (current) return;
|
|
1099
|
-
transition_in(basechart.$$.fragment, local);
|
|
1100
|
-
current = true;
|
|
1101
|
-
},
|
|
1102
|
-
o(local) {
|
|
1103
|
-
transition_out(basechart.$$.fragment, local);
|
|
1104
|
-
current = false;
|
|
1105
|
-
},
|
|
1106
|
-
d(detaching) {
|
|
1107
|
-
destroy_component(basechart, detaching);
|
|
1108
|
-
}
|
|
1109
|
-
};
|
|
1110
|
-
}
|
|
1111
|
-
|
|
1112
|
-
function instance$5($$self, $$props, $$invalidate) {
|
|
1113
|
-
const omit_props_names = ["chart","ref"];
|
|
1114
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1115
|
-
let { chart = null } = $$props;
|
|
1116
|
-
let { ref = null } = $$props;
|
|
1117
|
-
|
|
1118
|
-
function basechart_ref_binding(value) {
|
|
1119
|
-
ref = value;
|
|
1120
|
-
$$invalidate(1, ref);
|
|
1121
|
-
}
|
|
1122
|
-
|
|
1123
|
-
function basechart_chart_binding(value) {
|
|
1124
|
-
chart = value;
|
|
1125
|
-
$$invalidate(0, chart);
|
|
1126
|
-
}
|
|
1127
|
-
|
|
1128
|
-
function load_handler(event) {
|
|
1129
|
-
bubble.call(this, $$self, event);
|
|
1130
|
-
}
|
|
1131
|
-
|
|
1132
|
-
function update_handler(event) {
|
|
1133
|
-
bubble.call(this, $$self, event);
|
|
1134
|
-
}
|
|
1135
|
-
|
|
1136
|
-
function destroy_handler(event) {
|
|
1137
|
-
bubble.call(this, $$self, event);
|
|
1138
|
-
}
|
|
1139
|
-
|
|
1140
|
-
$$self.$$set = $$new_props => {
|
|
1141
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1142
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1143
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1144
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1145
|
-
};
|
|
1146
|
-
|
|
1147
|
-
return [
|
|
1148
|
-
chart,
|
|
1149
|
-
ref,
|
|
1150
|
-
$$restProps,
|
|
1151
|
-
basechart_ref_binding,
|
|
1152
|
-
basechart_chart_binding,
|
|
1153
|
-
load_handler,
|
|
1154
|
-
update_handler,
|
|
1155
|
-
destroy_handler
|
|
1156
|
-
];
|
|
1157
|
-
}
|
|
1158
|
-
|
|
1159
|
-
class BarChartStacked extends SvelteComponent {
|
|
1160
|
-
constructor(options) {
|
|
1161
|
-
super();
|
|
1162
|
-
init(this, options, instance$5, create_fragment$5, safe_not_equal, { chart: 0, ref: 1 });
|
|
1163
|
-
}
|
|
1164
|
-
}
|
|
1165
|
-
|
|
1166
|
-
/* src/BoxplotChart.svelte generated by Svelte v3.42.1 */
|
|
1167
|
-
|
|
1168
|
-
function create_fragment$6(ctx) {
|
|
1169
|
-
let basechart;
|
|
1170
|
-
let updating_ref;
|
|
1171
|
-
let updating_chart;
|
|
1172
|
-
let current;
|
|
1173
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: BoxplotChart }];
|
|
1174
|
-
|
|
1175
|
-
function basechart_ref_binding(value) {
|
|
1176
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1177
|
-
}
|
|
1178
|
-
|
|
1179
|
-
function basechart_chart_binding(value) {
|
|
1180
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1181
|
-
}
|
|
1182
|
-
|
|
1183
|
-
let basechart_props = {};
|
|
1184
|
-
|
|
1185
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1186
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1187
|
-
}
|
|
1188
|
-
|
|
1189
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1190
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1191
|
-
}
|
|
1192
|
-
|
|
1193
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1194
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1195
|
-
}
|
|
1196
|
-
|
|
1197
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1198
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1199
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1200
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1201
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1202
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1203
|
-
|
|
1204
|
-
return {
|
|
1205
|
-
c() {
|
|
1206
|
-
create_component(basechart.$$.fragment);
|
|
1207
|
-
},
|
|
1208
|
-
m(target, anchor) {
|
|
1209
|
-
mount_component(basechart, target, anchor);
|
|
1210
|
-
current = true;
|
|
1211
|
-
},
|
|
1212
|
-
p(ctx, [dirty]) {
|
|
1213
|
-
const basechart_changes = (dirty & /*$$restProps, BoxplotChart*/ 4)
|
|
1214
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1215
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1216
|
-
dirty & /*BoxplotChart*/ 0 && { Chart: BoxplotChart }
|
|
1217
|
-
])
|
|
1218
|
-
: {};
|
|
1219
|
-
|
|
1220
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1221
|
-
updating_ref = true;
|
|
1222
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1223
|
-
add_flush_callback(() => updating_ref = false);
|
|
1224
|
-
}
|
|
1225
|
-
|
|
1226
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1227
|
-
updating_chart = true;
|
|
1228
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1229
|
-
add_flush_callback(() => updating_chart = false);
|
|
1230
|
-
}
|
|
1231
|
-
|
|
1232
|
-
basechart.$set(basechart_changes);
|
|
1233
|
-
},
|
|
1234
|
-
i(local) {
|
|
1235
|
-
if (current) return;
|
|
1236
|
-
transition_in(basechart.$$.fragment, local);
|
|
1237
|
-
current = true;
|
|
1238
|
-
},
|
|
1239
|
-
o(local) {
|
|
1240
|
-
transition_out(basechart.$$.fragment, local);
|
|
1241
|
-
current = false;
|
|
1242
|
-
},
|
|
1243
|
-
d(detaching) {
|
|
1244
|
-
destroy_component(basechart, detaching);
|
|
1245
|
-
}
|
|
1246
|
-
};
|
|
1247
|
-
}
|
|
1248
|
-
|
|
1249
|
-
function instance$6($$self, $$props, $$invalidate) {
|
|
1250
|
-
const omit_props_names = ["chart","ref"];
|
|
1251
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1252
|
-
let { chart = null } = $$props;
|
|
1253
|
-
let { ref = null } = $$props;
|
|
1254
|
-
|
|
1255
|
-
function basechart_ref_binding(value) {
|
|
1256
|
-
ref = value;
|
|
1257
|
-
$$invalidate(1, ref);
|
|
1258
|
-
}
|
|
1259
|
-
|
|
1260
|
-
function basechart_chart_binding(value) {
|
|
1261
|
-
chart = value;
|
|
1262
|
-
$$invalidate(0, chart);
|
|
1263
|
-
}
|
|
1264
|
-
|
|
1265
|
-
function load_handler(event) {
|
|
1266
|
-
bubble.call(this, $$self, event);
|
|
1267
|
-
}
|
|
1268
|
-
|
|
1269
|
-
function update_handler(event) {
|
|
1270
|
-
bubble.call(this, $$self, event);
|
|
1271
|
-
}
|
|
1272
|
-
|
|
1273
|
-
function destroy_handler(event) {
|
|
1274
|
-
bubble.call(this, $$self, event);
|
|
1275
|
-
}
|
|
1276
|
-
|
|
1277
|
-
$$self.$$set = $$new_props => {
|
|
1278
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1279
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1280
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1281
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1282
|
-
};
|
|
1283
|
-
|
|
1284
|
-
return [
|
|
1285
|
-
chart,
|
|
1286
|
-
ref,
|
|
1287
|
-
$$restProps,
|
|
1288
|
-
basechart_ref_binding,
|
|
1289
|
-
basechart_chart_binding,
|
|
1290
|
-
load_handler,
|
|
1291
|
-
update_handler,
|
|
1292
|
-
destroy_handler
|
|
1293
|
-
];
|
|
1294
|
-
}
|
|
1295
|
-
|
|
1296
|
-
class BoxplotChart_1 extends SvelteComponent {
|
|
1297
|
-
constructor(options) {
|
|
1298
|
-
super();
|
|
1299
|
-
init(this, options, instance$6, create_fragment$6, safe_not_equal, { chart: 0, ref: 1 });
|
|
1300
|
-
}
|
|
1301
|
-
}
|
|
1302
|
-
|
|
1303
|
-
/* src/BubbleChart.svelte generated by Svelte v3.42.1 */
|
|
1304
|
-
|
|
1305
|
-
function create_fragment$7(ctx) {
|
|
1306
|
-
let basechart;
|
|
1307
|
-
let updating_ref;
|
|
1308
|
-
let updating_chart;
|
|
1309
|
-
let current;
|
|
1310
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: BubbleChart }];
|
|
1311
|
-
|
|
1312
|
-
function basechart_ref_binding(value) {
|
|
1313
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1314
|
-
}
|
|
1315
|
-
|
|
1316
|
-
function basechart_chart_binding(value) {
|
|
1317
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1318
|
-
}
|
|
1319
|
-
|
|
1320
|
-
let basechart_props = {};
|
|
1321
|
-
|
|
1322
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1323
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1324
|
-
}
|
|
1325
|
-
|
|
1326
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1327
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1328
|
-
}
|
|
1329
|
-
|
|
1330
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1331
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1332
|
-
}
|
|
1333
|
-
|
|
1334
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1335
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1336
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1337
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1338
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1339
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1340
|
-
|
|
1341
|
-
return {
|
|
1342
|
-
c() {
|
|
1343
|
-
create_component(basechart.$$.fragment);
|
|
1344
|
-
},
|
|
1345
|
-
m(target, anchor) {
|
|
1346
|
-
mount_component(basechart, target, anchor);
|
|
1347
|
-
current = true;
|
|
1348
|
-
},
|
|
1349
|
-
p(ctx, [dirty]) {
|
|
1350
|
-
const basechart_changes = (dirty & /*$$restProps, BubbleChart*/ 4)
|
|
1351
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1352
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1353
|
-
dirty & /*BubbleChart*/ 0 && { Chart: BubbleChart }
|
|
1354
|
-
])
|
|
1355
|
-
: {};
|
|
1356
|
-
|
|
1357
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1358
|
-
updating_ref = true;
|
|
1359
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1360
|
-
add_flush_callback(() => updating_ref = false);
|
|
1361
|
-
}
|
|
1362
|
-
|
|
1363
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1364
|
-
updating_chart = true;
|
|
1365
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1366
|
-
add_flush_callback(() => updating_chart = false);
|
|
1367
|
-
}
|
|
1368
|
-
|
|
1369
|
-
basechart.$set(basechart_changes);
|
|
1370
|
-
},
|
|
1371
|
-
i(local) {
|
|
1372
|
-
if (current) return;
|
|
1373
|
-
transition_in(basechart.$$.fragment, local);
|
|
1374
|
-
current = true;
|
|
1375
|
-
},
|
|
1376
|
-
o(local) {
|
|
1377
|
-
transition_out(basechart.$$.fragment, local);
|
|
1378
|
-
current = false;
|
|
1379
|
-
},
|
|
1380
|
-
d(detaching) {
|
|
1381
|
-
destroy_component(basechart, detaching);
|
|
1382
|
-
}
|
|
1383
|
-
};
|
|
1384
|
-
}
|
|
1385
|
-
|
|
1386
|
-
function instance$7($$self, $$props, $$invalidate) {
|
|
1387
|
-
const omit_props_names = ["chart","ref"];
|
|
1388
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1389
|
-
let { chart = null } = $$props;
|
|
1390
|
-
let { ref = null } = $$props;
|
|
1391
|
-
|
|
1392
|
-
function basechart_ref_binding(value) {
|
|
1393
|
-
ref = value;
|
|
1394
|
-
$$invalidate(1, ref);
|
|
1395
|
-
}
|
|
1396
|
-
|
|
1397
|
-
function basechart_chart_binding(value) {
|
|
1398
|
-
chart = value;
|
|
1399
|
-
$$invalidate(0, chart);
|
|
1400
|
-
}
|
|
1401
|
-
|
|
1402
|
-
function load_handler(event) {
|
|
1403
|
-
bubble.call(this, $$self, event);
|
|
1404
|
-
}
|
|
1405
|
-
|
|
1406
|
-
function update_handler(event) {
|
|
1407
|
-
bubble.call(this, $$self, event);
|
|
1408
|
-
}
|
|
1409
|
-
|
|
1410
|
-
function destroy_handler(event) {
|
|
1411
|
-
bubble.call(this, $$self, event);
|
|
1412
|
-
}
|
|
1413
|
-
|
|
1414
|
-
$$self.$$set = $$new_props => {
|
|
1415
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1416
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1417
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1418
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1419
|
-
};
|
|
1420
|
-
|
|
1421
|
-
return [
|
|
1422
|
-
chart,
|
|
1423
|
-
ref,
|
|
1424
|
-
$$restProps,
|
|
1425
|
-
basechart_ref_binding,
|
|
1426
|
-
basechart_chart_binding,
|
|
1427
|
-
load_handler,
|
|
1428
|
-
update_handler,
|
|
1429
|
-
destroy_handler
|
|
1430
|
-
];
|
|
1431
|
-
}
|
|
1432
|
-
|
|
1433
|
-
class BubbleChart_1 extends SvelteComponent {
|
|
1434
|
-
constructor(options) {
|
|
1435
|
-
super();
|
|
1436
|
-
init(this, options, instance$7, create_fragment$7, safe_not_equal, { chart: 0, ref: 1 });
|
|
1437
|
-
}
|
|
1438
|
-
}
|
|
1439
|
-
|
|
1440
|
-
/* src/BulletChart.svelte generated by Svelte v3.42.1 */
|
|
1441
|
-
|
|
1442
|
-
function create_fragment$8(ctx) {
|
|
1443
|
-
let basechart;
|
|
1444
|
-
let updating_ref;
|
|
1445
|
-
let updating_chart;
|
|
1446
|
-
let current;
|
|
1447
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: BulletChart }];
|
|
1448
|
-
|
|
1449
|
-
function basechart_ref_binding(value) {
|
|
1450
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1451
|
-
}
|
|
1452
|
-
|
|
1453
|
-
function basechart_chart_binding(value) {
|
|
1454
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1455
|
-
}
|
|
1456
|
-
|
|
1457
|
-
let basechart_props = {};
|
|
1458
|
-
|
|
1459
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1460
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1461
|
-
}
|
|
1462
|
-
|
|
1463
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1464
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1465
|
-
}
|
|
1466
|
-
|
|
1467
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1468
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1469
|
-
}
|
|
1470
|
-
|
|
1471
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1472
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1473
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1474
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1475
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1476
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1477
|
-
|
|
1478
|
-
return {
|
|
1479
|
-
c() {
|
|
1480
|
-
create_component(basechart.$$.fragment);
|
|
1481
|
-
},
|
|
1482
|
-
m(target, anchor) {
|
|
1483
|
-
mount_component(basechart, target, anchor);
|
|
1484
|
-
current = true;
|
|
1485
|
-
},
|
|
1486
|
-
p(ctx, [dirty]) {
|
|
1487
|
-
const basechart_changes = (dirty & /*$$restProps, BulletChart*/ 4)
|
|
1488
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1489
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1490
|
-
dirty & /*BulletChart*/ 0 && { Chart: BulletChart }
|
|
1491
|
-
])
|
|
1492
|
-
: {};
|
|
1493
|
-
|
|
1494
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1495
|
-
updating_ref = true;
|
|
1496
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1497
|
-
add_flush_callback(() => updating_ref = false);
|
|
1498
|
-
}
|
|
1499
|
-
|
|
1500
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1501
|
-
updating_chart = true;
|
|
1502
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1503
|
-
add_flush_callback(() => updating_chart = false);
|
|
1504
|
-
}
|
|
1505
|
-
|
|
1506
|
-
basechart.$set(basechart_changes);
|
|
1507
|
-
},
|
|
1508
|
-
i(local) {
|
|
1509
|
-
if (current) return;
|
|
1510
|
-
transition_in(basechart.$$.fragment, local);
|
|
1511
|
-
current = true;
|
|
1512
|
-
},
|
|
1513
|
-
o(local) {
|
|
1514
|
-
transition_out(basechart.$$.fragment, local);
|
|
1515
|
-
current = false;
|
|
1516
|
-
},
|
|
1517
|
-
d(detaching) {
|
|
1518
|
-
destroy_component(basechart, detaching);
|
|
1519
|
-
}
|
|
1520
|
-
};
|
|
1521
|
-
}
|
|
1522
|
-
|
|
1523
|
-
function instance$8($$self, $$props, $$invalidate) {
|
|
1524
|
-
const omit_props_names = ["chart","ref"];
|
|
1525
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1526
|
-
let { chart = null } = $$props;
|
|
1527
|
-
let { ref = null } = $$props;
|
|
1528
|
-
|
|
1529
|
-
function basechart_ref_binding(value) {
|
|
1530
|
-
ref = value;
|
|
1531
|
-
$$invalidate(1, ref);
|
|
1532
|
-
}
|
|
1533
|
-
|
|
1534
|
-
function basechart_chart_binding(value) {
|
|
1535
|
-
chart = value;
|
|
1536
|
-
$$invalidate(0, chart);
|
|
1537
|
-
}
|
|
1538
|
-
|
|
1539
|
-
function load_handler(event) {
|
|
1540
|
-
bubble.call(this, $$self, event);
|
|
1541
|
-
}
|
|
1542
|
-
|
|
1543
|
-
function update_handler(event) {
|
|
1544
|
-
bubble.call(this, $$self, event);
|
|
1545
|
-
}
|
|
1546
|
-
|
|
1547
|
-
function destroy_handler(event) {
|
|
1548
|
-
bubble.call(this, $$self, event);
|
|
1549
|
-
}
|
|
1550
|
-
|
|
1551
|
-
$$self.$$set = $$new_props => {
|
|
1552
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1553
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1554
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1555
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1556
|
-
};
|
|
1557
|
-
|
|
1558
|
-
return [
|
|
1559
|
-
chart,
|
|
1560
|
-
ref,
|
|
1561
|
-
$$restProps,
|
|
1562
|
-
basechart_ref_binding,
|
|
1563
|
-
basechart_chart_binding,
|
|
1564
|
-
load_handler,
|
|
1565
|
-
update_handler,
|
|
1566
|
-
destroy_handler
|
|
1567
|
-
];
|
|
1568
|
-
}
|
|
1569
|
-
|
|
1570
|
-
class BulletChart_1 extends SvelteComponent {
|
|
1571
|
-
constructor(options) {
|
|
1572
|
-
super();
|
|
1573
|
-
init(this, options, instance$8, create_fragment$8, safe_not_equal, { chart: 0, ref: 1 });
|
|
1574
|
-
}
|
|
1575
|
-
}
|
|
1576
|
-
|
|
1577
|
-
/* src/ComboChart.svelte generated by Svelte v3.42.1 */
|
|
1578
|
-
|
|
1579
|
-
function create_fragment$9(ctx) {
|
|
1580
|
-
let basechart;
|
|
1581
|
-
let updating_ref;
|
|
1582
|
-
let updating_chart;
|
|
1583
|
-
let current;
|
|
1584
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: ComboChart }];
|
|
1585
|
-
|
|
1586
|
-
function basechart_ref_binding(value) {
|
|
1587
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1588
|
-
}
|
|
1589
|
-
|
|
1590
|
-
function basechart_chart_binding(value) {
|
|
1591
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1592
|
-
}
|
|
1593
|
-
|
|
1594
|
-
let basechart_props = {};
|
|
1595
|
-
|
|
1596
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1597
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1598
|
-
}
|
|
1599
|
-
|
|
1600
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1601
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1602
|
-
}
|
|
1603
|
-
|
|
1604
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1605
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1606
|
-
}
|
|
1607
|
-
|
|
1608
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1609
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1610
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1611
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1612
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1613
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1614
|
-
|
|
1615
|
-
return {
|
|
1616
|
-
c() {
|
|
1617
|
-
create_component(basechart.$$.fragment);
|
|
1618
|
-
},
|
|
1619
|
-
m(target, anchor) {
|
|
1620
|
-
mount_component(basechart, target, anchor);
|
|
1621
|
-
current = true;
|
|
1622
|
-
},
|
|
1623
|
-
p(ctx, [dirty]) {
|
|
1624
|
-
const basechart_changes = (dirty & /*$$restProps, ComboChart*/ 4)
|
|
1625
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1626
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1627
|
-
dirty & /*ComboChart*/ 0 && { Chart: ComboChart }
|
|
1628
|
-
])
|
|
1629
|
-
: {};
|
|
1630
|
-
|
|
1631
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1632
|
-
updating_ref = true;
|
|
1633
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1634
|
-
add_flush_callback(() => updating_ref = false);
|
|
1635
|
-
}
|
|
1636
|
-
|
|
1637
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1638
|
-
updating_chart = true;
|
|
1639
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1640
|
-
add_flush_callback(() => updating_chart = false);
|
|
1641
|
-
}
|
|
1642
|
-
|
|
1643
|
-
basechart.$set(basechart_changes);
|
|
1644
|
-
},
|
|
1645
|
-
i(local) {
|
|
1646
|
-
if (current) return;
|
|
1647
|
-
transition_in(basechart.$$.fragment, local);
|
|
1648
|
-
current = true;
|
|
1649
|
-
},
|
|
1650
|
-
o(local) {
|
|
1651
|
-
transition_out(basechart.$$.fragment, local);
|
|
1652
|
-
current = false;
|
|
1653
|
-
},
|
|
1654
|
-
d(detaching) {
|
|
1655
|
-
destroy_component(basechart, detaching);
|
|
1656
|
-
}
|
|
1657
|
-
};
|
|
1658
|
-
}
|
|
1659
|
-
|
|
1660
|
-
function instance$9($$self, $$props, $$invalidate) {
|
|
1661
|
-
const omit_props_names = ["chart","ref"];
|
|
1662
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1663
|
-
let { chart = null } = $$props;
|
|
1664
|
-
let { ref = null } = $$props;
|
|
1665
|
-
|
|
1666
|
-
function basechart_ref_binding(value) {
|
|
1667
|
-
ref = value;
|
|
1668
|
-
$$invalidate(1, ref);
|
|
1669
|
-
}
|
|
1670
|
-
|
|
1671
|
-
function basechart_chart_binding(value) {
|
|
1672
|
-
chart = value;
|
|
1673
|
-
$$invalidate(0, chart);
|
|
1674
|
-
}
|
|
1675
|
-
|
|
1676
|
-
function load_handler(event) {
|
|
1677
|
-
bubble.call(this, $$self, event);
|
|
1678
|
-
}
|
|
1679
|
-
|
|
1680
|
-
function update_handler(event) {
|
|
1681
|
-
bubble.call(this, $$self, event);
|
|
1682
|
-
}
|
|
1683
|
-
|
|
1684
|
-
function destroy_handler(event) {
|
|
1685
|
-
bubble.call(this, $$self, event);
|
|
1686
|
-
}
|
|
1687
|
-
|
|
1688
|
-
$$self.$$set = $$new_props => {
|
|
1689
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1690
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1691
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1692
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1693
|
-
};
|
|
1694
|
-
|
|
1695
|
-
return [
|
|
1696
|
-
chart,
|
|
1697
|
-
ref,
|
|
1698
|
-
$$restProps,
|
|
1699
|
-
basechart_ref_binding,
|
|
1700
|
-
basechart_chart_binding,
|
|
1701
|
-
load_handler,
|
|
1702
|
-
update_handler,
|
|
1703
|
-
destroy_handler
|
|
1704
|
-
];
|
|
1705
|
-
}
|
|
1706
|
-
|
|
1707
|
-
class ComboChart_1 extends SvelteComponent {
|
|
1708
|
-
constructor(options) {
|
|
1709
|
-
super();
|
|
1710
|
-
init(this, options, instance$9, create_fragment$9, safe_not_equal, { chart: 0, ref: 1 });
|
|
1711
|
-
}
|
|
1712
|
-
}
|
|
1713
|
-
|
|
1714
|
-
/* src/DonutChart.svelte generated by Svelte v3.42.1 */
|
|
1715
|
-
|
|
1716
|
-
function create_fragment$a(ctx) {
|
|
1717
|
-
let basechart;
|
|
1718
|
-
let updating_ref;
|
|
1719
|
-
let updating_chart;
|
|
1720
|
-
let current;
|
|
1721
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: DonutChart }];
|
|
1722
|
-
|
|
1723
|
-
function basechart_ref_binding(value) {
|
|
1724
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1725
|
-
}
|
|
1726
|
-
|
|
1727
|
-
function basechart_chart_binding(value) {
|
|
1728
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1729
|
-
}
|
|
1730
|
-
|
|
1731
|
-
let basechart_props = {};
|
|
1732
|
-
|
|
1733
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1734
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1735
|
-
}
|
|
1736
|
-
|
|
1737
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1738
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1739
|
-
}
|
|
1740
|
-
|
|
1741
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1742
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1743
|
-
}
|
|
1744
|
-
|
|
1745
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1746
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1747
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1748
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1749
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1750
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1751
|
-
|
|
1752
|
-
return {
|
|
1753
|
-
c() {
|
|
1754
|
-
create_component(basechart.$$.fragment);
|
|
1755
|
-
},
|
|
1756
|
-
m(target, anchor) {
|
|
1757
|
-
mount_component(basechart, target, anchor);
|
|
1758
|
-
current = true;
|
|
1759
|
-
},
|
|
1760
|
-
p(ctx, [dirty]) {
|
|
1761
|
-
const basechart_changes = (dirty & /*$$restProps, DonutChart*/ 4)
|
|
1762
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1763
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1764
|
-
dirty & /*DonutChart*/ 0 && { Chart: DonutChart }
|
|
1765
|
-
])
|
|
1766
|
-
: {};
|
|
1767
|
-
|
|
1768
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1769
|
-
updating_ref = true;
|
|
1770
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1771
|
-
add_flush_callback(() => updating_ref = false);
|
|
1772
|
-
}
|
|
1773
|
-
|
|
1774
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1775
|
-
updating_chart = true;
|
|
1776
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1777
|
-
add_flush_callback(() => updating_chart = false);
|
|
1778
|
-
}
|
|
1779
|
-
|
|
1780
|
-
basechart.$set(basechart_changes);
|
|
1781
|
-
},
|
|
1782
|
-
i(local) {
|
|
1783
|
-
if (current) return;
|
|
1784
|
-
transition_in(basechart.$$.fragment, local);
|
|
1785
|
-
current = true;
|
|
1786
|
-
},
|
|
1787
|
-
o(local) {
|
|
1788
|
-
transition_out(basechart.$$.fragment, local);
|
|
1789
|
-
current = false;
|
|
1790
|
-
},
|
|
1791
|
-
d(detaching) {
|
|
1792
|
-
destroy_component(basechart, detaching);
|
|
1793
|
-
}
|
|
1794
|
-
};
|
|
1795
|
-
}
|
|
1796
|
-
|
|
1797
|
-
function instance$a($$self, $$props, $$invalidate) {
|
|
1798
|
-
const omit_props_names = ["chart","ref"];
|
|
1799
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1800
|
-
let { chart = null } = $$props;
|
|
1801
|
-
let { ref = null } = $$props;
|
|
1802
|
-
|
|
1803
|
-
function basechart_ref_binding(value) {
|
|
1804
|
-
ref = value;
|
|
1805
|
-
$$invalidate(1, ref);
|
|
1806
|
-
}
|
|
1807
|
-
|
|
1808
|
-
function basechart_chart_binding(value) {
|
|
1809
|
-
chart = value;
|
|
1810
|
-
$$invalidate(0, chart);
|
|
1811
|
-
}
|
|
1812
|
-
|
|
1813
|
-
function load_handler(event) {
|
|
1814
|
-
bubble.call(this, $$self, event);
|
|
1815
|
-
}
|
|
1816
|
-
|
|
1817
|
-
function update_handler(event) {
|
|
1818
|
-
bubble.call(this, $$self, event);
|
|
1819
|
-
}
|
|
1820
|
-
|
|
1821
|
-
function destroy_handler(event) {
|
|
1822
|
-
bubble.call(this, $$self, event);
|
|
1823
|
-
}
|
|
1824
|
-
|
|
1825
|
-
$$self.$$set = $$new_props => {
|
|
1826
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1827
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1828
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1829
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1830
|
-
};
|
|
1831
|
-
|
|
1832
|
-
return [
|
|
1833
|
-
chart,
|
|
1834
|
-
ref,
|
|
1835
|
-
$$restProps,
|
|
1836
|
-
basechart_ref_binding,
|
|
1837
|
-
basechart_chart_binding,
|
|
1838
|
-
load_handler,
|
|
1839
|
-
update_handler,
|
|
1840
|
-
destroy_handler
|
|
1841
|
-
];
|
|
1842
|
-
}
|
|
1843
|
-
|
|
1844
|
-
class DonutChart_1 extends SvelteComponent {
|
|
1845
|
-
constructor(options) {
|
|
1846
|
-
super();
|
|
1847
|
-
init(this, options, instance$a, create_fragment$a, safe_not_equal, { chart: 0, ref: 1 });
|
|
1848
|
-
}
|
|
1849
|
-
}
|
|
1850
|
-
|
|
1851
|
-
/* src/LineChart.svelte generated by Svelte v3.42.1 */
|
|
1852
|
-
|
|
1853
|
-
function create_fragment$b(ctx) {
|
|
1854
|
-
let basechart;
|
|
1855
|
-
let updating_ref;
|
|
1856
|
-
let updating_chart;
|
|
1857
|
-
let current;
|
|
1858
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: LineChart }];
|
|
1859
|
-
|
|
1860
|
-
function basechart_ref_binding(value) {
|
|
1861
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1862
|
-
}
|
|
1863
|
-
|
|
1864
|
-
function basechart_chart_binding(value) {
|
|
1865
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
1866
|
-
}
|
|
1867
|
-
|
|
1868
|
-
let basechart_props = {};
|
|
1869
|
-
|
|
1870
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
1871
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
1872
|
-
}
|
|
1873
|
-
|
|
1874
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
1875
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
1876
|
-
}
|
|
1877
|
-
|
|
1878
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
1879
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
1880
|
-
}
|
|
1881
|
-
|
|
1882
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
1883
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
1884
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
1885
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
1886
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
1887
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
1888
|
-
|
|
1889
|
-
return {
|
|
1890
|
-
c() {
|
|
1891
|
-
create_component(basechart.$$.fragment);
|
|
1892
|
-
},
|
|
1893
|
-
m(target, anchor) {
|
|
1894
|
-
mount_component(basechart, target, anchor);
|
|
1895
|
-
current = true;
|
|
1896
|
-
},
|
|
1897
|
-
p(ctx, [dirty]) {
|
|
1898
|
-
const basechart_changes = (dirty & /*$$restProps, LineChart*/ 4)
|
|
1899
|
-
? get_spread_update(basechart_spread_levels, [
|
|
1900
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
1901
|
-
dirty & /*LineChart*/ 0 && { Chart: LineChart }
|
|
1902
|
-
])
|
|
1903
|
-
: {};
|
|
1904
|
-
|
|
1905
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
1906
|
-
updating_ref = true;
|
|
1907
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
1908
|
-
add_flush_callback(() => updating_ref = false);
|
|
1909
|
-
}
|
|
1910
|
-
|
|
1911
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
1912
|
-
updating_chart = true;
|
|
1913
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
1914
|
-
add_flush_callback(() => updating_chart = false);
|
|
1915
|
-
}
|
|
1916
|
-
|
|
1917
|
-
basechart.$set(basechart_changes);
|
|
1918
|
-
},
|
|
1919
|
-
i(local) {
|
|
1920
|
-
if (current) return;
|
|
1921
|
-
transition_in(basechart.$$.fragment, local);
|
|
1922
|
-
current = true;
|
|
1923
|
-
},
|
|
1924
|
-
o(local) {
|
|
1925
|
-
transition_out(basechart.$$.fragment, local);
|
|
1926
|
-
current = false;
|
|
1927
|
-
},
|
|
1928
|
-
d(detaching) {
|
|
1929
|
-
destroy_component(basechart, detaching);
|
|
1930
|
-
}
|
|
1931
|
-
};
|
|
1932
|
-
}
|
|
1933
|
-
|
|
1934
|
-
function instance$b($$self, $$props, $$invalidate) {
|
|
1935
|
-
const omit_props_names = ["chart","ref"];
|
|
1936
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
1937
|
-
let { chart = null } = $$props;
|
|
1938
|
-
let { ref = null } = $$props;
|
|
1939
|
-
|
|
1940
|
-
function basechart_ref_binding(value) {
|
|
1941
|
-
ref = value;
|
|
1942
|
-
$$invalidate(1, ref);
|
|
1943
|
-
}
|
|
1944
|
-
|
|
1945
|
-
function basechart_chart_binding(value) {
|
|
1946
|
-
chart = value;
|
|
1947
|
-
$$invalidate(0, chart);
|
|
1948
|
-
}
|
|
1949
|
-
|
|
1950
|
-
function load_handler(event) {
|
|
1951
|
-
bubble.call(this, $$self, event);
|
|
1952
|
-
}
|
|
1953
|
-
|
|
1954
|
-
function update_handler(event) {
|
|
1955
|
-
bubble.call(this, $$self, event);
|
|
1956
|
-
}
|
|
1957
|
-
|
|
1958
|
-
function destroy_handler(event) {
|
|
1959
|
-
bubble.call(this, $$self, event);
|
|
1960
|
-
}
|
|
1961
|
-
|
|
1962
|
-
$$self.$$set = $$new_props => {
|
|
1963
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
1964
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
1965
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
1966
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
1967
|
-
};
|
|
1968
|
-
|
|
1969
|
-
return [
|
|
1970
|
-
chart,
|
|
1971
|
-
ref,
|
|
1972
|
-
$$restProps,
|
|
1973
|
-
basechart_ref_binding,
|
|
1974
|
-
basechart_chart_binding,
|
|
1975
|
-
load_handler,
|
|
1976
|
-
update_handler,
|
|
1977
|
-
destroy_handler
|
|
1978
|
-
];
|
|
1979
|
-
}
|
|
1980
|
-
|
|
1981
|
-
class LineChart_1 extends SvelteComponent {
|
|
1982
|
-
constructor(options) {
|
|
1983
|
-
super();
|
|
1984
|
-
init(this, options, instance$b, create_fragment$b, safe_not_equal, { chart: 0, ref: 1 });
|
|
1985
|
-
}
|
|
1986
|
-
}
|
|
1987
|
-
|
|
1988
|
-
/* src/LollipopChart.svelte generated by Svelte v3.42.1 */
|
|
1989
|
-
|
|
1990
|
-
function create_fragment$c(ctx) {
|
|
1991
|
-
let basechart;
|
|
1992
|
-
let updating_ref;
|
|
1993
|
-
let updating_chart;
|
|
1994
|
-
let current;
|
|
1995
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: LollipopChart }];
|
|
1996
|
-
|
|
1997
|
-
function basechart_ref_binding(value) {
|
|
1998
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
1999
|
-
}
|
|
2000
|
-
|
|
2001
|
-
function basechart_chart_binding(value) {
|
|
2002
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2003
|
-
}
|
|
2004
|
-
|
|
2005
|
-
let basechart_props = {};
|
|
2006
|
-
|
|
2007
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2008
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2009
|
-
}
|
|
2010
|
-
|
|
2011
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2012
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2013
|
-
}
|
|
2014
|
-
|
|
2015
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2016
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2017
|
-
}
|
|
2018
|
-
|
|
2019
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2020
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2021
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2022
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2023
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2024
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2025
|
-
|
|
2026
|
-
return {
|
|
2027
|
-
c() {
|
|
2028
|
-
create_component(basechart.$$.fragment);
|
|
2029
|
-
},
|
|
2030
|
-
m(target, anchor) {
|
|
2031
|
-
mount_component(basechart, target, anchor);
|
|
2032
|
-
current = true;
|
|
2033
|
-
},
|
|
2034
|
-
p(ctx, [dirty]) {
|
|
2035
|
-
const basechart_changes = (dirty & /*$$restProps, LollipopChart*/ 4)
|
|
2036
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2037
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2038
|
-
dirty & /*LollipopChart*/ 0 && { Chart: LollipopChart }
|
|
2039
|
-
])
|
|
2040
|
-
: {};
|
|
2041
|
-
|
|
2042
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2043
|
-
updating_ref = true;
|
|
2044
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2045
|
-
add_flush_callback(() => updating_ref = false);
|
|
2046
|
-
}
|
|
2047
|
-
|
|
2048
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2049
|
-
updating_chart = true;
|
|
2050
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2051
|
-
add_flush_callback(() => updating_chart = false);
|
|
2052
|
-
}
|
|
2053
|
-
|
|
2054
|
-
basechart.$set(basechart_changes);
|
|
2055
|
-
},
|
|
2056
|
-
i(local) {
|
|
2057
|
-
if (current) return;
|
|
2058
|
-
transition_in(basechart.$$.fragment, local);
|
|
2059
|
-
current = true;
|
|
2060
|
-
},
|
|
2061
|
-
o(local) {
|
|
2062
|
-
transition_out(basechart.$$.fragment, local);
|
|
2063
|
-
current = false;
|
|
2064
|
-
},
|
|
2065
|
-
d(detaching) {
|
|
2066
|
-
destroy_component(basechart, detaching);
|
|
2067
|
-
}
|
|
2068
|
-
};
|
|
2069
|
-
}
|
|
2070
|
-
|
|
2071
|
-
function instance$c($$self, $$props, $$invalidate) {
|
|
2072
|
-
const omit_props_names = ["chart","ref"];
|
|
2073
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2074
|
-
let { chart = null } = $$props;
|
|
2075
|
-
let { ref = null } = $$props;
|
|
2076
|
-
|
|
2077
|
-
function basechart_ref_binding(value) {
|
|
2078
|
-
ref = value;
|
|
2079
|
-
$$invalidate(1, ref);
|
|
2080
|
-
}
|
|
2081
|
-
|
|
2082
|
-
function basechart_chart_binding(value) {
|
|
2083
|
-
chart = value;
|
|
2084
|
-
$$invalidate(0, chart);
|
|
2085
|
-
}
|
|
2086
|
-
|
|
2087
|
-
function load_handler(event) {
|
|
2088
|
-
bubble.call(this, $$self, event);
|
|
2089
|
-
}
|
|
2090
|
-
|
|
2091
|
-
function update_handler(event) {
|
|
2092
|
-
bubble.call(this, $$self, event);
|
|
2093
|
-
}
|
|
2094
|
-
|
|
2095
|
-
function destroy_handler(event) {
|
|
2096
|
-
bubble.call(this, $$self, event);
|
|
2097
|
-
}
|
|
2098
|
-
|
|
2099
|
-
$$self.$$set = $$new_props => {
|
|
2100
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2101
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2102
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2103
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2104
|
-
};
|
|
2105
|
-
|
|
2106
|
-
return [
|
|
2107
|
-
chart,
|
|
2108
|
-
ref,
|
|
2109
|
-
$$restProps,
|
|
2110
|
-
basechart_ref_binding,
|
|
2111
|
-
basechart_chart_binding,
|
|
2112
|
-
load_handler,
|
|
2113
|
-
update_handler,
|
|
2114
|
-
destroy_handler
|
|
2115
|
-
];
|
|
2116
|
-
}
|
|
2117
|
-
|
|
2118
|
-
class LollipopChart_1 extends SvelteComponent {
|
|
2119
|
-
constructor(options) {
|
|
2120
|
-
super();
|
|
2121
|
-
init(this, options, instance$c, create_fragment$c, safe_not_equal, { chart: 0, ref: 1 });
|
|
2122
|
-
}
|
|
2123
|
-
}
|
|
2124
|
-
|
|
2125
|
-
/* src/PieChart.svelte generated by Svelte v3.42.1 */
|
|
2126
|
-
|
|
2127
|
-
function create_fragment$d(ctx) {
|
|
2128
|
-
let basechart;
|
|
2129
|
-
let updating_ref;
|
|
2130
|
-
let updating_chart;
|
|
2131
|
-
let current;
|
|
2132
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: PieChart }];
|
|
2133
|
-
|
|
2134
|
-
function basechart_ref_binding(value) {
|
|
2135
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2136
|
-
}
|
|
2137
|
-
|
|
2138
|
-
function basechart_chart_binding(value) {
|
|
2139
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2140
|
-
}
|
|
2141
|
-
|
|
2142
|
-
let basechart_props = {};
|
|
2143
|
-
|
|
2144
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2145
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2146
|
-
}
|
|
2147
|
-
|
|
2148
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2149
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2150
|
-
}
|
|
2151
|
-
|
|
2152
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2153
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2154
|
-
}
|
|
2155
|
-
|
|
2156
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2157
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2158
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2159
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2160
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2161
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2162
|
-
|
|
2163
|
-
return {
|
|
2164
|
-
c() {
|
|
2165
|
-
create_component(basechart.$$.fragment);
|
|
2166
|
-
},
|
|
2167
|
-
m(target, anchor) {
|
|
2168
|
-
mount_component(basechart, target, anchor);
|
|
2169
|
-
current = true;
|
|
2170
|
-
},
|
|
2171
|
-
p(ctx, [dirty]) {
|
|
2172
|
-
const basechart_changes = (dirty & /*$$restProps, PieChart*/ 4)
|
|
2173
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2174
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2175
|
-
dirty & /*PieChart*/ 0 && { Chart: PieChart }
|
|
2176
|
-
])
|
|
2177
|
-
: {};
|
|
2178
|
-
|
|
2179
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2180
|
-
updating_ref = true;
|
|
2181
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2182
|
-
add_flush_callback(() => updating_ref = false);
|
|
2183
|
-
}
|
|
2184
|
-
|
|
2185
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2186
|
-
updating_chart = true;
|
|
2187
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2188
|
-
add_flush_callback(() => updating_chart = false);
|
|
2189
|
-
}
|
|
2190
|
-
|
|
2191
|
-
basechart.$set(basechart_changes);
|
|
2192
|
-
},
|
|
2193
|
-
i(local) {
|
|
2194
|
-
if (current) return;
|
|
2195
|
-
transition_in(basechart.$$.fragment, local);
|
|
2196
|
-
current = true;
|
|
2197
|
-
},
|
|
2198
|
-
o(local) {
|
|
2199
|
-
transition_out(basechart.$$.fragment, local);
|
|
2200
|
-
current = false;
|
|
2201
|
-
},
|
|
2202
|
-
d(detaching) {
|
|
2203
|
-
destroy_component(basechart, detaching);
|
|
2204
|
-
}
|
|
2205
|
-
};
|
|
2206
|
-
}
|
|
2207
|
-
|
|
2208
|
-
function instance$d($$self, $$props, $$invalidate) {
|
|
2209
|
-
const omit_props_names = ["chart","ref"];
|
|
2210
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2211
|
-
let { chart = null } = $$props;
|
|
2212
|
-
let { ref = null } = $$props;
|
|
2213
|
-
|
|
2214
|
-
function basechart_ref_binding(value) {
|
|
2215
|
-
ref = value;
|
|
2216
|
-
$$invalidate(1, ref);
|
|
2217
|
-
}
|
|
2218
|
-
|
|
2219
|
-
function basechart_chart_binding(value) {
|
|
2220
|
-
chart = value;
|
|
2221
|
-
$$invalidate(0, chart);
|
|
2222
|
-
}
|
|
2223
|
-
|
|
2224
|
-
function load_handler(event) {
|
|
2225
|
-
bubble.call(this, $$self, event);
|
|
2226
|
-
}
|
|
2227
|
-
|
|
2228
|
-
function update_handler(event) {
|
|
2229
|
-
bubble.call(this, $$self, event);
|
|
2230
|
-
}
|
|
2231
|
-
|
|
2232
|
-
function destroy_handler(event) {
|
|
2233
|
-
bubble.call(this, $$self, event);
|
|
2234
|
-
}
|
|
2235
|
-
|
|
2236
|
-
$$self.$$set = $$new_props => {
|
|
2237
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2238
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2239
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2240
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2241
|
-
};
|
|
2242
|
-
|
|
2243
|
-
return [
|
|
2244
|
-
chart,
|
|
2245
|
-
ref,
|
|
2246
|
-
$$restProps,
|
|
2247
|
-
basechart_ref_binding,
|
|
2248
|
-
basechart_chart_binding,
|
|
2249
|
-
load_handler,
|
|
2250
|
-
update_handler,
|
|
2251
|
-
destroy_handler
|
|
2252
|
-
];
|
|
2253
|
-
}
|
|
2254
|
-
|
|
2255
|
-
class PieChart_1 extends SvelteComponent {
|
|
2256
|
-
constructor(options) {
|
|
2257
|
-
super();
|
|
2258
|
-
init(this, options, instance$d, create_fragment$d, safe_not_equal, { chart: 0, ref: 1 });
|
|
2259
|
-
}
|
|
2260
|
-
}
|
|
2261
|
-
|
|
2262
|
-
/* src/ScatterChart.svelte generated by Svelte v3.42.1 */
|
|
2263
|
-
|
|
2264
|
-
function create_fragment$e(ctx) {
|
|
2265
|
-
let basechart;
|
|
2266
|
-
let updating_ref;
|
|
2267
|
-
let updating_chart;
|
|
2268
|
-
let current;
|
|
2269
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: ScatterChart }];
|
|
2270
|
-
|
|
2271
|
-
function basechart_ref_binding(value) {
|
|
2272
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2273
|
-
}
|
|
2274
|
-
|
|
2275
|
-
function basechart_chart_binding(value) {
|
|
2276
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2277
|
-
}
|
|
2278
|
-
|
|
2279
|
-
let basechart_props = {};
|
|
2280
|
-
|
|
2281
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2282
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2283
|
-
}
|
|
2284
|
-
|
|
2285
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2286
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2287
|
-
}
|
|
2288
|
-
|
|
2289
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2290
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2291
|
-
}
|
|
2292
|
-
|
|
2293
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2294
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2295
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2296
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2297
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2298
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2299
|
-
|
|
2300
|
-
return {
|
|
2301
|
-
c() {
|
|
2302
|
-
create_component(basechart.$$.fragment);
|
|
2303
|
-
},
|
|
2304
|
-
m(target, anchor) {
|
|
2305
|
-
mount_component(basechart, target, anchor);
|
|
2306
|
-
current = true;
|
|
2307
|
-
},
|
|
2308
|
-
p(ctx, [dirty]) {
|
|
2309
|
-
const basechart_changes = (dirty & /*$$restProps, ScatterChart*/ 4)
|
|
2310
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2311
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2312
|
-
dirty & /*ScatterChart*/ 0 && { Chart: ScatterChart }
|
|
2313
|
-
])
|
|
2314
|
-
: {};
|
|
2315
|
-
|
|
2316
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2317
|
-
updating_ref = true;
|
|
2318
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2319
|
-
add_flush_callback(() => updating_ref = false);
|
|
2320
|
-
}
|
|
2321
|
-
|
|
2322
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2323
|
-
updating_chart = true;
|
|
2324
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2325
|
-
add_flush_callback(() => updating_chart = false);
|
|
2326
|
-
}
|
|
2327
|
-
|
|
2328
|
-
basechart.$set(basechart_changes);
|
|
2329
|
-
},
|
|
2330
|
-
i(local) {
|
|
2331
|
-
if (current) return;
|
|
2332
|
-
transition_in(basechart.$$.fragment, local);
|
|
2333
|
-
current = true;
|
|
2334
|
-
},
|
|
2335
|
-
o(local) {
|
|
2336
|
-
transition_out(basechart.$$.fragment, local);
|
|
2337
|
-
current = false;
|
|
2338
|
-
},
|
|
2339
|
-
d(detaching) {
|
|
2340
|
-
destroy_component(basechart, detaching);
|
|
2341
|
-
}
|
|
2342
|
-
};
|
|
2343
|
-
}
|
|
2344
|
-
|
|
2345
|
-
function instance$e($$self, $$props, $$invalidate) {
|
|
2346
|
-
const omit_props_names = ["chart","ref"];
|
|
2347
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2348
|
-
let { chart = null } = $$props;
|
|
2349
|
-
let { ref = null } = $$props;
|
|
2350
|
-
|
|
2351
|
-
function basechart_ref_binding(value) {
|
|
2352
|
-
ref = value;
|
|
2353
|
-
$$invalidate(1, ref);
|
|
2354
|
-
}
|
|
2355
|
-
|
|
2356
|
-
function basechart_chart_binding(value) {
|
|
2357
|
-
chart = value;
|
|
2358
|
-
$$invalidate(0, chart);
|
|
2359
|
-
}
|
|
2360
|
-
|
|
2361
|
-
function load_handler(event) {
|
|
2362
|
-
bubble.call(this, $$self, event);
|
|
2363
|
-
}
|
|
2364
|
-
|
|
2365
|
-
function update_handler(event) {
|
|
2366
|
-
bubble.call(this, $$self, event);
|
|
2367
|
-
}
|
|
2368
|
-
|
|
2369
|
-
function destroy_handler(event) {
|
|
2370
|
-
bubble.call(this, $$self, event);
|
|
2371
|
-
}
|
|
2372
|
-
|
|
2373
|
-
$$self.$$set = $$new_props => {
|
|
2374
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2375
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2376
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2377
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2378
|
-
};
|
|
2379
|
-
|
|
2380
|
-
return [
|
|
2381
|
-
chart,
|
|
2382
|
-
ref,
|
|
2383
|
-
$$restProps,
|
|
2384
|
-
basechart_ref_binding,
|
|
2385
|
-
basechart_chart_binding,
|
|
2386
|
-
load_handler,
|
|
2387
|
-
update_handler,
|
|
2388
|
-
destroy_handler
|
|
2389
|
-
];
|
|
2390
|
-
}
|
|
2391
|
-
|
|
2392
|
-
class ScatterChart_1 extends SvelteComponent {
|
|
2393
|
-
constructor(options) {
|
|
2394
|
-
super();
|
|
2395
|
-
init(this, options, instance$e, create_fragment$e, safe_not_equal, { chart: 0, ref: 1 });
|
|
2396
|
-
}
|
|
2397
|
-
}
|
|
2398
|
-
|
|
2399
|
-
/* src/RadarChart.svelte generated by Svelte v3.42.1 */
|
|
2400
|
-
|
|
2401
|
-
function create_fragment$f(ctx) {
|
|
2402
|
-
let basechart;
|
|
2403
|
-
let updating_ref;
|
|
2404
|
-
let updating_chart;
|
|
2405
|
-
let current;
|
|
2406
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: RadarChart }];
|
|
2407
|
-
|
|
2408
|
-
function basechart_ref_binding(value) {
|
|
2409
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2410
|
-
}
|
|
2411
|
-
|
|
2412
|
-
function basechart_chart_binding(value) {
|
|
2413
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2414
|
-
}
|
|
2415
|
-
|
|
2416
|
-
let basechart_props = {};
|
|
2417
|
-
|
|
2418
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2419
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2420
|
-
}
|
|
2421
|
-
|
|
2422
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2423
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2424
|
-
}
|
|
2425
|
-
|
|
2426
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2427
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2428
|
-
}
|
|
2429
|
-
|
|
2430
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2431
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2432
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2433
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2434
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2435
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2436
|
-
|
|
2437
|
-
return {
|
|
2438
|
-
c() {
|
|
2439
|
-
create_component(basechart.$$.fragment);
|
|
2440
|
-
},
|
|
2441
|
-
m(target, anchor) {
|
|
2442
|
-
mount_component(basechart, target, anchor);
|
|
2443
|
-
current = true;
|
|
2444
|
-
},
|
|
2445
|
-
p(ctx, [dirty]) {
|
|
2446
|
-
const basechart_changes = (dirty & /*$$restProps, RadarChart*/ 4)
|
|
2447
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2448
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2449
|
-
dirty & /*RadarChart*/ 0 && { Chart: RadarChart }
|
|
2450
|
-
])
|
|
2451
|
-
: {};
|
|
2452
|
-
|
|
2453
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2454
|
-
updating_ref = true;
|
|
2455
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2456
|
-
add_flush_callback(() => updating_ref = false);
|
|
2457
|
-
}
|
|
2458
|
-
|
|
2459
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2460
|
-
updating_chart = true;
|
|
2461
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2462
|
-
add_flush_callback(() => updating_chart = false);
|
|
2463
|
-
}
|
|
2464
|
-
|
|
2465
|
-
basechart.$set(basechart_changes);
|
|
2466
|
-
},
|
|
2467
|
-
i(local) {
|
|
2468
|
-
if (current) return;
|
|
2469
|
-
transition_in(basechart.$$.fragment, local);
|
|
2470
|
-
current = true;
|
|
2471
|
-
},
|
|
2472
|
-
o(local) {
|
|
2473
|
-
transition_out(basechart.$$.fragment, local);
|
|
2474
|
-
current = false;
|
|
2475
|
-
},
|
|
2476
|
-
d(detaching) {
|
|
2477
|
-
destroy_component(basechart, detaching);
|
|
2478
|
-
}
|
|
2479
|
-
};
|
|
2480
|
-
}
|
|
2481
|
-
|
|
2482
|
-
function instance$f($$self, $$props, $$invalidate) {
|
|
2483
|
-
const omit_props_names = ["chart","ref"];
|
|
2484
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2485
|
-
let { chart = null } = $$props;
|
|
2486
|
-
let { ref = null } = $$props;
|
|
2487
|
-
|
|
2488
|
-
function basechart_ref_binding(value) {
|
|
2489
|
-
ref = value;
|
|
2490
|
-
$$invalidate(1, ref);
|
|
2491
|
-
}
|
|
2492
|
-
|
|
2493
|
-
function basechart_chart_binding(value) {
|
|
2494
|
-
chart = value;
|
|
2495
|
-
$$invalidate(0, chart);
|
|
2496
|
-
}
|
|
2497
|
-
|
|
2498
|
-
function load_handler(event) {
|
|
2499
|
-
bubble.call(this, $$self, event);
|
|
2500
|
-
}
|
|
2501
|
-
|
|
2502
|
-
function update_handler(event) {
|
|
2503
|
-
bubble.call(this, $$self, event);
|
|
2504
|
-
}
|
|
2505
|
-
|
|
2506
|
-
function destroy_handler(event) {
|
|
2507
|
-
bubble.call(this, $$self, event);
|
|
2508
|
-
}
|
|
2509
|
-
|
|
2510
|
-
$$self.$$set = $$new_props => {
|
|
2511
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2512
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2513
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2514
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2515
|
-
};
|
|
2516
|
-
|
|
2517
|
-
return [
|
|
2518
|
-
chart,
|
|
2519
|
-
ref,
|
|
2520
|
-
$$restProps,
|
|
2521
|
-
basechart_ref_binding,
|
|
2522
|
-
basechart_chart_binding,
|
|
2523
|
-
load_handler,
|
|
2524
|
-
update_handler,
|
|
2525
|
-
destroy_handler
|
|
2526
|
-
];
|
|
2527
|
-
}
|
|
2528
|
-
|
|
2529
|
-
class RadarChart_1 extends SvelteComponent {
|
|
2530
|
-
constructor(options) {
|
|
2531
|
-
super();
|
|
2532
|
-
init(this, options, instance$f, create_fragment$f, safe_not_equal, { chart: 0, ref: 1 });
|
|
2533
|
-
}
|
|
2534
|
-
}
|
|
2535
|
-
|
|
2536
|
-
/* src/GaugeChart.svelte generated by Svelte v3.42.1 */
|
|
2537
|
-
|
|
2538
|
-
function create_fragment$g(ctx) {
|
|
2539
|
-
let basechart;
|
|
2540
|
-
let updating_ref;
|
|
2541
|
-
let updating_chart;
|
|
2542
|
-
let current;
|
|
2543
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: GaugeChart }];
|
|
2544
|
-
|
|
2545
|
-
function basechart_ref_binding(value) {
|
|
2546
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2547
|
-
}
|
|
2548
|
-
|
|
2549
|
-
function basechart_chart_binding(value) {
|
|
2550
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2551
|
-
}
|
|
2552
|
-
|
|
2553
|
-
let basechart_props = {};
|
|
2554
|
-
|
|
2555
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2556
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2557
|
-
}
|
|
2558
|
-
|
|
2559
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2560
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2561
|
-
}
|
|
2562
|
-
|
|
2563
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2564
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2565
|
-
}
|
|
2566
|
-
|
|
2567
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2568
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2569
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2570
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2571
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2572
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2573
|
-
|
|
2574
|
-
return {
|
|
2575
|
-
c() {
|
|
2576
|
-
create_component(basechart.$$.fragment);
|
|
2577
|
-
},
|
|
2578
|
-
m(target, anchor) {
|
|
2579
|
-
mount_component(basechart, target, anchor);
|
|
2580
|
-
current = true;
|
|
2581
|
-
},
|
|
2582
|
-
p(ctx, [dirty]) {
|
|
2583
|
-
const basechart_changes = (dirty & /*$$restProps, GaugeChart*/ 4)
|
|
2584
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2585
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2586
|
-
dirty & /*GaugeChart*/ 0 && { Chart: GaugeChart }
|
|
2587
|
-
])
|
|
2588
|
-
: {};
|
|
2589
|
-
|
|
2590
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2591
|
-
updating_ref = true;
|
|
2592
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2593
|
-
add_flush_callback(() => updating_ref = false);
|
|
2594
|
-
}
|
|
2595
|
-
|
|
2596
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2597
|
-
updating_chart = true;
|
|
2598
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2599
|
-
add_flush_callback(() => updating_chart = false);
|
|
2600
|
-
}
|
|
2601
|
-
|
|
2602
|
-
basechart.$set(basechart_changes);
|
|
2603
|
-
},
|
|
2604
|
-
i(local) {
|
|
2605
|
-
if (current) return;
|
|
2606
|
-
transition_in(basechart.$$.fragment, local);
|
|
2607
|
-
current = true;
|
|
2608
|
-
},
|
|
2609
|
-
o(local) {
|
|
2610
|
-
transition_out(basechart.$$.fragment, local);
|
|
2611
|
-
current = false;
|
|
2612
|
-
},
|
|
2613
|
-
d(detaching) {
|
|
2614
|
-
destroy_component(basechart, detaching);
|
|
2615
|
-
}
|
|
2616
|
-
};
|
|
2617
|
-
}
|
|
2618
|
-
|
|
2619
|
-
function instance$g($$self, $$props, $$invalidate) {
|
|
2620
|
-
const omit_props_names = ["chart","ref"];
|
|
2621
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2622
|
-
let { chart = null } = $$props;
|
|
2623
|
-
let { ref = null } = $$props;
|
|
2624
|
-
|
|
2625
|
-
function basechart_ref_binding(value) {
|
|
2626
|
-
ref = value;
|
|
2627
|
-
$$invalidate(1, ref);
|
|
2628
|
-
}
|
|
2629
|
-
|
|
2630
|
-
function basechart_chart_binding(value) {
|
|
2631
|
-
chart = value;
|
|
2632
|
-
$$invalidate(0, chart);
|
|
2633
|
-
}
|
|
2634
|
-
|
|
2635
|
-
function load_handler(event) {
|
|
2636
|
-
bubble.call(this, $$self, event);
|
|
2637
|
-
}
|
|
2638
|
-
|
|
2639
|
-
function update_handler(event) {
|
|
2640
|
-
bubble.call(this, $$self, event);
|
|
2641
|
-
}
|
|
2642
|
-
|
|
2643
|
-
function destroy_handler(event) {
|
|
2644
|
-
bubble.call(this, $$self, event);
|
|
2645
|
-
}
|
|
2646
|
-
|
|
2647
|
-
$$self.$$set = $$new_props => {
|
|
2648
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2649
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2650
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2651
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2652
|
-
};
|
|
2653
|
-
|
|
2654
|
-
return [
|
|
2655
|
-
chart,
|
|
2656
|
-
ref,
|
|
2657
|
-
$$restProps,
|
|
2658
|
-
basechart_ref_binding,
|
|
2659
|
-
basechart_chart_binding,
|
|
2660
|
-
load_handler,
|
|
2661
|
-
update_handler,
|
|
2662
|
-
destroy_handler
|
|
2663
|
-
];
|
|
2664
|
-
}
|
|
2665
|
-
|
|
2666
|
-
class GaugeChart_1 extends SvelteComponent {
|
|
2667
|
-
constructor(options) {
|
|
2668
|
-
super();
|
|
2669
|
-
init(this, options, instance$g, create_fragment$g, safe_not_equal, { chart: 0, ref: 1 });
|
|
2670
|
-
}
|
|
2671
|
-
}
|
|
2672
|
-
|
|
2673
|
-
/* src/HistogramChart.svelte generated by Svelte v3.42.1 */
|
|
2674
|
-
|
|
2675
|
-
function create_fragment$h(ctx) {
|
|
2676
|
-
let basechart;
|
|
2677
|
-
let updating_ref;
|
|
2678
|
-
let updating_chart;
|
|
2679
|
-
let current;
|
|
2680
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: HistogramChart }];
|
|
2681
|
-
|
|
2682
|
-
function basechart_ref_binding(value) {
|
|
2683
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2684
|
-
}
|
|
2685
|
-
|
|
2686
|
-
function basechart_chart_binding(value) {
|
|
2687
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2688
|
-
}
|
|
2689
|
-
|
|
2690
|
-
let basechart_props = {};
|
|
2691
|
-
|
|
2692
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2693
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2694
|
-
}
|
|
2695
|
-
|
|
2696
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2697
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2698
|
-
}
|
|
2699
|
-
|
|
2700
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2701
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2702
|
-
}
|
|
2703
|
-
|
|
2704
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2705
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2706
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2707
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2708
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2709
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2710
|
-
|
|
2711
|
-
return {
|
|
2712
|
-
c() {
|
|
2713
|
-
create_component(basechart.$$.fragment);
|
|
2714
|
-
},
|
|
2715
|
-
m(target, anchor) {
|
|
2716
|
-
mount_component(basechart, target, anchor);
|
|
2717
|
-
current = true;
|
|
2718
|
-
},
|
|
2719
|
-
p(ctx, [dirty]) {
|
|
2720
|
-
const basechart_changes = (dirty & /*$$restProps, HistogramChart*/ 4)
|
|
2721
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2722
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2723
|
-
dirty & /*HistogramChart*/ 0 && { Chart: HistogramChart }
|
|
2724
|
-
])
|
|
2725
|
-
: {};
|
|
2726
|
-
|
|
2727
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2728
|
-
updating_ref = true;
|
|
2729
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2730
|
-
add_flush_callback(() => updating_ref = false);
|
|
2731
|
-
}
|
|
2732
|
-
|
|
2733
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2734
|
-
updating_chart = true;
|
|
2735
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2736
|
-
add_flush_callback(() => updating_chart = false);
|
|
2737
|
-
}
|
|
2738
|
-
|
|
2739
|
-
basechart.$set(basechart_changes);
|
|
2740
|
-
},
|
|
2741
|
-
i(local) {
|
|
2742
|
-
if (current) return;
|
|
2743
|
-
transition_in(basechart.$$.fragment, local);
|
|
2744
|
-
current = true;
|
|
2745
|
-
},
|
|
2746
|
-
o(local) {
|
|
2747
|
-
transition_out(basechart.$$.fragment, local);
|
|
2748
|
-
current = false;
|
|
2749
|
-
},
|
|
2750
|
-
d(detaching) {
|
|
2751
|
-
destroy_component(basechart, detaching);
|
|
2752
|
-
}
|
|
2753
|
-
};
|
|
2754
|
-
}
|
|
2755
|
-
|
|
2756
|
-
function instance$h($$self, $$props, $$invalidate) {
|
|
2757
|
-
const omit_props_names = ["chart","ref"];
|
|
2758
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2759
|
-
let { chart = null } = $$props;
|
|
2760
|
-
let { ref = null } = $$props;
|
|
2761
|
-
|
|
2762
|
-
function basechart_ref_binding(value) {
|
|
2763
|
-
ref = value;
|
|
2764
|
-
$$invalidate(1, ref);
|
|
2765
|
-
}
|
|
2766
|
-
|
|
2767
|
-
function basechart_chart_binding(value) {
|
|
2768
|
-
chart = value;
|
|
2769
|
-
$$invalidate(0, chart);
|
|
2770
|
-
}
|
|
2771
|
-
|
|
2772
|
-
function load_handler(event) {
|
|
2773
|
-
bubble.call(this, $$self, event);
|
|
2774
|
-
}
|
|
2775
|
-
|
|
2776
|
-
function update_handler(event) {
|
|
2777
|
-
bubble.call(this, $$self, event);
|
|
2778
|
-
}
|
|
2779
|
-
|
|
2780
|
-
function destroy_handler(event) {
|
|
2781
|
-
bubble.call(this, $$self, event);
|
|
2782
|
-
}
|
|
2783
|
-
|
|
2784
|
-
$$self.$$set = $$new_props => {
|
|
2785
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2786
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2787
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2788
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2789
|
-
};
|
|
2790
|
-
|
|
2791
|
-
return [
|
|
2792
|
-
chart,
|
|
2793
|
-
ref,
|
|
2794
|
-
$$restProps,
|
|
2795
|
-
basechart_ref_binding,
|
|
2796
|
-
basechart_chart_binding,
|
|
2797
|
-
load_handler,
|
|
2798
|
-
update_handler,
|
|
2799
|
-
destroy_handler
|
|
2800
|
-
];
|
|
2801
|
-
}
|
|
2802
|
-
|
|
2803
|
-
class HistogramChart_1 extends SvelteComponent {
|
|
2804
|
-
constructor(options) {
|
|
2805
|
-
super();
|
|
2806
|
-
init(this, options, instance$h, create_fragment$h, safe_not_equal, { chart: 0, ref: 1 });
|
|
2807
|
-
}
|
|
2808
|
-
}
|
|
2809
|
-
|
|
2810
|
-
/* src/MeterChart.svelte generated by Svelte v3.42.1 */
|
|
2811
|
-
|
|
2812
|
-
function create_fragment$i(ctx) {
|
|
2813
|
-
let basechart;
|
|
2814
|
-
let updating_ref;
|
|
2815
|
-
let updating_chart;
|
|
2816
|
-
let current;
|
|
2817
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: MeterChart }];
|
|
2818
|
-
|
|
2819
|
-
function basechart_ref_binding(value) {
|
|
2820
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2821
|
-
}
|
|
2822
|
-
|
|
2823
|
-
function basechart_chart_binding(value) {
|
|
2824
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2825
|
-
}
|
|
2826
|
-
|
|
2827
|
-
let basechart_props = {};
|
|
2828
|
-
|
|
2829
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2830
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2831
|
-
}
|
|
2832
|
-
|
|
2833
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2834
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2835
|
-
}
|
|
2836
|
-
|
|
2837
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2838
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2839
|
-
}
|
|
2840
|
-
|
|
2841
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2842
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2843
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2844
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2845
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2846
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2847
|
-
|
|
2848
|
-
return {
|
|
2849
|
-
c() {
|
|
2850
|
-
create_component(basechart.$$.fragment);
|
|
2851
|
-
},
|
|
2852
|
-
m(target, anchor) {
|
|
2853
|
-
mount_component(basechart, target, anchor);
|
|
2854
|
-
current = true;
|
|
2855
|
-
},
|
|
2856
|
-
p(ctx, [dirty]) {
|
|
2857
|
-
const basechart_changes = (dirty & /*$$restProps, MeterChart*/ 4)
|
|
2858
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2859
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2860
|
-
dirty & /*MeterChart*/ 0 && { Chart: MeterChart }
|
|
2861
|
-
])
|
|
2862
|
-
: {};
|
|
2863
|
-
|
|
2864
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
2865
|
-
updating_ref = true;
|
|
2866
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
2867
|
-
add_flush_callback(() => updating_ref = false);
|
|
2868
|
-
}
|
|
2869
|
-
|
|
2870
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
2871
|
-
updating_chart = true;
|
|
2872
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
2873
|
-
add_flush_callback(() => updating_chart = false);
|
|
2874
|
-
}
|
|
2875
|
-
|
|
2876
|
-
basechart.$set(basechart_changes);
|
|
2877
|
-
},
|
|
2878
|
-
i(local) {
|
|
2879
|
-
if (current) return;
|
|
2880
|
-
transition_in(basechart.$$.fragment, local);
|
|
2881
|
-
current = true;
|
|
2882
|
-
},
|
|
2883
|
-
o(local) {
|
|
2884
|
-
transition_out(basechart.$$.fragment, local);
|
|
2885
|
-
current = false;
|
|
2886
|
-
},
|
|
2887
|
-
d(detaching) {
|
|
2888
|
-
destroy_component(basechart, detaching);
|
|
2889
|
-
}
|
|
2890
|
-
};
|
|
2891
|
-
}
|
|
2892
|
-
|
|
2893
|
-
function instance$i($$self, $$props, $$invalidate) {
|
|
2894
|
-
const omit_props_names = ["chart","ref"];
|
|
2895
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
2896
|
-
let { chart = null } = $$props;
|
|
2897
|
-
let { ref = null } = $$props;
|
|
2898
|
-
|
|
2899
|
-
function basechart_ref_binding(value) {
|
|
2900
|
-
ref = value;
|
|
2901
|
-
$$invalidate(1, ref);
|
|
2902
|
-
}
|
|
2903
|
-
|
|
2904
|
-
function basechart_chart_binding(value) {
|
|
2905
|
-
chart = value;
|
|
2906
|
-
$$invalidate(0, chart);
|
|
2907
|
-
}
|
|
2908
|
-
|
|
2909
|
-
function load_handler(event) {
|
|
2910
|
-
bubble.call(this, $$self, event);
|
|
2911
|
-
}
|
|
2912
|
-
|
|
2913
|
-
function update_handler(event) {
|
|
2914
|
-
bubble.call(this, $$self, event);
|
|
2915
|
-
}
|
|
2916
|
-
|
|
2917
|
-
function destroy_handler(event) {
|
|
2918
|
-
bubble.call(this, $$self, event);
|
|
2919
|
-
}
|
|
2920
|
-
|
|
2921
|
-
$$self.$$set = $$new_props => {
|
|
2922
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
2923
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
2924
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
2925
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
2926
|
-
};
|
|
2927
|
-
|
|
2928
|
-
return [
|
|
2929
|
-
chart,
|
|
2930
|
-
ref,
|
|
2931
|
-
$$restProps,
|
|
2932
|
-
basechart_ref_binding,
|
|
2933
|
-
basechart_chart_binding,
|
|
2934
|
-
load_handler,
|
|
2935
|
-
update_handler,
|
|
2936
|
-
destroy_handler
|
|
2937
|
-
];
|
|
2938
|
-
}
|
|
2939
|
-
|
|
2940
|
-
class MeterChart_1 extends SvelteComponent {
|
|
2941
|
-
constructor(options) {
|
|
2942
|
-
super();
|
|
2943
|
-
init(this, options, instance$i, create_fragment$i, safe_not_equal, { chart: 0, ref: 1 });
|
|
2944
|
-
}
|
|
2945
|
-
}
|
|
2946
|
-
|
|
2947
|
-
/* src/TreeChart.svelte generated by Svelte v3.42.1 */
|
|
2948
|
-
|
|
2949
|
-
function create_fragment$j(ctx) {
|
|
2950
|
-
let basechart;
|
|
2951
|
-
let updating_ref;
|
|
2952
|
-
let updating_chart;
|
|
2953
|
-
let current;
|
|
2954
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: TreeChart }];
|
|
2955
|
-
|
|
2956
|
-
function basechart_ref_binding(value) {
|
|
2957
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
2958
|
-
}
|
|
2959
|
-
|
|
2960
|
-
function basechart_chart_binding(value) {
|
|
2961
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
2962
|
-
}
|
|
2963
|
-
|
|
2964
|
-
let basechart_props = {};
|
|
2965
|
-
|
|
2966
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
2967
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
2968
|
-
}
|
|
2969
|
-
|
|
2970
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
2971
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
2972
|
-
}
|
|
2973
|
-
|
|
2974
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
2975
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
2976
|
-
}
|
|
2977
|
-
|
|
2978
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
2979
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
2980
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
2981
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
2982
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
2983
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
2984
|
-
|
|
2985
|
-
return {
|
|
2986
|
-
c() {
|
|
2987
|
-
create_component(basechart.$$.fragment);
|
|
2988
|
-
},
|
|
2989
|
-
m(target, anchor) {
|
|
2990
|
-
mount_component(basechart, target, anchor);
|
|
2991
|
-
current = true;
|
|
2992
|
-
},
|
|
2993
|
-
p(ctx, [dirty]) {
|
|
2994
|
-
const basechart_changes = (dirty & /*$$restProps, TreeChart*/ 4)
|
|
2995
|
-
? get_spread_update(basechart_spread_levels, [
|
|
2996
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
2997
|
-
dirty & /*TreeChart*/ 0 && { Chart: TreeChart }
|
|
2998
|
-
])
|
|
2999
|
-
: {};
|
|
3000
|
-
|
|
3001
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3002
|
-
updating_ref = true;
|
|
3003
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3004
|
-
add_flush_callback(() => updating_ref = false);
|
|
3005
|
-
}
|
|
3006
|
-
|
|
3007
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3008
|
-
updating_chart = true;
|
|
3009
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3010
|
-
add_flush_callback(() => updating_chart = false);
|
|
3011
|
-
}
|
|
3012
|
-
|
|
3013
|
-
basechart.$set(basechart_changes);
|
|
3014
|
-
},
|
|
3015
|
-
i(local) {
|
|
3016
|
-
if (current) return;
|
|
3017
|
-
transition_in(basechart.$$.fragment, local);
|
|
3018
|
-
current = true;
|
|
3019
|
-
},
|
|
3020
|
-
o(local) {
|
|
3021
|
-
transition_out(basechart.$$.fragment, local);
|
|
3022
|
-
current = false;
|
|
3023
|
-
},
|
|
3024
|
-
d(detaching) {
|
|
3025
|
-
destroy_component(basechart, detaching);
|
|
3026
|
-
}
|
|
3027
|
-
};
|
|
3028
|
-
}
|
|
3029
|
-
|
|
3030
|
-
function instance$j($$self, $$props, $$invalidate) {
|
|
3031
|
-
const omit_props_names = ["chart","ref"];
|
|
3032
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3033
|
-
let { chart = null } = $$props;
|
|
3034
|
-
let { ref = null } = $$props;
|
|
3035
|
-
|
|
3036
|
-
function basechart_ref_binding(value) {
|
|
3037
|
-
ref = value;
|
|
3038
|
-
$$invalidate(1, ref);
|
|
3039
|
-
}
|
|
3040
|
-
|
|
3041
|
-
function basechart_chart_binding(value) {
|
|
3042
|
-
chart = value;
|
|
3043
|
-
$$invalidate(0, chart);
|
|
3044
|
-
}
|
|
3045
|
-
|
|
3046
|
-
function load_handler(event) {
|
|
3047
|
-
bubble.call(this, $$self, event);
|
|
3048
|
-
}
|
|
3049
|
-
|
|
3050
|
-
function update_handler(event) {
|
|
3051
|
-
bubble.call(this, $$self, event);
|
|
3052
|
-
}
|
|
3053
|
-
|
|
3054
|
-
function destroy_handler(event) {
|
|
3055
|
-
bubble.call(this, $$self, event);
|
|
3056
|
-
}
|
|
3057
|
-
|
|
3058
|
-
$$self.$$set = $$new_props => {
|
|
3059
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3060
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3061
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3062
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3063
|
-
};
|
|
3064
|
-
|
|
3065
|
-
return [
|
|
3066
|
-
chart,
|
|
3067
|
-
ref,
|
|
3068
|
-
$$restProps,
|
|
3069
|
-
basechart_ref_binding,
|
|
3070
|
-
basechart_chart_binding,
|
|
3071
|
-
load_handler,
|
|
3072
|
-
update_handler,
|
|
3073
|
-
destroy_handler
|
|
3074
|
-
];
|
|
3075
|
-
}
|
|
3076
|
-
|
|
3077
|
-
class TreeChart_1 extends SvelteComponent {
|
|
3078
|
-
constructor(options) {
|
|
3079
|
-
super();
|
|
3080
|
-
init(this, options, instance$j, create_fragment$j, safe_not_equal, { chart: 0, ref: 1 });
|
|
3081
|
-
}
|
|
3082
|
-
}
|
|
3083
|
-
|
|
3084
|
-
/* src/TreemapChart.svelte generated by Svelte v3.42.1 */
|
|
3085
|
-
|
|
3086
|
-
function create_fragment$k(ctx) {
|
|
3087
|
-
let basechart;
|
|
3088
|
-
let updating_ref;
|
|
3089
|
-
let updating_chart;
|
|
3090
|
-
let current;
|
|
3091
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: TreemapChart }];
|
|
3092
|
-
|
|
3093
|
-
function basechart_ref_binding(value) {
|
|
3094
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
3095
|
-
}
|
|
3096
|
-
|
|
3097
|
-
function basechart_chart_binding(value) {
|
|
3098
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
3099
|
-
}
|
|
3100
|
-
|
|
3101
|
-
let basechart_props = {};
|
|
3102
|
-
|
|
3103
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
3104
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
3105
|
-
}
|
|
3106
|
-
|
|
3107
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
3108
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
3109
|
-
}
|
|
3110
|
-
|
|
3111
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
3112
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
3113
|
-
}
|
|
3114
|
-
|
|
3115
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
3116
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
3117
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
3118
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
3119
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
3120
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
3121
|
-
|
|
3122
|
-
return {
|
|
3123
|
-
c() {
|
|
3124
|
-
create_component(basechart.$$.fragment);
|
|
3125
|
-
},
|
|
3126
|
-
m(target, anchor) {
|
|
3127
|
-
mount_component(basechart, target, anchor);
|
|
3128
|
-
current = true;
|
|
3129
|
-
},
|
|
3130
|
-
p(ctx, [dirty]) {
|
|
3131
|
-
const basechart_changes = (dirty & /*$$restProps, TreemapChart*/ 4)
|
|
3132
|
-
? get_spread_update(basechart_spread_levels, [
|
|
3133
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
3134
|
-
dirty & /*TreemapChart*/ 0 && { Chart: TreemapChart }
|
|
3135
|
-
])
|
|
3136
|
-
: {};
|
|
3137
|
-
|
|
3138
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3139
|
-
updating_ref = true;
|
|
3140
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3141
|
-
add_flush_callback(() => updating_ref = false);
|
|
3142
|
-
}
|
|
3143
|
-
|
|
3144
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3145
|
-
updating_chart = true;
|
|
3146
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3147
|
-
add_flush_callback(() => updating_chart = false);
|
|
3148
|
-
}
|
|
3149
|
-
|
|
3150
|
-
basechart.$set(basechart_changes);
|
|
3151
|
-
},
|
|
3152
|
-
i(local) {
|
|
3153
|
-
if (current) return;
|
|
3154
|
-
transition_in(basechart.$$.fragment, local);
|
|
3155
|
-
current = true;
|
|
3156
|
-
},
|
|
3157
|
-
o(local) {
|
|
3158
|
-
transition_out(basechart.$$.fragment, local);
|
|
3159
|
-
current = false;
|
|
3160
|
-
},
|
|
3161
|
-
d(detaching) {
|
|
3162
|
-
destroy_component(basechart, detaching);
|
|
3163
|
-
}
|
|
3164
|
-
};
|
|
3165
|
-
}
|
|
3166
|
-
|
|
3167
|
-
function instance$k($$self, $$props, $$invalidate) {
|
|
3168
|
-
const omit_props_names = ["chart","ref"];
|
|
3169
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3170
|
-
let { chart = null } = $$props;
|
|
3171
|
-
let { ref = null } = $$props;
|
|
3172
|
-
|
|
3173
|
-
function basechart_ref_binding(value) {
|
|
3174
|
-
ref = value;
|
|
3175
|
-
$$invalidate(1, ref);
|
|
3176
|
-
}
|
|
3177
|
-
|
|
3178
|
-
function basechart_chart_binding(value) {
|
|
3179
|
-
chart = value;
|
|
3180
|
-
$$invalidate(0, chart);
|
|
3181
|
-
}
|
|
3182
|
-
|
|
3183
|
-
function load_handler(event) {
|
|
3184
|
-
bubble.call(this, $$self, event);
|
|
3185
|
-
}
|
|
3186
|
-
|
|
3187
|
-
function update_handler(event) {
|
|
3188
|
-
bubble.call(this, $$self, event);
|
|
3189
|
-
}
|
|
3190
|
-
|
|
3191
|
-
function destroy_handler(event) {
|
|
3192
|
-
bubble.call(this, $$self, event);
|
|
3193
|
-
}
|
|
3194
|
-
|
|
3195
|
-
$$self.$$set = $$new_props => {
|
|
3196
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3197
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3198
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3199
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3200
|
-
};
|
|
3201
|
-
|
|
3202
|
-
return [
|
|
3203
|
-
chart,
|
|
3204
|
-
ref,
|
|
3205
|
-
$$restProps,
|
|
3206
|
-
basechart_ref_binding,
|
|
3207
|
-
basechart_chart_binding,
|
|
3208
|
-
load_handler,
|
|
3209
|
-
update_handler,
|
|
3210
|
-
destroy_handler
|
|
3211
|
-
];
|
|
3212
|
-
}
|
|
3213
|
-
|
|
3214
|
-
class TreemapChart_1 extends SvelteComponent {
|
|
3215
|
-
constructor(options) {
|
|
3216
|
-
super();
|
|
3217
|
-
init(this, options, instance$k, create_fragment$k, safe_not_equal, { chart: 0, ref: 1 });
|
|
3218
|
-
}
|
|
3219
|
-
}
|
|
3220
|
-
|
|
3221
|
-
/* src/CirclePackChart.svelte generated by Svelte v3.42.1 */
|
|
3222
|
-
|
|
3223
|
-
function create_fragment$l(ctx) {
|
|
3224
|
-
let basechart;
|
|
3225
|
-
let updating_ref;
|
|
3226
|
-
let updating_chart;
|
|
3227
|
-
let current;
|
|
3228
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: CirclePackChart }];
|
|
3229
|
-
|
|
3230
|
-
function basechart_ref_binding(value) {
|
|
3231
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
3232
|
-
}
|
|
3233
|
-
|
|
3234
|
-
function basechart_chart_binding(value) {
|
|
3235
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
3236
|
-
}
|
|
3237
|
-
|
|
3238
|
-
let basechart_props = {};
|
|
3239
|
-
|
|
3240
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
3241
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
3242
|
-
}
|
|
3243
|
-
|
|
3244
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
3245
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
3246
|
-
}
|
|
3247
|
-
|
|
3248
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
3249
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
3250
|
-
}
|
|
3251
|
-
|
|
3252
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
3253
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
3254
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
3255
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
3256
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
3257
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
3258
|
-
|
|
3259
|
-
return {
|
|
3260
|
-
c() {
|
|
3261
|
-
create_component(basechart.$$.fragment);
|
|
3262
|
-
},
|
|
3263
|
-
m(target, anchor) {
|
|
3264
|
-
mount_component(basechart, target, anchor);
|
|
3265
|
-
current = true;
|
|
3266
|
-
},
|
|
3267
|
-
p(ctx, [dirty]) {
|
|
3268
|
-
const basechart_changes = (dirty & /*$$restProps, CirclePackChart*/ 4)
|
|
3269
|
-
? get_spread_update(basechart_spread_levels, [
|
|
3270
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
3271
|
-
dirty & /*CirclePackChart*/ 0 && { Chart: CirclePackChart }
|
|
3272
|
-
])
|
|
3273
|
-
: {};
|
|
3274
|
-
|
|
3275
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3276
|
-
updating_ref = true;
|
|
3277
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3278
|
-
add_flush_callback(() => updating_ref = false);
|
|
3279
|
-
}
|
|
3280
|
-
|
|
3281
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3282
|
-
updating_chart = true;
|
|
3283
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3284
|
-
add_flush_callback(() => updating_chart = false);
|
|
3285
|
-
}
|
|
3286
|
-
|
|
3287
|
-
basechart.$set(basechart_changes);
|
|
3288
|
-
},
|
|
3289
|
-
i(local) {
|
|
3290
|
-
if (current) return;
|
|
3291
|
-
transition_in(basechart.$$.fragment, local);
|
|
3292
|
-
current = true;
|
|
3293
|
-
},
|
|
3294
|
-
o(local) {
|
|
3295
|
-
transition_out(basechart.$$.fragment, local);
|
|
3296
|
-
current = false;
|
|
3297
|
-
},
|
|
3298
|
-
d(detaching) {
|
|
3299
|
-
destroy_component(basechart, detaching);
|
|
3300
|
-
}
|
|
3301
|
-
};
|
|
3302
|
-
}
|
|
3303
|
-
|
|
3304
|
-
function instance$l($$self, $$props, $$invalidate) {
|
|
3305
|
-
const omit_props_names = ["chart","ref"];
|
|
3306
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3307
|
-
let { chart = null } = $$props;
|
|
3308
|
-
let { ref = null } = $$props;
|
|
3309
|
-
|
|
3310
|
-
function basechart_ref_binding(value) {
|
|
3311
|
-
ref = value;
|
|
3312
|
-
$$invalidate(1, ref);
|
|
3313
|
-
}
|
|
3314
|
-
|
|
3315
|
-
function basechart_chart_binding(value) {
|
|
3316
|
-
chart = value;
|
|
3317
|
-
$$invalidate(0, chart);
|
|
3318
|
-
}
|
|
3319
|
-
|
|
3320
|
-
function load_handler(event) {
|
|
3321
|
-
bubble.call(this, $$self, event);
|
|
3322
|
-
}
|
|
3323
|
-
|
|
3324
|
-
function update_handler(event) {
|
|
3325
|
-
bubble.call(this, $$self, event);
|
|
3326
|
-
}
|
|
3327
|
-
|
|
3328
|
-
function destroy_handler(event) {
|
|
3329
|
-
bubble.call(this, $$self, event);
|
|
3330
|
-
}
|
|
3331
|
-
|
|
3332
|
-
$$self.$$set = $$new_props => {
|
|
3333
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3334
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3335
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3336
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3337
|
-
};
|
|
3338
|
-
|
|
3339
|
-
return [
|
|
3340
|
-
chart,
|
|
3341
|
-
ref,
|
|
3342
|
-
$$restProps,
|
|
3343
|
-
basechart_ref_binding,
|
|
3344
|
-
basechart_chart_binding,
|
|
3345
|
-
load_handler,
|
|
3346
|
-
update_handler,
|
|
3347
|
-
destroy_handler
|
|
3348
|
-
];
|
|
3349
|
-
}
|
|
3350
|
-
|
|
3351
|
-
class CirclePackChart_1 extends SvelteComponent {
|
|
3352
|
-
constructor(options) {
|
|
3353
|
-
super();
|
|
3354
|
-
init(this, options, instance$l, create_fragment$l, safe_not_equal, { chart: 0, ref: 1 });
|
|
3355
|
-
}
|
|
3356
|
-
}
|
|
3357
|
-
|
|
3358
|
-
/* src/WordCloudChart.svelte generated by Svelte v3.42.1 */
|
|
3359
|
-
|
|
3360
|
-
function create_fragment$m(ctx) {
|
|
3361
|
-
let basechart;
|
|
3362
|
-
let updating_ref;
|
|
3363
|
-
let updating_chart;
|
|
3364
|
-
let current;
|
|
3365
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: WordCloudChart }];
|
|
3366
|
-
|
|
3367
|
-
function basechart_ref_binding(value) {
|
|
3368
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
3369
|
-
}
|
|
3370
|
-
|
|
3371
|
-
function basechart_chart_binding(value) {
|
|
3372
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
3373
|
-
}
|
|
3374
|
-
|
|
3375
|
-
let basechart_props = {};
|
|
3376
|
-
|
|
3377
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
3378
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
3379
|
-
}
|
|
3380
|
-
|
|
3381
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
3382
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
3383
|
-
}
|
|
3384
|
-
|
|
3385
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
3386
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
3387
|
-
}
|
|
3388
|
-
|
|
3389
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
3390
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
3391
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
3392
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
3393
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
3394
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
3395
|
-
|
|
3396
|
-
return {
|
|
3397
|
-
c() {
|
|
3398
|
-
create_component(basechart.$$.fragment);
|
|
3399
|
-
},
|
|
3400
|
-
m(target, anchor) {
|
|
3401
|
-
mount_component(basechart, target, anchor);
|
|
3402
|
-
current = true;
|
|
3403
|
-
},
|
|
3404
|
-
p(ctx, [dirty]) {
|
|
3405
|
-
const basechart_changes = (dirty & /*$$restProps, WordCloudChart*/ 4)
|
|
3406
|
-
? get_spread_update(basechart_spread_levels, [
|
|
3407
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
3408
|
-
dirty & /*WordCloudChart*/ 0 && { Chart: WordCloudChart }
|
|
3409
|
-
])
|
|
3410
|
-
: {};
|
|
3411
|
-
|
|
3412
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3413
|
-
updating_ref = true;
|
|
3414
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3415
|
-
add_flush_callback(() => updating_ref = false);
|
|
3416
|
-
}
|
|
3417
|
-
|
|
3418
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3419
|
-
updating_chart = true;
|
|
3420
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3421
|
-
add_flush_callback(() => updating_chart = false);
|
|
3422
|
-
}
|
|
3423
|
-
|
|
3424
|
-
basechart.$set(basechart_changes);
|
|
3425
|
-
},
|
|
3426
|
-
i(local) {
|
|
3427
|
-
if (current) return;
|
|
3428
|
-
transition_in(basechart.$$.fragment, local);
|
|
3429
|
-
current = true;
|
|
3430
|
-
},
|
|
3431
|
-
o(local) {
|
|
3432
|
-
transition_out(basechart.$$.fragment, local);
|
|
3433
|
-
current = false;
|
|
3434
|
-
},
|
|
3435
|
-
d(detaching) {
|
|
3436
|
-
destroy_component(basechart, detaching);
|
|
3437
|
-
}
|
|
3438
|
-
};
|
|
3439
|
-
}
|
|
3440
|
-
|
|
3441
|
-
function instance$m($$self, $$props, $$invalidate) {
|
|
3442
|
-
const omit_props_names = ["chart","ref"];
|
|
3443
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3444
|
-
let { chart = null } = $$props;
|
|
3445
|
-
let { ref = null } = $$props;
|
|
3446
|
-
|
|
3447
|
-
function basechart_ref_binding(value) {
|
|
3448
|
-
ref = value;
|
|
3449
|
-
$$invalidate(1, ref);
|
|
3450
|
-
}
|
|
3451
|
-
|
|
3452
|
-
function basechart_chart_binding(value) {
|
|
3453
|
-
chart = value;
|
|
3454
|
-
$$invalidate(0, chart);
|
|
3455
|
-
}
|
|
3456
|
-
|
|
3457
|
-
function load_handler(event) {
|
|
3458
|
-
bubble.call(this, $$self, event);
|
|
3459
|
-
}
|
|
3460
|
-
|
|
3461
|
-
function update_handler(event) {
|
|
3462
|
-
bubble.call(this, $$self, event);
|
|
3463
|
-
}
|
|
3464
|
-
|
|
3465
|
-
function destroy_handler(event) {
|
|
3466
|
-
bubble.call(this, $$self, event);
|
|
3467
|
-
}
|
|
3468
|
-
|
|
3469
|
-
$$self.$$set = $$new_props => {
|
|
3470
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3471
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3472
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3473
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3474
|
-
};
|
|
3475
|
-
|
|
3476
|
-
return [
|
|
3477
|
-
chart,
|
|
3478
|
-
ref,
|
|
3479
|
-
$$restProps,
|
|
3480
|
-
basechart_ref_binding,
|
|
3481
|
-
basechart_chart_binding,
|
|
3482
|
-
load_handler,
|
|
3483
|
-
update_handler,
|
|
3484
|
-
destroy_handler
|
|
3485
|
-
];
|
|
3486
|
-
}
|
|
3487
|
-
|
|
3488
|
-
class WordCloudChart_1 extends SvelteComponent {
|
|
3489
|
-
constructor(options) {
|
|
3490
|
-
super();
|
|
3491
|
-
init(this, options, instance$m, create_fragment$m, safe_not_equal, { chart: 0, ref: 1 });
|
|
3492
|
-
}
|
|
3493
|
-
}
|
|
3494
|
-
|
|
3495
|
-
/* src/AlluvialChart.svelte generated by Svelte v3.42.1 */
|
|
3496
|
-
|
|
3497
|
-
function create_fragment$n(ctx) {
|
|
3498
|
-
let basechart;
|
|
3499
|
-
let updating_ref;
|
|
3500
|
-
let updating_chart;
|
|
3501
|
-
let current;
|
|
3502
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: AlluvialChart }];
|
|
3503
|
-
|
|
3504
|
-
function basechart_ref_binding(value) {
|
|
3505
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
3506
|
-
}
|
|
3507
|
-
|
|
3508
|
-
function basechart_chart_binding(value) {
|
|
3509
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
3510
|
-
}
|
|
3511
|
-
|
|
3512
|
-
let basechart_props = {};
|
|
3513
|
-
|
|
3514
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
3515
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
3516
|
-
}
|
|
3517
|
-
|
|
3518
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
3519
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
3520
|
-
}
|
|
3521
|
-
|
|
3522
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
3523
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
3524
|
-
}
|
|
3525
|
-
|
|
3526
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
3527
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
3528
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
3529
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
3530
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
3531
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
3532
|
-
|
|
3533
|
-
return {
|
|
3534
|
-
c() {
|
|
3535
|
-
create_component(basechart.$$.fragment);
|
|
3536
|
-
},
|
|
3537
|
-
m(target, anchor) {
|
|
3538
|
-
mount_component(basechart, target, anchor);
|
|
3539
|
-
current = true;
|
|
3540
|
-
},
|
|
3541
|
-
p(ctx, [dirty]) {
|
|
3542
|
-
const basechart_changes = (dirty & /*$$restProps, AlluvialChart*/ 4)
|
|
3543
|
-
? get_spread_update(basechart_spread_levels, [
|
|
3544
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
3545
|
-
dirty & /*AlluvialChart*/ 0 && { Chart: AlluvialChart }
|
|
3546
|
-
])
|
|
3547
|
-
: {};
|
|
3548
|
-
|
|
3549
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3550
|
-
updating_ref = true;
|
|
3551
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3552
|
-
add_flush_callback(() => updating_ref = false);
|
|
3553
|
-
}
|
|
3554
|
-
|
|
3555
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3556
|
-
updating_chart = true;
|
|
3557
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3558
|
-
add_flush_callback(() => updating_chart = false);
|
|
3559
|
-
}
|
|
3560
|
-
|
|
3561
|
-
basechart.$set(basechart_changes);
|
|
3562
|
-
},
|
|
3563
|
-
i(local) {
|
|
3564
|
-
if (current) return;
|
|
3565
|
-
transition_in(basechart.$$.fragment, local);
|
|
3566
|
-
current = true;
|
|
3567
|
-
},
|
|
3568
|
-
o(local) {
|
|
3569
|
-
transition_out(basechart.$$.fragment, local);
|
|
3570
|
-
current = false;
|
|
3571
|
-
},
|
|
3572
|
-
d(detaching) {
|
|
3573
|
-
destroy_component(basechart, detaching);
|
|
3574
|
-
}
|
|
3575
|
-
};
|
|
3576
|
-
}
|
|
3577
|
-
|
|
3578
|
-
function instance$n($$self, $$props, $$invalidate) {
|
|
3579
|
-
const omit_props_names = ["chart","ref"];
|
|
3580
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3581
|
-
let { chart = null } = $$props;
|
|
3582
|
-
let { ref = null } = $$props;
|
|
3583
|
-
|
|
3584
|
-
function basechart_ref_binding(value) {
|
|
3585
|
-
ref = value;
|
|
3586
|
-
$$invalidate(1, ref);
|
|
3587
|
-
}
|
|
3588
|
-
|
|
3589
|
-
function basechart_chart_binding(value) {
|
|
3590
|
-
chart = value;
|
|
3591
|
-
$$invalidate(0, chart);
|
|
3592
|
-
}
|
|
3593
|
-
|
|
3594
|
-
function load_handler(event) {
|
|
3595
|
-
bubble.call(this, $$self, event);
|
|
3596
|
-
}
|
|
3597
|
-
|
|
3598
|
-
function update_handler(event) {
|
|
3599
|
-
bubble.call(this, $$self, event);
|
|
3600
|
-
}
|
|
3601
|
-
|
|
3602
|
-
function destroy_handler(event) {
|
|
3603
|
-
bubble.call(this, $$self, event);
|
|
3604
|
-
}
|
|
3605
|
-
|
|
3606
|
-
$$self.$$set = $$new_props => {
|
|
3607
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3608
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3609
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3610
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3611
|
-
};
|
|
3612
|
-
|
|
3613
|
-
return [
|
|
3614
|
-
chart,
|
|
3615
|
-
ref,
|
|
3616
|
-
$$restProps,
|
|
3617
|
-
basechart_ref_binding,
|
|
3618
|
-
basechart_chart_binding,
|
|
3619
|
-
load_handler,
|
|
3620
|
-
update_handler,
|
|
3621
|
-
destroy_handler
|
|
3622
|
-
];
|
|
3623
|
-
}
|
|
3624
|
-
|
|
3625
|
-
class AlluvialChart_1 extends SvelteComponent {
|
|
3626
|
-
constructor(options) {
|
|
3627
|
-
super();
|
|
3628
|
-
init(this, options, instance$n, create_fragment$n, safe_not_equal, { chart: 0, ref: 1 });
|
|
3629
|
-
}
|
|
3630
|
-
}
|
|
3631
|
-
|
|
3632
|
-
/* src/HeatmapChart.svelte generated by Svelte v3.42.1 */
|
|
3633
|
-
|
|
3634
|
-
function create_fragment$o(ctx) {
|
|
3635
|
-
let basechart;
|
|
3636
|
-
let updating_ref;
|
|
3637
|
-
let updating_chart;
|
|
3638
|
-
let current;
|
|
3639
|
-
const basechart_spread_levels = [/*$$restProps*/ ctx[2], { Chart: HeatmapChart }];
|
|
3640
|
-
|
|
3641
|
-
function basechart_ref_binding(value) {
|
|
3642
|
-
/*basechart_ref_binding*/ ctx[3](value);
|
|
3643
|
-
}
|
|
3644
|
-
|
|
3645
|
-
function basechart_chart_binding(value) {
|
|
3646
|
-
/*basechart_chart_binding*/ ctx[4](value);
|
|
3647
|
-
}
|
|
3648
|
-
|
|
3649
|
-
let basechart_props = {};
|
|
3650
|
-
|
|
3651
|
-
for (let i = 0; i < basechart_spread_levels.length; i += 1) {
|
|
3652
|
-
basechart_props = assign(basechart_props, basechart_spread_levels[i]);
|
|
3653
|
-
}
|
|
3654
|
-
|
|
3655
|
-
if (/*ref*/ ctx[1] !== void 0) {
|
|
3656
|
-
basechart_props.ref = /*ref*/ ctx[1];
|
|
3657
|
-
}
|
|
3658
|
-
|
|
3659
|
-
if (/*chart*/ ctx[0] !== void 0) {
|
|
3660
|
-
basechart_props.chart = /*chart*/ ctx[0];
|
|
3661
|
-
}
|
|
3662
|
-
|
|
3663
|
-
basechart = new BaseChart({ props: basechart_props });
|
|
3664
|
-
binding_callbacks.push(() => bind(basechart, 'ref', basechart_ref_binding));
|
|
3665
|
-
binding_callbacks.push(() => bind(basechart, 'chart', basechart_chart_binding));
|
|
3666
|
-
basechart.$on("load", /*load_handler*/ ctx[5]);
|
|
3667
|
-
basechart.$on("update", /*update_handler*/ ctx[6]);
|
|
3668
|
-
basechart.$on("destroy", /*destroy_handler*/ ctx[7]);
|
|
3669
|
-
|
|
3670
|
-
return {
|
|
3671
|
-
c() {
|
|
3672
|
-
create_component(basechart.$$.fragment);
|
|
3673
|
-
},
|
|
3674
|
-
m(target, anchor) {
|
|
3675
|
-
mount_component(basechart, target, anchor);
|
|
3676
|
-
current = true;
|
|
3677
|
-
},
|
|
3678
|
-
p(ctx, [dirty]) {
|
|
3679
|
-
const basechart_changes = (dirty & /*$$restProps, HeatmapChart*/ 4)
|
|
3680
|
-
? get_spread_update(basechart_spread_levels, [
|
|
3681
|
-
dirty & /*$$restProps*/ 4 && get_spread_object(/*$$restProps*/ ctx[2]),
|
|
3682
|
-
dirty & /*HeatmapChart*/ 0 && { Chart: HeatmapChart }
|
|
3683
|
-
])
|
|
3684
|
-
: {};
|
|
3685
|
-
|
|
3686
|
-
if (!updating_ref && dirty & /*ref*/ 2) {
|
|
3687
|
-
updating_ref = true;
|
|
3688
|
-
basechart_changes.ref = /*ref*/ ctx[1];
|
|
3689
|
-
add_flush_callback(() => updating_ref = false);
|
|
3690
|
-
}
|
|
3691
|
-
|
|
3692
|
-
if (!updating_chart && dirty & /*chart*/ 1) {
|
|
3693
|
-
updating_chart = true;
|
|
3694
|
-
basechart_changes.chart = /*chart*/ ctx[0];
|
|
3695
|
-
add_flush_callback(() => updating_chart = false);
|
|
3696
|
-
}
|
|
3697
|
-
|
|
3698
|
-
basechart.$set(basechart_changes);
|
|
3699
|
-
},
|
|
3700
|
-
i(local) {
|
|
3701
|
-
if (current) return;
|
|
3702
|
-
transition_in(basechart.$$.fragment, local);
|
|
3703
|
-
current = true;
|
|
3704
|
-
},
|
|
3705
|
-
o(local) {
|
|
3706
|
-
transition_out(basechart.$$.fragment, local);
|
|
3707
|
-
current = false;
|
|
3708
|
-
},
|
|
3709
|
-
d(detaching) {
|
|
3710
|
-
destroy_component(basechart, detaching);
|
|
3711
|
-
}
|
|
3712
|
-
};
|
|
3713
|
-
}
|
|
3714
|
-
|
|
3715
|
-
function instance$o($$self, $$props, $$invalidate) {
|
|
3716
|
-
const omit_props_names = ["chart","ref"];
|
|
3717
|
-
let $$restProps = compute_rest_props($$props, omit_props_names);
|
|
3718
|
-
let { chart = null } = $$props;
|
|
3719
|
-
let { ref = null } = $$props;
|
|
3720
|
-
|
|
3721
|
-
function basechart_ref_binding(value) {
|
|
3722
|
-
ref = value;
|
|
3723
|
-
$$invalidate(1, ref);
|
|
3724
|
-
}
|
|
3725
|
-
|
|
3726
|
-
function basechart_chart_binding(value) {
|
|
3727
|
-
chart = value;
|
|
3728
|
-
$$invalidate(0, chart);
|
|
3729
|
-
}
|
|
3730
|
-
|
|
3731
|
-
function load_handler(event) {
|
|
3732
|
-
bubble.call(this, $$self, event);
|
|
3733
|
-
}
|
|
3734
|
-
|
|
3735
|
-
function update_handler(event) {
|
|
3736
|
-
bubble.call(this, $$self, event);
|
|
3737
|
-
}
|
|
3738
|
-
|
|
3739
|
-
function destroy_handler(event) {
|
|
3740
|
-
bubble.call(this, $$self, event);
|
|
3741
|
-
}
|
|
3742
|
-
|
|
3743
|
-
$$self.$$set = $$new_props => {
|
|
3744
|
-
$$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
|
|
3745
|
-
$$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
|
|
3746
|
-
if ('chart' in $$new_props) $$invalidate(0, chart = $$new_props.chart);
|
|
3747
|
-
if ('ref' in $$new_props) $$invalidate(1, ref = $$new_props.ref);
|
|
3748
|
-
};
|
|
3749
|
-
|
|
3750
|
-
return [
|
|
3751
|
-
chart,
|
|
3752
|
-
ref,
|
|
3753
|
-
$$restProps,
|
|
3754
|
-
basechart_ref_binding,
|
|
3755
|
-
basechart_chart_binding,
|
|
3756
|
-
load_handler,
|
|
3757
|
-
update_handler,
|
|
3758
|
-
destroy_handler
|
|
3759
|
-
];
|
|
3760
|
-
}
|
|
3761
|
-
|
|
3762
|
-
class HeatmapChart_1 extends SvelteComponent {
|
|
3763
|
-
constructor(options) {
|
|
3764
|
-
super();
|
|
3765
|
-
init(this, options, instance$o, create_fragment$o, safe_not_equal, { chart: 0, ref: 1 });
|
|
3766
|
-
}
|
|
3767
|
-
}
|
|
3768
|
-
|
|
3769
|
-
export { AlluvialChart_1 as AlluvialChart, AreaChart_1 as AreaChart, BarChartGrouped, BarChartSimple, BarChartStacked, BoxplotChart_1 as BoxplotChart, BubbleChart_1 as BubbleChart, BulletChart_1 as BulletChart, CirclePackChart_1 as CirclePackChart, ComboChart_1 as ComboChart, DonutChart_1 as DonutChart, GaugeChart_1 as GaugeChart, HeatmapChart_1 as HeatmapChart, HistogramChart_1 as HistogramChart, LineChart_1 as LineChart, LollipopChart_1 as LollipopChart, MeterChart_1 as MeterChart, PieChart_1 as PieChart, RadarChart_1 as RadarChart, ScatterChart_1 as ScatterChart, StackedAreaChart_1 as StackedAreaChart, TreeChart_1 as TreeChart, TreemapChart_1 as TreemapChart, WordCloudChart_1 as WordCloudChart };
|