If channel values are specified as an array, it breaks faceting; we should assume that the channel values should be indexed in parallel with the faceted data. about plot HOT 3 CLOSED

I've tried to address this issue, but I'm not sure what is considered to be broken.

Here's my current test https://observablehq.com/d/d36850d4bd824097

data = [{l: "A", n: 1}, {l: "B", n: 3},{l: "C", n: 2}];

Plot.plot({
  facet: { data, y: "l" },
  marks: [
    Plot.ruleY(data, {y: "n", stroke: ["red", "blue", "orange"]})
  ]
})

With no faceting, this creates three rules, with the three colors.

Once we activate faceting, each facet has 1 rule, but only the "red" stroke is ever used. I don't think it's wrong ("red" goes to the first line of the facet, "blue" to the second, etc. And if I want to join the stroke array with the data I should do it before feeding them to plot (?).)

But this probably only shows that I didn't understand the issue :) You probably have a different example in mind?

from plot.

Aside: the stroke values here are abstract, not literal colors, so I changed your test to use ["foo", "bar", "baz"] for clarity. These are then assigned colors through the color scale, whose range defaults to tableau10 for ordinal values.

The behavior that I was imagining should be equivalent to the data having an additional stroke property:

data = [
  {l: "A", n: 1, stroke: "foo"}, 
  {l: "B", n: 3, stroke: "bar"},
  {l: "C", n: 2, stroke: "baz"}
]

And then referencing that property:

Plot.plot({
  facet: {data, y: "l"},
  marks: [
    Plot.ruleY(data, {y: "n", stroke: "stroke"})
  ]
})

The intent of specifying channel values as an array is to support columnar data such as this:

flatdata = ({
  i: [0, 1, 2],
  l: ["A", "B", "C"],
  n: [1, 2, 3],
  stroke: ["foo", "bar", "baz"]
})

This works fine without faceting, e.g.:

Plot.plot({
  marks: [
    Plot.ruleY(flatdata.i, {y: flatdata.n, stroke: flatdata.stroke})
  ]
})

But it is not consistent with row-oriented data with faceting. This should be equivalent to the above example using the stroke field:

Plot.plot({
  facet: {data: flatdata.i, y: flatdata.l},
  marks: [
    Plot.ruleY(flatdata.i, {y: flatdata.n, stroke: flatdata.stroke})
  ]
})

from plot.

The reason the function definition of stroke works, while the array definition does not, is that mark.initialize is called repeatedly for each facet’s data:

However, if the channel’s value is already an array, it is returned as-is here, and thus all facets share the same channel values, rather than faceting them:

My guess is that we need to do something like pass the facetIndex to mark.initialize, and when present and the channel is specified as an array, the Channel constructor should take the corresponding values (Array.from(index, i => values[i])) from the channel definition for each facet.

from plot.