Антон Спирин

const foo = (array, obj) => array.some(el => Object.values(obj).includes(el));

Демо

Потому что вы неправильно его используете. Попробуйте так:

const obj = arr.reduce((acc, el) => ({ ...acc, ...el }), {});

Ваш вариант в исправленном виде:

const toObj = arr => {
  let obj = {};

  arr.forEach(el => {
   obj = { ...obj, ...el };
  });

  return obj;
};

Видимо, потому что в исходном коде плагина реализована своя функция filter

К слову о возможности применения методов массивов на объектах. Вот этот код отлично работает:

const obj = {
  '0': 'some value 0',
  '1': 'some value 1',
  '2': false,
  length: 3,
};

const filteredArr = Array.prototype.filter.call(obj, el => el);
console.log(filteredArr); // ["0 value", "1 value"]

Массив это лишь особый вид объекта с особым набором ключей и дополнительными методами в прототипе.

Решение плохое. В таком случае можно было и вовсе обойтись без Redux. Обернуть в connect можно любой компонент. И чем ближе вы будете передавать части состояния к месту их использования, тем меньше в вашем приложении будет лишних перерисовок.
Одно модальное окно на все приложение не лучшее решение.

Правильнее будет вынести функции в прототип и использовать свойства экземпляра для состояния:

function Slider(props) {
  /* ...  */
  this.images = props.images;
  this.currentSlide = 1;
  /* ...  */
}

Slider.prototype.changeSlide = function() {
  /* ...  */
  if (this.currentSlide === this.images.length) {
    currentSlide = 1;
  } else {
    this.currentSlide++;
  }
  /* ...  */
}

Самый простой вариант это передавать хандлер и данные через родителя:

class Parent extends Component {
  state = {
    search: '',
    data: [],
  };

  componentDidMount() {
    fetchData().then(({ data }) => this.setState({ data }));
  }

  handleFilterChange = e => {
    this.setState({ search: e.target.value });
  };

  render() {
    const { data, search } = this.state;
    const filteredData = data.filter(el => /* some stuff */);
    
    return (
      <Wrapper>
        <SearchFilter onChange={this.handleFilterChange} />
        <DataList data={filteredData} />
     </Wrapper>
    )
  }
}

Зачем вам ключ? Передавайте сам элемент:

сlick(e, item) {
  console.log(item);
}

render() {
    const { array } = this.state;
    const unit = array.map((item, index) => (
      <a 
        key={index}
        style={{display:"block"}}
        onClick={(e) => this.click(e, item)}
      >
        Hello, {item}
      </a>
     ));

Если все-таки нужен именно ключ, то просто добавьте еще один аргумент в вызов click.

Если, что-то проще сделать без redux, не надо это туда тянуть. Это касается всего: форм, модалок, фильтров и прочего.
Определять версию лучше по user agent, а передавать эти данные через контекст.

Видимо в initialState пустой массив items не задаете или уничтожаете его в редьюсере в кейсе FETCH_MENU. Без кода редьюсера точно не сказать. Но думаю дело именно в этом.

На будущее. Прикладывайте к вопросу примеры кода, а не скриншоты. И примеры именно того кода который вызывает ошибку, а не какого-то другого.

Вы задаете state в конструкторе. Конструктор вызывается лишь раз, при инициализации компонента.
this.props.data обновляется, просто, вы его, видимо, не используете.

Насколько я понимаю вашу задачу, вам нет никакого смысла писать props в state. Просто используйте props напрямую в методе render и все. Если надо их менять по какому либо событию, то предавайте дополнительно хандлер из родителя.

Старайтесь избегать макарон вида:

label={this.props._sharedData.loc.advanced_search.select_brand}

Вы неправильно работаете с асинхронным кодом. Вызывать его в render неправильно.
Вы что сделать то хотите?
Для работы с асинхронными вызовами основанными на Promise используйте метод then или async/await функции.
Пример использования метода then:

isValidEmail("mail@gmail.com").then(result => someAction(result));

Пример использования async/await:

async someHandler() {
  const result = await isValidEmail("mail@gmail.com");

  return someAction(result);
}

async someOtherHandler() {
  const result = await isValidEmail("mail@gmail.com");
  
  /* вызов someOtherAsyncAction тоже возвращает Promise, поэтому ждем 
     и возвращаем только когда придет результат, для этого используем 
     ключевое слово await                                             */
  return await someOtherAsyncAction(result); 
}

Можно так:

const wrapperStyle = {
  position: 'fixed',
  top: 0,
  bottom: 0,
  left: 0, 
  right: 0,
  display: 'flex',
  justifyContent: 'center',
  alignItems: 'center',
  height: '100%'
};

const Preloader = () => (
  <div style={wrapperStyle}>
    <div className="spinner" />
  </div>
);

Юникод
Статья на Википедии

Вариант 1:

<li className={someCondition ? someClass : someOtherClass} />

где someCondition условие, например:
someProp === SOME_CONSTRANT

Вариант2:
<li className={getClassName(someProp)} />

Вы передаете в вызове map элемент первым аргументом, но при этом обращаетесь к нему через массив:
key = {this.props.data[index]['id']}
очень нелогичный ход, исправьте на:
key = {value.id}

const min = res.data.reduce(
  (acc, el) => (acc > el.price ? el.price : acc),
  Infinity
);

const max = res.data.reduce(
  (acc, el) => (acc < el.price ? el.price : acc),
  -Infinity
);

this.setState({ studios: res.data, isLoading: false, min, max });

Опечатка и неправильное условие. Исправить можно так:

onChange = value => {
  const [from, to] = value;

  const filteredStudios = this.state.studios.filter(studio => 
    studio.price >= from && studio.price <= to
  );

  this.setState({
    studios: filteredStudios,
    from,
    to,
  });
};

Только вы перезаписываете отфильтрованный state поверх не отфильтрованного. Это тоже думаю неправильно.

Причина бага в том, что вы рендерите списки моделей через map и передаете в key индекс, а индекс в вашем случае всегда равен 0. Само решение показывать списки таким способом очень плохое.
Как можно переделать. Во-первых использовать для mark не массив, а строку. Использование массива для значения mark необоснованно. Во-вторых все модели автомобилей с фильтров хранить в объекте вида:

const allCars = {
  bmw: [
    { name: 'x1',  ... },
     ...
  ],
  ...
}

Тогда:

render() {
  const { mark } = this.props;
  const models = allCars[mark]; 
  
  return (
    <div>
      {mark && (
        <div>
          <label>{mark}</label>
          {models.map(model => (
            <div key={model.name}>
              <label>{model.name}</label>
              <input
                name="model"
                value={model.name}
                type="checkbox"
                onClick={this.props.changemodel}
              />
            </div>
          ))}
        <div>
      )}
    </div>
  );
}

Менять состояние так как это делаете вы нельзя, так как вызов setState асинхронный. Например код метода changeMark можно переписать так:

changeMark (e) {
  const { value } = e.target;

  this.setState({ 
    mark: value === 'all' ? [] : [...prevState.mark, value],
    model: [],
    page: 1,
  });
  }
}

