{{ message }}
Repository navigation
Expand file tree
/
Copy pathplot_template.js
More file actions
315 lines (288 loc) · 12.4 KB
/
Copy pathplot_template.js
File metadata and controls
315 lines (288 loc) · 12.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
'use strict';
var Lib = require('../lib');
var plotAttributes = require('../plots/attributes');
var TEMPLATEITEMNAME = 'templateitemname';
var templateAttrs = {
name: {
valType: 'string',
editType: 'none',
description: [
'When used in a template, named items are created in the output figure',
'in addition to any items the figure already has in this array.',
'You can modify these items in the output figure by making your own',
'item with `templateitemname` matching this `name`',
'alongside your modifications (including `visible: false` or',
'`enabled: false` to hide it).',
'Has no effect outside of a template.'
].join(' ')
}
};
templateAttrs[TEMPLATEITEMNAME] = {
valType: 'string',
editType: 'calc',
description: [
'Used to refer to a named item in this array in the template. Named',
'items from the template will be created even without a matching item',
'in the input figure, but you can modify one by making an item with',
'`templateitemname` matching its `name`, alongside your modifications',
'(including `visible: false` or `enabled: false` to hide it).',
'If there is no template or no matching item, this item will be',
'hidden unless you explicitly show it with `visible: true`.'
].join(' ')
};
/**
* templatedArray: decorate an attributes object with templating (and array)
* properties.
*
* @param {string} name: the singular form of the array name. Sets
* `_isLinkedToArray` to this, so the schema knows to treat this as an array.
* @param {object} attrs: the item attributes. Since all callers are expected
* to be constructing this object on the spot, we mutate it here for
* performance, rather than extending a new object with it.
*
* @returns {object}: the decorated `attrs` object
*/
exports.templatedArray = function(name, attrs) {
attrs._isLinkedToArray = name;
attrs.name = templateAttrs.name;
attrs[TEMPLATEITEMNAME] = templateAttrs[TEMPLATEITEMNAME];
return attrs;
};
/**
* traceTemplater: logic for matching traces to trace templates
*
* @param {object} dataTemplate: collection of {traceType: [{template}, ...]}
* ie each type the template applies to contains a list of template objects,
* to be provided cyclically to data traces of that type.
*
* @returns {object}: {newTrace}, a function:
* newTrace(traceIn): that takes the input traceIn, coerces its type, then
* uses that type to find the next template to apply. returns the output
* traceOut with template attached, ready to continue supplyDefaults.
*/
exports.traceTemplater = function(dataTemplate) {
var traceCounts = {};
var traceType, typeTemplates;
for(traceType in dataTemplate) {
typeTemplates = dataTemplate[traceType];
if(Array.isArray(typeTemplates) && typeTemplates.length) {
traceCounts[traceType] = 0;
}
}
function newTrace(traceIn) {
traceType = Lib.coerce(traceIn, {}, plotAttributes, 'type');
var traceOut = {type: traceType, _template: null};
if(traceType in traceCounts) {
typeTemplates = dataTemplate[traceType];
// cycle through traces in the template set for this type
var typei = traceCounts[traceType] % typeTemplates.length;
traceCounts[traceType]++;
traceOut._template = typeTemplates[typei];
} else {
// TODO: anything we should do for types missing from the template?
// try to apply some other type? Or just bail as we do here?
// Actually I think yes, we should apply other types; would be nice
// if all scatter* could inherit from each other, and if histogram
// could inherit from bar, etc... but how to specify this? And do we
// compose them, or if a type is present require it to be complete?
// Actually this could apply to layout too - 3D annotations
// inheriting from 2D, axes of different types inheriting from each
// other...
}
return traceOut;
}
return {
newTrace: newTrace
// TODO: function to figure out what's left & what didn't work
};
};
/**
* newContainer: Create a new sub-container inside `container` and propagate any
* applicable template to it. If there's no template, still propagates
* `undefined` so relinkPrivate will not retain an old template!
*
* @param {object} container: the outer container, should already have _template
* if there *is* a template for this plot
* @param {string} name: the key of the new container to make
* @param {string} baseName: if applicable, a base attribute to take the
* template from, ie for xaxis3 the base would be xaxis
*
* @returns {object}: an object for inclusion _full*, empty except for the
* appropriate template piece
*/
exports.newContainer = function(container, name, baseName) {
var template = container._template;
var part = template && (template[name] || (baseName && template[baseName]));
if(!Lib.isPlainObject(part)) part = null;
var out = container[name] = {_template: part};
return out;
};
/**
* arrayTemplater: special logic for templating both defaults and specific items
* in a container array (annotations etc)
*
* @param {object} container: the outer container, should already have _template
* if there *is* a template for this plot
* @param {string} name: the name of the array to template (ie 'annotations')
* will be used to find default ('annotationdefaults' object) and specific
* ('annotations' array) template specs.
* @param {string} inclusionAttr: the attribute determining this item's
* inclusion in the output, usually 'visible' or 'enabled'
*
* @returns {object}: {newItem, defaultItems}, both functions:
* newItem(itemIn): create an output item, bare except for the correct
* template and name(s), as the base for supplyDefaults
* defaultItems(): to be called after all newItem calls, return any
* specific template items that have not already beeen included,
* also as bare output items ready for supplyDefaults.
*/
exports.arrayTemplater = function(container, name, inclusionAttr) {
var template = container._template;
var defaultsTemplate = template && template[arrayDefaultKey(name)];
var templateItems = template && template[name];
if(!Array.isArray(templateItems) || !templateItems.length) {
templateItems = [];
}
var usedNames = {};
function newItem(itemIn) {
// include name and templateitemname in the output object for ALL
// container array items. Note: you could potentially use different
// name and templateitemname, if you're using one template to make
// another template. templateitemname would be the name in the original
// template, and name is the new "subclassed" item name.
var out = {name: itemIn.name, _input: itemIn};
var templateItemName = out[TEMPLATEITEMNAME] = itemIn[TEMPLATEITEMNAME];
// no itemname: use the default template
if(!validItemName(templateItemName)) {
out._template = defaultsTemplate;
return out;
}
// look for an item matching this itemname
// note these do not inherit from the default template, only the item.
for(var i = 0; i < templateItems.length; i++) {
var templateItem = templateItems[i];
if(templateItem.name === templateItemName) {
// Note: it's OK to use a template item more than once
// but using it at least once will stop it from generating
// a default item at the end.
usedNames[templateItemName] = 1;
out._template = templateItem;
return out;
}
}
// Didn't find a matching template item, so since this item is intended
// to only be modifications it's most likely broken. Hide it unless
// it's explicitly marked visible - in which case it gets NO template,
// not even the default.
out[inclusionAttr] = itemIn[inclusionAttr] || false;
// special falsy value we can look for in validateTemplate
out._template = false;
return out;
}
function defaultItems() {
var out = [];
for(var i = 0; i < templateItems.length; i++) {
var templateItem = templateItems[i];
var name = templateItem.name;
// only allow named items to be added as defaults,
// and only allow each name once
if(validItemName(name) && !usedNames[name]) {
var outi = {
_template: templateItem,
name: name,
_input: {_templateitemname: name}
};
outi[TEMPLATEITEMNAME] = templateItem[TEMPLATEITEMNAME];
out.push(outi);
usedNames[name] = 1;
}
}
return out;
}
return {
newItem: newItem,
defaultItems: defaultItems
};
};
function validItemName(name) {
return name && typeof name === 'string';
}
function arrayDefaultKey(name) {
var lastChar = name.length - 1;
if(name.charAt(lastChar) !== 's') {
Lib.warn('bad argument to arrayDefaultKey: ' + name);
}
return name.slice(0, -1) + 'defaults';
}
exports.arrayDefaultKey = arrayDefaultKey;
/**
* arrayEditor: helper for editing array items that may have come from
* template defaults (in which case they will not exist in the input yet)
*
* @param {object} parentIn: the input container (eg gd.layout)
* @param {string} containerStr: the attribute string for the container inside
* `parentIn`.
* @param {object} itemOut: the _full* item (eg gd._fullLayout.annotations[0])
* that we'll be editing. Assumed to have been created by `arrayTemplater`.
*
* @returns {object}: {modifyBase, modifyItem, getUpdateObj, applyUpdate}, all functions:
* modifyBase(attr, value): Add an update that's *not* related to the item.
* `attr` is the full attribute string.
* modifyItem(attr, value): Add an update to the item. `attr` is just the
* portion of the attribute string inside the item.
* getUpdateObj(): Get the final constructed update object, to use in
* `restyle` or `relayout`. Also resets the update object in case this
* update was canceled.
* applyUpdate(attr, value): optionally add an update `attr: value`,
* then apply it to `parent` which should be the parent of `containerIn`,
* ie the object to which `containerStr` is the attribute string.
*/
exports.arrayEditor = function(parentIn, containerStr, itemOut) {
var lengthIn = (Lib.nestedProperty(parentIn, containerStr).get() || []).length;
var index = itemOut._index;
// Check that we are indeed off the end of this container.
// Otherwise a devious user could put a key `_templateitemname` in their
// own input and break lots of things.
var templateItemName = (index >= lengthIn) && (itemOut._input || {})._templateitemname;
if(templateItemName) index = lengthIn;
var itemStr = containerStr + '[' + index + ']';
var update;
function resetUpdate() {
update = {};
if(templateItemName) {
update[itemStr] = {};
update[itemStr][TEMPLATEITEMNAME] = templateItemName;
}
}
resetUpdate();
function modifyBase(attr, value) {
update[attr] = value;
}
function modifyItem(attr, value) {
if(templateItemName) {
// we're making a new object: edit that object
Lib.nestedProperty(update[itemStr], attr).set(value);
} else {
// we're editing an existing object: include *just* the edit
update[itemStr + '.' + attr] = value;
}
}
function getUpdateObj() {
var updateOut = update;
resetUpdate();
return updateOut;
}
function applyUpdate(attr, value) {
if(attr) modifyItem(attr, value);
var updateToApply = getUpdateObj();
for(var key in updateToApply) {
Lib.nestedProperty(parentIn, key).set(updateToApply[key]);
}
}
return {
modifyBase: modifyBase,
modifyItem: modifyItem,
getUpdateObj: getUpdateObj,
applyUpdate: applyUpdate
};
};
You can’t perform that action at this time.