@wibetter/json-utils 5.0.7 → 5.0.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/dist/index.esm.js +696 -5
- package/dist/index.esm.min.js +1268 -950
- package/dist/index.js +661 -335
- package/dist/index.js.LICENSE.txt +2 -2
- package/package.json +1 -1
package/dist/index.esm.min.js
CHANGED
|
@@ -12,12 +12,15 @@ function i(e) {
|
|
|
12
12
|
function a(e, t) {
|
|
13
13
|
return r(e, t);
|
|
14
14
|
}
|
|
15
|
-
function s(e, t
|
|
15
|
+
function s(e, t) {
|
|
16
|
+
return new Function('data', 'with(data) { return (' + e + ');}')(t);
|
|
17
|
+
}
|
|
18
|
+
function l(e, t, r) {
|
|
16
19
|
var o = t;
|
|
17
20
|
if ((r && (o = n(t)), e))
|
|
18
21
|
for (var i = e.split('-'), a = 0, s = i.length; a < s; a++) {
|
|
19
|
-
var
|
|
20
|
-
|
|
22
|
+
var l = i[a];
|
|
23
|
+
l && (o = o && o[l]);
|
|
21
24
|
}
|
|
22
25
|
return o;
|
|
23
26
|
}
|
|
@@ -25,73 +28,73 @@ function u(e, t, r) {
|
|
|
25
28
|
var o = t;
|
|
26
29
|
if ((r && (o = n(t)), e))
|
|
27
30
|
for (var i = e.split('-'), a = 0, s = i.length; a < s; a++) {
|
|
28
|
-
var
|
|
31
|
+
var l = i[a];
|
|
29
32
|
if (
|
|
30
|
-
'0' !==
|
|
33
|
+
'0' !== l ||
|
|
31
34
|
('array' !== o.type &&
|
|
32
35
|
'radio' !== o.type &&
|
|
33
36
|
'select' !== o.type &&
|
|
34
37
|
'checkboxes' !== o.type) ||
|
|
35
38
|
(!o.options && !o.items)
|
|
36
39
|
) {
|
|
37
|
-
if (
|
|
38
|
-
var
|
|
39
|
-
if (o.propertyOrder)
|
|
40
|
+
if (l) {
|
|
41
|
+
var u = '0';
|
|
42
|
+
if (o.propertyOrder) u = o.propertyOrder[l];
|
|
40
43
|
else if (o.properties) {
|
|
41
|
-
|
|
44
|
+
u = Object.keys(o.properties)[l];
|
|
42
45
|
}
|
|
43
|
-
o = o.properties[
|
|
46
|
+
o = o.properties[u];
|
|
44
47
|
}
|
|
45
48
|
} else o = o.options || o.items;
|
|
46
49
|
}
|
|
47
50
|
return o;
|
|
48
51
|
}
|
|
49
|
-
function
|
|
52
|
+
function p(e, t, r) {
|
|
50
53
|
var o = t;
|
|
51
54
|
if ((r && (o = n(t)), e && o))
|
|
52
55
|
for (var i = e.split('-'), a = 0, s = i.length; a < s; a++) {
|
|
53
|
-
var
|
|
54
|
-
|
|
56
|
+
var l = i[a];
|
|
57
|
+
l && o.properties && (o = o.properties[l]);
|
|
55
58
|
}
|
|
56
59
|
return o;
|
|
57
60
|
}
|
|
58
|
-
function
|
|
61
|
+
function c(e, t) {
|
|
59
62
|
for (var r = t, n = '', o = e.split('-'), i = 0, a = o.length; i < a; i++) {
|
|
60
63
|
var s = o[i];
|
|
61
64
|
if ('0' === s && r.items) (r = r.items), (n = n ? n + '-items' : 'items');
|
|
62
65
|
else if ('0' === s && r.options)
|
|
63
66
|
(r = r.options), (n = n ? n + '-options' : 'options');
|
|
64
67
|
else if (s) {
|
|
65
|
-
var
|
|
66
|
-
if (r.propertyOrder)
|
|
68
|
+
var l = '0';
|
|
69
|
+
if (r.propertyOrder) l = r.propertyOrder[s];
|
|
67
70
|
else if (r.properties) {
|
|
68
|
-
|
|
71
|
+
l = Object.keys(r.properties)[s];
|
|
69
72
|
}
|
|
70
|
-
(r = r.properties[
|
|
73
|
+
(r = r.properties[l]), (n = n ? n + '-' + l : l);
|
|
71
74
|
}
|
|
72
75
|
}
|
|
73
76
|
return n;
|
|
74
77
|
}
|
|
75
|
-
function
|
|
78
|
+
function d(e, t) {
|
|
76
79
|
for (var r = t, n = '', o = e.split('-'), i = 0, a = o.length; i < a; i++) {
|
|
77
80
|
var s = o[i];
|
|
78
81
|
if (s) {
|
|
79
|
-
var
|
|
82
|
+
var l = -1;
|
|
80
83
|
if (r.propertyOrder)
|
|
81
|
-
(
|
|
84
|
+
(l = r.propertyOrder.indexOf(s)), (r = r.properties[s]);
|
|
82
85
|
else if (r.properties) {
|
|
83
|
-
(
|
|
86
|
+
(l = Object.keys(r.properties).indexOf(s)), (r = r.properties[s]);
|
|
84
87
|
} else
|
|
85
88
|
r.items
|
|
86
|
-
? ((
|
|
87
|
-
: r.options && ((
|
|
88
|
-
n = n ? n + '-' +
|
|
89
|
+
? ((l = 0), (r = r.items))
|
|
90
|
+
: r.options && ((l = 0), (r = r.options));
|
|
91
|
+
n = n ? n + '-' + l : l.toString();
|
|
89
92
|
}
|
|
90
93
|
}
|
|
91
94
|
return n;
|
|
92
95
|
}
|
|
93
|
-
var
|
|
94
|
-
|
|
96
|
+
var f,
|
|
97
|
+
v = {
|
|
95
98
|
type: 'event',
|
|
96
99
|
title: '事件',
|
|
97
100
|
isContainer: !1,
|
|
@@ -121,7 +124,7 @@ var d,
|
|
|
121
124
|
},
|
|
122
125
|
propertyOrder: ['type', 'trigger', 'eventData'],
|
|
123
126
|
},
|
|
124
|
-
|
|
127
|
+
y = {
|
|
125
128
|
type: 'datasource',
|
|
126
129
|
title: '数据源',
|
|
127
130
|
isContainer: !1,
|
|
@@ -153,11 +156,11 @@ var d,
|
|
|
153
156
|
},
|
|
154
157
|
propertyOrder: ['type', 'data', 'filter'],
|
|
155
158
|
},
|
|
156
|
-
|
|
157
|
-
(((
|
|
158
|
-
(
|
|
159
|
-
(
|
|
160
|
-
(
|
|
159
|
+
h =
|
|
160
|
+
(((f = { type: 'object' }).type = 'datasource'),
|
|
161
|
+
(f.title = '数据源'),
|
|
162
|
+
(f.isContainer = !1),
|
|
163
|
+
(f.properties = {
|
|
161
164
|
type: {
|
|
162
165
|
type: 'select',
|
|
163
166
|
default: 'remote',
|
|
@@ -183,15 +186,15 @@ var d,
|
|
|
183
186
|
isRequired: !0,
|
|
184
187
|
},
|
|
185
188
|
}),
|
|
186
|
-
(
|
|
187
|
-
|
|
188
|
-
|
|
189
|
+
(f.propertyOrder = ['type', 'data', 'filter']),
|
|
190
|
+
f),
|
|
191
|
+
b = {
|
|
189
192
|
type: 'local',
|
|
190
193
|
config: { dataName: '', body: {}, filter: 'return data;' },
|
|
191
194
|
data: '{}',
|
|
192
195
|
localFilter: 'return data;',
|
|
193
196
|
},
|
|
194
|
-
|
|
197
|
+
m = {
|
|
195
198
|
jsonschema: {
|
|
196
199
|
type: 'object',
|
|
197
200
|
title: 'jsonSchemaObject',
|
|
@@ -273,7 +276,6 @@ var d,
|
|
|
273
276
|
type: 'array',
|
|
274
277
|
title: '数组Array',
|
|
275
278
|
description: '',
|
|
276
|
-
default: [],
|
|
277
279
|
items: {
|
|
278
280
|
type: 'object',
|
|
279
281
|
title: '数组项',
|
|
@@ -345,6 +347,13 @@ var d,
|
|
|
345
347
|
maximum: 1e3,
|
|
346
348
|
description: '',
|
|
347
349
|
},
|
|
350
|
+
'input-image': {
|
|
351
|
+
title: '图片地址',
|
|
352
|
+
type: 'input-image',
|
|
353
|
+
description: '',
|
|
354
|
+
accept: '.jpeg,.jpg,.png',
|
|
355
|
+
multiple: !0,
|
|
356
|
+
},
|
|
348
357
|
json: { title: 'json数据', type: 'json', default: '{}', description: '' },
|
|
349
358
|
codearea: {
|
|
350
359
|
type: 'codearea',
|
|
@@ -535,8 +544,8 @@ var d,
|
|
|
535
544
|
},
|
|
536
545
|
propertyOrder: ['type', 'config', 'data', 'localFilter'],
|
|
537
546
|
},
|
|
538
|
-
datasource:
|
|
539
|
-
event:
|
|
547
|
+
datasource: y,
|
|
548
|
+
event: v,
|
|
540
549
|
'dynamic-config': {
|
|
541
550
|
type: 'dynamic-config',
|
|
542
551
|
title: '动态配置',
|
|
@@ -564,6 +573,8 @@ var d,
|
|
|
564
573
|
default: '',
|
|
565
574
|
description: '',
|
|
566
575
|
placeholder: '',
|
|
576
|
+
onShow:
|
|
577
|
+
'type === "DevDefaults" || type === "Content" || type === "RuntimeConst"',
|
|
567
578
|
},
|
|
568
579
|
description: {
|
|
569
580
|
title: '属性名称',
|
|
@@ -571,6 +582,7 @@ var d,
|
|
|
571
582
|
default: '',
|
|
572
583
|
description: '',
|
|
573
584
|
placeholder: '',
|
|
585
|
+
onShow: 'type === "ContentStaticConfig" || type === "ResourceCenter"',
|
|
574
586
|
},
|
|
575
587
|
valueType: {
|
|
576
588
|
type: 'radio',
|
|
@@ -582,12 +594,15 @@ var d,
|
|
|
582
594
|
default: 'string',
|
|
583
595
|
isConditionProp: !0,
|
|
584
596
|
description: '',
|
|
597
|
+
onShow: 'type === "ContentStaticConfig" || type === "ResourceCenter"',
|
|
585
598
|
},
|
|
586
599
|
range: {
|
|
587
600
|
type: 'select',
|
|
588
601
|
title: '可选项',
|
|
589
602
|
multiple: !0,
|
|
590
603
|
options: [],
|
|
604
|
+
onShow:
|
|
605
|
+
'(type === "ContentStaticConfig" || type === "ResourceCenter") && valueType === "select"',
|
|
591
606
|
description: '这里会使用value中的配置选项作为options',
|
|
592
607
|
},
|
|
593
608
|
},
|
|
@@ -625,6 +640,7 @@ var d,
|
|
|
625
640
|
default: '',
|
|
626
641
|
description: '',
|
|
627
642
|
placeholder: '',
|
|
643
|
+
onShow: 'type === "ContentStaticConfig"',
|
|
628
644
|
},
|
|
629
645
|
dataType: {
|
|
630
646
|
type: 'radio',
|
|
@@ -642,6 +658,7 @@ var d,
|
|
|
642
658
|
default: '',
|
|
643
659
|
description: '',
|
|
644
660
|
placeholder: '',
|
|
661
|
+
onShow: 'type === "RuntimeDataSelfDefine"',
|
|
645
662
|
},
|
|
646
663
|
CONTENTTYPE: {
|
|
647
664
|
type: 'select',
|
|
@@ -652,6 +669,7 @@ var d,
|
|
|
652
669
|
{ label: 'block', value: 'block' },
|
|
653
670
|
],
|
|
654
671
|
description: '',
|
|
672
|
+
onShow: 'type === "RuntimeDataSelfDefine"',
|
|
655
673
|
},
|
|
656
674
|
},
|
|
657
675
|
propertyOrder: [
|
|
@@ -865,8 +883,285 @@ var d,
|
|
|
865
883
|
},
|
|
866
884
|
propertyOrder: ['globalEventMap', 'event'],
|
|
867
885
|
},
|
|
886
|
+
'sohu-ad': {
|
|
887
|
+
type: 'object',
|
|
888
|
+
title: '广告配置',
|
|
889
|
+
description: '',
|
|
890
|
+
properties: {
|
|
891
|
+
type: {
|
|
892
|
+
type: 'select',
|
|
893
|
+
title: '数据源类型',
|
|
894
|
+
isConditionProp: !0,
|
|
895
|
+
options: [
|
|
896
|
+
{ label: '模板直接设置', value: 'DevDefaults' },
|
|
897
|
+
{ label: '资源中心配置', value: 'ResourceCenter' },
|
|
898
|
+
],
|
|
899
|
+
description: '',
|
|
900
|
+
},
|
|
901
|
+
value: {
|
|
902
|
+
type: 'object',
|
|
903
|
+
title: '广告规则',
|
|
904
|
+
description: '',
|
|
905
|
+
onShow: 'type === "DevDefaults"',
|
|
906
|
+
properties: {
|
|
907
|
+
id: {
|
|
908
|
+
title: '广告ID',
|
|
909
|
+
type: 'input',
|
|
910
|
+
default: '',
|
|
911
|
+
description: '',
|
|
912
|
+
placeholder: '',
|
|
913
|
+
},
|
|
914
|
+
rule: {
|
|
915
|
+
type: 'radio',
|
|
916
|
+
title: '规则类型',
|
|
917
|
+
options: [
|
|
918
|
+
{ label: '固定位置', value: 1 },
|
|
919
|
+
{ label: '隔几出几', value: 2 },
|
|
920
|
+
{ label: '固定位置隔几出几', value: 3 },
|
|
921
|
+
],
|
|
922
|
+
default: 1,
|
|
923
|
+
description: '',
|
|
924
|
+
},
|
|
925
|
+
fixArray: {
|
|
926
|
+
type: 'select',
|
|
927
|
+
title: '固定位置',
|
|
928
|
+
default: 1,
|
|
929
|
+
description: '',
|
|
930
|
+
options: [
|
|
931
|
+
{ label: '1', value: 1 },
|
|
932
|
+
{ label: '2', value: 2 },
|
|
933
|
+
{ label: '3', value: 3 },
|
|
934
|
+
{ label: '4', value: 4 },
|
|
935
|
+
{ label: '5', value: 5 },
|
|
936
|
+
{ label: '6', value: 6 },
|
|
937
|
+
{ label: '7', value: 7 },
|
|
938
|
+
{ label: '8', value: 8 },
|
|
939
|
+
{ label: '9', value: 9 },
|
|
940
|
+
{ label: '10', value: 10 },
|
|
941
|
+
{ label: '11', value: 11 },
|
|
942
|
+
{ label: '12', value: 12 },
|
|
943
|
+
{ label: '13', value: 13 },
|
|
944
|
+
{ label: '14', value: 14 },
|
|
945
|
+
{ label: '15', value: 15 },
|
|
946
|
+
{ label: '16', value: 16 },
|
|
947
|
+
{ label: '17', value: 17 },
|
|
948
|
+
{ label: '18', value: 18 },
|
|
949
|
+
{ label: '19', value: 19 },
|
|
950
|
+
{ label: '20', value: 20 },
|
|
951
|
+
{ label: '21', value: 21 },
|
|
952
|
+
{ label: '22', value: 22 },
|
|
953
|
+
{ label: '23', value: 23 },
|
|
954
|
+
{ label: '24', value: 24 },
|
|
955
|
+
{ label: '25', value: 25 },
|
|
956
|
+
{ label: '26', value: 26 },
|
|
957
|
+
{ label: '27', value: 27 },
|
|
958
|
+
{ label: '28', value: 28 },
|
|
959
|
+
{ label: '29', value: 29 },
|
|
960
|
+
{ label: '30', value: 30 },
|
|
961
|
+
{ label: '31', value: 31 },
|
|
962
|
+
{ label: '32', value: 32 },
|
|
963
|
+
{ label: '33', value: 33 },
|
|
964
|
+
{ label: '34', value: 34 },
|
|
965
|
+
{ label: '35', value: 35 },
|
|
966
|
+
{ label: '36', value: 36 },
|
|
967
|
+
{ label: '37', value: 37 },
|
|
968
|
+
{ label: '38', value: 38 },
|
|
969
|
+
{ label: '39', value: 39 },
|
|
970
|
+
{ label: '40', value: 40 },
|
|
971
|
+
{ label: '41', value: 41 },
|
|
972
|
+
{ label: '42', value: 42 },
|
|
973
|
+
{ label: '43', value: 43 },
|
|
974
|
+
{ label: '44', value: 44 },
|
|
975
|
+
{ label: '45', value: 45 },
|
|
976
|
+
{ label: '46', value: 46 },
|
|
977
|
+
{ label: '47', value: 47 },
|
|
978
|
+
{ label: '48', value: 48 },
|
|
979
|
+
{ label: '49', value: 49 },
|
|
980
|
+
{ label: '50', value: 50 },
|
|
981
|
+
],
|
|
982
|
+
},
|
|
983
|
+
begin: {
|
|
984
|
+
type: 'number',
|
|
985
|
+
title: '开始位置',
|
|
986
|
+
default: 1,
|
|
987
|
+
minimum: '1',
|
|
988
|
+
maximum: '50',
|
|
989
|
+
description: '',
|
|
990
|
+
},
|
|
991
|
+
turn: {
|
|
992
|
+
type: 'number',
|
|
993
|
+
title: '间隔/隔',
|
|
994
|
+
default: 1,
|
|
995
|
+
minimum: '1',
|
|
996
|
+
maximum: '50',
|
|
997
|
+
description: '',
|
|
998
|
+
},
|
|
999
|
+
number: {
|
|
1000
|
+
type: 'number',
|
|
1001
|
+
title: '间隔/出',
|
|
1002
|
+
default: 1,
|
|
1003
|
+
minimum: '1',
|
|
1004
|
+
maximum: '50',
|
|
1005
|
+
description: '',
|
|
1006
|
+
},
|
|
1007
|
+
mergeType: {
|
|
1008
|
+
type: 'radio',
|
|
1009
|
+
title: '插入规则',
|
|
1010
|
+
options: [
|
|
1011
|
+
{ label: '覆盖', value: 0 },
|
|
1012
|
+
{ label: '插入', value: 1 },
|
|
1013
|
+
],
|
|
1014
|
+
default: 0,
|
|
1015
|
+
description: '',
|
|
1016
|
+
},
|
|
1017
|
+
},
|
|
1018
|
+
propertyOrder: [
|
|
1019
|
+
'id',
|
|
1020
|
+
'rule',
|
|
1021
|
+
'fixArray',
|
|
1022
|
+
'begin',
|
|
1023
|
+
'turn',
|
|
1024
|
+
'number',
|
|
1025
|
+
'mergeType',
|
|
1026
|
+
],
|
|
1027
|
+
},
|
|
1028
|
+
range: {
|
|
1029
|
+
type: 'array',
|
|
1030
|
+
title: '广告规则列表',
|
|
1031
|
+
description: '',
|
|
1032
|
+
onShow: 'type === "ResourceCenter"',
|
|
1033
|
+
items: {
|
|
1034
|
+
type: 'object',
|
|
1035
|
+
title: '数组项',
|
|
1036
|
+
description: '',
|
|
1037
|
+
properties: {
|
|
1038
|
+
id: {
|
|
1039
|
+
title: '广告ID',
|
|
1040
|
+
type: 'input',
|
|
1041
|
+
default: '',
|
|
1042
|
+
description: '',
|
|
1043
|
+
placeholder: '',
|
|
1044
|
+
},
|
|
1045
|
+
rule: {
|
|
1046
|
+
type: 'radio',
|
|
1047
|
+
title: '规则类型',
|
|
1048
|
+
options: [
|
|
1049
|
+
{ label: '固定位置', value: 1 },
|
|
1050
|
+
{ label: '隔几出几', value: 2 },
|
|
1051
|
+
{ label: '固定位置隔几出几', value: 3 },
|
|
1052
|
+
],
|
|
1053
|
+
default: 1,
|
|
1054
|
+
description: '',
|
|
1055
|
+
},
|
|
1056
|
+
fixArray: {
|
|
1057
|
+
type: 'select',
|
|
1058
|
+
title: '固定位置',
|
|
1059
|
+
default: 1,
|
|
1060
|
+
description: '',
|
|
1061
|
+
options: [
|
|
1062
|
+
{ label: '1', value: 1 },
|
|
1063
|
+
{ label: '2', value: 2 },
|
|
1064
|
+
{ label: '3', value: 3 },
|
|
1065
|
+
{ label: '4', value: 4 },
|
|
1066
|
+
{ label: '5', value: 5 },
|
|
1067
|
+
{ label: '6', value: 6 },
|
|
1068
|
+
{ label: '7', value: 7 },
|
|
1069
|
+
{ label: '8', value: 8 },
|
|
1070
|
+
{ label: '9', value: 9 },
|
|
1071
|
+
{ label: '10', value: 10 },
|
|
1072
|
+
{ label: '11', value: 11 },
|
|
1073
|
+
{ label: '12', value: 12 },
|
|
1074
|
+
{ label: '13', value: 13 },
|
|
1075
|
+
{ label: '14', value: 14 },
|
|
1076
|
+
{ label: '15', value: 15 },
|
|
1077
|
+
{ label: '16', value: 16 },
|
|
1078
|
+
{ label: '17', value: 17 },
|
|
1079
|
+
{ label: '18', value: 18 },
|
|
1080
|
+
{ label: '19', value: 19 },
|
|
1081
|
+
{ label: '20', value: 20 },
|
|
1082
|
+
{ label: '21', value: 21 },
|
|
1083
|
+
{ label: '22', value: 22 },
|
|
1084
|
+
{ label: '23', value: 23 },
|
|
1085
|
+
{ label: '24', value: 24 },
|
|
1086
|
+
{ label: '25', value: 25 },
|
|
1087
|
+
{ label: '26', value: 26 },
|
|
1088
|
+
{ label: '27', value: 27 },
|
|
1089
|
+
{ label: '28', value: 28 },
|
|
1090
|
+
{ label: '29', value: 29 },
|
|
1091
|
+
{ label: '30', value: 30 },
|
|
1092
|
+
{ label: '31', value: 31 },
|
|
1093
|
+
{ label: '32', value: 32 },
|
|
1094
|
+
{ label: '33', value: 33 },
|
|
1095
|
+
{ label: '34', value: 34 },
|
|
1096
|
+
{ label: '35', value: 35 },
|
|
1097
|
+
{ label: '36', value: 36 },
|
|
1098
|
+
{ label: '37', value: 37 },
|
|
1099
|
+
{ label: '38', value: 38 },
|
|
1100
|
+
{ label: '39', value: 39 },
|
|
1101
|
+
{ label: '40', value: 40 },
|
|
1102
|
+
{ label: '41', value: 41 },
|
|
1103
|
+
{ label: '42', value: 42 },
|
|
1104
|
+
{ label: '43', value: 43 },
|
|
1105
|
+
{ label: '44', value: 44 },
|
|
1106
|
+
{ label: '45', value: 45 },
|
|
1107
|
+
{ label: '46', value: 46 },
|
|
1108
|
+
{ label: '47', value: 47 },
|
|
1109
|
+
{ label: '48', value: 48 },
|
|
1110
|
+
{ label: '49', value: 49 },
|
|
1111
|
+
{ label: '50', value: 50 },
|
|
1112
|
+
],
|
|
1113
|
+
},
|
|
1114
|
+
begin: {
|
|
1115
|
+
type: 'number',
|
|
1116
|
+
title: '开始位置',
|
|
1117
|
+
default: 1,
|
|
1118
|
+
minimum: '1',
|
|
1119
|
+
maximum: '50',
|
|
1120
|
+
description: '',
|
|
1121
|
+
},
|
|
1122
|
+
turn: {
|
|
1123
|
+
type: 'number',
|
|
1124
|
+
title: '间隔/隔',
|
|
1125
|
+
default: 1,
|
|
1126
|
+
minimum: '1',
|
|
1127
|
+
maximum: '50',
|
|
1128
|
+
description: '',
|
|
1129
|
+
},
|
|
1130
|
+
number: {
|
|
1131
|
+
type: 'number',
|
|
1132
|
+
title: '间隔/出',
|
|
1133
|
+
default: 1,
|
|
1134
|
+
minimum: '1',
|
|
1135
|
+
maximum: '50',
|
|
1136
|
+
description: '',
|
|
1137
|
+
},
|
|
1138
|
+
mergeType: {
|
|
1139
|
+
type: 'radio',
|
|
1140
|
+
title: '插入规则',
|
|
1141
|
+
options: [
|
|
1142
|
+
{ label: '覆盖', value: 0 },
|
|
1143
|
+
{ label: '插入', value: 1 },
|
|
1144
|
+
],
|
|
1145
|
+
default: 0,
|
|
1146
|
+
description: '',
|
|
1147
|
+
},
|
|
1148
|
+
},
|
|
1149
|
+
propertyOrder: [
|
|
1150
|
+
'id',
|
|
1151
|
+
'rule',
|
|
1152
|
+
'fixArray',
|
|
1153
|
+
'begin',
|
|
1154
|
+
'turn',
|
|
1155
|
+
'number',
|
|
1156
|
+
'mergeType',
|
|
1157
|
+
],
|
|
1158
|
+
},
|
|
1159
|
+
},
|
|
1160
|
+
},
|
|
1161
|
+
propertyOrder: ['type', 'value', 'range'],
|
|
1162
|
+
},
|
|
868
1163
|
},
|
|
869
|
-
|
|
1164
|
+
g = {
|
|
870
1165
|
on: {
|
|
871
1166
|
type: 'event',
|
|
872
1167
|
title: '事件',
|
|
@@ -897,16 +1192,16 @@ var d,
|
|
|
897
1192
|
},
|
|
898
1193
|
propertyOrder: ['type', 'register', 'actionFunc'],
|
|
899
1194
|
},
|
|
900
|
-
emit:
|
|
1195
|
+
emit: v,
|
|
901
1196
|
},
|
|
902
|
-
|
|
903
|
-
function
|
|
1197
|
+
O = { local: y, remote: h };
|
|
1198
|
+
function E(e) {
|
|
904
1199
|
return /^http[s]?:\/\/.*/.test(e);
|
|
905
1200
|
}
|
|
906
|
-
function
|
|
1201
|
+
function N(e) {
|
|
907
1202
|
return 'String' === Object.prototype.toString.call(e).slice(8, -1);
|
|
908
1203
|
}
|
|
909
|
-
function
|
|
1204
|
+
function w(e) {
|
|
910
1205
|
return (
|
|
911
1206
|
'number' == typeof e ||
|
|
912
1207
|
'[object Number]' === Object.prototype.toString.call(e)
|
|
@@ -915,28 +1210,28 @@ function N(e) {
|
|
|
915
1210
|
function _(e) {
|
|
916
1211
|
return 'Boolean' === Object.prototype.toString.call(e).slice(8, -1);
|
|
917
1212
|
}
|
|
918
|
-
function
|
|
1213
|
+
function x(e) {
|
|
919
1214
|
return /^\d{4}-\d{2}-\d{2}$/.test(e);
|
|
920
1215
|
}
|
|
921
|
-
function
|
|
1216
|
+
function j(e) {
|
|
922
1217
|
return (
|
|
923
1218
|
/^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}$/.test(e) ||
|
|
924
1219
|
/^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}$/.test(e)
|
|
925
1220
|
);
|
|
926
1221
|
}
|
|
927
|
-
function
|
|
1222
|
+
function S(e) {
|
|
928
1223
|
return /^\d{2}:\d{2}:\d{2}$/.test(e) || /^\d{2}:\d{2}$/.test(e);
|
|
929
1224
|
}
|
|
930
|
-
function
|
|
1225
|
+
function D(e) {
|
|
931
1226
|
var t = !1;
|
|
932
1227
|
return (
|
|
933
1228
|
'Array' === Object.prototype.toString.call(e).slice(8, -1) && (t = !0), t
|
|
934
1229
|
);
|
|
935
1230
|
}
|
|
936
|
-
function
|
|
937
|
-
if (!
|
|
1231
|
+
function C(e) {
|
|
1232
|
+
if (!D(e)) return !1;
|
|
938
1233
|
for (var t = 0, r = e.length; t < r; t++) {
|
|
939
|
-
if (!
|
|
1234
|
+
if (!N(e[t])) return !1;
|
|
940
1235
|
}
|
|
941
1236
|
return !0;
|
|
942
1237
|
}
|
|
@@ -948,18 +1243,18 @@ function A(e) {
|
|
|
948
1243
|
}
|
|
949
1244
|
function V(e) {
|
|
950
1245
|
var t = !1;
|
|
951
|
-
return
|
|
1246
|
+
return m.quantity.properties.quantity.enum.indexOf(e) >= 0 && (t = !0), t;
|
|
952
1247
|
}
|
|
953
|
-
function
|
|
1248
|
+
function T(e) {
|
|
954
1249
|
return /^#[0-9a-f]{6}$/.test(e) || /^#[0-9a-f]{3}$/.test(e);
|
|
955
1250
|
}
|
|
956
|
-
function
|
|
1251
|
+
function k(e) {
|
|
957
1252
|
var t = !1;
|
|
958
1253
|
return (
|
|
959
1254
|
'Function' === Object.prototype.toString.call(e).slice(8, -1) && (t = !0), t
|
|
960
1255
|
);
|
|
961
1256
|
}
|
|
962
|
-
function
|
|
1257
|
+
function R(e) {
|
|
963
1258
|
var t = {};
|
|
964
1259
|
return (
|
|
965
1260
|
(t =
|
|
@@ -969,88 +1264,88 @@ function k(e) {
|
|
|
969
1264
|
if (A(e)) {
|
|
970
1265
|
var r = Object.keys(e);
|
|
971
1266
|
e.data && e.filter && 2 === r.length
|
|
972
|
-
? (t =
|
|
1267
|
+
? (t = D(e.data) || A(e.data) ? n(O.local) : n(O.remote))
|
|
973
1268
|
: e.trigger && e.eventData && 2 === r.length
|
|
974
|
-
? (t = n(
|
|
1269
|
+
? (t = n(g.emit))
|
|
975
1270
|
: e.register && e.actionFunc && 2 === r.length
|
|
976
|
-
? (t = n(
|
|
1271
|
+
? (t = n(g.on))
|
|
977
1272
|
: e.quantity && V(e.quantity) && 2 === r.length
|
|
978
|
-
? (t = n(
|
|
979
|
-
: ((t = n(
|
|
1273
|
+
? (t = n(m.quantity))
|
|
1274
|
+
: ((t = n(m['empty-object'])),
|
|
980
1275
|
Object.keys(e).map(function (r) {
|
|
981
1276
|
var n = e[r];
|
|
982
|
-
t.properties[r] =
|
|
1277
|
+
t.properties[r] = R(n);
|
|
983
1278
|
}));
|
|
984
1279
|
}
|
|
985
1280
|
return t;
|
|
986
1281
|
})(e)
|
|
987
|
-
: e &&
|
|
1282
|
+
: e && D(e)
|
|
988
1283
|
? (function (e) {
|
|
989
1284
|
var t;
|
|
990
|
-
if (e &&
|
|
991
|
-
if (
|
|
992
|
-
(t = n(
|
|
1285
|
+
if (e && D(e))
|
|
1286
|
+
if (C(e)) {
|
|
1287
|
+
(t = n(m.select)).items.enum = e;
|
|
993
1288
|
var r = t.items.enumextra.length,
|
|
994
1289
|
o = e.length;
|
|
995
1290
|
if (o > r)
|
|
996
1291
|
for (var i = r, a = o; i < a; i++)
|
|
997
1292
|
t.items.enumextra.push('选项' + e(i));
|
|
998
1293
|
} else {
|
|
999
|
-
t = n(
|
|
1000
|
-
var s =
|
|
1294
|
+
t = n(m['empty-array']);
|
|
1295
|
+
var s = R(e[0]);
|
|
1001
1296
|
t.items.properties = s.properties;
|
|
1002
1297
|
}
|
|
1003
1298
|
return t;
|
|
1004
1299
|
})(e)
|
|
1005
1300
|
: (function (e) {
|
|
1006
1301
|
var t = '';
|
|
1007
|
-
if (_(e)) t = n(
|
|
1008
|
-
else if (
|
|
1009
|
-
else if (
|
|
1010
|
-
else if (
|
|
1011
|
-
else if (
|
|
1012
|
-
else if (
|
|
1013
|
-
else if (
|
|
1302
|
+
if (_(e)) t = n(m.boolean);
|
|
1303
|
+
else if (w(e)) t = n(m.number);
|
|
1304
|
+
else if (E(e)) t = n(m.url);
|
|
1305
|
+
else if (x(e)) t = n(m.date);
|
|
1306
|
+
else if (j(e)) t = n(m['date-time']);
|
|
1307
|
+
else if (S(e)) t = n(m.time);
|
|
1308
|
+
else if (T(e)) t = n(m.color);
|
|
1014
1309
|
else
|
|
1015
1310
|
try {
|
|
1016
|
-
t =
|
|
1311
|
+
t = w(JSON.parse(e)) ? n(m.input) : n(m.json);
|
|
1017
1312
|
} catch (r) {
|
|
1018
|
-
t = e && e.length > 30 ? n(
|
|
1313
|
+
t = e && e.length > 30 ? n(m.textarea) : n(m.input);
|
|
1019
1314
|
}
|
|
1020
1315
|
return t;
|
|
1021
1316
|
})(e)),
|
|
1022
1317
|
t
|
|
1023
1318
|
);
|
|
1024
1319
|
}
|
|
1025
|
-
function
|
|
1320
|
+
function P(e, t) {
|
|
1026
1321
|
var r = t || {};
|
|
1027
1322
|
if (A(e) && 'object' === getExpectType(e.type) && e.properties) {
|
|
1028
1323
|
(e.propertyOrder ? e.propertyOrder : Object.keys(e.properties)).map(
|
|
1029
1324
|
function (t) {
|
|
1030
1325
|
var n = e.properties[t];
|
|
1031
|
-
r =
|
|
1326
|
+
r = I(n, r);
|
|
1032
1327
|
},
|
|
1033
1328
|
);
|
|
1034
1329
|
}
|
|
1035
1330
|
return r;
|
|
1036
1331
|
}
|
|
1037
|
-
function
|
|
1332
|
+
function I(e, t) {
|
|
1038
1333
|
var r = !t,
|
|
1039
1334
|
n = t || {};
|
|
1040
1335
|
if (e && '{}' !== JSON.stringify(e)) {
|
|
1041
1336
|
var o = e.type;
|
|
1042
1337
|
'object' === o || 'func' === o || 'style' === o || 'data' === o
|
|
1043
|
-
? (!r && n.object ? (n.object += 1) : r || (n.object = 1), (n =
|
|
1338
|
+
? (!r && n.object ? (n.object += 1) : r || (n.object = 1), (n = P(e, n)))
|
|
1044
1339
|
: 'array' === o
|
|
1045
1340
|
? (!r && n.array ? (n.array += 1) : r || (n.array = 1),
|
|
1046
|
-
(n =
|
|
1341
|
+
(n = P((e = e.items), n)))
|
|
1047
1342
|
: !r && n[o]
|
|
1048
1343
|
? (n[o] += 1)
|
|
1049
1344
|
: r || (n[o] = 1);
|
|
1050
1345
|
}
|
|
1051
1346
|
return n;
|
|
1052
1347
|
}
|
|
1053
|
-
function
|
|
1348
|
+
function M(e) {
|
|
1054
1349
|
var t = n(e);
|
|
1055
1350
|
if (
|
|
1056
1351
|
(!t.title && t.description && (t.title = t.description),
|
|
@@ -1076,7 +1371,7 @@ function I(e) {
|
|
|
1076
1371
|
'quantity' === t.type)
|
|
1077
1372
|
) {
|
|
1078
1373
|
var r = t.properties,
|
|
1079
|
-
o = n(
|
|
1374
|
+
o = n(m.quantity);
|
|
1080
1375
|
if (r.quantity && A(r.quantity) && r.quantity.default) {
|
|
1081
1376
|
var a = r.quantity.default;
|
|
1082
1377
|
o.properties.quantity.default = 'percent' === a ? '%' : a;
|
|
@@ -1085,42 +1380,42 @@ function I(e) {
|
|
|
1085
1380
|
}
|
|
1086
1381
|
if ('datasource' === t.type) {
|
|
1087
1382
|
var s = t.properties,
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
'local' ===
|
|
1092
|
-
? ((t = n(
|
|
1093
|
-
: ((t = n(
|
|
1094
|
-
(t.properties.filter.default =
|
|
1383
|
+
l = s.type && s.type.default,
|
|
1384
|
+
u = s.data && s.data.default,
|
|
1385
|
+
p = s.filter && s.filter.default;
|
|
1386
|
+
'local' === l
|
|
1387
|
+
? ((t = n(O.local)).properties.data.default = u ? n(u) : '{}')
|
|
1388
|
+
: ((t = n(O.remote)).properties.data.default = u ? n(u) : 'http://xxx'),
|
|
1389
|
+
(t.properties.filter.default = p ? n(p) : '() => {}');
|
|
1095
1390
|
}
|
|
1096
1391
|
if ('event' === t.type) {
|
|
1097
|
-
var
|
|
1098
|
-
d =
|
|
1392
|
+
var c = t.properties,
|
|
1393
|
+
d = c.type && c.type.default;
|
|
1099
1394
|
if ('in' === d || 'on' === d) {
|
|
1100
|
-
var f = (
|
|
1101
|
-
(t = n(
|
|
1102
|
-
|
|
1103
|
-
A(
|
|
1104
|
-
(t.properties.actionFunc.default =
|
|
1395
|
+
var f = (c.filter && c.filter.default) || '() => {}';
|
|
1396
|
+
(t = n(g.on)),
|
|
1397
|
+
c.actionFunc &&
|
|
1398
|
+
A(c.actionFunc) &&
|
|
1399
|
+
(t.properties.actionFunc.default = c.actionFunc.default || n(f));
|
|
1105
1400
|
} else {
|
|
1106
|
-
var
|
|
1107
|
-
(t = n(
|
|
1108
|
-
|
|
1109
|
-
A(
|
|
1110
|
-
(t.properties.eventData.default =
|
|
1401
|
+
var v = (c.filter && c.filter.default) || '{}';
|
|
1402
|
+
(t = n(g.emit)),
|
|
1403
|
+
c.eventData &&
|
|
1404
|
+
A(c.eventData) &&
|
|
1405
|
+
(t.properties.eventData.default = c.eventData.default || n(v));
|
|
1111
1406
|
}
|
|
1112
1407
|
}
|
|
1113
1408
|
return (
|
|
1114
1409
|
t.properties &&
|
|
1115
1410
|
(t.propertyOrder || (t.propertyOrder = Object.keys(t.properties)),
|
|
1116
1411
|
t.propertyOrder.map(function (e) {
|
|
1117
|
-
t.properties[e] =
|
|
1412
|
+
t.properties[e] = L(t.properties[e]);
|
|
1118
1413
|
})),
|
|
1119
|
-
t.items && (t.items =
|
|
1414
|
+
t.items && (t.items = L(t.items)),
|
|
1120
1415
|
t
|
|
1121
1416
|
);
|
|
1122
1417
|
}
|
|
1123
|
-
function
|
|
1418
|
+
function L(e) {
|
|
1124
1419
|
var t = n(e);
|
|
1125
1420
|
return (
|
|
1126
1421
|
t.required || delete t.required,
|
|
@@ -1144,19 +1439,19 @@ function M(e) {
|
|
|
1144
1439
|
t.properties &&
|
|
1145
1440
|
(t.propertyOrder || (t.propertyOrder = Object.keys(t.properties)),
|
|
1146
1441
|
t.propertyOrder.map(function (e) {
|
|
1147
|
-
t.properties[e] =
|
|
1442
|
+
t.properties[e] = L(t.properties[e]);
|
|
1148
1443
|
})),
|
|
1149
|
-
'array' === t.type && t.items && (t.items =
|
|
1444
|
+
'array' === t.type && t.items && (t.items = L(t.items)),
|
|
1150
1445
|
t
|
|
1151
1446
|
);
|
|
1152
1447
|
}
|
|
1153
|
-
var
|
|
1154
|
-
Object.freeze(
|
|
1155
|
-
var
|
|
1156
|
-
function
|
|
1448
|
+
var B = [];
|
|
1449
|
+
Object.freeze(B);
|
|
1450
|
+
var q = {};
|
|
1451
|
+
function U() {
|
|
1157
1452
|
return ++ut.mobxGuid;
|
|
1158
1453
|
}
|
|
1159
|
-
function
|
|
1454
|
+
function F(e) {
|
|
1160
1455
|
throw (G(!1, e), 'X');
|
|
1161
1456
|
}
|
|
1162
1457
|
function G(e, t) {
|
|
@@ -1167,23 +1462,23 @@ function G(e, t) {
|
|
|
1167
1462
|
'An invariant failed, however the error is obfuscated because this is a production build.'),
|
|
1168
1463
|
);
|
|
1169
1464
|
}
|
|
1170
|
-
function
|
|
1465
|
+
function K(e) {
|
|
1171
1466
|
var t = !1;
|
|
1172
1467
|
return function () {
|
|
1173
1468
|
if (!t) return (t = !0), e.apply(this, arguments);
|
|
1174
1469
|
};
|
|
1175
1470
|
}
|
|
1176
|
-
Object.freeze(
|
|
1177
|
-
var
|
|
1178
|
-
function
|
|
1471
|
+
Object.freeze(q);
|
|
1472
|
+
var z = function () {};
|
|
1473
|
+
function J(e) {
|
|
1179
1474
|
return null !== e && 'object' == typeof e;
|
|
1180
1475
|
}
|
|
1181
|
-
function
|
|
1476
|
+
function H(e) {
|
|
1182
1477
|
if (null === e || 'object' != typeof e) return !1;
|
|
1183
1478
|
var t = Object.getPrototypeOf(e);
|
|
1184
1479
|
return t === Object.prototype || null === t;
|
|
1185
1480
|
}
|
|
1186
|
-
function
|
|
1481
|
+
function W(e, t, r) {
|
|
1187
1482
|
Object.defineProperty(e, t, {
|
|
1188
1483
|
enumerable: !1,
|
|
1189
1484
|
writable: !0,
|
|
@@ -1191,26 +1486,26 @@ function H(e, t, r) {
|
|
|
1191
1486
|
value: r,
|
|
1192
1487
|
});
|
|
1193
1488
|
}
|
|
1194
|
-
function
|
|
1489
|
+
function $(e, t) {
|
|
1195
1490
|
var r = Object.getOwnPropertyDescriptor(e, t);
|
|
1196
1491
|
return !r || (!1 !== r.configurable && !1 !== r.writable);
|
|
1197
1492
|
}
|
|
1198
|
-
function
|
|
1493
|
+
function X(e, t) {
|
|
1199
1494
|
var r = 'isMobX' + e;
|
|
1200
1495
|
return (
|
|
1201
1496
|
(t.prototype[r] = !0),
|
|
1202
1497
|
function (e) {
|
|
1203
|
-
return
|
|
1498
|
+
return J(e) && !0 === e[r];
|
|
1204
1499
|
}
|
|
1205
1500
|
);
|
|
1206
1501
|
}
|
|
1207
|
-
function
|
|
1502
|
+
function Y(e) {
|
|
1208
1503
|
return e instanceof Map;
|
|
1209
1504
|
}
|
|
1210
|
-
function
|
|
1505
|
+
function Z(e) {
|
|
1211
1506
|
return e instanceof Set;
|
|
1212
1507
|
}
|
|
1213
|
-
function
|
|
1508
|
+
function Q(e) {
|
|
1214
1509
|
var t = new Set();
|
|
1215
1510
|
for (var r in e) t.add(r);
|
|
1216
1511
|
return (
|
|
@@ -1220,13 +1515,13 @@ function Z(e) {
|
|
|
1220
1515
|
Array.from(t)
|
|
1221
1516
|
);
|
|
1222
1517
|
}
|
|
1223
|
-
function
|
|
1518
|
+
function ee(e) {
|
|
1224
1519
|
return e && e.toString ? e.toString() : new String(e).toString();
|
|
1225
1520
|
}
|
|
1226
|
-
function
|
|
1521
|
+
function te(e) {
|
|
1227
1522
|
return null === e ? null : 'object' == typeof e ? '' + e : e;
|
|
1228
1523
|
}
|
|
1229
|
-
var
|
|
1524
|
+
var re =
|
|
1230
1525
|
'undefined' != typeof Reflect && Reflect.ownKeys
|
|
1231
1526
|
? Reflect.ownKeys
|
|
1232
1527
|
: Object.getOwnPropertySymbols
|
|
@@ -1236,17 +1531,17 @@ var te =
|
|
|
1236
1531
|
);
|
|
1237
1532
|
}
|
|
1238
1533
|
: Object.getOwnPropertyNames,
|
|
1239
|
-
|
|
1240
|
-
|
|
1534
|
+
ne = Symbol('mobx administration'),
|
|
1535
|
+
oe = (function () {
|
|
1241
1536
|
function e(e) {
|
|
1242
|
-
void 0 === e && (e = 'Atom@' +
|
|
1537
|
+
void 0 === e && (e = 'Atom@' + U()),
|
|
1243
1538
|
(this.name = e),
|
|
1244
1539
|
(this.isPendingUnobservation = !1),
|
|
1245
1540
|
(this.isBeingObserved = !1),
|
|
1246
1541
|
(this.observers = new Set()),
|
|
1247
1542
|
(this.diffValue = 0),
|
|
1248
1543
|
(this.lastAccessedBy = 0),
|
|
1249
|
-
(this.lowestObserverState =
|
|
1544
|
+
(this.lowestObserverState = Re.NOT_TRACKING);
|
|
1250
1545
|
}
|
|
1251
1546
|
return (
|
|
1252
1547
|
(e.prototype.onBecomeObserved = function () {
|
|
@@ -1262,20 +1557,20 @@ var te =
|
|
|
1262
1557
|
});
|
|
1263
1558
|
}),
|
|
1264
1559
|
(e.prototype.reportObserved = function () {
|
|
1265
|
-
return
|
|
1560
|
+
return yt(this);
|
|
1266
1561
|
}),
|
|
1267
1562
|
(e.prototype.reportChanged = function () {
|
|
1268
|
-
|
|
1563
|
+
ft(),
|
|
1269
1564
|
(function (e) {
|
|
1270
|
-
if (e.lowestObserverState ===
|
|
1271
|
-
(e.lowestObserverState =
|
|
1565
|
+
if (e.lowestObserverState === Re.STALE) return;
|
|
1566
|
+
(e.lowestObserverState = Re.STALE),
|
|
1272
1567
|
e.observers.forEach(function (t) {
|
|
1273
|
-
t.dependenciesState ===
|
|
1274
|
-
(t.isTracing !==
|
|
1275
|
-
(t.dependenciesState =
|
|
1568
|
+
t.dependenciesState === Re.UP_TO_DATE &&
|
|
1569
|
+
(t.isTracing !== Pe.NONE && ht(t, e), t.onBecomeStale()),
|
|
1570
|
+
(t.dependenciesState = Re.STALE);
|
|
1276
1571
|
});
|
|
1277
1572
|
})(this),
|
|
1278
|
-
|
|
1573
|
+
vt();
|
|
1279
1574
|
}),
|
|
1280
1575
|
(e.prototype.toString = function () {
|
|
1281
1576
|
return this.name;
|
|
@@ -1283,30 +1578,30 @@ var te =
|
|
|
1283
1578
|
e
|
|
1284
1579
|
);
|
|
1285
1580
|
})(),
|
|
1286
|
-
|
|
1287
|
-
function
|
|
1288
|
-
void 0 === t && (t =
|
|
1581
|
+
ie = X('Atom', oe);
|
|
1582
|
+
function ae(e, t, r) {
|
|
1583
|
+
void 0 === t && (t = z), void 0 === r && (r = z);
|
|
1289
1584
|
var n,
|
|
1290
|
-
o = new
|
|
1291
|
-
return t !==
|
|
1585
|
+
o = new oe(e);
|
|
1586
|
+
return t !== z && Vt('onBecomeObserved', o, t, n), r !== z && At(o, r), o;
|
|
1292
1587
|
}
|
|
1293
|
-
var
|
|
1588
|
+
var se = {
|
|
1294
1589
|
identity: function (e, t) {
|
|
1295
1590
|
return e === t;
|
|
1296
1591
|
},
|
|
1297
1592
|
structural: function (e, t) {
|
|
1298
|
-
return
|
|
1593
|
+
return Or(e, t);
|
|
1299
1594
|
},
|
|
1300
1595
|
default: function (e, t) {
|
|
1301
1596
|
return Object.is(e, t);
|
|
1302
1597
|
},
|
|
1303
1598
|
shallow: function (e, t) {
|
|
1304
|
-
return
|
|
1599
|
+
return Or(e, t, 1);
|
|
1305
1600
|
},
|
|
1306
1601
|
},
|
|
1307
|
-
|
|
1602
|
+
le = function (e, t) {
|
|
1308
1603
|
return (
|
|
1309
|
-
(
|
|
1604
|
+
(le =
|
|
1310
1605
|
Object.setPrototypeOf ||
|
|
1311
1606
|
({ __proto__: [] } instanceof Array &&
|
|
1312
1607
|
function (e, t) {
|
|
@@ -1315,7 +1610,7 @@ var ae = {
|
|
|
1315
1610
|
function (e, t) {
|
|
1316
1611
|
for (var r in t) t.hasOwnProperty(r) && (e[r] = t[r]);
|
|
1317
1612
|
}),
|
|
1318
|
-
|
|
1613
|
+
le(e, t)
|
|
1319
1614
|
);
|
|
1320
1615
|
};
|
|
1321
1616
|
/*! *****************************************************************************
|
|
@@ -1345,7 +1640,7 @@ and limitations under the License.
|
|
|
1345
1640
|
ue.apply(this, arguments)
|
|
1346
1641
|
);
|
|
1347
1642
|
};
|
|
1348
|
-
function
|
|
1643
|
+
function pe(e) {
|
|
1349
1644
|
var t = 'function' == typeof Symbol && e[Symbol.iterator],
|
|
1350
1645
|
r = 0;
|
|
1351
1646
|
return t
|
|
@@ -1358,7 +1653,7 @@ function ce(e) {
|
|
|
1358
1653
|
},
|
|
1359
1654
|
};
|
|
1360
1655
|
}
|
|
1361
|
-
function
|
|
1656
|
+
function ce(e, t) {
|
|
1362
1657
|
var r = 'function' == typeof Symbol && e[Symbol.iterator];
|
|
1363
1658
|
if (!r) return e;
|
|
1364
1659
|
var n,
|
|
@@ -1378,24 +1673,24 @@ function le(e, t) {
|
|
|
1378
1673
|
}
|
|
1379
1674
|
return a;
|
|
1380
1675
|
}
|
|
1381
|
-
function
|
|
1676
|
+
function de() {
|
|
1382
1677
|
for (var e = [], t = 0; t < arguments.length; t++)
|
|
1383
|
-
e = e.concat(
|
|
1678
|
+
e = e.concat(ce(arguments[t]));
|
|
1384
1679
|
return e;
|
|
1385
1680
|
}
|
|
1386
|
-
var
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
function
|
|
1681
|
+
var fe = Symbol('mobx did run lazy initializers'),
|
|
1682
|
+
ve = Symbol('mobx pending decorators'),
|
|
1683
|
+
ye = {},
|
|
1684
|
+
he = {};
|
|
1685
|
+
function be(e) {
|
|
1391
1686
|
var t, r;
|
|
1392
|
-
if (!0 !== e[
|
|
1393
|
-
var n = e[
|
|
1687
|
+
if (!0 !== e[fe]) {
|
|
1688
|
+
var n = e[ve];
|
|
1394
1689
|
if (n) {
|
|
1395
|
-
|
|
1396
|
-
var o =
|
|
1690
|
+
W(e, fe, !0);
|
|
1691
|
+
var o = de(Object.getOwnPropertySymbols(n), Object.keys(n));
|
|
1397
1692
|
try {
|
|
1398
|
-
for (var i =
|
|
1693
|
+
for (var i = pe(o), a = i.next(); !a.done; a = i.next()) {
|
|
1399
1694
|
var s = n[a.value];
|
|
1400
1695
|
s.propertyCreator(
|
|
1401
1696
|
e,
|
|
@@ -1417,24 +1712,24 @@ function ye(e) {
|
|
|
1417
1712
|
}
|
|
1418
1713
|
}
|
|
1419
1714
|
}
|
|
1420
|
-
function
|
|
1715
|
+
function me(e, t) {
|
|
1421
1716
|
return function () {
|
|
1422
1717
|
var r,
|
|
1423
1718
|
n = function (n, o, i, a) {
|
|
1424
1719
|
if (!0 === a) return t(n, o, i, n, r), null;
|
|
1425
1720
|
if (
|
|
1426
1721
|
('production' === process.env.NODE_ENV ||
|
|
1427
|
-
|
|
1428
|
-
|
|
1722
|
+
ge(arguments) ||
|
|
1723
|
+
F(
|
|
1429
1724
|
"This function is a decorator, but it wasn't invoked like a decorator",
|
|
1430
1725
|
),
|
|
1431
|
-
!Object.prototype.hasOwnProperty.call(n,
|
|
1726
|
+
!Object.prototype.hasOwnProperty.call(n, ve))
|
|
1432
1727
|
) {
|
|
1433
|
-
var s = n[
|
|
1434
|
-
|
|
1728
|
+
var s = n[ve];
|
|
1729
|
+
W(n, ve, ue({}, s));
|
|
1435
1730
|
}
|
|
1436
1731
|
return (
|
|
1437
|
-
(n[
|
|
1732
|
+
(n[ve][o] = {
|
|
1438
1733
|
prop: o,
|
|
1439
1734
|
propertyCreator: t,
|
|
1440
1735
|
descriptor: i,
|
|
@@ -1442,59 +1737,59 @@ function be(e, t) {
|
|
|
1442
1737
|
decoratorArguments: r,
|
|
1443
1738
|
}),
|
|
1444
1739
|
(function (e, t) {
|
|
1445
|
-
var r = t ?
|
|
1740
|
+
var r = t ? ye : he;
|
|
1446
1741
|
return (
|
|
1447
1742
|
r[e] ||
|
|
1448
1743
|
(r[e] = {
|
|
1449
1744
|
configurable: !0,
|
|
1450
1745
|
enumerable: t,
|
|
1451
1746
|
get: function () {
|
|
1452
|
-
return
|
|
1747
|
+
return be(this), this[e];
|
|
1453
1748
|
},
|
|
1454
1749
|
set: function (t) {
|
|
1455
|
-
|
|
1750
|
+
be(this), (this[e] = t);
|
|
1456
1751
|
},
|
|
1457
1752
|
})
|
|
1458
1753
|
);
|
|
1459
1754
|
})(o, e)
|
|
1460
1755
|
);
|
|
1461
1756
|
};
|
|
1462
|
-
return
|
|
1463
|
-
? ((r =
|
|
1757
|
+
return ge(arguments)
|
|
1758
|
+
? ((r = B), n.apply(null, arguments))
|
|
1464
1759
|
: ((r = Array.prototype.slice.call(arguments)), n);
|
|
1465
1760
|
};
|
|
1466
1761
|
}
|
|
1467
|
-
function
|
|
1762
|
+
function ge(e) {
|
|
1468
1763
|
return (
|
|
1469
1764
|
((2 === e.length || 3 === e.length) &&
|
|
1470
1765
|
('string' == typeof e[1] || 'symbol' == typeof e[1])) ||
|
|
1471
1766
|
(4 === e.length && !0 === e[3])
|
|
1472
1767
|
);
|
|
1473
1768
|
}
|
|
1474
|
-
function
|
|
1475
|
-
return
|
|
1769
|
+
function Oe(e, t, r) {
|
|
1770
|
+
return Mt(e)
|
|
1476
1771
|
? e
|
|
1477
1772
|
: Array.isArray(e)
|
|
1478
|
-
?
|
|
1479
|
-
:
|
|
1480
|
-
?
|
|
1481
|
-
:
|
|
1482
|
-
?
|
|
1483
|
-
:
|
|
1484
|
-
?
|
|
1773
|
+
? Te.array(e, { name: r })
|
|
1774
|
+
: H(e)
|
|
1775
|
+
? Te.object(e, void 0, { name: r })
|
|
1776
|
+
: Y(e)
|
|
1777
|
+
? Te.map(e, { name: r })
|
|
1778
|
+
: Z(e)
|
|
1779
|
+
? Te.set(e, { name: r })
|
|
1485
1780
|
: e;
|
|
1486
1781
|
}
|
|
1487
|
-
function
|
|
1782
|
+
function Ee(e) {
|
|
1488
1783
|
return e;
|
|
1489
1784
|
}
|
|
1490
|
-
function
|
|
1785
|
+
function Ne(e) {
|
|
1491
1786
|
G(e);
|
|
1492
|
-
var t =
|
|
1787
|
+
var t = me(!0, function (t, r, n, o, i) {
|
|
1493
1788
|
'production' !== process.env.NODE_ENV &&
|
|
1494
1789
|
G(
|
|
1495
1790
|
!n || !n.get,
|
|
1496
1791
|
'@observable cannot be used on getter (property "' +
|
|
1497
|
-
|
|
1792
|
+
ee(r) +
|
|
1498
1793
|
'"), use @computed instead.',
|
|
1499
1794
|
);
|
|
1500
1795
|
var a = n ? (n.initializer ? n.initializer.call(t) : n.value) : void 0;
|
|
@@ -1506,7 +1801,7 @@ function Ee(e) {
|
|
|
1506
1801
|
'production' !== process.env.NODE_ENV
|
|
1507
1802
|
? function () {
|
|
1508
1803
|
return arguments.length < 2
|
|
1509
|
-
?
|
|
1804
|
+
? F(
|
|
1510
1805
|
"Incorrect decorator invocation. @observable decorator doesn't expect any arguments",
|
|
1511
1806
|
)
|
|
1512
1807
|
: t.apply(null, arguments);
|
|
@@ -1514,66 +1809,66 @@ function Ee(e) {
|
|
|
1514
1809
|
: t;
|
|
1515
1810
|
return (r.enhancer = e), r;
|
|
1516
1811
|
}
|
|
1517
|
-
var
|
|
1812
|
+
var we = { deep: !0, name: void 0, defaultDecorator: void 0, proxy: !0 };
|
|
1518
1813
|
function _e(e) {
|
|
1519
1814
|
/^(deep|name|equals|defaultDecorator|proxy)$/.test(e) ||
|
|
1520
|
-
|
|
1815
|
+
F('invalid option for (extend)observable: ' + e);
|
|
1521
1816
|
}
|
|
1522
|
-
function
|
|
1523
|
-
if (null == e) return
|
|
1817
|
+
function xe(e) {
|
|
1818
|
+
if (null == e) return we;
|
|
1524
1819
|
if ('string' == typeof e) return { name: e, deep: !0, proxy: !0 };
|
|
1525
1820
|
if ('production' !== process.env.NODE_ENV) {
|
|
1526
|
-
if ('object' != typeof e) return
|
|
1821
|
+
if ('object' != typeof e) return F('expected options object');
|
|
1527
1822
|
Object.keys(e).forEach(_e);
|
|
1528
1823
|
}
|
|
1529
1824
|
return e;
|
|
1530
1825
|
}
|
|
1531
|
-
Object.freeze(
|
|
1532
|
-
var
|
|
1533
|
-
|
|
1534
|
-
return null == e ||
|
|
1826
|
+
Object.freeze(we);
|
|
1827
|
+
var je = Ne(Oe),
|
|
1828
|
+
Se = Ne(function (e, t, r) {
|
|
1829
|
+
return null == e || vr(e) || er(e) || or(e) || sr(e)
|
|
1535
1830
|
? e
|
|
1536
1831
|
: Array.isArray(e)
|
|
1537
|
-
?
|
|
1538
|
-
:
|
|
1539
|
-
?
|
|
1540
|
-
:
|
|
1541
|
-
?
|
|
1542
|
-
:
|
|
1543
|
-
?
|
|
1544
|
-
:
|
|
1832
|
+
? Te.array(e, { name: r, deep: !1 })
|
|
1833
|
+
: H(e)
|
|
1834
|
+
? Te.object(e, void 0, { name: r, deep: !1 })
|
|
1835
|
+
: Y(e)
|
|
1836
|
+
? Te.map(e, { name: r, deep: !1 })
|
|
1837
|
+
: Z(e)
|
|
1838
|
+
? Te.set(e, { name: r, deep: !1 })
|
|
1839
|
+
: F(
|
|
1545
1840
|
'production' !== process.env.NODE_ENV &&
|
|
1546
1841
|
'The shallow modifier / decorator can only used in combination with arrays, objects, maps and sets',
|
|
1547
1842
|
);
|
|
1548
1843
|
}),
|
|
1549
|
-
|
|
1550
|
-
|
|
1551
|
-
if ('production' !== process.env.NODE_ENV &&
|
|
1844
|
+
De = Ne(Ee),
|
|
1845
|
+
Ce = Ne(function (e, t, r) {
|
|
1846
|
+
if ('production' !== process.env.NODE_ENV && Mt(e))
|
|
1552
1847
|
throw 'observable.struct should not be used with observable values';
|
|
1553
|
-
return
|
|
1848
|
+
return Or(e, t) ? t : e;
|
|
1554
1849
|
});
|
|
1555
1850
|
function Ae(e) {
|
|
1556
1851
|
return e.defaultDecorator
|
|
1557
1852
|
? e.defaultDecorator.enhancer
|
|
1558
1853
|
: !1 === e.deep
|
|
1559
|
-
?
|
|
1560
|
-
:
|
|
1854
|
+
? Ee
|
|
1855
|
+
: Oe;
|
|
1561
1856
|
}
|
|
1562
1857
|
var Ve = {
|
|
1563
1858
|
box: function (e, t) {
|
|
1564
|
-
arguments.length > 2 &&
|
|
1565
|
-
var r =
|
|
1566
|
-
return new
|
|
1859
|
+
arguments.length > 2 && ke('box');
|
|
1860
|
+
var r = xe(t);
|
|
1861
|
+
return new rt(e, Ae(r), r.name, !0, r.equals);
|
|
1567
1862
|
},
|
|
1568
1863
|
array: function (e, t) {
|
|
1569
|
-
arguments.length > 2 &&
|
|
1570
|
-
var r =
|
|
1864
|
+
arguments.length > 2 && ke('array');
|
|
1865
|
+
var r = xe(t);
|
|
1571
1866
|
return (function (e, t, r, n) {
|
|
1572
|
-
void 0 === r && (r = 'ObservableArray@' +
|
|
1867
|
+
void 0 === r && (r = 'ObservableArray@' + U());
|
|
1573
1868
|
void 0 === n && (n = !1);
|
|
1574
|
-
var o = new
|
|
1869
|
+
var o = new Xt(r, t, n);
|
|
1575
1870
|
(i = o.values),
|
|
1576
|
-
(a =
|
|
1871
|
+
(a = ne),
|
|
1577
1872
|
(s = o),
|
|
1578
1873
|
Object.defineProperty(i, a, {
|
|
1579
1874
|
enumerable: !1,
|
|
@@ -1582,61 +1877,61 @@ var Ve = {
|
|
|
1582
1877
|
value: s,
|
|
1583
1878
|
});
|
|
1584
1879
|
var i, a, s;
|
|
1585
|
-
var
|
|
1586
|
-
if (((o.proxy =
|
|
1587
|
-
var
|
|
1588
|
-
o.spliceWithArray(0, 0, e),
|
|
1880
|
+
var l = new Proxy(o.values, $t);
|
|
1881
|
+
if (((o.proxy = l), e && e.length)) {
|
|
1882
|
+
var u = et(!0);
|
|
1883
|
+
o.spliceWithArray(0, 0, e), tt(u);
|
|
1589
1884
|
}
|
|
1590
|
-
return
|
|
1885
|
+
return l;
|
|
1591
1886
|
})(e, Ae(r), r.name);
|
|
1592
1887
|
},
|
|
1593
1888
|
map: function (e, t) {
|
|
1594
|
-
arguments.length > 2 &&
|
|
1595
|
-
var r =
|
|
1596
|
-
return new
|
|
1889
|
+
arguments.length > 2 && ke('map');
|
|
1890
|
+
var r = xe(t);
|
|
1891
|
+
return new nr(e, Ae(r), r.name);
|
|
1597
1892
|
},
|
|
1598
1893
|
set: function (e, t) {
|
|
1599
|
-
arguments.length > 2 &&
|
|
1600
|
-
var r =
|
|
1601
|
-
return new
|
|
1894
|
+
arguments.length > 2 && ke('set');
|
|
1895
|
+
var r = xe(t);
|
|
1896
|
+
return new ar(e, Ae(r), r.name);
|
|
1602
1897
|
},
|
|
1603
1898
|
object: function (e, t, r) {
|
|
1604
|
-
'string' == typeof arguments[1] &&
|
|
1605
|
-
var n =
|
|
1606
|
-
if (!1 === n.proxy) return
|
|
1607
|
-
var o =
|
|
1899
|
+
'string' == typeof arguments[1] && ke('object');
|
|
1900
|
+
var n = xe(r);
|
|
1901
|
+
if (!1 === n.proxy) return Tt({}, e, t, n);
|
|
1902
|
+
var o = kt(n),
|
|
1608
1903
|
i = (function (e) {
|
|
1609
|
-
var t = new Proxy(e,
|
|
1610
|
-
return (e[
|
|
1611
|
-
})(
|
|
1612
|
-
return
|
|
1904
|
+
var t = new Proxy(e, Ft);
|
|
1905
|
+
return (e[ne].proxy = t), t;
|
|
1906
|
+
})(Tt({}, void 0, void 0, n));
|
|
1907
|
+
return Rt(i, e, t, o), i;
|
|
1613
1908
|
},
|
|
1614
|
-
ref:
|
|
1615
|
-
shallow:
|
|
1616
|
-
deep:
|
|
1617
|
-
struct:
|
|
1909
|
+
ref: De,
|
|
1910
|
+
shallow: Se,
|
|
1911
|
+
deep: je,
|
|
1912
|
+
struct: Ce,
|
|
1618
1913
|
},
|
|
1619
|
-
|
|
1914
|
+
Te = function (e, t, r) {
|
|
1620
1915
|
if ('string' == typeof arguments[1] || 'symbol' == typeof arguments[1])
|
|
1621
|
-
return
|
|
1622
|
-
if (
|
|
1623
|
-
var n =
|
|
1624
|
-
?
|
|
1916
|
+
return je.apply(null, arguments);
|
|
1917
|
+
if (Mt(e)) return e;
|
|
1918
|
+
var n = H(e)
|
|
1919
|
+
? Te.object(e, t, r)
|
|
1625
1920
|
: Array.isArray(e)
|
|
1626
|
-
?
|
|
1627
|
-
:
|
|
1628
|
-
?
|
|
1629
|
-
:
|
|
1630
|
-
?
|
|
1921
|
+
? Te.array(e, t)
|
|
1922
|
+
: Y(e)
|
|
1923
|
+
? Te.map(e, t)
|
|
1924
|
+
: Z(e)
|
|
1925
|
+
? Te.set(e, t)
|
|
1631
1926
|
: e;
|
|
1632
1927
|
if (n !== e) return n;
|
|
1633
|
-
|
|
1928
|
+
F(
|
|
1634
1929
|
'production' !== process.env.NODE_ENV &&
|
|
1635
1930
|
"The provided value could not be converted into an observable. If you want just create an observable reference to the object use 'observable.box(value)'",
|
|
1636
1931
|
);
|
|
1637
1932
|
};
|
|
1638
|
-
function
|
|
1639
|
-
|
|
1933
|
+
function ke(e) {
|
|
1934
|
+
F(
|
|
1640
1935
|
'Expected one or two arguments to observable.' +
|
|
1641
1936
|
e +
|
|
1642
1937
|
'. Did you accidentally try to use observable.' +
|
|
@@ -1645,16 +1940,16 @@ function Te(e) {
|
|
|
1645
1940
|
);
|
|
1646
1941
|
}
|
|
1647
1942
|
Object.keys(Ve).forEach(function (e) {
|
|
1648
|
-
return (
|
|
1943
|
+
return (Te[e] = Ve[e]);
|
|
1649
1944
|
});
|
|
1650
|
-
var
|
|
1651
|
-
|
|
1652
|
-
|
|
1945
|
+
var Re,
|
|
1946
|
+
Pe,
|
|
1947
|
+
Ie = me(!1, function (e, t, r, n, o) {
|
|
1653
1948
|
'production' !== process.env.NODE_ENV &&
|
|
1654
1949
|
G(
|
|
1655
1950
|
r && r.get,
|
|
1656
1951
|
"Trying to declare a computed value for unspecified getter '" +
|
|
1657
|
-
|
|
1952
|
+
ee(t) +
|
|
1658
1953
|
"'",
|
|
1659
1954
|
);
|
|
1660
1955
|
var i = r.get,
|
|
@@ -1662,64 +1957,64 @@ var ke,
|
|
|
1662
1957
|
s = o[0] || {};
|
|
1663
1958
|
ur(e).addComputedProp(e, t, ue({ get: i, set: a, context: e }, s));
|
|
1664
1959
|
});
|
|
1665
|
-
|
|
1960
|
+
Ie({ equals: se.structural }),
|
|
1666
1961
|
(function (e) {
|
|
1667
1962
|
(e[(e.NOT_TRACKING = -1)] = 'NOT_TRACKING'),
|
|
1668
1963
|
(e[(e.UP_TO_DATE = 0)] = 'UP_TO_DATE'),
|
|
1669
1964
|
(e[(e.POSSIBLY_STALE = 1)] = 'POSSIBLY_STALE'),
|
|
1670
1965
|
(e[(e.STALE = 2)] = 'STALE');
|
|
1671
|
-
})(
|
|
1966
|
+
})(Re || (Re = {})),
|
|
1672
1967
|
(function (e) {
|
|
1673
1968
|
(e[(e.NONE = 0)] = 'NONE'),
|
|
1674
1969
|
(e[(e.LOG = 1)] = 'LOG'),
|
|
1675
1970
|
(e[(e.BREAK = 2)] = 'BREAK');
|
|
1676
|
-
})(
|
|
1677
|
-
var
|
|
1971
|
+
})(Pe || (Pe = {}));
|
|
1972
|
+
var Me = function (e) {
|
|
1678
1973
|
this.cause = e;
|
|
1679
1974
|
};
|
|
1680
|
-
function Me(e) {
|
|
1681
|
-
return e instanceof Ie;
|
|
1682
|
-
}
|
|
1683
1975
|
function Le(e) {
|
|
1976
|
+
return e instanceof Me;
|
|
1977
|
+
}
|
|
1978
|
+
function Be(e) {
|
|
1684
1979
|
switch (e.dependenciesState) {
|
|
1685
|
-
case
|
|
1980
|
+
case Re.UP_TO_DATE:
|
|
1686
1981
|
return !1;
|
|
1687
|
-
case
|
|
1688
|
-
case
|
|
1982
|
+
case Re.NOT_TRACKING:
|
|
1983
|
+
case Re.STALE:
|
|
1689
1984
|
return !0;
|
|
1690
|
-
case
|
|
1985
|
+
case Re.POSSIBLY_STALE:
|
|
1691
1986
|
for (
|
|
1692
|
-
var t =
|
|
1987
|
+
var t = Je(!0), r = Ke(), n = e.observing, o = n.length, i = 0;
|
|
1693
1988
|
i < o;
|
|
1694
1989
|
i++
|
|
1695
1990
|
) {
|
|
1696
1991
|
var a = n[i];
|
|
1697
|
-
if (
|
|
1992
|
+
if (ot(a)) {
|
|
1698
1993
|
if (ut.disableErrorBoundaries) a.get();
|
|
1699
1994
|
else
|
|
1700
1995
|
try {
|
|
1701
1996
|
a.get();
|
|
1702
1997
|
} catch (e) {
|
|
1703
|
-
return
|
|
1998
|
+
return ze(r), He(t), !0;
|
|
1704
1999
|
}
|
|
1705
|
-
if (e.dependenciesState ===
|
|
2000
|
+
if (e.dependenciesState === Re.STALE) return ze(r), He(t), !0;
|
|
1706
2001
|
}
|
|
1707
2002
|
}
|
|
1708
|
-
return
|
|
2003
|
+
return We(e), ze(r), He(t), !1;
|
|
1709
2004
|
}
|
|
1710
2005
|
}
|
|
1711
|
-
function
|
|
2006
|
+
function qe(e) {
|
|
1712
2007
|
var t = e.observers.size > 0;
|
|
1713
2008
|
ut.computationDepth > 0 &&
|
|
1714
2009
|
t &&
|
|
1715
|
-
|
|
2010
|
+
F(
|
|
1716
2011
|
'production' !== process.env.NODE_ENV &&
|
|
1717
2012
|
'Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: ' +
|
|
1718
2013
|
e.name,
|
|
1719
2014
|
),
|
|
1720
2015
|
ut.allowStateChanges ||
|
|
1721
2016
|
(!t && 'strict' !== ut.enforceActions) ||
|
|
1722
|
-
|
|
2017
|
+
F(
|
|
1723
2018
|
'production' !== process.env.NODE_ENV &&
|
|
1724
2019
|
(ut.enforceActions
|
|
1725
2020
|
? 'Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: '
|
|
@@ -1727,9 +2022,9 @@ function Be(e) {
|
|
|
1727
2022
|
e.name,
|
|
1728
2023
|
);
|
|
1729
2024
|
}
|
|
1730
|
-
function
|
|
1731
|
-
var n =
|
|
1732
|
-
|
|
2025
|
+
function Ue(e, t, r) {
|
|
2026
|
+
var n = Je(!0);
|
|
2027
|
+
We(e),
|
|
1733
2028
|
(e.newObserving = new Array(e.observing.length + 100)),
|
|
1734
2029
|
(e.unboundDepsCount = 0),
|
|
1735
2030
|
(e.runId = ++ut.runId);
|
|
@@ -1741,7 +2036,7 @@ function qe(e, t, r) {
|
|
|
1741
2036
|
try {
|
|
1742
2037
|
o = t.call(r);
|
|
1743
2038
|
} catch (e) {
|
|
1744
|
-
o = new
|
|
2039
|
+
o = new Me(e);
|
|
1745
2040
|
}
|
|
1746
2041
|
return (
|
|
1747
2042
|
(ut.trackingDerivation = i),
|
|
@@ -1749,7 +2044,7 @@ function qe(e, t, r) {
|
|
|
1749
2044
|
for (
|
|
1750
2045
|
var t = e.observing,
|
|
1751
2046
|
r = (e.observing = e.newObserving),
|
|
1752
|
-
n =
|
|
2047
|
+
n = Re.UP_TO_DATE,
|
|
1753
2048
|
o = 0,
|
|
1754
2049
|
i = e.unboundDepsCount,
|
|
1755
2050
|
a = 0;
|
|
@@ -1762,13 +2057,13 @@ function qe(e, t, r) {
|
|
|
1762
2057
|
}
|
|
1763
2058
|
(r.length = o), (e.newObserving = null), (i = t.length);
|
|
1764
2059
|
for (; i--; ) {
|
|
1765
|
-
0 === (s = t[i]).diffValue &&
|
|
2060
|
+
0 === (s = t[i]).diffValue && ct(s, e), (s.diffValue = 0);
|
|
1766
2061
|
}
|
|
1767
2062
|
for (; o--; ) {
|
|
1768
2063
|
var s;
|
|
1769
|
-
1 === (s = r[o]).diffValue && ((s.diffValue = 0),
|
|
2064
|
+
1 === (s = r[o]).diffValue && ((s.diffValue = 0), pt(s, e));
|
|
1770
2065
|
}
|
|
1771
|
-
n !==
|
|
2066
|
+
n !== Re.UP_TO_DATE && ((e.dependenciesState = n), e.onBecomeStale());
|
|
1772
2067
|
})(e),
|
|
1773
2068
|
(function (e) {
|
|
1774
2069
|
if ('production' === process.env.NODE_ENV) return;
|
|
@@ -1780,54 +2075,54 @@ function qe(e, t, r) {
|
|
|
1780
2075
|
' is created/updated without reading any observable value',
|
|
1781
2076
|
);
|
|
1782
2077
|
})(e),
|
|
1783
|
-
|
|
2078
|
+
He(n),
|
|
1784
2079
|
o
|
|
1785
2080
|
);
|
|
1786
2081
|
}
|
|
1787
|
-
function
|
|
2082
|
+
function Fe(e) {
|
|
1788
2083
|
var t = e.observing;
|
|
1789
2084
|
e.observing = [];
|
|
1790
|
-
for (var r = t.length; r--; )
|
|
1791
|
-
e.dependenciesState =
|
|
2085
|
+
for (var r = t.length; r--; ) ct(t[r], e);
|
|
2086
|
+
e.dependenciesState = Re.NOT_TRACKING;
|
|
1792
2087
|
}
|
|
1793
2088
|
function Ge(e) {
|
|
1794
|
-
var t =
|
|
2089
|
+
var t = Ke();
|
|
1795
2090
|
try {
|
|
1796
2091
|
return e();
|
|
1797
2092
|
} finally {
|
|
1798
|
-
|
|
2093
|
+
ze(t);
|
|
1799
2094
|
}
|
|
1800
2095
|
}
|
|
1801
|
-
function
|
|
2096
|
+
function Ke() {
|
|
1802
2097
|
var e = ut.trackingDerivation;
|
|
1803
2098
|
return (ut.trackingDerivation = null), e;
|
|
1804
2099
|
}
|
|
1805
|
-
function
|
|
2100
|
+
function ze(e) {
|
|
1806
2101
|
ut.trackingDerivation = e;
|
|
1807
2102
|
}
|
|
1808
|
-
function
|
|
2103
|
+
function Je(e) {
|
|
1809
2104
|
var t = ut.allowStateReads;
|
|
1810
2105
|
return (ut.allowStateReads = e), t;
|
|
1811
2106
|
}
|
|
1812
|
-
function
|
|
2107
|
+
function He(e) {
|
|
1813
2108
|
ut.allowStateReads = e;
|
|
1814
2109
|
}
|
|
1815
|
-
function
|
|
1816
|
-
if (e.dependenciesState !==
|
|
1817
|
-
e.dependenciesState =
|
|
2110
|
+
function We(e) {
|
|
2111
|
+
if (e.dependenciesState !== Re.UP_TO_DATE) {
|
|
2112
|
+
e.dependenciesState = Re.UP_TO_DATE;
|
|
1818
2113
|
for (var t = e.observing, r = t.length; r--; )
|
|
1819
|
-
t[r].lowestObserverState =
|
|
2114
|
+
t[r].lowestObserverState = Re.UP_TO_DATE;
|
|
1820
2115
|
}
|
|
1821
2116
|
}
|
|
1822
|
-
var
|
|
1823
|
-
|
|
1824
|
-
|
|
1825
|
-
|
|
1826
|
-
function
|
|
2117
|
+
var $e = 0,
|
|
2118
|
+
Xe = 1,
|
|
2119
|
+
Ye = Object.getOwnPropertyDescriptor(function () {}, 'name'),
|
|
2120
|
+
Ze = Ye && Ye.configurable;
|
|
2121
|
+
function Qe(e, t, r) {
|
|
1827
2122
|
'production' !== process.env.NODE_ENV &&
|
|
1828
2123
|
(G('function' == typeof t, '`action` can only be invoked on functions'),
|
|
1829
2124
|
('string' == typeof e && e) ||
|
|
1830
|
-
|
|
2125
|
+
F("actions should have valid names, got: '" + e + "'"));
|
|
1831
2126
|
var n = function () {
|
|
1832
2127
|
return (function (e, t, r, n) {
|
|
1833
2128
|
var o = (function (e, t, r) {
|
|
@@ -1838,22 +2133,22 @@ function Ze(e, t, r) {
|
|
|
1838
2133
|
var i = (r && r.length) || 0,
|
|
1839
2134
|
a = new Array(i);
|
|
1840
2135
|
if (i > 0) for (var s = 0; s < i; s++) a[s] = r[s];
|
|
1841
|
-
|
|
2136
|
+
jt({ type: 'action', name: e, object: t, arguments: a });
|
|
1842
2137
|
}
|
|
1843
|
-
var
|
|
1844
|
-
|
|
1845
|
-
var
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
prevDerivation:
|
|
1849
|
-
prevAllowStateChanges:
|
|
1850
|
-
prevAllowStateReads:
|
|
2138
|
+
var l = Ke();
|
|
2139
|
+
ft();
|
|
2140
|
+
var u = et(!0),
|
|
2141
|
+
p = Je(!0),
|
|
2142
|
+
c = {
|
|
2143
|
+
prevDerivation: l,
|
|
2144
|
+
prevAllowStateChanges: u,
|
|
2145
|
+
prevAllowStateReads: p,
|
|
1851
2146
|
notifySpy: n,
|
|
1852
2147
|
startTime: o,
|
|
1853
|
-
actionId:
|
|
1854
|
-
parentActionId:
|
|
2148
|
+
actionId: Xe++,
|
|
2149
|
+
parentActionId: $e,
|
|
1855
2150
|
};
|
|
1856
|
-
return (
|
|
2151
|
+
return ($e = c.actionId), c;
|
|
1857
2152
|
})(e, r, n);
|
|
1858
2153
|
try {
|
|
1859
2154
|
return t.apply(r, n);
|
|
@@ -1861,17 +2156,17 @@ function Ze(e, t, r) {
|
|
|
1861
2156
|
throw ((o.error = e), e);
|
|
1862
2157
|
} finally {
|
|
1863
2158
|
!(function (e) {
|
|
1864
|
-
|
|
1865
|
-
|
|
1866
|
-
(
|
|
2159
|
+
$e !== e.actionId &&
|
|
2160
|
+
F('invalid action stack. did you forget to finish an action?');
|
|
2161
|
+
($e = e.parentActionId),
|
|
1867
2162
|
void 0 !== e.error && (ut.suppressReactionErrors = !0);
|
|
1868
|
-
|
|
1869
|
-
|
|
1870
|
-
|
|
1871
|
-
|
|
2163
|
+
tt(e.prevAllowStateChanges),
|
|
2164
|
+
He(e.prevAllowStateReads),
|
|
2165
|
+
vt(),
|
|
2166
|
+
ze(e.prevDerivation),
|
|
1872
2167
|
e.notifySpy &&
|
|
1873
2168
|
'production' !== process.env.NODE_ENV &&
|
|
1874
|
-
|
|
2169
|
+
Dt({ time: Date.now() - e.startTime });
|
|
1875
2170
|
ut.suppressReactionErrors = !1;
|
|
1876
2171
|
})(o);
|
|
1877
2172
|
}
|
|
@@ -1880,23 +2175,23 @@ function Ze(e, t, r) {
|
|
|
1880
2175
|
return (
|
|
1881
2176
|
(n.isMobxAction = !0),
|
|
1882
2177
|
'production' !== process.env.NODE_ENV &&
|
|
1883
|
-
|
|
2178
|
+
Ze &&
|
|
1884
2179
|
Object.defineProperty(n, 'name', { value: e }),
|
|
1885
2180
|
n
|
|
1886
2181
|
);
|
|
1887
2182
|
}
|
|
1888
|
-
function
|
|
2183
|
+
function et(e) {
|
|
1889
2184
|
var t = ut.allowStateChanges;
|
|
1890
2185
|
return (ut.allowStateChanges = e), t;
|
|
1891
2186
|
}
|
|
1892
|
-
function
|
|
2187
|
+
function tt(e) {
|
|
1893
2188
|
ut.allowStateChanges = e;
|
|
1894
2189
|
}
|
|
1895
|
-
var
|
|
2190
|
+
var rt = (function (e) {
|
|
1896
2191
|
function t(t, r, n, o, i) {
|
|
1897
|
-
void 0 === n && (n = 'ObservableValue@' +
|
|
2192
|
+
void 0 === n && (n = 'ObservableValue@' + U()),
|
|
1898
2193
|
void 0 === o && (o = !0),
|
|
1899
|
-
void 0 === i && (i =
|
|
2194
|
+
void 0 === i && (i = se.default);
|
|
1900
2195
|
var a = e.call(this, n) || this;
|
|
1901
2196
|
return (
|
|
1902
2197
|
(a.enhancer = r),
|
|
@@ -1907,7 +2202,7 @@ var tt = (function (e) {
|
|
|
1907
2202
|
o &&
|
|
1908
2203
|
_t() &&
|
|
1909
2204
|
'production' !== process.env.NODE_ENV &&
|
|
1910
|
-
|
|
2205
|
+
xt({ type: 'create', name: a.name, newValue: '' + a.value }),
|
|
1911
2206
|
a
|
|
1912
2207
|
);
|
|
1913
2208
|
}
|
|
@@ -1916,7 +2211,7 @@ var tt = (function (e) {
|
|
|
1916
2211
|
function r() {
|
|
1917
2212
|
this.constructor = e;
|
|
1918
2213
|
}
|
|
1919
|
-
|
|
2214
|
+
le(e, t),
|
|
1920
2215
|
(e.prototype =
|
|
1921
2216
|
null === t
|
|
1922
2217
|
? Object.create(t)
|
|
@@ -1931,14 +2226,14 @@ var tt = (function (e) {
|
|
|
1931
2226
|
var r = _t();
|
|
1932
2227
|
r &&
|
|
1933
2228
|
'production' !== process.env.NODE_ENV &&
|
|
1934
|
-
|
|
2229
|
+
jt({ type: 'update', name: this.name, newValue: e, oldValue: t }),
|
|
1935
2230
|
this.setNewValue(e),
|
|
1936
|
-
r && 'production' !== process.env.NODE_ENV &&
|
|
2231
|
+
r && 'production' !== process.env.NODE_ENV && Dt();
|
|
1937
2232
|
}
|
|
1938
2233
|
}),
|
|
1939
2234
|
(t.prototype.prepareNewValue = function (e) {
|
|
1940
|
-
if ((
|
|
1941
|
-
var t =
|
|
2235
|
+
if ((qe(this), Gt(this))) {
|
|
2236
|
+
var t = zt(this, { object: this, type: 'update', newValue: e });
|
|
1942
2237
|
if (!t) return ut.UNCHANGED;
|
|
1943
2238
|
e = t.newValue;
|
|
1944
2239
|
}
|
|
@@ -1951,14 +2246,14 @@ var tt = (function (e) {
|
|
|
1951
2246
|
var t = this.value;
|
|
1952
2247
|
(this.value = e),
|
|
1953
2248
|
this.reportChanged(),
|
|
1954
|
-
|
|
1955
|
-
|
|
2249
|
+
Jt(this) &&
|
|
2250
|
+
Wt(this, { type: 'update', object: this, newValue: e, oldValue: t });
|
|
1956
2251
|
}),
|
|
1957
2252
|
(t.prototype.get = function () {
|
|
1958
2253
|
return this.reportObserved(), this.dehanceValue(this.value);
|
|
1959
2254
|
}),
|
|
1960
2255
|
(t.prototype.intercept = function (e) {
|
|
1961
|
-
return
|
|
2256
|
+
return Kt(this, e);
|
|
1962
2257
|
}),
|
|
1963
2258
|
(t.prototype.observe = function (e, t) {
|
|
1964
2259
|
return (
|
|
@@ -1969,7 +2264,7 @@ var tt = (function (e) {
|
|
|
1969
2264
|
newValue: this.value,
|
|
1970
2265
|
oldValue: void 0,
|
|
1971
2266
|
}),
|
|
1972
|
-
|
|
2267
|
+
Ht(this, e)
|
|
1973
2268
|
);
|
|
1974
2269
|
}),
|
|
1975
2270
|
(t.prototype.toJSON = function () {
|
|
@@ -1979,18 +2274,18 @@ var tt = (function (e) {
|
|
|
1979
2274
|
return this.name + '[' + this.value + ']';
|
|
1980
2275
|
}),
|
|
1981
2276
|
(t.prototype.valueOf = function () {
|
|
1982
|
-
return
|
|
2277
|
+
return te(this.get());
|
|
1983
2278
|
}),
|
|
1984
2279
|
(t.prototype[Symbol.toPrimitive] = function () {
|
|
1985
2280
|
return this.valueOf();
|
|
1986
2281
|
}),
|
|
1987
2282
|
t
|
|
1988
2283
|
);
|
|
1989
|
-
})(
|
|
1990
|
-
|
|
1991
|
-
var
|
|
2284
|
+
})(oe);
|
|
2285
|
+
X('ObservableValue', rt);
|
|
2286
|
+
var nt = (function () {
|
|
1992
2287
|
function e(e) {
|
|
1993
|
-
(this.dependenciesState =
|
|
2288
|
+
(this.dependenciesState = Re.NOT_TRACKING),
|
|
1994
2289
|
(this.observing = []),
|
|
1995
2290
|
(this.newObserving = null),
|
|
1996
2291
|
(this.isBeingObserved = !1),
|
|
@@ -1999,20 +2294,20 @@ var rt = (function () {
|
|
|
1999
2294
|
(this.diffValue = 0),
|
|
2000
2295
|
(this.runId = 0),
|
|
2001
2296
|
(this.lastAccessedBy = 0),
|
|
2002
|
-
(this.lowestObserverState =
|
|
2297
|
+
(this.lowestObserverState = Re.UP_TO_DATE),
|
|
2003
2298
|
(this.unboundDepsCount = 0),
|
|
2004
|
-
(this.__mapid = '#' +
|
|
2005
|
-
(this.value = new
|
|
2299
|
+
(this.__mapid = '#' + U()),
|
|
2300
|
+
(this.value = new Me(null)),
|
|
2006
2301
|
(this.isComputing = !1),
|
|
2007
2302
|
(this.isRunningSetter = !1),
|
|
2008
|
-
(this.isTracing =
|
|
2303
|
+
(this.isTracing = Pe.NONE),
|
|
2009
2304
|
G(e.get, 'missing option for computed: get'),
|
|
2010
2305
|
(this.derivation = e.get),
|
|
2011
|
-
(this.name = e.name || 'ComputedValue@' +
|
|
2012
|
-
e.set && (this.setter =
|
|
2306
|
+
(this.name = e.name || 'ComputedValue@' + U()),
|
|
2307
|
+
e.set && (this.setter = Qe(this.name + '-setter', e.set)),
|
|
2013
2308
|
(this.equals =
|
|
2014
2309
|
e.equals ||
|
|
2015
|
-
(e.compareStructural || e.struct ?
|
|
2310
|
+
(e.compareStructural || e.struct ? se.structural : se.default)),
|
|
2016
2311
|
(this.scope = e.context),
|
|
2017
2312
|
(this.requiresReaction = !!e.requiresReaction),
|
|
2018
2313
|
(this.keepAlive = !!e.keepAlive);
|
|
@@ -2020,12 +2315,12 @@ var rt = (function () {
|
|
|
2020
2315
|
return (
|
|
2021
2316
|
(e.prototype.onBecomeStale = function () {
|
|
2022
2317
|
!(function (e) {
|
|
2023
|
-
if (e.lowestObserverState !==
|
|
2024
|
-
(e.lowestObserverState =
|
|
2318
|
+
if (e.lowestObserverState !== Re.UP_TO_DATE) return;
|
|
2319
|
+
(e.lowestObserverState = Re.POSSIBLY_STALE),
|
|
2025
2320
|
e.observers.forEach(function (t) {
|
|
2026
|
-
t.dependenciesState ===
|
|
2027
|
-
((t.dependenciesState =
|
|
2028
|
-
t.isTracing !==
|
|
2321
|
+
t.dependenciesState === Re.UP_TO_DATE &&
|
|
2322
|
+
((t.dependenciesState = Re.POSSIBLY_STALE),
|
|
2323
|
+
t.isTracing !== Pe.NONE && ht(t, e),
|
|
2029
2324
|
t.onBecomeStale());
|
|
2030
2325
|
});
|
|
2031
2326
|
})(this);
|
|
@@ -2044,38 +2339,38 @@ var rt = (function () {
|
|
|
2044
2339
|
}),
|
|
2045
2340
|
(e.prototype.get = function () {
|
|
2046
2341
|
this.isComputing &&
|
|
2047
|
-
|
|
2342
|
+
F(
|
|
2048
2343
|
'Cycle detected in computation ' +
|
|
2049
2344
|
this.name +
|
|
2050
2345
|
': ' +
|
|
2051
2346
|
this.derivation,
|
|
2052
2347
|
),
|
|
2053
2348
|
0 !== ut.inBatch || 0 !== this.observers.size || this.keepAlive
|
|
2054
|
-
? (
|
|
2055
|
-
|
|
2349
|
+
? (yt(this),
|
|
2350
|
+
Be(this) &&
|
|
2056
2351
|
this.trackAndCompute() &&
|
|
2057
2352
|
(function (e) {
|
|
2058
|
-
if (e.lowestObserverState ===
|
|
2059
|
-
(e.lowestObserverState =
|
|
2353
|
+
if (e.lowestObserverState === Re.STALE) return;
|
|
2354
|
+
(e.lowestObserverState = Re.STALE),
|
|
2060
2355
|
e.observers.forEach(function (t) {
|
|
2061
|
-
t.dependenciesState ===
|
|
2062
|
-
? (t.dependenciesState =
|
|
2063
|
-
: t.dependenciesState ===
|
|
2064
|
-
(e.lowestObserverState =
|
|
2356
|
+
t.dependenciesState === Re.POSSIBLY_STALE
|
|
2357
|
+
? (t.dependenciesState = Re.STALE)
|
|
2358
|
+
: t.dependenciesState === Re.UP_TO_DATE &&
|
|
2359
|
+
(e.lowestObserverState = Re.UP_TO_DATE);
|
|
2065
2360
|
});
|
|
2066
2361
|
})(this))
|
|
2067
|
-
:
|
|
2362
|
+
: Be(this) &&
|
|
2068
2363
|
(this.warnAboutUntrackedRead(),
|
|
2069
|
-
|
|
2364
|
+
ft(),
|
|
2070
2365
|
(this.value = this.computeValue(!1)),
|
|
2071
|
-
|
|
2366
|
+
vt());
|
|
2072
2367
|
var e = this.value;
|
|
2073
|
-
if (
|
|
2368
|
+
if (Le(e)) throw e.cause;
|
|
2074
2369
|
return e;
|
|
2075
2370
|
}),
|
|
2076
2371
|
(e.prototype.peek = function () {
|
|
2077
2372
|
var e = this.computeValue(!1);
|
|
2078
|
-
if (
|
|
2373
|
+
if (Le(e)) throw e.cause;
|
|
2079
2374
|
return e;
|
|
2080
2375
|
}),
|
|
2081
2376
|
(e.prototype.set = function (e) {
|
|
@@ -2104,36 +2399,36 @@ var rt = (function () {
|
|
|
2104
2399
|
(e.prototype.trackAndCompute = function () {
|
|
2105
2400
|
_t() &&
|
|
2106
2401
|
'production' !== process.env.NODE_ENV &&
|
|
2107
|
-
|
|
2402
|
+
xt({ object: this.scope, type: 'compute', name: this.name });
|
|
2108
2403
|
var e = this.value,
|
|
2109
|
-
t = this.dependenciesState ===
|
|
2404
|
+
t = this.dependenciesState === Re.NOT_TRACKING,
|
|
2110
2405
|
r = this.computeValue(!0),
|
|
2111
|
-
n = t ||
|
|
2406
|
+
n = t || Le(e) || Le(r) || !this.equals(e, r);
|
|
2112
2407
|
return n && (this.value = r), n;
|
|
2113
2408
|
}),
|
|
2114
2409
|
(e.prototype.computeValue = function (e) {
|
|
2115
2410
|
var t;
|
|
2116
2411
|
if (((this.isComputing = !0), ut.computationDepth++, e))
|
|
2117
|
-
t =
|
|
2412
|
+
t = Ue(this, this.derivation, this.scope);
|
|
2118
2413
|
else if (!0 === ut.disableErrorBoundaries)
|
|
2119
2414
|
t = this.derivation.call(this.scope);
|
|
2120
2415
|
else
|
|
2121
2416
|
try {
|
|
2122
2417
|
t = this.derivation.call(this.scope);
|
|
2123
2418
|
} catch (e) {
|
|
2124
|
-
t = new
|
|
2419
|
+
t = new Me(e);
|
|
2125
2420
|
}
|
|
2126
2421
|
return ut.computationDepth--, (this.isComputing = !1), t;
|
|
2127
2422
|
}),
|
|
2128
2423
|
(e.prototype.suspend = function () {
|
|
2129
|
-
this.keepAlive || (
|
|
2424
|
+
this.keepAlive || (Fe(this), (this.value = void 0));
|
|
2130
2425
|
}),
|
|
2131
2426
|
(e.prototype.observe = function (e, t) {
|
|
2132
2427
|
var r = this,
|
|
2133
2428
|
n = !0,
|
|
2134
2429
|
o = void 0;
|
|
2135
2430
|
return (function (e, t) {
|
|
2136
|
-
void 0 === t && (t =
|
|
2431
|
+
void 0 === t && (t = q);
|
|
2137
2432
|
'production' !== process.env.NODE_ENV &&
|
|
2138
2433
|
(G(
|
|
2139
2434
|
'function' == typeof e,
|
|
@@ -2145,7 +2440,7 @@ var rt = (function () {
|
|
|
2145
2440
|
));
|
|
2146
2441
|
var r;
|
|
2147
2442
|
var n,
|
|
2148
|
-
o = (t && t.name) || e.name || 'Autorun@' +
|
|
2443
|
+
o = (t && t.name) || e.name || 'Autorun@' + U();
|
|
2149
2444
|
if (t.scheduler || t.delay) {
|
|
2150
2445
|
var i = (function (e) {
|
|
2151
2446
|
return e.scheduler
|
|
@@ -2154,10 +2449,10 @@ var rt = (function () {
|
|
|
2154
2449
|
? function (t) {
|
|
2155
2450
|
return setTimeout(t, e.delay);
|
|
2156
2451
|
}
|
|
2157
|
-
:
|
|
2452
|
+
: Ct;
|
|
2158
2453
|
})(t),
|
|
2159
2454
|
a = !1;
|
|
2160
|
-
n = new
|
|
2455
|
+
n = new mt(
|
|
2161
2456
|
o,
|
|
2162
2457
|
function () {
|
|
2163
2458
|
a ||
|
|
@@ -2170,7 +2465,7 @@ var rt = (function () {
|
|
|
2170
2465
|
t.requiresObservable,
|
|
2171
2466
|
);
|
|
2172
2467
|
} else
|
|
2173
|
-
n = new
|
|
2468
|
+
n = new mt(
|
|
2174
2469
|
o,
|
|
2175
2470
|
function () {
|
|
2176
2471
|
this.track(s);
|
|
@@ -2185,8 +2480,8 @@ var rt = (function () {
|
|
|
2185
2480
|
})(function () {
|
|
2186
2481
|
var i = r.get();
|
|
2187
2482
|
if (!n || t) {
|
|
2188
|
-
var a =
|
|
2189
|
-
e({ type: 'update', object: r, newValue: i, oldValue: o }),
|
|
2483
|
+
var a = Ke();
|
|
2484
|
+
e({ type: 'update', object: r, newValue: i, oldValue: o }), ze(a);
|
|
2190
2485
|
}
|
|
2191
2486
|
(n = !1), (o = i);
|
|
2192
2487
|
});
|
|
@@ -2194,12 +2489,12 @@ var rt = (function () {
|
|
|
2194
2489
|
(e.prototype.warnAboutUntrackedRead = function () {
|
|
2195
2490
|
'production' !== process.env.NODE_ENV &&
|
|
2196
2491
|
(!0 === this.requiresReaction &&
|
|
2197
|
-
|
|
2492
|
+
F(
|
|
2198
2493
|
'[mobx] Computed value ' +
|
|
2199
2494
|
this.name +
|
|
2200
2495
|
' is read outside a reactive context',
|
|
2201
2496
|
),
|
|
2202
|
-
this.isTracing !==
|
|
2497
|
+
this.isTracing !== Pe.NONE &&
|
|
2203
2498
|
console.log(
|
|
2204
2499
|
"[mobx.trace] '" +
|
|
2205
2500
|
this.name +
|
|
@@ -2219,7 +2514,7 @@ var rt = (function () {
|
|
|
2219
2514
|
return this.name + '[' + this.derivation.toString() + ']';
|
|
2220
2515
|
}),
|
|
2221
2516
|
(e.prototype.valueOf = function () {
|
|
2222
|
-
return
|
|
2517
|
+
return te(this.get());
|
|
2223
2518
|
}),
|
|
2224
2519
|
(e.prototype[Symbol.toPrimitive] = function () {
|
|
2225
2520
|
return this.valueOf();
|
|
@@ -2227,8 +2522,8 @@ var rt = (function () {
|
|
|
2227
2522
|
e
|
|
2228
2523
|
);
|
|
2229
2524
|
})(),
|
|
2230
|
-
|
|
2231
|
-
|
|
2525
|
+
ot = X('ComputedValue', nt),
|
|
2526
|
+
it = function () {
|
|
2232
2527
|
(this.version = 5),
|
|
2233
2528
|
(this.UNCHANGED = {}),
|
|
2234
2529
|
(this.trackingDerivation = null),
|
|
@@ -2251,68 +2546,68 @@ var rt = (function () {
|
|
|
2251
2546
|
(this.disableErrorBoundaries = !1),
|
|
2252
2547
|
(this.suppressReactionErrors = !1);
|
|
2253
2548
|
},
|
|
2254
|
-
|
|
2255
|
-
function
|
|
2549
|
+
at = {};
|
|
2550
|
+
function st() {
|
|
2256
2551
|
return 'undefined' != typeof window
|
|
2257
2552
|
? window
|
|
2258
2553
|
: 'undefined' != typeof global
|
|
2259
2554
|
? global
|
|
2260
2555
|
: 'undefined' != typeof self
|
|
2261
2556
|
? self
|
|
2262
|
-
:
|
|
2557
|
+
: at;
|
|
2263
2558
|
}
|
|
2264
|
-
var
|
|
2559
|
+
var lt = !0,
|
|
2265
2560
|
ut = (function () {
|
|
2266
|
-
var e =
|
|
2561
|
+
var e = st();
|
|
2267
2562
|
return (
|
|
2268
|
-
e.__mobxInstanceCount > 0 && !e.__mobxGlobals && (
|
|
2563
|
+
e.__mobxInstanceCount > 0 && !e.__mobxGlobals && (lt = !1),
|
|
2269
2564
|
e.__mobxGlobals &&
|
|
2270
|
-
e.__mobxGlobals.version !== new
|
|
2271
|
-
(
|
|
2272
|
-
|
|
2565
|
+
e.__mobxGlobals.version !== new it().version &&
|
|
2566
|
+
(lt = !1),
|
|
2567
|
+
lt
|
|
2273
2568
|
? e.__mobxGlobals
|
|
2274
2569
|
? ((e.__mobxInstanceCount += 1),
|
|
2275
2570
|
e.__mobxGlobals.UNCHANGED || (e.__mobxGlobals.UNCHANGED = {}),
|
|
2276
2571
|
e.__mobxGlobals)
|
|
2277
|
-
: ((e.__mobxInstanceCount = 1), (e.__mobxGlobals = new
|
|
2572
|
+
: ((e.__mobxInstanceCount = 1), (e.__mobxGlobals = new it()))
|
|
2278
2573
|
: (setTimeout(function () {
|
|
2279
|
-
|
|
2574
|
+
F(
|
|
2280
2575
|
'There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`',
|
|
2281
2576
|
);
|
|
2282
2577
|
}, 1),
|
|
2283
|
-
new
|
|
2578
|
+
new it())
|
|
2284
2579
|
);
|
|
2285
2580
|
})();
|
|
2286
|
-
function
|
|
2581
|
+
function pt(e, t) {
|
|
2287
2582
|
e.observers.add(t),
|
|
2288
2583
|
e.lowestObserverState > t.dependenciesState &&
|
|
2289
2584
|
(e.lowestObserverState = t.dependenciesState);
|
|
2290
2585
|
}
|
|
2291
|
-
function
|
|
2292
|
-
e.observers.delete(t), 0 === e.observers.size &&
|
|
2586
|
+
function ct(e, t) {
|
|
2587
|
+
e.observers.delete(t), 0 === e.observers.size && dt(e);
|
|
2293
2588
|
}
|
|
2294
|
-
function
|
|
2589
|
+
function dt(e) {
|
|
2295
2590
|
!1 === e.isPendingUnobservation &&
|
|
2296
2591
|
((e.isPendingUnobservation = !0), ut.pendingUnobservations.push(e));
|
|
2297
2592
|
}
|
|
2298
|
-
function
|
|
2593
|
+
function ft() {
|
|
2299
2594
|
ut.inBatch++;
|
|
2300
2595
|
}
|
|
2301
|
-
function
|
|
2596
|
+
function vt() {
|
|
2302
2597
|
if (0 == --ut.inBatch) {
|
|
2303
|
-
|
|
2598
|
+
Et();
|
|
2304
2599
|
for (var e = ut.pendingUnobservations, t = 0; t < e.length; t++) {
|
|
2305
2600
|
var r = e[t];
|
|
2306
2601
|
(r.isPendingUnobservation = !1),
|
|
2307
2602
|
0 === r.observers.size &&
|
|
2308
2603
|
(r.isBeingObserved &&
|
|
2309
2604
|
((r.isBeingObserved = !1), r.onBecomeUnobserved()),
|
|
2310
|
-
r instanceof
|
|
2605
|
+
r instanceof nt && r.suspend());
|
|
2311
2606
|
}
|
|
2312
2607
|
ut.pendingUnobservations = [];
|
|
2313
2608
|
}
|
|
2314
2609
|
}
|
|
2315
|
-
function
|
|
2610
|
+
function yt(e) {
|
|
2316
2611
|
!(function (e) {
|
|
2317
2612
|
'production' !== process.env.NODE_ENV &&
|
|
2318
2613
|
!ut.allowStateReads &&
|
|
@@ -2330,9 +2625,9 @@ function ht(e) {
|
|
|
2330
2625
|
(t.newObserving[t.unboundDepsCount++] = e),
|
|
2331
2626
|
e.isBeingObserved || ((e.isBeingObserved = !0), e.onBecomeObserved())),
|
|
2332
2627
|
!0)
|
|
2333
|
-
: (0 === e.observers.size && ut.inBatch > 0 &&
|
|
2628
|
+
: (0 === e.observers.size && ut.inBatch > 0 && dt(e), !1);
|
|
2334
2629
|
}
|
|
2335
|
-
function
|
|
2630
|
+
function ht(e, t) {
|
|
2336
2631
|
if (
|
|
2337
2632
|
(console.log(
|
|
2338
2633
|
"[mobx.trace] '" +
|
|
@@ -2341,10 +2636,10 @@ function vt(e, t) {
|
|
|
2341
2636
|
t.name +
|
|
2342
2637
|
"'",
|
|
2343
2638
|
),
|
|
2344
|
-
e.isTracing ===
|
|
2639
|
+
e.isTracing === Pe.BREAK)
|
|
2345
2640
|
) {
|
|
2346
2641
|
var r = [];
|
|
2347
|
-
|
|
2642
|
+
bt(Pt(yr(e, n)), r, 1),
|
|
2348
2643
|
new Function(
|
|
2349
2644
|
"debugger;\n/*\nTracing '" +
|
|
2350
2645
|
e.name +
|
|
@@ -2353,7 +2648,7 @@ function vt(e, t) {
|
|
|
2353
2648
|
"' is being traced and '" +
|
|
2354
2649
|
t.name +
|
|
2355
2650
|
"' is now forcing it to update.\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\n\n" +
|
|
2356
|
-
(e instanceof
|
|
2651
|
+
(e instanceof nt
|
|
2357
2652
|
? e.derivation.toString().replace(/[*]\//g, '/')
|
|
2358
2653
|
: '') +
|
|
2359
2654
|
'\n\nThe dependencies for this derivation are:\n\n' +
|
|
@@ -2363,18 +2658,18 @@ function vt(e, t) {
|
|
|
2363
2658
|
}
|
|
2364
2659
|
var n;
|
|
2365
2660
|
}
|
|
2366
|
-
function
|
|
2661
|
+
function bt(e, t, r) {
|
|
2367
2662
|
t.length >= 1e3
|
|
2368
2663
|
? t.push('(and many more)')
|
|
2369
2664
|
: (t.push('' + new Array(r).join('\t') + e.name),
|
|
2370
2665
|
e.dependencies &&
|
|
2371
2666
|
e.dependencies.forEach(function (e) {
|
|
2372
|
-
return
|
|
2667
|
+
return bt(e, t, r + 1);
|
|
2373
2668
|
}));
|
|
2374
2669
|
}
|
|
2375
|
-
var
|
|
2670
|
+
var mt = (function () {
|
|
2376
2671
|
function e(e, t, r, n) {
|
|
2377
|
-
void 0 === e && (e = 'Reaction@' +
|
|
2672
|
+
void 0 === e && (e = 'Reaction@' + U()),
|
|
2378
2673
|
void 0 === n && (n = !1),
|
|
2379
2674
|
(this.name = e),
|
|
2380
2675
|
(this.onInvalidate = t),
|
|
@@ -2382,16 +2677,16 @@ var bt = (function () {
|
|
|
2382
2677
|
(this.requiresObservable = n),
|
|
2383
2678
|
(this.observing = []),
|
|
2384
2679
|
(this.newObserving = []),
|
|
2385
|
-
(this.dependenciesState =
|
|
2680
|
+
(this.dependenciesState = Re.NOT_TRACKING),
|
|
2386
2681
|
(this.diffValue = 0),
|
|
2387
2682
|
(this.runId = 0),
|
|
2388
2683
|
(this.unboundDepsCount = 0),
|
|
2389
|
-
(this.__mapid = '#' +
|
|
2684
|
+
(this.__mapid = '#' + U()),
|
|
2390
2685
|
(this.isDisposed = !1),
|
|
2391
2686
|
(this._isScheduled = !1),
|
|
2392
2687
|
(this._isTrackPending = !1),
|
|
2393
2688
|
(this._isRunning = !1),
|
|
2394
|
-
(this.isTracing =
|
|
2689
|
+
(this.isTracing = Pe.NONE);
|
|
2395
2690
|
}
|
|
2396
2691
|
return (
|
|
2397
2692
|
(e.prototype.onBecomeStale = function () {
|
|
@@ -2399,46 +2694,46 @@ var bt = (function () {
|
|
|
2399
2694
|
}),
|
|
2400
2695
|
(e.prototype.schedule = function () {
|
|
2401
2696
|
this._isScheduled ||
|
|
2402
|
-
((this._isScheduled = !0), ut.pendingReactions.push(this),
|
|
2697
|
+
((this._isScheduled = !0), ut.pendingReactions.push(this), Et());
|
|
2403
2698
|
}),
|
|
2404
2699
|
(e.prototype.isScheduled = function () {
|
|
2405
2700
|
return this._isScheduled;
|
|
2406
2701
|
}),
|
|
2407
2702
|
(e.prototype.runReaction = function () {
|
|
2408
2703
|
if (!this.isDisposed) {
|
|
2409
|
-
if ((
|
|
2704
|
+
if ((ft(), (this._isScheduled = !1), Be(this))) {
|
|
2410
2705
|
this._isTrackPending = !0;
|
|
2411
2706
|
try {
|
|
2412
2707
|
this.onInvalidate(),
|
|
2413
2708
|
this._isTrackPending &&
|
|
2414
2709
|
_t() &&
|
|
2415
2710
|
'production' !== process.env.NODE_ENV &&
|
|
2416
|
-
|
|
2711
|
+
xt({ name: this.name, type: 'scheduled-reaction' });
|
|
2417
2712
|
} catch (e) {
|
|
2418
2713
|
this.reportExceptionInDerivation(e);
|
|
2419
2714
|
}
|
|
2420
2715
|
}
|
|
2421
|
-
|
|
2716
|
+
vt();
|
|
2422
2717
|
}
|
|
2423
2718
|
}),
|
|
2424
2719
|
(e.prototype.track = function (e) {
|
|
2425
2720
|
if (!this.isDisposed) {
|
|
2426
|
-
|
|
2721
|
+
ft();
|
|
2427
2722
|
var t,
|
|
2428
2723
|
r = _t();
|
|
2429
2724
|
r &&
|
|
2430
2725
|
'production' !== process.env.NODE_ENV &&
|
|
2431
|
-
((t = Date.now()),
|
|
2726
|
+
((t = Date.now()), jt({ name: this.name, type: 'reaction' })),
|
|
2432
2727
|
(this._isRunning = !0);
|
|
2433
|
-
var n =
|
|
2728
|
+
var n = Ue(this, e, void 0);
|
|
2434
2729
|
(this._isRunning = !1),
|
|
2435
2730
|
(this._isTrackPending = !1),
|
|
2436
|
-
this.isDisposed &&
|
|
2437
|
-
|
|
2731
|
+
this.isDisposed && Fe(this),
|
|
2732
|
+
Le(n) && this.reportExceptionInDerivation(n.cause),
|
|
2438
2733
|
r &&
|
|
2439
2734
|
'production' !== process.env.NODE_ENV &&
|
|
2440
|
-
|
|
2441
|
-
|
|
2735
|
+
Dt({ time: Date.now() - t }),
|
|
2736
|
+
vt();
|
|
2442
2737
|
}
|
|
2443
2738
|
}),
|
|
2444
2739
|
(e.prototype.reportExceptionInDerivation = function (e) {
|
|
@@ -2458,7 +2753,7 @@ var bt = (function () {
|
|
|
2458
2753
|
)
|
|
2459
2754
|
: console.error(r, e),
|
|
2460
2755
|
_t() &&
|
|
2461
|
-
|
|
2756
|
+
xt({ type: 'error', name: this.name, message: r, error: '' + e }),
|
|
2462
2757
|
ut.globalReactionErrorHandlers.forEach(function (r) {
|
|
2463
2758
|
return r(e, t);
|
|
2464
2759
|
});
|
|
@@ -2466,11 +2761,11 @@ var bt = (function () {
|
|
|
2466
2761
|
}),
|
|
2467
2762
|
(e.prototype.dispose = function () {
|
|
2468
2763
|
this.isDisposed ||
|
|
2469
|
-
((this.isDisposed = !0), this._isRunning || (
|
|
2764
|
+
((this.isDisposed = !0), this._isRunning || (ft(), Fe(this), vt()));
|
|
2470
2765
|
}),
|
|
2471
2766
|
(e.prototype.getDisposer = function () {
|
|
2472
2767
|
var e = this.dispose.bind(this);
|
|
2473
|
-
return (e[
|
|
2768
|
+
return (e[ne] = this), e;
|
|
2474
2769
|
}),
|
|
2475
2770
|
(e.prototype.toString = function () {
|
|
2476
2771
|
return 'Reaction[' + this.name + ']';
|
|
@@ -2487,38 +2782,38 @@ var bt = (function () {
|
|
|
2487
2782
|
case 0:
|
|
2488
2783
|
return ut.trackingDerivation;
|
|
2489
2784
|
case 1:
|
|
2490
|
-
return
|
|
2785
|
+
return yr(e[0]);
|
|
2491
2786
|
case 2:
|
|
2492
|
-
return
|
|
2787
|
+
return yr(e[0], e[1]);
|
|
2493
2788
|
}
|
|
2494
2789
|
})(e);
|
|
2495
2790
|
if (!n)
|
|
2496
|
-
return
|
|
2791
|
+
return F(
|
|
2497
2792
|
'production' !== process.env.NODE_ENV &&
|
|
2498
2793
|
"'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly",
|
|
2499
2794
|
);
|
|
2500
|
-
n.isTracing ===
|
|
2795
|
+
n.isTracing === Pe.NONE &&
|
|
2501
2796
|
console.log("[mobx.trace] '" + n.name + "' tracing enabled");
|
|
2502
|
-
n.isTracing = r ?
|
|
2797
|
+
n.isTracing = r ? Pe.BREAK : Pe.LOG;
|
|
2503
2798
|
})(this, e);
|
|
2504
2799
|
}),
|
|
2505
2800
|
e
|
|
2506
2801
|
);
|
|
2507
2802
|
})(),
|
|
2508
|
-
|
|
2509
|
-
|
|
2803
|
+
gt = 100,
|
|
2804
|
+
Ot = function (e) {
|
|
2510
2805
|
return e();
|
|
2511
2806
|
};
|
|
2512
|
-
function Ot() {
|
|
2513
|
-
ut.inBatch > 0 || ut.isRunningReactions || gt(Et);
|
|
2514
|
-
}
|
|
2515
2807
|
function Et() {
|
|
2808
|
+
ut.inBatch > 0 || ut.isRunningReactions || Ot(Nt);
|
|
2809
|
+
}
|
|
2810
|
+
function Nt() {
|
|
2516
2811
|
ut.isRunningReactions = !0;
|
|
2517
2812
|
for (var e = ut.pendingReactions, t = 0; e.length > 0; ) {
|
|
2518
|
-
++t ===
|
|
2813
|
+
++t === gt &&
|
|
2519
2814
|
(console.error(
|
|
2520
2815
|
"Reaction doesn't converge to a stable state after " +
|
|
2521
|
-
|
|
2816
|
+
gt +
|
|
2522
2817
|
' iterations. Probably there is a cycle in the reactive function: ' +
|
|
2523
2818
|
e[0],
|
|
2524
2819
|
),
|
|
@@ -2528,37 +2823,37 @@ function Et() {
|
|
|
2528
2823
|
}
|
|
2529
2824
|
ut.isRunningReactions = !1;
|
|
2530
2825
|
}
|
|
2531
|
-
var
|
|
2826
|
+
var wt = X('Reaction', mt);
|
|
2532
2827
|
function _t() {
|
|
2533
2828
|
return 'production' !== process.env.NODE_ENV && !!ut.spyListeners.length;
|
|
2534
2829
|
}
|
|
2535
|
-
function
|
|
2830
|
+
function xt(e) {
|
|
2536
2831
|
if ('production' !== process.env.NODE_ENV && ut.spyListeners.length)
|
|
2537
2832
|
for (var t = ut.spyListeners, r = 0, n = t.length; r < n; r++) t[r](e);
|
|
2538
2833
|
}
|
|
2539
|
-
function
|
|
2834
|
+
function jt(e) {
|
|
2540
2835
|
'production' !== process.env.NODE_ENV &&
|
|
2541
|
-
|
|
2836
|
+
xt(ue(ue({}, e), { spyReportStart: !0 }));
|
|
2542
2837
|
}
|
|
2543
|
-
var
|
|
2544
|
-
function
|
|
2838
|
+
var St = { spyReportEnd: !0 };
|
|
2839
|
+
function Dt(e) {
|
|
2545
2840
|
'production' !== process.env.NODE_ENV &&
|
|
2546
|
-
|
|
2841
|
+
xt(e ? ue(ue({}, e), { spyReportEnd: !0 }) : St);
|
|
2547
2842
|
}
|
|
2548
|
-
var
|
|
2843
|
+
var Ct = function (e) {
|
|
2549
2844
|
return e();
|
|
2550
2845
|
};
|
|
2551
2846
|
function At(e, t, r) {
|
|
2552
2847
|
return Vt('onBecomeUnobserved', e, t, r);
|
|
2553
2848
|
}
|
|
2554
2849
|
function Vt(e, t, r, n) {
|
|
2555
|
-
var o = 'function' == typeof n ?
|
|
2850
|
+
var o = 'function' == typeof n ? yr(t, r) : yr(t),
|
|
2556
2851
|
i = 'function' == typeof n ? n : r,
|
|
2557
2852
|
a = e + 'Listeners';
|
|
2558
2853
|
return (
|
|
2559
2854
|
o[a] ? o[a].add(i) : (o[a] = new Set([i])),
|
|
2560
2855
|
'function' != typeof o[e]
|
|
2561
|
-
?
|
|
2856
|
+
? F(
|
|
2562
2857
|
'production' !== process.env.NODE_ENV &&
|
|
2563
2858
|
'Not an atom that can be (un)observed',
|
|
2564
2859
|
)
|
|
@@ -2568,7 +2863,7 @@ function Vt(e, t, r, n) {
|
|
|
2568
2863
|
}
|
|
2569
2864
|
);
|
|
2570
2865
|
}
|
|
2571
|
-
function
|
|
2866
|
+
function Tt(e, t, r, n) {
|
|
2572
2867
|
'production' !== process.env.NODE_ENV &&
|
|
2573
2868
|
(G(
|
|
2574
2869
|
arguments.length >= 2 && arguments.length <= 4,
|
|
@@ -2579,32 +2874,32 @@ function Ct(e, t, r, n) {
|
|
|
2579
2874
|
"'extendObservable' expects an object as first argument",
|
|
2580
2875
|
),
|
|
2581
2876
|
G(
|
|
2582
|
-
!
|
|
2877
|
+
!or(e),
|
|
2583
2878
|
"'extendObservable' should not be used on maps, use map.merge instead",
|
|
2584
2879
|
));
|
|
2585
|
-
var o =
|
|
2586
|
-
return
|
|
2880
|
+
var o = kt((n = xe(n)));
|
|
2881
|
+
return be(e), ur(e, n.name, o.enhancer), t && Rt(e, t, r, o), e;
|
|
2587
2882
|
}
|
|
2588
|
-
function
|
|
2589
|
-
return e.defaultDecorator || (!1 === e.deep ?
|
|
2883
|
+
function kt(e) {
|
|
2884
|
+
return e.defaultDecorator || (!1 === e.deep ? De : je);
|
|
2590
2885
|
}
|
|
2591
|
-
function
|
|
2886
|
+
function Rt(e, t, r, n) {
|
|
2592
2887
|
var o, i, a, s;
|
|
2593
2888
|
if (
|
|
2594
2889
|
'production' !== process.env.NODE_ENV &&
|
|
2595
2890
|
(G(
|
|
2596
|
-
!
|
|
2891
|
+
!Mt(t),
|
|
2597
2892
|
'Extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540',
|
|
2598
2893
|
),
|
|
2599
2894
|
r)
|
|
2600
2895
|
) {
|
|
2601
|
-
var
|
|
2896
|
+
var l = Q(r);
|
|
2602
2897
|
try {
|
|
2603
|
-
for (var
|
|
2604
|
-
(f =
|
|
2605
|
-
|
|
2898
|
+
for (var u = pe(l), p = u.next(); !p.done; p = u.next()) {
|
|
2899
|
+
(f = p.value) in t ||
|
|
2900
|
+
F(
|
|
2606
2901
|
"Trying to declare a decorator for unspecified property '" +
|
|
2607
|
-
|
|
2902
|
+
ee(f) +
|
|
2608
2903
|
"'",
|
|
2609
2904
|
);
|
|
2610
2905
|
}
|
|
@@ -2612,49 +2907,49 @@ function kt(e, t, r, n) {
|
|
|
2612
2907
|
o = { error: e };
|
|
2613
2908
|
} finally {
|
|
2614
2909
|
try {
|
|
2615
|
-
|
|
2910
|
+
p && !p.done && (i = u.return) && i.call(u);
|
|
2616
2911
|
} finally {
|
|
2617
2912
|
if (o) throw o.error;
|
|
2618
2913
|
}
|
|
2619
2914
|
}
|
|
2620
2915
|
}
|
|
2621
|
-
|
|
2916
|
+
ft();
|
|
2622
2917
|
try {
|
|
2623
|
-
|
|
2918
|
+
l = re(t);
|
|
2624
2919
|
try {
|
|
2625
|
-
for (var
|
|
2920
|
+
for (var c = pe(l), d = c.next(); !d.done; d = c.next()) {
|
|
2626
2921
|
var f = d.value,
|
|
2627
|
-
|
|
2922
|
+
v = Object.getOwnPropertyDescriptor(t, f);
|
|
2628
2923
|
'production' !== process.env.NODE_ENV &&
|
|
2629
|
-
(
|
|
2630
|
-
|
|
2924
|
+
(H(t) ||
|
|
2925
|
+
F(
|
|
2631
2926
|
"'extendObservable' only accepts plain objects as second argument",
|
|
2632
2927
|
),
|
|
2633
|
-
|
|
2634
|
-
|
|
2928
|
+
It(v.value) &&
|
|
2929
|
+
F(
|
|
2635
2930
|
"Passing a 'computed' as initial property value is no longer supported by extendObservable. Use a getter or decorator instead",
|
|
2636
2931
|
));
|
|
2637
|
-
var
|
|
2932
|
+
var y = r && f in r ? r[f] : v.get ? Ie : n;
|
|
2638
2933
|
'production' !== process.env.NODE_ENV &&
|
|
2639
|
-
'function' != typeof
|
|
2640
|
-
|
|
2641
|
-
var
|
|
2642
|
-
|
|
2934
|
+
'function' != typeof y &&
|
|
2935
|
+
F("Not a valid decorator for '" + ee(f) + "', got: " + y);
|
|
2936
|
+
var h = y(e, f, v, !0);
|
|
2937
|
+
h && Object.defineProperty(e, f, h);
|
|
2643
2938
|
}
|
|
2644
2939
|
} catch (e) {
|
|
2645
2940
|
a = { error: e };
|
|
2646
2941
|
} finally {
|
|
2647
2942
|
try {
|
|
2648
|
-
d && !d.done && (s =
|
|
2943
|
+
d && !d.done && (s = c.return) && s.call(c);
|
|
2649
2944
|
} finally {
|
|
2650
2945
|
if (a) throw a.error;
|
|
2651
2946
|
}
|
|
2652
2947
|
}
|
|
2653
2948
|
} finally {
|
|
2654
|
-
|
|
2949
|
+
vt();
|
|
2655
2950
|
}
|
|
2656
2951
|
}
|
|
2657
|
-
function
|
|
2952
|
+
function Pt(e) {
|
|
2658
2953
|
var t,
|
|
2659
2954
|
r,
|
|
2660
2955
|
n = { name: e.name };
|
|
@@ -2666,31 +2961,31 @@ function Rt(e) {
|
|
|
2666
2961
|
t.forEach(function (e) {
|
|
2667
2962
|
-1 === r.indexOf(e) && r.push(e);
|
|
2668
2963
|
}),
|
|
2669
|
-
r).map(
|
|
2964
|
+
r).map(Pt)),
|
|
2670
2965
|
n
|
|
2671
2966
|
);
|
|
2672
2967
|
}
|
|
2673
|
-
function
|
|
2968
|
+
function It(e) {
|
|
2674
2969
|
return arguments.length > 1
|
|
2675
|
-
?
|
|
2970
|
+
? F(
|
|
2676
2971
|
'production' !== process.env.NODE_ENV &&
|
|
2677
2972
|
'isComputed expects only 1 argument. Use isObservableProp to inspect the observability of a property',
|
|
2678
2973
|
)
|
|
2679
2974
|
: (function (e, t) {
|
|
2680
2975
|
if (null == e) return !1;
|
|
2681
2976
|
if (void 0 !== t) {
|
|
2682
|
-
if (!1 ===
|
|
2683
|
-
if (!e[
|
|
2684
|
-
var r =
|
|
2685
|
-
return
|
|
2977
|
+
if (!1 === vr(e)) return !1;
|
|
2978
|
+
if (!e[ne].values.has(t)) return !1;
|
|
2979
|
+
var r = yr(e, t);
|
|
2980
|
+
return ot(r);
|
|
2686
2981
|
}
|
|
2687
|
-
return
|
|
2982
|
+
return ot(e);
|
|
2688
2983
|
})(e);
|
|
2689
2984
|
}
|
|
2690
|
-
function
|
|
2985
|
+
function Mt(e) {
|
|
2691
2986
|
return (
|
|
2692
2987
|
1 !== arguments.length &&
|
|
2693
|
-
|
|
2988
|
+
F(
|
|
2694
2989
|
'production' !== process.env.NODE_ENV &&
|
|
2695
2990
|
'isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property',
|
|
2696
2991
|
),
|
|
@@ -2698,109 +2993,109 @@ function It(e) {
|
|
|
2698
2993
|
return (
|
|
2699
2994
|
null != e &&
|
|
2700
2995
|
(void 0 !== t
|
|
2701
|
-
? 'production' !== process.env.NODE_ENV && (
|
|
2702
|
-
?
|
|
2996
|
+
? 'production' !== process.env.NODE_ENV && (or(e) || er(e))
|
|
2997
|
+
? F(
|
|
2703
2998
|
'isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.',
|
|
2704
2999
|
)
|
|
2705
|
-
: !!
|
|
2706
|
-
:
|
|
3000
|
+
: !!vr(e) && e[ne].values.has(t)
|
|
3001
|
+
: vr(e) || !!e[ne] || ie(e) || wt(e) || ot(e))
|
|
2707
3002
|
);
|
|
2708
3003
|
})(e)
|
|
2709
3004
|
);
|
|
2710
3005
|
}
|
|
2711
|
-
function
|
|
2712
|
-
if (2 !== arguments.length ||
|
|
2713
|
-
if (
|
|
2714
|
-
var n = e[
|
|
3006
|
+
function Lt(e, t, r) {
|
|
3007
|
+
if (2 !== arguments.length || sr(e))
|
|
3008
|
+
if (vr(e)) {
|
|
3009
|
+
var n = e[ne];
|
|
2715
3010
|
n.values.get(t)
|
|
2716
3011
|
? n.write(t, r)
|
|
2717
3012
|
: n.addObservableProp(t, r, n.defaultEnhancer);
|
|
2718
|
-
} else if (
|
|
2719
|
-
else if (
|
|
3013
|
+
} else if (or(e)) e.set(t, r);
|
|
3014
|
+
else if (sr(e)) e.add(t);
|
|
2720
3015
|
else {
|
|
2721
|
-
if (!
|
|
2722
|
-
return
|
|
3016
|
+
if (!er(e))
|
|
3017
|
+
return F(
|
|
2723
3018
|
'production' !== process.env.NODE_ENV &&
|
|
2724
3019
|
"'set()' can only be used on observable objects, arrays and maps",
|
|
2725
3020
|
);
|
|
2726
3021
|
'number' != typeof t && (t = parseInt(t, 10)),
|
|
2727
3022
|
G(t >= 0, "Not a valid index: '" + t + "'"),
|
|
2728
|
-
|
|
3023
|
+
ft(),
|
|
2729
3024
|
t >= e.length && (e.length = t + 1),
|
|
2730
3025
|
(e[t] = r),
|
|
2731
|
-
|
|
3026
|
+
vt();
|
|
2732
3027
|
}
|
|
2733
3028
|
else {
|
|
2734
|
-
|
|
3029
|
+
ft();
|
|
2735
3030
|
var o = t;
|
|
2736
3031
|
try {
|
|
2737
|
-
for (var i in o)
|
|
3032
|
+
for (var i in o) Lt(e, i, o[i]);
|
|
2738
3033
|
} finally {
|
|
2739
|
-
|
|
3034
|
+
vt();
|
|
2740
3035
|
}
|
|
2741
3036
|
}
|
|
2742
3037
|
}
|
|
2743
|
-
function
|
|
2744
|
-
void 0 === t && (t = void 0),
|
|
3038
|
+
function Bt(e, t) {
|
|
3039
|
+
void 0 === t && (t = void 0), ft();
|
|
2745
3040
|
try {
|
|
2746
3041
|
return e.apply(t);
|
|
2747
3042
|
} finally {
|
|
2748
|
-
|
|
3043
|
+
vt();
|
|
2749
3044
|
}
|
|
2750
3045
|
}
|
|
2751
|
-
function Bt(e) {
|
|
2752
|
-
return e[re];
|
|
2753
|
-
}
|
|
2754
3046
|
function qt(e) {
|
|
3047
|
+
return e[ne];
|
|
3048
|
+
}
|
|
3049
|
+
function Ut(e) {
|
|
2755
3050
|
return 'string' == typeof e || 'number' == typeof e || 'symbol' == typeof e;
|
|
2756
3051
|
}
|
|
2757
|
-
var
|
|
3052
|
+
var Ft = {
|
|
2758
3053
|
has: function (e, t) {
|
|
2759
|
-
if (t ===
|
|
2760
|
-
var r =
|
|
2761
|
-
return
|
|
3054
|
+
if (t === ne || 'constructor' === t || t === fe) return !0;
|
|
3055
|
+
var r = qt(e);
|
|
3056
|
+
return Ut(t) ? r.has(t) : t in e;
|
|
2762
3057
|
},
|
|
2763
3058
|
get: function (e, t) {
|
|
2764
|
-
if (t ===
|
|
2765
|
-
var r =
|
|
3059
|
+
if (t === ne || 'constructor' === t || t === fe) return e[t];
|
|
3060
|
+
var r = qt(e),
|
|
2766
3061
|
n = r.values.get(t);
|
|
2767
|
-
if (n instanceof
|
|
3062
|
+
if (n instanceof oe) {
|
|
2768
3063
|
var o = n.get();
|
|
2769
3064
|
return void 0 === o && r.has(t), o;
|
|
2770
3065
|
}
|
|
2771
|
-
return
|
|
3066
|
+
return Ut(t) && r.has(t), e[t];
|
|
2772
3067
|
},
|
|
2773
3068
|
set: function (e, t, r) {
|
|
2774
|
-
return !!
|
|
3069
|
+
return !!Ut(t) && (Lt(e, t, r), !0);
|
|
2775
3070
|
},
|
|
2776
3071
|
deleteProperty: function (e, t) {
|
|
2777
|
-
return !!
|
|
3072
|
+
return !!Ut(t) && (qt(e).remove(t), !0);
|
|
2778
3073
|
},
|
|
2779
3074
|
ownKeys: function (e) {
|
|
2780
|
-
return
|
|
3075
|
+
return qt(e).keysAtom.reportObserved(), Reflect.ownKeys(e);
|
|
2781
3076
|
},
|
|
2782
3077
|
preventExtensions: function (e) {
|
|
2783
|
-
return
|
|
3078
|
+
return F('Dynamic observable objects cannot be frozen'), !1;
|
|
2784
3079
|
},
|
|
2785
3080
|
};
|
|
2786
3081
|
function Gt(e) {
|
|
2787
3082
|
return void 0 !== e.interceptors && e.interceptors.length > 0;
|
|
2788
3083
|
}
|
|
2789
|
-
function
|
|
3084
|
+
function Kt(e, t) {
|
|
2790
3085
|
var r = e.interceptors || (e.interceptors = []);
|
|
2791
3086
|
return (
|
|
2792
3087
|
r.push(t),
|
|
2793
|
-
|
|
3088
|
+
K(function () {
|
|
2794
3089
|
var e = r.indexOf(t);
|
|
2795
3090
|
-1 !== e && r.splice(e, 1);
|
|
2796
3091
|
})
|
|
2797
3092
|
);
|
|
2798
3093
|
}
|
|
2799
|
-
function
|
|
2800
|
-
var r =
|
|
3094
|
+
function zt(e, t) {
|
|
3095
|
+
var r = Ke();
|
|
2801
3096
|
try {
|
|
2802
3097
|
for (
|
|
2803
|
-
var n =
|
|
3098
|
+
var n = de(e.interceptors || []), o = 0, i = n.length;
|
|
2804
3099
|
o < i &&
|
|
2805
3100
|
(G(
|
|
2806
3101
|
!(t = n[o](t)) || t.type,
|
|
@@ -2811,65 +3106,65 @@ function Kt(e, t) {
|
|
|
2811
3106
|
);
|
|
2812
3107
|
return t;
|
|
2813
3108
|
} finally {
|
|
2814
|
-
|
|
3109
|
+
ze(r);
|
|
2815
3110
|
}
|
|
2816
3111
|
}
|
|
2817
|
-
function
|
|
3112
|
+
function Jt(e) {
|
|
2818
3113
|
return void 0 !== e.changeListeners && e.changeListeners.length > 0;
|
|
2819
3114
|
}
|
|
2820
|
-
function
|
|
3115
|
+
function Ht(e, t) {
|
|
2821
3116
|
var r = e.changeListeners || (e.changeListeners = []);
|
|
2822
3117
|
return (
|
|
2823
3118
|
r.push(t),
|
|
2824
|
-
|
|
3119
|
+
K(function () {
|
|
2825
3120
|
var e = r.indexOf(t);
|
|
2826
3121
|
-1 !== e && r.splice(e, 1);
|
|
2827
3122
|
})
|
|
2828
3123
|
);
|
|
2829
3124
|
}
|
|
2830
|
-
function
|
|
2831
|
-
var r =
|
|
3125
|
+
function Wt(e, t) {
|
|
3126
|
+
var r = Ke(),
|
|
2832
3127
|
n = e.changeListeners;
|
|
2833
3128
|
if (n) {
|
|
2834
3129
|
for (var o = 0, i = (n = n.slice()).length; o < i; o++) n[o](t);
|
|
2835
|
-
|
|
3130
|
+
ze(r);
|
|
2836
3131
|
}
|
|
2837
3132
|
}
|
|
2838
|
-
var
|
|
3133
|
+
var $t = {
|
|
2839
3134
|
get: function (e, t) {
|
|
2840
|
-
return t ===
|
|
2841
|
-
? e[
|
|
3135
|
+
return t === ne
|
|
3136
|
+
? e[ne]
|
|
2842
3137
|
: 'length' === t
|
|
2843
|
-
? e[
|
|
3138
|
+
? e[ne].getArrayLength()
|
|
2844
3139
|
: 'number' == typeof t
|
|
2845
|
-
?
|
|
3140
|
+
? Yt.get.call(e, t)
|
|
2846
3141
|
: 'string' != typeof t || isNaN(t)
|
|
2847
|
-
?
|
|
2848
|
-
?
|
|
3142
|
+
? Yt.hasOwnProperty(t)
|
|
3143
|
+
? Yt[t]
|
|
2849
3144
|
: e[t]
|
|
2850
|
-
:
|
|
3145
|
+
: Yt.get.call(e, parseInt(t));
|
|
2851
3146
|
},
|
|
2852
3147
|
set: function (e, t, r) {
|
|
2853
3148
|
return (
|
|
2854
|
-
'length' === t && e[
|
|
2855
|
-
'number' == typeof t &&
|
|
3149
|
+
'length' === t && e[ne].setArrayLength(r),
|
|
3150
|
+
'number' == typeof t && Yt.set.call(e, t, r),
|
|
2856
3151
|
'symbol' == typeof t || isNaN(t)
|
|
2857
3152
|
? (e[t] = r)
|
|
2858
|
-
:
|
|
3153
|
+
: Yt.set.call(e, parseInt(t), r),
|
|
2859
3154
|
!0
|
|
2860
3155
|
);
|
|
2861
3156
|
},
|
|
2862
3157
|
preventExtensions: function (e) {
|
|
2863
|
-
return
|
|
3158
|
+
return F('Observable arrays cannot be frozen'), !1;
|
|
2864
3159
|
},
|
|
2865
3160
|
};
|
|
2866
|
-
var
|
|
3161
|
+
var Xt = (function () {
|
|
2867
3162
|
function e(e, t, r) {
|
|
2868
3163
|
(this.owned = r),
|
|
2869
3164
|
(this.values = []),
|
|
2870
3165
|
(this.proxy = void 0),
|
|
2871
3166
|
(this.lastKnownLength = 0),
|
|
2872
|
-
(this.atom = new
|
|
3167
|
+
(this.atom = new oe(e || 'ObservableArray@' + U())),
|
|
2873
3168
|
(this.enhancer = function (r, n) {
|
|
2874
3169
|
return t(r, n, e + '[..]');
|
|
2875
3170
|
});
|
|
@@ -2884,7 +3179,7 @@ var $t = (function () {
|
|
|
2884
3179
|
: e;
|
|
2885
3180
|
}),
|
|
2886
3181
|
(e.prototype.intercept = function (e) {
|
|
2887
|
-
return
|
|
3182
|
+
return Kt(this, e);
|
|
2888
3183
|
}),
|
|
2889
3184
|
(e.prototype.observe = function (e, t) {
|
|
2890
3185
|
return (
|
|
@@ -2899,7 +3194,7 @@ var $t = (function () {
|
|
|
2899
3194
|
removed: [],
|
|
2900
3195
|
removedCount: 0,
|
|
2901
3196
|
}),
|
|
2902
|
-
|
|
3197
|
+
Ht(this, e)
|
|
2903
3198
|
);
|
|
2904
3199
|
}),
|
|
2905
3200
|
(e.prototype.getArrayLength = function () {
|
|
@@ -2924,7 +3219,7 @@ var $t = (function () {
|
|
|
2924
3219
|
}),
|
|
2925
3220
|
(e.prototype.spliceWithArray = function (e, t, r) {
|
|
2926
3221
|
var n = this;
|
|
2927
|
-
|
|
3222
|
+
qe(this.atom);
|
|
2928
3223
|
var o = this.values.length;
|
|
2929
3224
|
if (
|
|
2930
3225
|
(void 0 === e
|
|
@@ -2938,17 +3233,17 @@ var $t = (function () {
|
|
|
2938
3233
|
: null == t
|
|
2939
3234
|
? 0
|
|
2940
3235
|
: Math.max(0, Math.min(t, o - e))),
|
|
2941
|
-
void 0 === r && (r =
|
|
3236
|
+
void 0 === r && (r = B),
|
|
2942
3237
|
Gt(this))
|
|
2943
3238
|
) {
|
|
2944
|
-
var i =
|
|
3239
|
+
var i = zt(this, {
|
|
2945
3240
|
object: this.proxy,
|
|
2946
3241
|
type: 'splice',
|
|
2947
3242
|
index: e,
|
|
2948
3243
|
removedCount: t,
|
|
2949
3244
|
added: r,
|
|
2950
3245
|
});
|
|
2951
|
-
if (!i) return
|
|
3246
|
+
if (!i) return B;
|
|
2952
3247
|
(t = i.removedCount), (r = i.added);
|
|
2953
3248
|
}
|
|
2954
3249
|
if (
|
|
@@ -2972,7 +3267,7 @@ var $t = (function () {
|
|
|
2972
3267
|
(e.prototype.spliceItemsIntoValues = function (e, t, r) {
|
|
2973
3268
|
var n;
|
|
2974
3269
|
if (r.length < 1e4)
|
|
2975
|
-
return (n = this.values).splice.apply(n,
|
|
3270
|
+
return (n = this.values).splice.apply(n, de([e, t], r));
|
|
2976
3271
|
var o = this.values.slice(e, e + t);
|
|
2977
3272
|
return (
|
|
2978
3273
|
(this.values = this.values
|
|
@@ -2983,7 +3278,7 @@ var $t = (function () {
|
|
|
2983
3278
|
}),
|
|
2984
3279
|
(e.prototype.notifyArrayChildUpdate = function (e, t, r) {
|
|
2985
3280
|
var n = !this.owned && _t(),
|
|
2986
|
-
o =
|
|
3281
|
+
o = Jt(this),
|
|
2987
3282
|
i =
|
|
2988
3283
|
o || n
|
|
2989
3284
|
? {
|
|
@@ -2996,14 +3291,14 @@ var $t = (function () {
|
|
|
2996
3291
|
: null;
|
|
2997
3292
|
n &&
|
|
2998
3293
|
'production' !== process.env.NODE_ENV &&
|
|
2999
|
-
|
|
3294
|
+
jt(ue(ue({}, i), { name: this.atom.name })),
|
|
3000
3295
|
this.atom.reportChanged(),
|
|
3001
|
-
o &&
|
|
3002
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
3296
|
+
o && Wt(this, i),
|
|
3297
|
+
n && 'production' !== process.env.NODE_ENV && Dt();
|
|
3003
3298
|
}),
|
|
3004
3299
|
(e.prototype.notifyArraySplice = function (e, t, r) {
|
|
3005
3300
|
var n = !this.owned && _t(),
|
|
3006
|
-
o =
|
|
3301
|
+
o = Jt(this),
|
|
3007
3302
|
i =
|
|
3008
3303
|
o || n
|
|
3009
3304
|
? {
|
|
@@ -3018,26 +3313,26 @@ var $t = (function () {
|
|
|
3018
3313
|
: null;
|
|
3019
3314
|
n &&
|
|
3020
3315
|
'production' !== process.env.NODE_ENV &&
|
|
3021
|
-
|
|
3316
|
+
jt(ue(ue({}, i), { name: this.atom.name })),
|
|
3022
3317
|
this.atom.reportChanged(),
|
|
3023
|
-
o &&
|
|
3024
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
3318
|
+
o && Wt(this, i),
|
|
3319
|
+
n && 'production' !== process.env.NODE_ENV && Dt();
|
|
3025
3320
|
}),
|
|
3026
3321
|
e
|
|
3027
3322
|
);
|
|
3028
3323
|
})(),
|
|
3029
|
-
|
|
3324
|
+
Yt = {
|
|
3030
3325
|
intercept: function (e) {
|
|
3031
|
-
return this[
|
|
3326
|
+
return this[ne].intercept(e);
|
|
3032
3327
|
},
|
|
3033
3328
|
observe: function (e, t) {
|
|
3034
|
-
return void 0 === t && (t = !1), this[
|
|
3329
|
+
return void 0 === t && (t = !1), this[ne].observe(e, t);
|
|
3035
3330
|
},
|
|
3036
3331
|
clear: function () {
|
|
3037
3332
|
return this.splice(0);
|
|
3038
3333
|
},
|
|
3039
3334
|
replace: function (e) {
|
|
3040
|
-
var t = this[
|
|
3335
|
+
var t = this[ne];
|
|
3041
3336
|
return t.spliceWithArray(0, t.values.length, e);
|
|
3042
3337
|
},
|
|
3043
3338
|
toJS: function () {
|
|
@@ -3049,7 +3344,7 @@ var $t = (function () {
|
|
|
3049
3344
|
splice: function (e, t) {
|
|
3050
3345
|
for (var r = [], n = 2; n < arguments.length; n++)
|
|
3051
3346
|
r[n - 2] = arguments[n];
|
|
3052
|
-
var o = this[
|
|
3347
|
+
var o = this[ne];
|
|
3053
3348
|
switch (arguments.length) {
|
|
3054
3349
|
case 0:
|
|
3055
3350
|
return [];
|
|
@@ -3061,22 +3356,22 @@ var $t = (function () {
|
|
|
3061
3356
|
return o.spliceWithArray(e, t, r);
|
|
3062
3357
|
},
|
|
3063
3358
|
spliceWithArray: function (e, t, r) {
|
|
3064
|
-
return this[
|
|
3359
|
+
return this[ne].spliceWithArray(e, t, r);
|
|
3065
3360
|
},
|
|
3066
3361
|
push: function () {
|
|
3067
3362
|
for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
|
|
3068
|
-
var r = this[
|
|
3363
|
+
var r = this[ne];
|
|
3069
3364
|
return r.spliceWithArray(r.values.length, 0, e), r.values.length;
|
|
3070
3365
|
},
|
|
3071
3366
|
pop: function () {
|
|
3072
|
-
return this.splice(Math.max(this[
|
|
3367
|
+
return this.splice(Math.max(this[ne].values.length - 1, 0), 1)[0];
|
|
3073
3368
|
},
|
|
3074
3369
|
shift: function () {
|
|
3075
3370
|
return this.splice(0, 1)[0];
|
|
3076
3371
|
},
|
|
3077
3372
|
unshift: function () {
|
|
3078
3373
|
for (var e = [], t = 0; t < arguments.length; t++) e[t] = arguments[t];
|
|
3079
|
-
var r = this[
|
|
3374
|
+
var r = this[ne];
|
|
3080
3375
|
return r.spliceWithArray(0, 0, e), r.values.length;
|
|
3081
3376
|
},
|
|
3082
3377
|
reverse: function () {
|
|
@@ -3096,12 +3391,12 @@ var $t = (function () {
|
|
|
3096
3391
|
return t.sort.apply(t, arguments);
|
|
3097
3392
|
},
|
|
3098
3393
|
remove: function (e) {
|
|
3099
|
-
var t = this[
|
|
3394
|
+
var t = this[ne],
|
|
3100
3395
|
r = t.dehanceValues(t.values).indexOf(e);
|
|
3101
3396
|
return r > -1 && (this.splice(r, 1), !0);
|
|
3102
3397
|
},
|
|
3103
3398
|
get: function (e) {
|
|
3104
|
-
var t = this[
|
|
3399
|
+
var t = this[ne];
|
|
3105
3400
|
if (t) {
|
|
3106
3401
|
if (e < t.values.length)
|
|
3107
3402
|
return t.atom.reportObserved(), t.dehanceValue(t.values[e]);
|
|
@@ -3115,13 +3410,13 @@ var $t = (function () {
|
|
|
3115
3410
|
}
|
|
3116
3411
|
},
|
|
3117
3412
|
set: function (e, t) {
|
|
3118
|
-
var r = this[
|
|
3413
|
+
var r = this[ne],
|
|
3119
3414
|
n = r.values;
|
|
3120
3415
|
if (e < n.length) {
|
|
3121
|
-
|
|
3416
|
+
qe(r.atom);
|
|
3122
3417
|
var o = n[e];
|
|
3123
3418
|
if (Gt(r)) {
|
|
3124
|
-
var i =
|
|
3419
|
+
var i = zt(r, {
|
|
3125
3420
|
type: 'update',
|
|
3126
3421
|
object: r.proxy,
|
|
3127
3422
|
index: e,
|
|
@@ -3156,8 +3451,8 @@ var $t = (function () {
|
|
|
3156
3451
|
'toLocaleString',
|
|
3157
3452
|
].forEach(function (e) {
|
|
3158
3453
|
'function' == typeof Array.prototype[e] &&
|
|
3159
|
-
(
|
|
3160
|
-
var t = this[
|
|
3454
|
+
(Yt[e] = function () {
|
|
3455
|
+
var t = this[ne];
|
|
3161
3456
|
t.atom.reportObserved();
|
|
3162
3457
|
var r = t.dehanceValues(t.values);
|
|
3163
3458
|
return r[e].apply(r, arguments);
|
|
@@ -3174,9 +3469,9 @@ var $t = (function () {
|
|
|
3174
3469
|
'some',
|
|
3175
3470
|
].forEach(function (e) {
|
|
3176
3471
|
'function' == typeof Array.prototype[e] &&
|
|
3177
|
-
(
|
|
3472
|
+
(Yt[e] = function (t, r) {
|
|
3178
3473
|
var n = this,
|
|
3179
|
-
o = this[
|
|
3474
|
+
o = this[ne];
|
|
3180
3475
|
return (
|
|
3181
3476
|
o.atom.reportObserved(),
|
|
3182
3477
|
o.dehanceValues(o.values)[e](function (e, o) {
|
|
@@ -3186,9 +3481,9 @@ var $t = (function () {
|
|
|
3186
3481
|
});
|
|
3187
3482
|
}),
|
|
3188
3483
|
['reduce', 'reduceRight'].forEach(function (e) {
|
|
3189
|
-
|
|
3484
|
+
Yt[e] = function () {
|
|
3190
3485
|
var t = this,
|
|
3191
|
-
r = this[
|
|
3486
|
+
r = this[ne];
|
|
3192
3487
|
r.atom.reportObserved();
|
|
3193
3488
|
var n = arguments[0];
|
|
3194
3489
|
return (
|
|
@@ -3199,22 +3494,22 @@ var $t = (function () {
|
|
|
3199
3494
|
);
|
|
3200
3495
|
};
|
|
3201
3496
|
});
|
|
3202
|
-
var
|
|
3203
|
-
|
|
3204
|
-
function
|
|
3205
|
-
return
|
|
3206
|
-
}
|
|
3207
|
-
var
|
|
3208
|
-
|
|
3209
|
-
|
|
3497
|
+
var Zt,
|
|
3498
|
+
Qt = X('ObservableArrayAdministration', Xt);
|
|
3499
|
+
function er(e) {
|
|
3500
|
+
return J(e) && Qt(e[ne]);
|
|
3501
|
+
}
|
|
3502
|
+
var tr,
|
|
3503
|
+
rr = {},
|
|
3504
|
+
nr = (function () {
|
|
3210
3505
|
function e(e, t, r) {
|
|
3211
3506
|
if (
|
|
3212
|
-
(void 0 === t && (t =
|
|
3213
|
-
void 0 === r && (r = 'ObservableMap@' +
|
|
3507
|
+
(void 0 === t && (t = Oe),
|
|
3508
|
+
void 0 === r && (r = 'ObservableMap@' + U()),
|
|
3214
3509
|
(this.enhancer = t),
|
|
3215
3510
|
(this.name = r),
|
|
3216
|
-
(this[
|
|
3217
|
-
(this._keysAtom =
|
|
3511
|
+
(this[Zt] = rr),
|
|
3512
|
+
(this._keysAtom = ae(this.name + '.keys()')),
|
|
3218
3513
|
(this[Symbol.toStringTag] = 'Map'),
|
|
3219
3514
|
'function' != typeof Map)
|
|
3220
3515
|
)
|
|
@@ -3232,10 +3527,10 @@ var er,
|
|
|
3232
3527
|
if (!ut.trackingDerivation) return this._has(e);
|
|
3233
3528
|
var r = this._hasMap.get(e);
|
|
3234
3529
|
if (!r) {
|
|
3235
|
-
var n = (r = new
|
|
3530
|
+
var n = (r = new rt(
|
|
3236
3531
|
this._has(e),
|
|
3237
|
-
|
|
3238
|
-
this.name + '.' +
|
|
3532
|
+
Ee,
|
|
3533
|
+
this.name + '.' + ee(e) + '?',
|
|
3239
3534
|
!1,
|
|
3240
3535
|
));
|
|
3241
3536
|
this._hasMap.set(e, n),
|
|
@@ -3248,7 +3543,7 @@ var er,
|
|
|
3248
3543
|
(e.prototype.set = function (e, t) {
|
|
3249
3544
|
var r = this._has(e);
|
|
3250
3545
|
if (Gt(this)) {
|
|
3251
|
-
var n =
|
|
3546
|
+
var n = zt(this, {
|
|
3252
3547
|
type: r ? 'update' : 'add',
|
|
3253
3548
|
object: this,
|
|
3254
3549
|
newValue: t,
|
|
@@ -3262,13 +3557,13 @@ var er,
|
|
|
3262
3557
|
(e.prototype.delete = function (e) {
|
|
3263
3558
|
var t = this;
|
|
3264
3559
|
if (
|
|
3265
|
-
(
|
|
3266
|
-
!(o =
|
|
3560
|
+
(qe(this._keysAtom), Gt(this)) &&
|
|
3561
|
+
!(o = zt(this, { type: 'delete', object: this, name: e }))
|
|
3267
3562
|
)
|
|
3268
3563
|
return !1;
|
|
3269
3564
|
if (this._has(e)) {
|
|
3270
3565
|
var r = _t(),
|
|
3271
|
-
n =
|
|
3566
|
+
n = Jt(this),
|
|
3272
3567
|
o =
|
|
3273
3568
|
n || r
|
|
3274
3569
|
? {
|
|
@@ -3281,15 +3576,15 @@ var er,
|
|
|
3281
3576
|
return (
|
|
3282
3577
|
r &&
|
|
3283
3578
|
'production' !== process.env.NODE_ENV &&
|
|
3284
|
-
|
|
3285
|
-
|
|
3579
|
+
jt(ue(ue({}, o), { name: this.name, key: e })),
|
|
3580
|
+
Bt(function () {
|
|
3286
3581
|
t._keysAtom.reportChanged(),
|
|
3287
3582
|
t._updateHasMapEntry(e, !1),
|
|
3288
3583
|
t._data.get(e).setNewValue(void 0),
|
|
3289
3584
|
t._data.delete(e);
|
|
3290
3585
|
}),
|
|
3291
|
-
n &&
|
|
3292
|
-
r && 'production' !== process.env.NODE_ENV &&
|
|
3586
|
+
n && Wt(this, o),
|
|
3587
|
+
r && 'production' !== process.env.NODE_ENV && Dt(),
|
|
3293
3588
|
!0
|
|
3294
3589
|
);
|
|
3295
3590
|
}
|
|
@@ -3303,7 +3598,7 @@ var er,
|
|
|
3303
3598
|
var r = this._data.get(e);
|
|
3304
3599
|
if ((t = r.prepareNewValue(t)) !== ut.UNCHANGED) {
|
|
3305
3600
|
var n = _t(),
|
|
3306
|
-
o =
|
|
3601
|
+
o = Jt(this),
|
|
3307
3602
|
i =
|
|
3308
3603
|
o || n
|
|
3309
3604
|
? {
|
|
@@ -3316,31 +3611,31 @@ var er,
|
|
|
3316
3611
|
: null;
|
|
3317
3612
|
n &&
|
|
3318
3613
|
'production' !== process.env.NODE_ENV &&
|
|
3319
|
-
|
|
3614
|
+
jt(ue(ue({}, i), { name: this.name, key: e })),
|
|
3320
3615
|
r.setNewValue(t),
|
|
3321
|
-
o &&
|
|
3322
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
3616
|
+
o && Wt(this, i),
|
|
3617
|
+
n && 'production' !== process.env.NODE_ENV && Dt();
|
|
3323
3618
|
}
|
|
3324
3619
|
}),
|
|
3325
3620
|
(e.prototype._addValue = function (e, t) {
|
|
3326
3621
|
var r = this;
|
|
3327
|
-
|
|
3328
|
-
|
|
3329
|
-
var n = new
|
|
3622
|
+
qe(this._keysAtom),
|
|
3623
|
+
Bt(function () {
|
|
3624
|
+
var n = new rt(t, r.enhancer, r.name + '.' + ee(e), !1);
|
|
3330
3625
|
r._data.set(e, n),
|
|
3331
3626
|
(t = n.value),
|
|
3332
3627
|
r._updateHasMapEntry(e, !0),
|
|
3333
3628
|
r._keysAtom.reportChanged();
|
|
3334
3629
|
});
|
|
3335
3630
|
var n = _t(),
|
|
3336
|
-
o =
|
|
3631
|
+
o = Jt(this),
|
|
3337
3632
|
i =
|
|
3338
3633
|
o || n ? { type: 'add', object: this, name: e, newValue: t } : null;
|
|
3339
3634
|
n &&
|
|
3340
3635
|
'production' !== process.env.NODE_ENV &&
|
|
3341
|
-
|
|
3342
|
-
o &&
|
|
3343
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
3636
|
+
jt(ue(ue({}, i), { name: this.name, key: e })),
|
|
3637
|
+
o && Wt(this, i),
|
|
3638
|
+
n && 'production' !== process.env.NODE_ENV && Dt();
|
|
3344
3639
|
}),
|
|
3345
3640
|
(e.prototype.get = function (e) {
|
|
3346
3641
|
return this.has(e)
|
|
@@ -3377,17 +3672,17 @@ var er,
|
|
|
3377
3672
|
},
|
|
3378
3673
|
});
|
|
3379
3674
|
}),
|
|
3380
|
-
(e.prototype[((
|
|
3675
|
+
(e.prototype[((Zt = ne), Symbol.iterator)] = function () {
|
|
3381
3676
|
return this.entries();
|
|
3382
3677
|
}),
|
|
3383
3678
|
(e.prototype.forEach = function (e, t) {
|
|
3384
3679
|
var r, n;
|
|
3385
3680
|
try {
|
|
3386
|
-
for (var o =
|
|
3387
|
-
var a =
|
|
3681
|
+
for (var o = pe(this), i = o.next(); !i.done; i = o.next()) {
|
|
3682
|
+
var a = ce(i.value, 2),
|
|
3388
3683
|
s = a[0],
|
|
3389
|
-
|
|
3390
|
-
e.call(t,
|
|
3684
|
+
l = a[1];
|
|
3685
|
+
e.call(t, l, s, this);
|
|
3391
3686
|
}
|
|
3392
3687
|
} catch (e) {
|
|
3393
3688
|
r = { error: e };
|
|
@@ -3402,33 +3697,33 @@ var er,
|
|
|
3402
3697
|
(e.prototype.merge = function (e) {
|
|
3403
3698
|
var t = this;
|
|
3404
3699
|
return (
|
|
3405
|
-
|
|
3406
|
-
|
|
3407
|
-
var r =
|
|
3700
|
+
or(e) && (e = e.toJS()),
|
|
3701
|
+
Bt(function () {
|
|
3702
|
+
var r = et(!0);
|
|
3408
3703
|
try {
|
|
3409
|
-
|
|
3410
|
-
?
|
|
3704
|
+
H(e)
|
|
3705
|
+
? Q(e).forEach(function (r) {
|
|
3411
3706
|
return t.set(r, e[r]);
|
|
3412
3707
|
})
|
|
3413
3708
|
: Array.isArray(e)
|
|
3414
3709
|
? e.forEach(function (e) {
|
|
3415
|
-
var r =
|
|
3710
|
+
var r = ce(e, 2),
|
|
3416
3711
|
n = r[0],
|
|
3417
3712
|
o = r[1];
|
|
3418
3713
|
return t.set(n, o);
|
|
3419
3714
|
})
|
|
3420
|
-
:
|
|
3715
|
+
: Y(e)
|
|
3421
3716
|
? (e.constructor !== Map &&
|
|
3422
|
-
|
|
3717
|
+
F(
|
|
3423
3718
|
'Cannot initialize from classes that inherit from Map: ' +
|
|
3424
3719
|
e.constructor.name,
|
|
3425
3720
|
),
|
|
3426
3721
|
e.forEach(function (e, r) {
|
|
3427
3722
|
return t.set(r, e);
|
|
3428
3723
|
}))
|
|
3429
|
-
: null != e &&
|
|
3724
|
+
: null != e && F('Cannot initialize map from ' + e);
|
|
3430
3725
|
} finally {
|
|
3431
|
-
|
|
3726
|
+
tt(r);
|
|
3432
3727
|
}
|
|
3433
3728
|
}),
|
|
3434
3729
|
this
|
|
@@ -3436,11 +3731,11 @@ var er,
|
|
|
3436
3731
|
}),
|
|
3437
3732
|
(e.prototype.clear = function () {
|
|
3438
3733
|
var e = this;
|
|
3439
|
-
|
|
3734
|
+
Bt(function () {
|
|
3440
3735
|
Ge(function () {
|
|
3441
3736
|
var t, r;
|
|
3442
3737
|
try {
|
|
3443
|
-
for (var n =
|
|
3738
|
+
for (var n = pe(e.keys()), o = n.next(); !o.done; o = n.next()) {
|
|
3444
3739
|
var i = o.value;
|
|
3445
3740
|
e.delete(i);
|
|
3446
3741
|
}
|
|
@@ -3459,69 +3754,69 @@ var er,
|
|
|
3459
3754
|
(e.prototype.replace = function (e) {
|
|
3460
3755
|
var t = this;
|
|
3461
3756
|
return (
|
|
3462
|
-
|
|
3757
|
+
Bt(function () {
|
|
3463
3758
|
var r,
|
|
3464
3759
|
n,
|
|
3465
3760
|
o,
|
|
3466
3761
|
i,
|
|
3467
3762
|
a = (function (e) {
|
|
3468
|
-
if (
|
|
3763
|
+
if (Y(e) || or(e)) return e;
|
|
3469
3764
|
if (Array.isArray(e)) return new Map(e);
|
|
3470
|
-
if (
|
|
3765
|
+
if (H(e)) {
|
|
3471
3766
|
var t = new Map();
|
|
3472
3767
|
for (var r in e) t.set(r, e[r]);
|
|
3473
3768
|
return t;
|
|
3474
3769
|
}
|
|
3475
|
-
return
|
|
3770
|
+
return F("Cannot convert to map from '" + e + "'");
|
|
3476
3771
|
})(e),
|
|
3477
3772
|
s = new Map(),
|
|
3478
|
-
|
|
3773
|
+
l = !1;
|
|
3479
3774
|
try {
|
|
3480
3775
|
for (
|
|
3481
|
-
var
|
|
3482
|
-
!
|
|
3483
|
-
|
|
3776
|
+
var u = pe(t._data.keys()), p = u.next();
|
|
3777
|
+
!p.done;
|
|
3778
|
+
p = u.next()
|
|
3484
3779
|
) {
|
|
3485
|
-
var
|
|
3486
|
-
if (!a.has(
|
|
3487
|
-
if (t.delete(
|
|
3780
|
+
var c = p.value;
|
|
3781
|
+
if (!a.has(c))
|
|
3782
|
+
if (t.delete(c)) l = !0;
|
|
3488
3783
|
else {
|
|
3489
|
-
var d = t._data.get(
|
|
3490
|
-
s.set(
|
|
3784
|
+
var d = t._data.get(c);
|
|
3785
|
+
s.set(c, d);
|
|
3491
3786
|
}
|
|
3492
3787
|
}
|
|
3493
3788
|
} catch (e) {
|
|
3494
3789
|
r = { error: e };
|
|
3495
3790
|
} finally {
|
|
3496
3791
|
try {
|
|
3497
|
-
|
|
3792
|
+
p && !p.done && (n = u.return) && n.call(u);
|
|
3498
3793
|
} finally {
|
|
3499
3794
|
if (r) throw r.error;
|
|
3500
3795
|
}
|
|
3501
3796
|
}
|
|
3502
3797
|
try {
|
|
3503
3798
|
for (
|
|
3504
|
-
var f =
|
|
3505
|
-
!
|
|
3506
|
-
|
|
3799
|
+
var f = pe(a.entries()), v = f.next();
|
|
3800
|
+
!v.done;
|
|
3801
|
+
v = f.next()
|
|
3507
3802
|
) {
|
|
3508
|
-
var
|
|
3509
|
-
|
|
3510
|
-
if ((t.set(
|
|
3511
|
-
var b = t._data.get(
|
|
3512
|
-
s.set(
|
|
3803
|
+
var y = ce(v.value, 2),
|
|
3804
|
+
h = ((c = y[0]), (d = y[1]), t._data.has(c));
|
|
3805
|
+
if ((t.set(c, d), t._data.has(c))) {
|
|
3806
|
+
var b = t._data.get(c);
|
|
3807
|
+
s.set(c, b), h || (l = !0);
|
|
3513
3808
|
}
|
|
3514
3809
|
}
|
|
3515
3810
|
} catch (e) {
|
|
3516
3811
|
o = { error: e };
|
|
3517
3812
|
} finally {
|
|
3518
3813
|
try {
|
|
3519
|
-
|
|
3814
|
+
v && !v.done && (i = f.return) && i.call(f);
|
|
3520
3815
|
} finally {
|
|
3521
3816
|
if (o) throw o.error;
|
|
3522
3817
|
}
|
|
3523
3818
|
}
|
|
3524
|
-
if (!
|
|
3819
|
+
if (!l)
|
|
3525
3820
|
if (t._data.size !== s.size) t._keysAtom.reportChanged();
|
|
3526
3821
|
else
|
|
3527
3822
|
for (
|
|
@@ -3555,11 +3850,11 @@ var er,
|
|
|
3555
3850
|
t,
|
|
3556
3851
|
r = {};
|
|
3557
3852
|
try {
|
|
3558
|
-
for (var n =
|
|
3559
|
-
var i =
|
|
3853
|
+
for (var n = pe(this), o = n.next(); !o.done; o = n.next()) {
|
|
3854
|
+
var i = ce(o.value, 2),
|
|
3560
3855
|
a = i[0],
|
|
3561
3856
|
s = i[1];
|
|
3562
|
-
r['symbol' == typeof a ? a :
|
|
3857
|
+
r['symbol' == typeof a ? a : ee(a)] = s;
|
|
3563
3858
|
}
|
|
3564
3859
|
} catch (t) {
|
|
3565
3860
|
e = { error: t };
|
|
@@ -3585,7 +3880,7 @@ var er,
|
|
|
3585
3880
|
'[{ ' +
|
|
3586
3881
|
Array.from(this.keys())
|
|
3587
3882
|
.map(function (t) {
|
|
3588
|
-
return
|
|
3883
|
+
return ee(t) + ': ' + e.get(t);
|
|
3589
3884
|
})
|
|
3590
3885
|
.join(', ') +
|
|
3591
3886
|
' }]'
|
|
@@ -3598,26 +3893,26 @@ var er,
|
|
|
3598
3893
|
!0 !== t,
|
|
3599
3894
|
"`observe` doesn't support fireImmediately=true in combination with maps.",
|
|
3600
3895
|
),
|
|
3601
|
-
|
|
3896
|
+
Ht(this, e)
|
|
3602
3897
|
);
|
|
3603
3898
|
}),
|
|
3604
3899
|
(e.prototype.intercept = function (e) {
|
|
3605
|
-
return
|
|
3900
|
+
return Kt(this, e);
|
|
3606
3901
|
}),
|
|
3607
3902
|
e
|
|
3608
3903
|
);
|
|
3609
3904
|
})(),
|
|
3610
|
-
|
|
3611
|
-
|
|
3612
|
-
|
|
3905
|
+
or = X('ObservableMap', nr),
|
|
3906
|
+
ir = {},
|
|
3907
|
+
ar = (function () {
|
|
3613
3908
|
function e(e, t, r) {
|
|
3614
3909
|
if (
|
|
3615
|
-
(void 0 === t && (t =
|
|
3616
|
-
void 0 === r && (r = 'ObservableSet@' +
|
|
3910
|
+
(void 0 === t && (t = Oe),
|
|
3911
|
+
void 0 === r && (r = 'ObservableSet@' + U()),
|
|
3617
3912
|
(this.name = r),
|
|
3618
|
-
(this[
|
|
3913
|
+
(this[tr] = ir),
|
|
3619
3914
|
(this._data = new Set()),
|
|
3620
|
-
(this._atom =
|
|
3915
|
+
(this._atom = ae(this.name)),
|
|
3621
3916
|
(this[Symbol.toStringTag] = 'Set'),
|
|
3622
3917
|
'function' != typeof Set)
|
|
3623
3918
|
)
|
|
@@ -3635,12 +3930,12 @@ var er,
|
|
|
3635
3930
|
}),
|
|
3636
3931
|
(e.prototype.clear = function () {
|
|
3637
3932
|
var e = this;
|
|
3638
|
-
|
|
3933
|
+
Bt(function () {
|
|
3639
3934
|
Ge(function () {
|
|
3640
3935
|
var t, r;
|
|
3641
3936
|
try {
|
|
3642
3937
|
for (
|
|
3643
|
-
var n =
|
|
3938
|
+
var n = pe(e._data.values()), o = n.next();
|
|
3644
3939
|
!o.done;
|
|
3645
3940
|
o = n.next()
|
|
3646
3941
|
) {
|
|
@@ -3662,7 +3957,7 @@ var er,
|
|
|
3662
3957
|
(e.prototype.forEach = function (e, t) {
|
|
3663
3958
|
var r, n;
|
|
3664
3959
|
try {
|
|
3665
|
-
for (var o =
|
|
3960
|
+
for (var o = pe(this), i = o.next(); !i.done; i = o.next()) {
|
|
3666
3961
|
var a = i.value;
|
|
3667
3962
|
e.call(t, a, a, this);
|
|
3668
3963
|
}
|
|
@@ -3686,20 +3981,20 @@ var er,
|
|
|
3686
3981
|
(e.prototype.add = function (e) {
|
|
3687
3982
|
var t = this;
|
|
3688
3983
|
if (
|
|
3689
|
-
(
|
|
3690
|
-
!(o =
|
|
3984
|
+
(qe(this._atom), Gt(this)) &&
|
|
3985
|
+
!(o = zt(this, { type: 'add', object: this, newValue: e }))
|
|
3691
3986
|
)
|
|
3692
3987
|
return this;
|
|
3693
3988
|
if (!this.has(e)) {
|
|
3694
|
-
|
|
3989
|
+
Bt(function () {
|
|
3695
3990
|
t._data.add(t.enhancer(e, void 0)), t._atom.reportChanged();
|
|
3696
3991
|
});
|
|
3697
3992
|
var r = _t(),
|
|
3698
|
-
n =
|
|
3993
|
+
n = Jt(this),
|
|
3699
3994
|
o = n || r ? { type: 'add', object: this, newValue: e } : null;
|
|
3700
|
-
r && 'production' !== process.env.NODE_ENV &&
|
|
3701
|
-
n &&
|
|
3702
|
-
r && 'production' !== process.env.NODE_ENV &&
|
|
3995
|
+
r && 'production' !== process.env.NODE_ENV && jt(o),
|
|
3996
|
+
n && Wt(this, o),
|
|
3997
|
+
r && 'production' !== process.env.NODE_ENV && Dt();
|
|
3703
3998
|
}
|
|
3704
3999
|
return this;
|
|
3705
4000
|
}),
|
|
@@ -3707,22 +4002,22 @@ var er,
|
|
|
3707
4002
|
var t = this;
|
|
3708
4003
|
if (
|
|
3709
4004
|
Gt(this) &&
|
|
3710
|
-
!(o =
|
|
4005
|
+
!(o = zt(this, { type: 'delete', object: this, oldValue: e }))
|
|
3711
4006
|
)
|
|
3712
4007
|
return !1;
|
|
3713
4008
|
if (this.has(e)) {
|
|
3714
4009
|
var r = _t(),
|
|
3715
|
-
n =
|
|
4010
|
+
n = Jt(this),
|
|
3716
4011
|
o = n || r ? { type: 'delete', object: this, oldValue: e } : null;
|
|
3717
4012
|
return (
|
|
3718
4013
|
r &&
|
|
3719
4014
|
'production' !== process.env.NODE_ENV &&
|
|
3720
|
-
|
|
3721
|
-
|
|
4015
|
+
jt(ue(ue({}, o), { name: this.name })),
|
|
4016
|
+
Bt(function () {
|
|
3722
4017
|
t._atom.reportChanged(), t._data.delete(e);
|
|
3723
4018
|
}),
|
|
3724
|
-
n &&
|
|
3725
|
-
r && 'production' !== process.env.NODE_ENV &&
|
|
4019
|
+
n && Wt(this, o),
|
|
4020
|
+
r && 'production' !== process.env.NODE_ENV && Dt(),
|
|
3726
4021
|
!0
|
|
3727
4022
|
);
|
|
3728
4023
|
}
|
|
@@ -3766,18 +4061,18 @@ var er,
|
|
|
3766
4061
|
(e.prototype.replace = function (e) {
|
|
3767
4062
|
var t = this;
|
|
3768
4063
|
return (
|
|
3769
|
-
|
|
3770
|
-
|
|
3771
|
-
var r =
|
|
4064
|
+
sr(e) && (e = e.toJS()),
|
|
4065
|
+
Bt(function () {
|
|
4066
|
+
var r = et(!0);
|
|
3772
4067
|
try {
|
|
3773
|
-
Array.isArray(e) ||
|
|
4068
|
+
Array.isArray(e) || Z(e)
|
|
3774
4069
|
? (t.clear(),
|
|
3775
4070
|
e.forEach(function (e) {
|
|
3776
4071
|
return t.add(e);
|
|
3777
4072
|
}))
|
|
3778
|
-
: null != e &&
|
|
4073
|
+
: null != e && F('Cannot initialize set from ' + e);
|
|
3779
4074
|
} finally {
|
|
3780
|
-
|
|
4075
|
+
tt(r);
|
|
3781
4076
|
}
|
|
3782
4077
|
}),
|
|
3783
4078
|
this
|
|
@@ -3790,11 +4085,11 @@ var er,
|
|
|
3790
4085
|
!0 !== t,
|
|
3791
4086
|
"`observe` doesn't support fireImmediately=true in combination with sets.",
|
|
3792
4087
|
),
|
|
3793
|
-
|
|
4088
|
+
Ht(this, e)
|
|
3794
4089
|
);
|
|
3795
4090
|
}),
|
|
3796
4091
|
(e.prototype.intercept = function (e) {
|
|
3797
|
-
return
|
|
4092
|
+
return Kt(this, e);
|
|
3798
4093
|
}),
|
|
3799
4094
|
(e.prototype.toJS = function () {
|
|
3800
4095
|
return new Set(this);
|
|
@@ -3802,21 +4097,21 @@ var er,
|
|
|
3802
4097
|
(e.prototype.toString = function () {
|
|
3803
4098
|
return this.name + '[ ' + Array.from(this).join(', ') + ' ]';
|
|
3804
4099
|
}),
|
|
3805
|
-
(e.prototype[((
|
|
4100
|
+
(e.prototype[((tr = ne), Symbol.iterator)] = function () {
|
|
3806
4101
|
return this.values();
|
|
3807
4102
|
}),
|
|
3808
4103
|
e
|
|
3809
4104
|
);
|
|
3810
4105
|
})(),
|
|
3811
|
-
|
|
3812
|
-
|
|
4106
|
+
sr = X('ObservableSet', ar),
|
|
4107
|
+
lr = (function () {
|
|
3813
4108
|
function e(e, t, r, n) {
|
|
3814
4109
|
void 0 === t && (t = new Map()),
|
|
3815
4110
|
(this.target = e),
|
|
3816
4111
|
(this.values = t),
|
|
3817
4112
|
(this.name = r),
|
|
3818
4113
|
(this.defaultEnhancer = n),
|
|
3819
|
-
(this.keysAtom = new
|
|
4114
|
+
(this.keysAtom = new oe(r + '.keys'));
|
|
3820
4115
|
}
|
|
3821
4116
|
return (
|
|
3822
4117
|
(e.prototype.read = function (e) {
|
|
@@ -3825,11 +4120,11 @@ var er,
|
|
|
3825
4120
|
(e.prototype.write = function (e, t) {
|
|
3826
4121
|
var r = this.target,
|
|
3827
4122
|
n = this.values.get(e);
|
|
3828
|
-
if (n instanceof
|
|
4123
|
+
if (n instanceof nt) n.set(t);
|
|
3829
4124
|
else {
|
|
3830
4125
|
if (Gt(this)) {
|
|
3831
4126
|
if (
|
|
3832
|
-
!(a =
|
|
4127
|
+
!(a = zt(this, {
|
|
3833
4128
|
type: 'update',
|
|
3834
4129
|
object: this.proxy || r,
|
|
3835
4130
|
name: e,
|
|
@@ -3840,7 +4135,7 @@ var er,
|
|
|
3840
4135
|
t = a.newValue;
|
|
3841
4136
|
}
|
|
3842
4137
|
if ((t = n.prepareNewValue(t)) !== ut.UNCHANGED) {
|
|
3843
|
-
var o =
|
|
4138
|
+
var o = Jt(this),
|
|
3844
4139
|
i = _t(),
|
|
3845
4140
|
a =
|
|
3846
4141
|
o || i
|
|
@@ -3854,10 +4149,10 @@ var er,
|
|
|
3854
4149
|
: null;
|
|
3855
4150
|
i &&
|
|
3856
4151
|
'production' !== process.env.NODE_ENV &&
|
|
3857
|
-
|
|
4152
|
+
jt(ue(ue({}, a), { name: this.name, key: e })),
|
|
3858
4153
|
n.setNewValue(t),
|
|
3859
|
-
o &&
|
|
3860
|
-
i && 'production' !== process.env.NODE_ENV &&
|
|
4154
|
+
o && Wt(this, a),
|
|
4155
|
+
i && 'production' !== process.env.NODE_ENV && Dt();
|
|
3861
4156
|
}
|
|
3862
4157
|
}
|
|
3863
4158
|
}),
|
|
@@ -3867,7 +4162,7 @@ var er,
|
|
|
3867
4162
|
if (r) return r.get();
|
|
3868
4163
|
var n = !!this.values.get(e);
|
|
3869
4164
|
return (
|
|
3870
|
-
(r = new
|
|
4165
|
+
(r = new rt(n, Ee, this.name + '.' + ee(e) + '?', !1)),
|
|
3871
4166
|
t.set(e, r),
|
|
3872
4167
|
r.get()
|
|
3873
4168
|
);
|
|
@@ -3881,15 +4176,15 @@ var er,
|
|
|
3881
4176
|
((n = i),
|
|
3882
4177
|
(o = e),
|
|
3883
4178
|
'production' === process.env.NODE_ENV ||
|
|
3884
|
-
|
|
3885
|
-
|
|
4179
|
+
$(n, o) ||
|
|
4180
|
+
F(
|
|
3886
4181
|
"Cannot make property '" +
|
|
3887
4182
|
o.toString() +
|
|
3888
4183
|
"' observable, it is not configurable and writable in the target object",
|
|
3889
4184
|
),
|
|
3890
4185
|
Gt(this))
|
|
3891
4186
|
) {
|
|
3892
|
-
var a =
|
|
4187
|
+
var a = zt(this, {
|
|
3893
4188
|
object: this.proxy || i,
|
|
3894
4189
|
name: e,
|
|
3895
4190
|
type: 'add',
|
|
@@ -3898,7 +4193,7 @@ var er,
|
|
|
3898
4193
|
if (!a) return;
|
|
3899
4194
|
t = a.newValue;
|
|
3900
4195
|
}
|
|
3901
|
-
var s = new
|
|
4196
|
+
var s = new rt(t, r, this.name + '.' + ee(e), !1);
|
|
3902
4197
|
this.values.set(e, s),
|
|
3903
4198
|
(t = s.value),
|
|
3904
4199
|
Object.defineProperty(
|
|
@@ -3906,15 +4201,15 @@ var er,
|
|
|
3906
4201
|
e,
|
|
3907
4202
|
(function (e) {
|
|
3908
4203
|
return (
|
|
3909
|
-
|
|
3910
|
-
(
|
|
4204
|
+
pr[e] ||
|
|
4205
|
+
(pr[e] = {
|
|
3911
4206
|
configurable: !0,
|
|
3912
4207
|
enumerable: !0,
|
|
3913
4208
|
get: function () {
|
|
3914
|
-
return this[
|
|
4209
|
+
return this[ne].read(e);
|
|
3915
4210
|
},
|
|
3916
4211
|
set: function (t) {
|
|
3917
|
-
this[
|
|
4212
|
+
this[ne].write(e, t);
|
|
3918
4213
|
},
|
|
3919
4214
|
})
|
|
3920
4215
|
);
|
|
@@ -3924,23 +4219,23 @@ var er,
|
|
|
3924
4219
|
}),
|
|
3925
4220
|
(e.prototype.addComputedProp = function (e, t, r) {
|
|
3926
4221
|
var n = this.target;
|
|
3927
|
-
(r.name = r.name || this.name + '.' +
|
|
3928
|
-
this.values.set(t, new
|
|
3929
|
-
(e === n ||
|
|
4222
|
+
(r.name = r.name || this.name + '.' + ee(t)),
|
|
4223
|
+
this.values.set(t, new nt(r)),
|
|
4224
|
+
(e === n || $(e, t)) &&
|
|
3930
4225
|
Object.defineProperty(
|
|
3931
4226
|
e,
|
|
3932
4227
|
t,
|
|
3933
4228
|
(function (e) {
|
|
3934
4229
|
return (
|
|
3935
|
-
|
|
3936
|
-
(
|
|
4230
|
+
cr[e] ||
|
|
4231
|
+
(cr[e] = {
|
|
3937
4232
|
configurable: ut.computedConfigurable,
|
|
3938
4233
|
enumerable: !1,
|
|
3939
4234
|
get: function () {
|
|
3940
|
-
return
|
|
4235
|
+
return dr(this).read(e);
|
|
3941
4236
|
},
|
|
3942
4237
|
set: function (t) {
|
|
3943
|
-
|
|
4238
|
+
dr(this).write(e, t);
|
|
3944
4239
|
},
|
|
3945
4240
|
})
|
|
3946
4241
|
);
|
|
@@ -3952,7 +4247,7 @@ var er,
|
|
|
3952
4247
|
var t = this.target;
|
|
3953
4248
|
if (Gt(this))
|
|
3954
4249
|
if (
|
|
3955
|
-
!(s =
|
|
4250
|
+
!(s = zt(this, {
|
|
3956
4251
|
object: this.proxy || t,
|
|
3957
4252
|
name: e,
|
|
3958
4253
|
type: 'remove',
|
|
@@ -3960,8 +4255,8 @@ var er,
|
|
|
3960
4255
|
)
|
|
3961
4256
|
return;
|
|
3962
4257
|
try {
|
|
3963
|
-
|
|
3964
|
-
var r =
|
|
4258
|
+
ft();
|
|
4259
|
+
var r = Jt(this),
|
|
3965
4260
|
n = _t(),
|
|
3966
4261
|
o = this.values.get(e),
|
|
3967
4262
|
i = o && o.get();
|
|
@@ -3986,11 +4281,11 @@ var er,
|
|
|
3986
4281
|
: null;
|
|
3987
4282
|
n &&
|
|
3988
4283
|
'production' !== process.env.NODE_ENV &&
|
|
3989
|
-
|
|
3990
|
-
r &&
|
|
3991
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
4284
|
+
jt(ue(ue({}, s), { name: this.name, key: e })),
|
|
4285
|
+
r && Wt(this, s),
|
|
4286
|
+
n && 'production' !== process.env.NODE_ENV && Dt();
|
|
3992
4287
|
} finally {
|
|
3993
|
-
|
|
4288
|
+
vt();
|
|
3994
4289
|
}
|
|
3995
4290
|
}
|
|
3996
4291
|
}),
|
|
@@ -4010,14 +4305,14 @@ var er,
|
|
|
4010
4305
|
!0 !== t,
|
|
4011
4306
|
"`observe` doesn't support the fire immediately property for observable objects.",
|
|
4012
4307
|
),
|
|
4013
|
-
|
|
4308
|
+
Ht(this, e)
|
|
4014
4309
|
);
|
|
4015
4310
|
}),
|
|
4016
4311
|
(e.prototype.intercept = function (e) {
|
|
4017
|
-
return
|
|
4312
|
+
return Kt(this, e);
|
|
4018
4313
|
}),
|
|
4019
4314
|
(e.prototype.notifyPropertyAddition = function (e, t) {
|
|
4020
|
-
var r =
|
|
4315
|
+
var r = Jt(this),
|
|
4021
4316
|
n = _t(),
|
|
4022
4317
|
o =
|
|
4023
4318
|
r || n
|
|
@@ -4031,9 +4326,9 @@ var er,
|
|
|
4031
4326
|
if (
|
|
4032
4327
|
(n &&
|
|
4033
4328
|
'production' !== process.env.NODE_ENV &&
|
|
4034
|
-
|
|
4035
|
-
r &&
|
|
4036
|
-
n && 'production' !== process.env.NODE_ENV &&
|
|
4329
|
+
jt(ue(ue({}, o), { name: this.name, key: e })),
|
|
4330
|
+
r && Wt(this, o),
|
|
4331
|
+
n && 'production' !== process.env.NODE_ENV && Dt(),
|
|
4037
4332
|
this.pendingKeys)
|
|
4038
4333
|
) {
|
|
4039
4334
|
var i = this.pendingKeys.get(e);
|
|
@@ -4046,10 +4341,10 @@ var er,
|
|
|
4046
4341
|
this.keysAtom.reportObserved();
|
|
4047
4342
|
var r = [];
|
|
4048
4343
|
try {
|
|
4049
|
-
for (var n =
|
|
4050
|
-
var i =
|
|
4344
|
+
for (var n = pe(this.values), o = n.next(); !o.done; o = n.next()) {
|
|
4345
|
+
var i = ce(o.value, 2),
|
|
4051
4346
|
a = i[0];
|
|
4052
|
-
i[1] instanceof
|
|
4347
|
+
i[1] instanceof rt && r.push(a);
|
|
4053
4348
|
}
|
|
4054
4349
|
} catch (t) {
|
|
4055
4350
|
e = { error: t };
|
|
@@ -4068,113 +4363,113 @@ var er,
|
|
|
4068
4363
|
function ur(e, t, r) {
|
|
4069
4364
|
if (
|
|
4070
4365
|
(void 0 === t && (t = ''),
|
|
4071
|
-
void 0 === r && (r =
|
|
4072
|
-
Object.prototype.hasOwnProperty.call(e,
|
|
4366
|
+
void 0 === r && (r = Oe),
|
|
4367
|
+
Object.prototype.hasOwnProperty.call(e, ne))
|
|
4073
4368
|
)
|
|
4074
|
-
return e[
|
|
4369
|
+
return e[ne];
|
|
4075
4370
|
'production' !== process.env.NODE_ENV &&
|
|
4076
4371
|
G(
|
|
4077
4372
|
Object.isExtensible(e),
|
|
4078
4373
|
'Cannot make the designated object observable; it is not extensible',
|
|
4079
4374
|
),
|
|
4080
|
-
|
|
4081
|
-
t || (t = 'ObservableObject@' +
|
|
4082
|
-
var n = new
|
|
4083
|
-
return
|
|
4375
|
+
H(e) || (t = (e.constructor.name || 'ObservableObject') + '@' + U()),
|
|
4376
|
+
t || (t = 'ObservableObject@' + U());
|
|
4377
|
+
var n = new lr(e, new Map(), ee(t), r);
|
|
4378
|
+
return W(e, ne, n), n;
|
|
4084
4379
|
}
|
|
4085
|
-
var
|
|
4086
|
-
|
|
4087
|
-
function
|
|
4088
|
-
var t = e[
|
|
4089
|
-
return t || (
|
|
4380
|
+
var pr = Object.create(null),
|
|
4381
|
+
cr = Object.create(null);
|
|
4382
|
+
function dr(e) {
|
|
4383
|
+
var t = e[ne];
|
|
4384
|
+
return t || (be(e), e[ne]);
|
|
4090
4385
|
}
|
|
4091
|
-
var
|
|
4092
|
-
function
|
|
4093
|
-
return !!
|
|
4386
|
+
var fr = X('ObservableObjectAdministration', lr);
|
|
4387
|
+
function vr(e) {
|
|
4388
|
+
return !!J(e) && (be(e), fr(e[ne]));
|
|
4094
4389
|
}
|
|
4095
|
-
function
|
|
4390
|
+
function yr(e, t) {
|
|
4096
4391
|
if ('object' == typeof e && null !== e) {
|
|
4097
|
-
if (
|
|
4392
|
+
if (er(e))
|
|
4098
4393
|
return (
|
|
4099
4394
|
void 0 !== t &&
|
|
4100
|
-
|
|
4395
|
+
F(
|
|
4101
4396
|
'production' !== process.env.NODE_ENV &&
|
|
4102
4397
|
'It is not possible to get index atoms from arrays',
|
|
4103
4398
|
),
|
|
4104
|
-
e[
|
|
4399
|
+
e[ne].atom
|
|
4105
4400
|
);
|
|
4106
|
-
if (
|
|
4107
|
-
if (
|
|
4401
|
+
if (sr(e)) return e[ne];
|
|
4402
|
+
if (or(e)) {
|
|
4108
4403
|
var r = e;
|
|
4109
4404
|
return void 0 === t
|
|
4110
4405
|
? r._keysAtom
|
|
4111
4406
|
: ((n = r._data.get(t) || r._hasMap.get(t)) ||
|
|
4112
|
-
|
|
4407
|
+
F(
|
|
4113
4408
|
'production' !== process.env.NODE_ENV &&
|
|
4114
4409
|
"the entry '" +
|
|
4115
4410
|
t +
|
|
4116
4411
|
"' does not exist in the observable map '" +
|
|
4117
|
-
|
|
4412
|
+
br(e) +
|
|
4118
4413
|
"'",
|
|
4119
4414
|
),
|
|
4120
4415
|
n);
|
|
4121
4416
|
}
|
|
4122
4417
|
var n;
|
|
4123
|
-
if ((
|
|
4418
|
+
if ((be(e), t && !e[ne] && e[t], vr(e)))
|
|
4124
4419
|
return t
|
|
4125
|
-
? ((n = e[
|
|
4126
|
-
|
|
4420
|
+
? ((n = e[ne].values.get(t)) ||
|
|
4421
|
+
F(
|
|
4127
4422
|
'production' !== process.env.NODE_ENV &&
|
|
4128
4423
|
"no observable property '" +
|
|
4129
4424
|
t +
|
|
4130
4425
|
"' found on the observable object '" +
|
|
4131
|
-
|
|
4426
|
+
br(e) +
|
|
4132
4427
|
"'",
|
|
4133
4428
|
),
|
|
4134
4429
|
n)
|
|
4135
|
-
:
|
|
4430
|
+
: F(
|
|
4136
4431
|
'production' !== process.env.NODE_ENV &&
|
|
4137
4432
|
'please specify a property',
|
|
4138
4433
|
);
|
|
4139
|
-
if (
|
|
4140
|
-
} else if ('function' == typeof e &&
|
|
4141
|
-
return
|
|
4434
|
+
if (ie(e) || ot(e) || wt(e)) return e;
|
|
4435
|
+
} else if ('function' == typeof e && wt(e[ne])) return e[ne];
|
|
4436
|
+
return F(
|
|
4142
4437
|
'production' !== process.env.NODE_ENV && 'Cannot obtain atom from ' + e,
|
|
4143
4438
|
);
|
|
4144
4439
|
}
|
|
4145
|
-
function
|
|
4440
|
+
function hr(e, t) {
|
|
4146
4441
|
return (
|
|
4147
|
-
e ||
|
|
4442
|
+
e || F('Expecting some object'),
|
|
4148
4443
|
void 0 !== t
|
|
4149
|
-
?
|
|
4150
|
-
:
|
|
4444
|
+
? hr(yr(e, t))
|
|
4445
|
+
: ie(e) || ot(e) || wt(e) || or(e) || sr(e)
|
|
4151
4446
|
? e
|
|
4152
|
-
: (
|
|
4153
|
-
e[
|
|
4154
|
-
? e[
|
|
4155
|
-
: void
|
|
4447
|
+
: (be(e),
|
|
4448
|
+
e[ne]
|
|
4449
|
+
? e[ne]
|
|
4450
|
+
: void F(
|
|
4156
4451
|
'production' !== process.env.NODE_ENV &&
|
|
4157
4452
|
'Cannot obtain administration from ' + e,
|
|
4158
4453
|
))
|
|
4159
4454
|
);
|
|
4160
4455
|
}
|
|
4161
|
-
function
|
|
4162
|
-
return (void 0 !== t ?
|
|
4456
|
+
function br(e, t) {
|
|
4457
|
+
return (void 0 !== t ? yr(e, t) : vr(e) || or(e) || sr(e) ? hr(e) : yr(e))
|
|
4163
4458
|
.name;
|
|
4164
4459
|
}
|
|
4165
|
-
var
|
|
4166
|
-
|
|
4167
|
-
function
|
|
4168
|
-
return void 0 === r && (r = -1),
|
|
4460
|
+
var mr,
|
|
4461
|
+
gr = Object.prototype.toString;
|
|
4462
|
+
function Or(e, t, r) {
|
|
4463
|
+
return void 0 === r && (r = -1), Er(e, t, r);
|
|
4169
4464
|
}
|
|
4170
|
-
function
|
|
4465
|
+
function Er(e, t, r, n, o) {
|
|
4171
4466
|
if (e === t) return 0 !== e || 1 / e == 1 / t;
|
|
4172
4467
|
if (null == e || null == t) return !1;
|
|
4173
4468
|
if (e != e) return t != t;
|
|
4174
4469
|
var i = typeof e;
|
|
4175
4470
|
if ('function' !== i && 'object' !== i && 'object' != typeof t) return !1;
|
|
4176
|
-
var a =
|
|
4177
|
-
if (a !==
|
|
4471
|
+
var a = gr.call(e);
|
|
4472
|
+
if (a !== gr.call(t)) return !1;
|
|
4178
4473
|
switch (a) {
|
|
4179
4474
|
case '[object RegExp]':
|
|
4180
4475
|
case '[object String]':
|
|
@@ -4193,19 +4488,19 @@ function Or(e, t, r, n, o) {
|
|
|
4193
4488
|
case '[object Set]':
|
|
4194
4489
|
r >= 0 && r++;
|
|
4195
4490
|
}
|
|
4196
|
-
(e =
|
|
4491
|
+
(e = Nr(e)), (t = Nr(t));
|
|
4197
4492
|
var s = '[object Array]' === a;
|
|
4198
4493
|
if (!s) {
|
|
4199
4494
|
if ('object' != typeof e || 'object' != typeof t) return !1;
|
|
4200
|
-
var
|
|
4201
|
-
|
|
4495
|
+
var l = e.constructor,
|
|
4496
|
+
u = t.constructor;
|
|
4202
4497
|
if (
|
|
4203
|
-
|
|
4498
|
+
l !== u &&
|
|
4204
4499
|
!(
|
|
4500
|
+
'function' == typeof l &&
|
|
4501
|
+
l instanceof l &&
|
|
4205
4502
|
'function' == typeof u &&
|
|
4206
|
-
u instanceof u
|
|
4207
|
-
'function' == typeof c &&
|
|
4208
|
-
c instanceof c
|
|
4503
|
+
u instanceof u
|
|
4209
4504
|
) &&
|
|
4210
4505
|
'constructor' in e &&
|
|
4211
4506
|
'constructor' in t
|
|
@@ -4214,33 +4509,33 @@ function Or(e, t, r, n, o) {
|
|
|
4214
4509
|
}
|
|
4215
4510
|
if (0 === r) return !1;
|
|
4216
4511
|
r < 0 && (r = -1), (o = o || []);
|
|
4217
|
-
for (var
|
|
4512
|
+
for (var p = (n = n || []).length; p--; ) if (n[p] === e) return o[p] === t;
|
|
4218
4513
|
if ((n.push(e), o.push(t), s)) {
|
|
4219
|
-
if ((
|
|
4220
|
-
for (;
|
|
4514
|
+
if ((p = e.length) !== t.length) return !1;
|
|
4515
|
+
for (; p--; ) if (!Er(e[p], t[p], r - 1, n, o)) return !1;
|
|
4221
4516
|
} else {
|
|
4222
|
-
var
|
|
4517
|
+
var c = Object.keys(e),
|
|
4223
4518
|
d = void 0;
|
|
4224
|
-
if (((
|
|
4225
|
-
for (;
|
|
4226
|
-
if (!
|
|
4519
|
+
if (((p = c.length), Object.keys(t).length !== p)) return !1;
|
|
4520
|
+
for (; p--; )
|
|
4521
|
+
if (!wr(t, (d = c[p])) || !Er(e[d], t[d], r - 1, n, o)) return !1;
|
|
4227
4522
|
}
|
|
4228
4523
|
return n.pop(), o.pop(), !0;
|
|
4229
4524
|
}
|
|
4230
|
-
function
|
|
4231
|
-
return
|
|
4525
|
+
function Nr(e) {
|
|
4526
|
+
return er(e)
|
|
4232
4527
|
? e.slice()
|
|
4233
|
-
:
|
|
4528
|
+
: Y(e) || or(e) || Z(e) || sr(e)
|
|
4234
4529
|
? Array.from(e.entries())
|
|
4235
4530
|
: e;
|
|
4236
4531
|
}
|
|
4237
|
-
function
|
|
4532
|
+
function wr(e, t) {
|
|
4238
4533
|
return Object.prototype.hasOwnProperty.call(e, t);
|
|
4239
4534
|
}
|
|
4240
4535
|
function _r(e) {
|
|
4241
|
-
return (e[Symbol.iterator] =
|
|
4536
|
+
return (e[Symbol.iterator] = xr), e;
|
|
4242
4537
|
}
|
|
4243
|
-
function
|
|
4538
|
+
function xr() {
|
|
4244
4539
|
return this;
|
|
4245
4540
|
}
|
|
4246
4541
|
if ('undefined' == typeof Proxy || 'undefined' == typeof Symbol)
|
|
@@ -4250,8 +4545,8 @@ if ('undefined' == typeof Proxy || 'undefined' == typeof Symbol)
|
|
|
4250
4545
|
try {
|
|
4251
4546
|
process.env.NODE_ENV;
|
|
4252
4547
|
} catch (e) {
|
|
4253
|
-
var
|
|
4254
|
-
'undefined' == typeof process && (
|
|
4548
|
+
var jr = st();
|
|
4549
|
+
'undefined' == typeof process && (jr.process = {}), (jr.process.env = {});
|
|
4255
4550
|
}
|
|
4256
4551
|
!(function () {
|
|
4257
4552
|
if (
|
|
@@ -4275,17 +4570,17 @@ try {
|
|
|
4275
4570
|
? (console.warn('[mobx.spy] Is a no-op in production builds'),
|
|
4276
4571
|
function () {})
|
|
4277
4572
|
: (ut.spyListeners.push(e),
|
|
4278
|
-
|
|
4573
|
+
K(function () {
|
|
4279
4574
|
ut.spyListeners = ut.spyListeners.filter(function (t) {
|
|
4280
4575
|
return t !== e;
|
|
4281
4576
|
});
|
|
4282
4577
|
}));
|
|
4283
4578
|
},
|
|
4284
|
-
extras: { getDebugName:
|
|
4285
|
-
$mobx:
|
|
4579
|
+
extras: { getDebugName: br },
|
|
4580
|
+
$mobx: ne,
|
|
4286
4581
|
});
|
|
4287
|
-
var
|
|
4288
|
-
(((
|
|
4582
|
+
var Sr =
|
|
4583
|
+
(((mr = {
|
|
4289
4584
|
array: 'array',
|
|
4290
4585
|
boolean: 'boolean',
|
|
4291
4586
|
'box-style': 'object',
|
|
@@ -4302,26 +4597,27 @@ var jr =
|
|
|
4302
4597
|
input: 'string',
|
|
4303
4598
|
json: 'string',
|
|
4304
4599
|
number: 'number',
|
|
4600
|
+
'input-image': 'string',
|
|
4305
4601
|
object: 'object',
|
|
4306
4602
|
quantity: 'object',
|
|
4307
4603
|
radio: 'string',
|
|
4308
4604
|
select: 'array',
|
|
4309
4605
|
}).select = 'string'),
|
|
4310
|
-
(
|
|
4311
|
-
(
|
|
4312
|
-
(
|
|
4313
|
-
(
|
|
4314
|
-
(
|
|
4315
|
-
(
|
|
4316
|
-
(
|
|
4317
|
-
|
|
4318
|
-
function
|
|
4319
|
-
return
|
|
4320
|
-
}
|
|
4321
|
-
function
|
|
4322
|
-
|
|
4323
|
-
? console.warn('当前已经存在' + e + '(' +
|
|
4324
|
-
: (
|
|
4606
|
+
(mr.textarea = 'string'),
|
|
4607
|
+
(mr['text-editor'] = 'string'),
|
|
4608
|
+
(mr.time = 'string'),
|
|
4609
|
+
(mr.url = 'string'),
|
|
4610
|
+
(mr['dynamic-config'] = 'object'),
|
|
4611
|
+
(mr['sohu-source'] = 'object'),
|
|
4612
|
+
(mr['sohu-event'] = 'object'),
|
|
4613
|
+
mr);
|
|
4614
|
+
function Dr(e) {
|
|
4615
|
+
return Sr[e] || e;
|
|
4616
|
+
}
|
|
4617
|
+
function Cr(e, t) {
|
|
4618
|
+
Sr[e]
|
|
4619
|
+
? console.warn('当前已经存在' + e + '(' + Sr[e] + '),暂时不支持覆盖。')
|
|
4620
|
+
: (Sr[e] = t);
|
|
4325
4621
|
}
|
|
4326
4622
|
function Ar(e) {
|
|
4327
4623
|
var t = !0;
|
|
@@ -4349,13 +4645,13 @@ function Vr(e) {
|
|
|
4349
4645
|
n = new Date('2024-10-05T00:01:00.691Z').getTime();
|
|
4350
4646
|
return r && new Date(r).getTime() >= n && (t = !0), t;
|
|
4351
4647
|
}
|
|
4352
|
-
function
|
|
4648
|
+
function Tr(e) {
|
|
4353
4649
|
var t = !1,
|
|
4354
|
-
r =
|
|
4650
|
+
r = Dr(e.type),
|
|
4355
4651
|
n = void 0 === e.isContainer || e.isContainer;
|
|
4356
4652
|
return 'object' === r && n && (t = !0), t;
|
|
4357
4653
|
}
|
|
4358
|
-
function
|
|
4654
|
+
function kr(e) {
|
|
4359
4655
|
var t = !0;
|
|
4360
4656
|
return (
|
|
4361
4657
|
'object' === e.type && e.propertyOrder && e.properties
|
|
@@ -4367,12 +4663,12 @@ function Tr(e) {
|
|
|
4367
4663
|
t
|
|
4368
4664
|
);
|
|
4369
4665
|
}
|
|
4370
|
-
function
|
|
4666
|
+
function Rr(e, t) {
|
|
4371
4667
|
var r = e.split('-'),
|
|
4372
4668
|
n = t.split('-');
|
|
4373
4669
|
return r.pop(), n.pop(), r.join('-') === n.join('-');
|
|
4374
4670
|
}
|
|
4375
|
-
function
|
|
4671
|
+
function Pr(e, t) {
|
|
4376
4672
|
for (
|
|
4377
4673
|
var r = e.split('-'),
|
|
4378
4674
|
n = t.split('-'),
|
|
@@ -4386,32 +4682,32 @@ function Rr(e, t) {
|
|
|
4386
4682
|
}
|
|
4387
4683
|
return o;
|
|
4388
4684
|
}
|
|
4389
|
-
function
|
|
4685
|
+
function Ir(e) {
|
|
4390
4686
|
var t = e.split('-');
|
|
4391
4687
|
return t.pop(), t.join('-');
|
|
4392
4688
|
}
|
|
4393
|
-
function
|
|
4689
|
+
function Mr(e) {
|
|
4394
4690
|
var t = e.split('-'),
|
|
4395
4691
|
r = t.pop(),
|
|
4396
4692
|
n = Number(r) + 1;
|
|
4397
4693
|
return t.push('' + n), t.join('-');
|
|
4398
4694
|
}
|
|
4399
|
-
function
|
|
4695
|
+
function Lr(e) {
|
|
4400
4696
|
var t = e.split('-'),
|
|
4401
4697
|
r = t.pop();
|
|
4402
4698
|
return [t.join('-'), r];
|
|
4403
4699
|
}
|
|
4404
|
-
function
|
|
4700
|
+
function Br(e) {
|
|
4405
4701
|
var t = e.split('-'),
|
|
4406
4702
|
r = t.pop();
|
|
4407
4703
|
return t.push(Number(r) - 1), t.join('-');
|
|
4408
4704
|
}
|
|
4409
|
-
function
|
|
4705
|
+
function qr(e) {
|
|
4410
4706
|
var t = e.split('-'),
|
|
4411
4707
|
r = t.pop();
|
|
4412
4708
|
return t.push(Number(r) + 1), t.join('-');
|
|
4413
4709
|
}
|
|
4414
|
-
function
|
|
4710
|
+
function Ur(e, t) {
|
|
4415
4711
|
var r = '',
|
|
4416
4712
|
n = !1;
|
|
4417
4713
|
return (
|
|
@@ -4420,7 +4716,7 @@ function qr(e, t) {
|
|
|
4420
4716
|
r
|
|
4421
4717
|
);
|
|
4422
4718
|
}
|
|
4423
|
-
function
|
|
4719
|
+
function Fr(e, t) {
|
|
4424
4720
|
var r = '',
|
|
4425
4721
|
n = t;
|
|
4426
4722
|
i(n) && i(e.default) && typeof n != typeof e.default && (n = void 0);
|
|
@@ -4428,10 +4724,10 @@ function Ur(e, t) {
|
|
|
4428
4724
|
switch (e.type) {
|
|
4429
4725
|
case 'select':
|
|
4430
4726
|
case 'radio':
|
|
4431
|
-
r = o ||
|
|
4727
|
+
r = o || Ur(e);
|
|
4432
4728
|
break;
|
|
4433
4729
|
case 'checkboxes':
|
|
4434
|
-
r = o ||
|
|
4730
|
+
r = o || Ur(e, !0);
|
|
4435
4731
|
break;
|
|
4436
4732
|
case 'color':
|
|
4437
4733
|
('#fff' !== o && '#FFF' !== o) || (o = '#ffffff'),
|
|
@@ -4445,8 +4741,8 @@ function Ur(e, t) {
|
|
|
4445
4741
|
break;
|
|
4446
4742
|
case 'json':
|
|
4447
4743
|
var a = '';
|
|
4448
|
-
if (A(o) ||
|
|
4449
|
-
else if (
|
|
4744
|
+
if (A(o) || D(o)) a = o;
|
|
4745
|
+
else if (k(o) || '' === o) a = {};
|
|
4450
4746
|
else
|
|
4451
4747
|
try {
|
|
4452
4748
|
a = JSON.parse(o);
|
|
@@ -4468,61 +4764,63 @@ function Ur(e, t) {
|
|
|
4468
4764
|
function Gr(e, t) {
|
|
4469
4765
|
var r = {},
|
|
4470
4766
|
o = e.type;
|
|
4471
|
-
if (A(e) && 'object' ===
|
|
4767
|
+
if (A(e) && 'object' === Dr(e.type)) {
|
|
4472
4768
|
var a = e,
|
|
4473
4769
|
s = t;
|
|
4474
|
-
i(s) &&
|
|
4475
|
-
|
|
4770
|
+
i(s) &&
|
|
4771
|
+
((i(a.default) && typeof s != typeof e.default) || !A(s)) &&
|
|
4772
|
+
(s = void 0);
|
|
4773
|
+
var l = i(s) ? s : a.default;
|
|
4476
4774
|
if ('dynamic-data' === o)
|
|
4477
|
-
(r = n(
|
|
4478
|
-
|
|
4775
|
+
(r = n(b)),
|
|
4776
|
+
l && A(l) && '{}' !== JSON.stringify(l) && (r = Object.assign(r, l));
|
|
4479
4777
|
else if ('datasource' === o)
|
|
4480
4778
|
a.properties &&
|
|
4481
4779
|
a.properties.type &&
|
|
4482
4780
|
a.properties.type.default &&
|
|
4483
4781
|
'local' === a.properties.type.default
|
|
4484
4782
|
? ((r = { data: '{}', filter: '() => {}' }),
|
|
4485
|
-
|
|
4486
|
-
|
|
4783
|
+
l && l.data && (r.data = l.data),
|
|
4784
|
+
l && l.filter && (r.filter = l.filter),
|
|
4487
4785
|
'http://xxx' === r.data && (r.data = '{}'))
|
|
4488
4786
|
: ((r = { data: 'http://xxx', filter: '() => {}' }),
|
|
4489
|
-
|
|
4490
|
-
|
|
4787
|
+
l && l.data && (r.data = l.data),
|
|
4788
|
+
l && l.filter && (r.filter = l.filter),
|
|
4491
4789
|
'{}' === r.data && (r.data = 'http://xxx'));
|
|
4492
4790
|
else if ('event' === o)
|
|
4493
4791
|
a.properties &&
|
|
4494
4792
|
a.properties.type &&
|
|
4495
4793
|
a.properties.type.default &&
|
|
4496
4794
|
'emit' === a.properties.type.default
|
|
4497
|
-
?
|
|
4498
|
-
? (r = { trigger: (
|
|
4795
|
+
? l && 'out' === l.type
|
|
4796
|
+
? (r = { trigger: (l && l.filter) || 'eventName', eventData: '{}' })
|
|
4499
4797
|
: ((r = { trigger: 'eventName', eventData: '{}' }),
|
|
4500
|
-
|
|
4501
|
-
|
|
4502
|
-
:
|
|
4798
|
+
l && l.trigger && (r.trigger = l.trigger),
|
|
4799
|
+
l && l.eventData && (r.eventData = l.eventData))
|
|
4800
|
+
: l && 'in' === l.type
|
|
4503
4801
|
? (r = {
|
|
4504
4802
|
register: 'eventName',
|
|
4505
|
-
actionFunc: (
|
|
4803
|
+
actionFunc: (l && l.filter) || '() => {}',
|
|
4506
4804
|
})
|
|
4507
4805
|
: ((r = { register: 'eventName', actionFunc: '() => {}' }),
|
|
4508
|
-
|
|
4509
|
-
|
|
4510
|
-
else if (!1 === e.isContainer &&
|
|
4511
|
-
r = Object.assign(r,
|
|
4806
|
+
l && l.register && (r.register = l.register),
|
|
4807
|
+
l && l.actionFunc && (r.actionFunc = l.actionFunc));
|
|
4808
|
+
else if (!1 === e.isContainer && l && A(l) && '{}' !== JSON.stringify(l))
|
|
4809
|
+
r = Object.assign(r, l);
|
|
4512
4810
|
else if (e.properties) {
|
|
4513
4811
|
(e.propertyOrder ? e.propertyOrder : Object.keys(e.properties)).map(
|
|
4514
4812
|
function (n) {
|
|
4515
4813
|
var o = e.properties[n],
|
|
4516
4814
|
i = t && t[n];
|
|
4517
|
-
switch (
|
|
4815
|
+
switch (Dr(o.type)) {
|
|
4518
4816
|
case 'array':
|
|
4519
|
-
r[n] =
|
|
4817
|
+
r[n] = Kr(o, i);
|
|
4520
4818
|
break;
|
|
4521
4819
|
case 'object':
|
|
4522
4820
|
r[n] = Gr(o, i);
|
|
4523
4821
|
break;
|
|
4524
4822
|
default:
|
|
4525
|
-
r[n] =
|
|
4823
|
+
r[n] = Fr(o, i);
|
|
4526
4824
|
}
|
|
4527
4825
|
},
|
|
4528
4826
|
);
|
|
@@ -4530,14 +4828,16 @@ function Gr(e, t) {
|
|
|
4530
4828
|
}
|
|
4531
4829
|
return r;
|
|
4532
4830
|
}
|
|
4533
|
-
function
|
|
4831
|
+
function Kr(e, t) {
|
|
4534
4832
|
var r = [];
|
|
4535
|
-
if (e && 'array' ===
|
|
4833
|
+
if (e && 'array' === Dr(e.type)) {
|
|
4536
4834
|
var n = t;
|
|
4537
|
-
i(n) &&
|
|
4835
|
+
i(n) &&
|
|
4836
|
+
((i(e.default) && typeof n != typeof e.default) || !D(n)) &&
|
|
4837
|
+
(n = void 0);
|
|
4538
4838
|
var o = i(n) ? n : e.default;
|
|
4539
|
-
if ('array' ===
|
|
4540
|
-
if (
|
|
4839
|
+
if ('array' === Dr(e.type))
|
|
4840
|
+
if (D(o))
|
|
4541
4841
|
o.map(function (t) {
|
|
4542
4842
|
r.push(Gr(e.items, t));
|
|
4543
4843
|
});
|
|
@@ -4550,15 +4850,15 @@ function Fr(e, t) {
|
|
|
4550
4850
|
}
|
|
4551
4851
|
return r;
|
|
4552
4852
|
}
|
|
4553
|
-
function
|
|
4554
|
-
return 'object' ===
|
|
4853
|
+
function zr(e, t) {
|
|
4854
|
+
return 'object' === Dr(e.type)
|
|
4555
4855
|
? Gr(e, t)
|
|
4556
|
-
: 'array' ===
|
|
4557
|
-
?
|
|
4558
|
-
:
|
|
4856
|
+
: 'array' === Dr(e.type)
|
|
4857
|
+
? Kr(e, t)
|
|
4858
|
+
: Fr(e, t);
|
|
4559
4859
|
}
|
|
4560
|
-
var
|
|
4561
|
-
function
|
|
4860
|
+
var Jr = m;
|
|
4861
|
+
function Hr(e, t) {
|
|
4562
4862
|
var r = t || [];
|
|
4563
4863
|
if (e && '{}' !== JSON.stringify(e))
|
|
4564
4864
|
if (A(e))
|
|
@@ -4581,17 +4881,17 @@ function Jr(e, t) {
|
|
|
4581
4881
|
r.push({ id: e.config.id, dataName: e.config.dataName, body: n });
|
|
4582
4882
|
} else {
|
|
4583
4883
|
Object.keys(e).map(function (t) {
|
|
4584
|
-
|
|
4884
|
+
Hr(e[t], r);
|
|
4585
4885
|
});
|
|
4586
4886
|
}
|
|
4587
4887
|
else
|
|
4588
|
-
|
|
4888
|
+
D(e) &&
|
|
4589
4889
|
e.map(function (e) {
|
|
4590
|
-
|
|
4890
|
+
Hr(e, r);
|
|
4591
4891
|
});
|
|
4592
4892
|
return r;
|
|
4593
4893
|
}
|
|
4594
|
-
function
|
|
4894
|
+
function Wr(e, t) {
|
|
4595
4895
|
var r = t || 'data';
|
|
4596
4896
|
return (
|
|
4597
4897
|
e.split('-').map(function (e) {
|
|
@@ -4600,36 +4900,52 @@ function Hr(e, t) {
|
|
|
4600
4900
|
r
|
|
4601
4901
|
);
|
|
4602
4902
|
}
|
|
4603
|
-
function
|
|
4903
|
+
function $r(e, t) {
|
|
4604
4904
|
var r = [];
|
|
4605
4905
|
A(e)
|
|
4606
4906
|
? Object.keys(e).map(function (n) {
|
|
4607
4907
|
var o = e[n],
|
|
4608
4908
|
i = t ? t + '-' + n : n;
|
|
4609
|
-
A(o) ||
|
|
4610
|
-
? r.push({ title: n, value: i, key: i, children:
|
|
4909
|
+
A(o) || D(o)
|
|
4910
|
+
? r.push({ title: n, value: i, key: i, children: $r(o, i) })
|
|
4611
4911
|
: r.push({ title: n, value: i, key: i });
|
|
4612
4912
|
})
|
|
4613
|
-
:
|
|
4913
|
+
: D(e) &&
|
|
4614
4914
|
e.map(function (e, n) {
|
|
4615
4915
|
var o = n.toString(),
|
|
4616
4916
|
i = t ? t + '-' + n : o;
|
|
4617
|
-
A(e) ||
|
|
4618
|
-
? r.push({ title: o, value: i, key: i, children:
|
|
4917
|
+
A(e) || D(e)
|
|
4918
|
+
? r.push({ title: o, value: i, key: i, children: $r(e, i) })
|
|
4619
4919
|
: r.push({ title: o, value: i, key: i });
|
|
4620
4920
|
});
|
|
4621
4921
|
return r;
|
|
4622
4922
|
}
|
|
4623
|
-
function
|
|
4923
|
+
function Xr(e, t) {
|
|
4924
|
+
var r = '';
|
|
4925
|
+
if ('object' === Dr(e.type) && e.properties) {
|
|
4926
|
+
(e.propertyOrder ? e.propertyOrder : Object.keys(e.properties)).map(
|
|
4927
|
+
function (n) {
|
|
4928
|
+
var o = e.properties[n],
|
|
4929
|
+
i = t[n];
|
|
4930
|
+
('array' === Dr(o.type) && 'object' === Dr(o.type)) ||
|
|
4931
|
+
(i &&
|
|
4932
|
+
o.isConditionProp &&
|
|
4933
|
+
(r.indexOf('-') > 0 ? (r += '-' + i) : (r = i)));
|
|
4934
|
+
},
|
|
4935
|
+
);
|
|
4936
|
+
}
|
|
4937
|
+
return r;
|
|
4938
|
+
}
|
|
4939
|
+
function Yr(e) {
|
|
4624
4940
|
var t = e.split('-');
|
|
4625
4941
|
return t.pop(), t.join('-');
|
|
4626
4942
|
}
|
|
4627
|
-
function
|
|
4943
|
+
function Zr(e) {
|
|
4628
4944
|
var t = e.split('-'),
|
|
4629
4945
|
r = t.pop();
|
|
4630
4946
|
return [t.join('-'), r];
|
|
4631
4947
|
}
|
|
4632
|
-
var
|
|
4948
|
+
var Qr = [
|
|
4633
4949
|
'key',
|
|
4634
4950
|
'enum',
|
|
4635
4951
|
'enumextra',
|
|
@@ -4659,55 +4975,57 @@ var Yr = [
|
|
|
4659
4975
|
'object',
|
|
4660
4976
|
];
|
|
4661
4977
|
export {
|
|
4662
|
-
|
|
4663
|
-
|
|
4664
|
-
|
|
4665
|
-
|
|
4666
|
-
|
|
4667
|
-
|
|
4668
|
-
|
|
4669
|
-
|
|
4670
|
-
|
|
4671
|
-
|
|
4672
|
-
|
|
4673
|
-
|
|
4674
|
-
|
|
4675
|
-
|
|
4676
|
-
|
|
4978
|
+
O as DataSourceTypeList,
|
|
4979
|
+
g as EventTypeDataList,
|
|
4980
|
+
Qr as KeyWordList,
|
|
4981
|
+
m as TypeDataList,
|
|
4982
|
+
Wr as dataRoute2dataPath,
|
|
4983
|
+
Hr as dynamicDataAnalyzer,
|
|
4984
|
+
s as expressionOn,
|
|
4985
|
+
Pr as getCurPosition,
|
|
4986
|
+
Ur as getDefaultOptionVal,
|
|
4987
|
+
Dr as getExpectType,
|
|
4988
|
+
l as getJsonDataByKeyRoute,
|
|
4989
|
+
Mr as getNextIndexRoute,
|
|
4990
|
+
Ir as getParentIndexRoute,
|
|
4991
|
+
Lr as getParentIndexRoute_CurIndex,
|
|
4992
|
+
Yr as getParentKeyRoute,
|
|
4993
|
+
Zr as getParentKeyRoute_CurKey,
|
|
4677
4994
|
u as getSchemaByIndexRoute,
|
|
4678
|
-
|
|
4995
|
+
p as getSchemaByKeyRoute,
|
|
4679
4996
|
i as hasProperties,
|
|
4680
|
-
|
|
4681
|
-
|
|
4997
|
+
c as indexRoute2keyRoute,
|
|
4998
|
+
D as isArray,
|
|
4682
4999
|
_ as isBoolean,
|
|
4683
|
-
|
|
4684
|
-
|
|
4685
|
-
|
|
4686
|
-
|
|
5000
|
+
T as isColor,
|
|
5001
|
+
Tr as isContainerSchema,
|
|
5002
|
+
x as isDateStr,
|
|
5003
|
+
j as isDateTimeStr,
|
|
4687
5004
|
Ar as isEmptySchema,
|
|
4688
5005
|
o as isEqual,
|
|
4689
|
-
|
|
5006
|
+
k as isFunction,
|
|
4690
5007
|
Vr as isNewSchemaData,
|
|
4691
|
-
|
|
5008
|
+
w as isNumber,
|
|
4692
5009
|
A as isObject,
|
|
4693
5010
|
V as isQuantity,
|
|
4694
|
-
|
|
4695
|
-
|
|
4696
|
-
|
|
4697
|
-
|
|
4698
|
-
|
|
4699
|
-
|
|
4700
|
-
|
|
4701
|
-
|
|
4702
|
-
|
|
4703
|
-
|
|
4704
|
-
|
|
4705
|
-
|
|
5011
|
+
Rr as isSameParent,
|
|
5012
|
+
C as isSelect,
|
|
5013
|
+
N as isString,
|
|
5014
|
+
kr as isStructuredSchema,
|
|
5015
|
+
S as isTimeStr,
|
|
5016
|
+
E as isURL,
|
|
5017
|
+
R as json2schema,
|
|
5018
|
+
$r as json2treeData,
|
|
5019
|
+
d as keyRoute2indexRoute,
|
|
5020
|
+
I as metaElemAnalyzer,
|
|
5021
|
+
qr as moveBackward,
|
|
5022
|
+
Br as moveForward,
|
|
4706
5023
|
n as objClone,
|
|
4707
|
-
|
|
4708
|
-
|
|
4709
|
-
|
|
4710
|
-
|
|
4711
|
-
zr as
|
|
5024
|
+
L as oldSchemaToNewSchema,
|
|
5025
|
+
M as oldSchemaToNewSchemaV1,
|
|
5026
|
+
Cr as registerExpectType,
|
|
5027
|
+
Xr as schema2conditionValue,
|
|
5028
|
+
zr as schema2json,
|
|
5029
|
+
Jr as schemaMetaList,
|
|
4712
5030
|
a as truncate,
|
|
4713
5031
|
};
|