Для изменения состояния на основе предыдущего передавайте в setState функцию возвращающую состояние, на момент вызова первым аргументом(prevState в примере) в нее придет текущее состояние компонента.

Для переменных значение которых не переопределяется правильней использовать const, а не let.

Хандлеры changeBody и changeModel можно объединить в один, а использовав xor из lodash сократить до такого вида:

handleCheckboxCheck(e) {
    const { name, value } = e.target;

    this.setState(prevState => ({
      [name]: _.xor(prevState[name], +value), 
    }));
}

Черную магию с array.push и array.length = 0 для обновления состояния, забудьте и никогда не вспоминайте.

Метод render это самое худшее место для бинда хандлера. Антипатерн. Так можно делать только если надо передать аргументы.
Вместо этого бинд лучше сделать в конструкторе:

constructor(props) {
  super(props);
  this.changeModel = this.changeModel.bind(this);
}

Либо переписав хандлер с метода класса в поле класса:
метод класса:

changeModel (e) {
    // some actions
}

поле класса:

changeModel = e => {
  // some actions
};

Вариант 1: Создаваемым объектам можно переопределять свойство __proto__, а взять его можно из экземпляра класса:

class myClass {    
  createSomeObj() {
    const newObj = { 1: 1, 2: 2 };

    newObj.__proto__ = this.__proto__;

    return newObj;
  }
}
  
const instance = new myClass();
const instanceOfInstance = instance.createSomeObj();

console.log(instanceOfInstance.createSomeObj()); // myClass {1: 1, 2: 2}

Демо.
Объекту будут доступны методы класса и он будет проходить проверку instanceof.

Вариант 2: Вы так же можете переопределять лишь конструктор:

class myClass {    
  createSomeObj() {
    const newObj = { 1: 1, 2: 2 };

    newObj.__proto__.constructor = myClass;

    return newObj;
  }
}
  
const instance = new myClass();

console.log(instance.createSomeObj()); // myClass {1: 1, 2: 2}

Демо.
В этом случае объекту не будут доступны методы класса и он не будет проходить проверку instanceof.

Вариант 3: Статический метод и прямое создание экземпляра.

class myClass {
  constructor(props) {
    Object.keys(props).forEach(key => this[key] = props[key]);
  }
  
  static createSomeObj() {   
    return new myClass({ 1: 1, 2: 2 });
  }
}
  
console.log(myClass.createSomeObj()); // myClass {1: 1, 2: 2}

Демо.
Прямое создание экземпляра класса, без необходимости в экземпляре для его создания.

Думаю, вам больше подойдут третий или первый варианты.