How to use the algoliasearch-helper function in algoliasearch-helper

getConfiguration(currentConfiguration) {
    // we need to create a REAL helper to then get its state. Because some parameters
    // like hierarchicalFacet.rootPath are then triggering a default refinement that would
    // be not present if it was not going trough the SearchParameters constructor
    this.originalConfig = algoliasearchHelper({}, currentConfiguration.index, currentConfiguration).state;
    return this.searchParametersFromUrl;
  }

configureIndex(indexName: string) {
    this.indices[indexName] = algoliasearchHelper(this.client, indexName, {
      disjunctiveFacets: ['category']
    });

    this.searchState = {} as SearchState;

    // handle algolia events
    ['search', 'result', 'change', 'error'].forEach(eventName => {
      this.searchState[`${eventName}$`] = new Observable(observer => {
        const handler = e => observer.next(e);
        this.indices[indexName].on(eventName, handler);
        return () => this.indices[indexName].removeListener(eventName, handler);
      });
    });
  }

test('should be constructed with a helper instance', () => {
    const client = algoliaClient('appId', 'apiKey');
    const helper = algoliaHelper(client);
    const store = new Store(helper);

    expect(store.algoliaHelper).toBe(helper);
  });

export default function createInstantSearchManager({
  indexName,
  initialState = {},
  searchClient,
  resultsState,
  stalledSearchDelay,
}) {
  const helper = algoliasearchHelper(searchClient, indexName, {
    ...HIGHLIGHT_TAGS,
  });

  addAlgoliaAgents(searchClient);

  helper
    .on('search', handleNewSearch)
    .on('result', handleSearchSuccess({ indexId: indexName }))
    .on('error', handleSearchError);

  let skip = false;
  let stalledSearchTimer = null;
  let initialSearchParameters = helper.state;

  const widgetsManager = createWidgetsManager(onWidgetsUpdate);

...indexIds.map(indexId => {
      const parameters = derivedParameters[indexId];

      return algoliasearchHelper(client, parameters.index).searchOnce(
        parameters
      );
    }),
  ];

import React from 'react';
import ReactDOM from 'react-dom';
import algoliasearch from 'algoliasearch';
import algoliasearchHelper from 'algoliasearch-helper';
import Provider from '../src/Provider.js';

import App from './App';

const client = algoliasearch('latency', 'ffc36feb6e9df06e1c3c4549b5af2b31');
const helper = algoliasearchHelper(client, 'starbucks');

ReactDOM.render(
  
    
  ,
  document.getElementById('root')
);

search.hydrate = instantSearchState => {
    if (!instantSearchState || !instantSearchState.lastResults) {
      warn('The result of `getState()` needs to be passed to `hydrate()`.');
      return;
    }
    const { lastResults } = instantSearchState;
    search.searchParameters = lastResults._state;
    search.helper = algoliaHelper(searchClient, indexName, lastResults._state);
    search.helper.lastResults = new SearchResults(
      new SearchParameters(lastResults._state),
      lastResults._rawResults
    );

    search.hydrated = true;
  };

require('./helper.scss');

import algoliasearch from 'algoliasearch'
import algoliasearchHelper from 'algoliasearch-helper'

const { API_KEY, APP_ID, INDEX_NAME } = process.env;

const client = algoliasearch(APP_ID, API_KEY),
      helper = algoliasearchHelper(client, INDEX_NAME, {
        clickAnalytics: true
      });

const input = document.querySelector('#q'),
      hitsContainer = document.querySelector('#hits');

input.addEventListener('input', (e) => {
  helper.setQuery(e.target.value).search();
})

helper.on('result', function(content) {
  renderHits(content);
});

const hit = (hit, index) => {
  return `