renderingContent

Type: Object

Engine default:

Parameter syntax

'renderingContent' => array

renderingContent: RenderingContent

renderingContent: RenderingContent

'renderingContent': dict

renderingContent = RenderingContent

renderingContent: RenderingContent

new IndexSettings { RenderingContent = new RenderingContent() }

new IndexSettings().setRenderingContent()

RenderingContent = RenderingContent

renderingContent = Object

Can be used in these methods:
setSettings set_settings setSettings set_settings setSettings setSettings SetSettings setSettings SetSettings setSettings

See code examples

About this parameter

Defines how you want to render results in the search interface.

You can set a default with setSettings and override it with Rules.

facetOrdering. Controls the order of facets in your UI.
- values. Controls the order and visibility of specific facet values with order and hide properties.
- sortRemainingBy. Determines how to sort remaining values if a facet value isn’t specified. It can be one of:
  - alpha sorts by facet value, alphabetically in ascending order
  - count sorts by facet value count, numerically in descending order
  - hidden hides facet values that aren’t included in the values list.
widgets. Controls the configuration of specific InstantSearch widgets in your UI. You can’t set this property with the setSettings method. Use Rules instead.
- banners. Determines how InstantSearch may display any banner configured by Rules. If this property is populated, the Hits widget or InfiniteHits widget displays a banner by default.

This property has a 2 MB size limit. Exceeding this limit will result in an error message. This is true when setting the property with setSettings or when using Rules to override it.

Usage notes

InstantSearch uses this property to define the UI through configuration—for example, with the dynamicWidgets widget.

If you’re not using InstantSearch for your frontend, you can build a UI with renderingContent

Examples

Set `renderingContent`

The following example snippet uses renderingContent to define how results are displayed:

