An unnecessarily thorough analysis
When you look at the behavior of the methods on a d3.selection, they fall into one of two categories:
- those that create a new selection, e.g.,
.filter(),.exit(),.enter(),.append(), etc.; and - those that mutate the existing selection, e.g.,
.attr(),.style(),on(), etc.
Question: Are these categories disjoint and exhaustive?
Note that for the latter category, the order in which they are applied in a method chain is irrelevant as long as the arguments are provied as values, or functions that do not read from the this variable. If the values that these functions return only depend on the data associated with the selection and not the selection itself, you can permute them as you please.
Furthermore, if you call, for example, .on('click') multiple times with a different callback function, the last callback function will be the only one that your code will register with the selection. In other words, the latter category have a getter-setter behavior. When you use them as method-chanined objects, they are typically only used as setters. In this case youc annot change order of an .on('click') call relative other .on('click') calls without changing the behavior of yoru program.
This is not the case for the .transform() class of methods that you are proposing. In particular .translate() and .scale() do not commute. Not only that but the "last one wins" behavior that of getter-setters does not apply in this case. Multiple calls to translate() should be cumulative.
For these reasons, I don't think it's a good idea to include them as methods on d3.selection. Rather, they should be their own object, with their own semantics and rules for composition.
/* Creates an identity transform */
var tid = d3.transform()/* Creates a transform of the given kind, given kind-specific parameters. Kinds
* include: rotate, scale, matrix, translate, etc.
*/
var t2 = d3.transform('<kind>', args*)/* Right-composes the transformation specified by the arguments of transform
* with `t`.
*/
t.transform('<kind>', args*)/* Right-composes the transformation `t2` with `t1`.*/
t1.transform(t2)The result of all calls to transform() should be a function that, when applied, will produce a string that can be set to the transform attribute of an SVG element.