brand ordering starts with “uniqlo”, never shows the value “muji”, and all other facet values, such as “timberland”, are sorted by facet value count.
The size ordering sequence is “S”, “M”, and “L” and other facet values, such as “XS”, are hidden.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$index->setSettings([
  'renderingContent' => [
    'facetOrdering' => [
      'facets' => [
        'order' => ['size', 'brand']
      ],
      'values' => [
        'brand'=> [
          'order' => ['uniqlo'],
          'hide' => ['muji'],
          'sortRemainingBy' => 'count'
        ],
        'size'=> [
          'order' => ['S', 'M', 'L'],
          'sortRemainingBy' => 'hidden'
        ],
      ]
    ]
  ]
]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
index.set_settings({
  renderingContent: {
    facetOrdering: {
      facets: {
        order: ['size', 'brand']
      },
      values: {
        brand: {
          order: ['uniqlo'],
          hide: ['muji'],
          sortRemainingBy: 'count'
        },
        size: {
          order: ['S', 'M', 'L'],
          sortRemainingBy: 'hidden'
        },
      }
    }
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
index
  .setSettings({
    renderingContent: {
      facetOrdering: {
        facets: {
          order: ['size', 'brand'],
        },
        values: {
          brand: {
            order: ['uniqlo'],
            hide: ['muji'],
            sortRemainingBy: 'count',
          },
          size: {
            order: ['S', 'M', 'L'],
            sortRemainingBy: 'hidden',
          },
        },
      },
    },
  })
  .then(() => {
    // done
  });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
index.setSettings({
  renderingContent: {
    facetOrdering: {
      facets: {
        order: ['size', 'brand'],
        values: {
          brand: {
            order: ['uniqlo'],
            hide: ['muji'],
            sortRemainingBy: 'count',
          },
          size: {
            order: ['S', 'M', 'L'],
            sortRemainingBy: 'hidden',
          },
        },
      },
    },
  },
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
let facetOrdering = FacetOrdering(facets: FacetsOrder(order: ["size", "brand"]),
                                  values: [
                                   "brand": FacetValuesOrder(
                                      order: ["uniqlo"],
                                      hide: ["muji"],
                                      sortRemainingBy: .count
                                    ),
                                   "size": FacetValuesOrder(
                                      order: ["S", "M", "L"],
                                      sortRemainingBy: .hidden
                                    )
                                  ])

let renderingContent = RenderingContent(facetOrdering: facetOrdering)

let settings = Settings()
  .set(\.renderingContent, to: renderingContent)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
val facetOrdering = FacetOrdering(
    facets = FacetsOrder(order = listOf("size", "brand")),
    values = mapOf(
        Attribute("brand") to FacetValuesOrder
            order = listOf("uniqlo"),
            hide = listOf("muji"),
            sortRemainingBy = SortRule.Count),
        Attribute("size") to FacetValuesOrder(
            order = listOf("S", "M", "L"),
            sortRemainingBy = SortRule.Hidden
        )
    )
)
val renderingContent = RenderingContent(facetOrdering)
val settings = Settings(renderingContent = renderingContent)
index.setSettings(settings)

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
var settings = new IndexSettings
{
  RenderingContent = new RenderingContent
  {
    FacetOrdering = new FacetOrdering
    {
      Facets = new FacetsOrder
      {
        Order = new List<string> { "size", "brand" }
      },
      Values = new Dictionary<string, FacetValuesOrder>
      {
        {
          "brand",
          new FacetValuesOrder
          {
            Order = new List<string> { "uniqlo" },
            Hide = new List<string> { "muji" },
            SortRemainingBy = "count"
          }
        },
        {
          "size",
          new FacetValuesOrder
          {
            Order = new List<string> { "S", "M", "L" },
            SortRemainingBy = "hidden"
          }
        }
      }
    }
  }
};

index.SetSettings(settings);

// Asynchronous
await index.SetSettingsAsync(settings);

1
2
3
4
5
6
7
8
9
10
11
FacetsOrder facetsOrder = new FacetsOrder(Arrays.asList("size", "brand"));
Map<String, FacetValuesOrder> values = new LinkedHashMap<>();
values.put("brand", new FacetValuesOrder(Collections.singletonList("uniqlo"), Collections.singletonList("muji"), "count"));
values.put("size", new FacetValuesOrder(Arrays.asList("S", "M", "L"), "hidden"));
FacetOrdering facetOrdering = new FacetOrdering(facetsOrder, values);
RenderingContent renderingContent = new RenderingContent(facetOrdering);

// Synchronous
index.setSettings(new IndexSettings().setRenderingContent(renderingContent));
// Asynchronous
index.setSettingsAsync(new IndexSettings().setRenderingContent(renderingContent));

1
2
3
4
5
6
7
8
9
10
11
var renderingContent = search.RenderingContent{FacetOrdering: &search.FacetOrdering{
  Facets: &search.FacetsOrder{Order: []string{"size", "brand"}},
  Values: map[string]search.FacetValuesOrder{
    "brand": search.NewFacetValuesOrder([]string{"Uniqlo"}, []string{"Muji"}, search.Count),
    "size":  search.NewFacetValuesOrder([]string{"S", "M", "L"}, search.Hidden),
  },
}}

res, err := index.SetSettings(search.Settings{
    RenderingContent: &renderingContent,
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
val facetOrdering = FacetOrdering(
  facets = FacetsOrder(order = Seq("size", "brand")),
  values = Map(
    "brand" -> FacetValuesOrder(
      order = Seq("uniqlo"),
      hide = Seq("muji"),
      sortRemainingBy = Some(SortRule.count)
    ),
    "size" -> FacetValuesOrder(
      order = Seq("S", "M", "L"),
      sortRemainingBy = Some(SortRule.hidden)
    )
  )
)
val renderingContent = RenderingContent(facetOrdering = Some(facetOrdering))
client.execute {
  setSettings of "myIndex" `with` IndexSettings(renderingContent = Some(renderingContent))
}

Did you find this page helpful?

renderingContent

About this parameter

Usage notes

Examples

Set renderingContent

On this page

Set `renderingContent`