10 examples of 'filter in react' in JavaScript

8
export function filterRender(component) {
9
  if (!component) {
10
    return undefined;
11
  }
12
13
  if (Array.isArray(component)) {
14
    return Children
15
      .map(component, filterRender)
16
      .filter((component) => component);
17
  }
18
19
  if (!isReactElement(component)) {
20
    return component;
21
  }
22
23
  return createElement(
24
    component.type,
25
    omit(component.props, ['snippetIgnore', 'snippetReplace', 'snippetSkip']),
26
    filterRender(component.props.children));
27
}

679
function test_filterWhere() {
680
    reactWrapper =
681
        reactWrapper.filterWhere(wrapper => {
682
            wrapper.props().stringProp;
683
            return true;
684
        });
685
}

105
isFilterActive() {
106
    return this.component.isFilterActive();
107
}

9
function * filterInput (input, props) {
10
  for (let substring of substrings(input || '', props)) {
11
    if (!props.filter || props.filter(substring)) {
12
      const score = props.greedy
13
        ? 0.1 + (1 - (1 / substring.length))
14
        : 0.1 + (1 / substring.length)
15
      yield {
16
        words: [{text: substring, input: true}],
17
        result: substring,
18
        remaining: input.substring(substring.length),
19
        score
20
      }
21
    }
22
  }
23
}

12
function useFilter<T extends string>(initialFilter: IFilter<T>): UseFilter<T> {
13
  const [data, dispatchFilterAction] = useReducer<
14
    React.Reducer<IFilter<T>, FilterReducerAction<T>>
15
  >(reduceFilter, initialFilter);
16
17
  const reset = () =>
18
    dispatchFilterAction({
19
      payload: {
20
        reset: initialFilter
21
      },
22
      type: "reset"
23
    });
24
25
  useEffect(reset, [initialFilter]);
26
27
  return [data, dispatchFilterAction, reset];
28
}

33
function filter(props: {}) {
34
  return omit(props, registered);
35
}

46
export default function filterReactProps(props, config = {}) {
47
  const { tagName = 'div' } = config
48
49
  return Object.keys(props)
50
    .filter(propName => shouldForwardProperty(tagName, propName))
51
    .reduce((acc, propName) => ({ ...acc, [propName]: props[propName] }), {})
52
}

39
export function filter() {
40
  return purry(_filter(false), arguments, filter.lazy);
41
}

24
function getNewFilters(isOpen: boolean): ReactWrapper<IFiltersProps, any> {
25
  const activeFilter = getNewFilterType(1);
26
  return mount(
27
    <Filters
28
      activeFilter={activeFilter}
29
      layouts={[1, 2].map((seed: number) => getNewLayout(seed))}
30
      isOpen={isOpen}
31
    />,
32
  );
33
}

6
function Filter({
7
  checked,
8
  className,
9
  dispatch,
10
  name,
11
  submitOnClick,
12
  text,
13
  value,
14
}) {
15
  function getClassNames() {
16
    return classnames('Filter__radio', className);
17
  }
18
19
  function handleOnClick() {
20
    setTimeout(() => dispatch(submit('form')), 50);
21
  }
22
23
  return (
24
    <label className={classnames('Filter', className)}>
25
      <Field
26
        name={name}
27
        type="radio"
28
        value={value}
29
        component={({ input, meta }) => {
30
          return (
31
            <input
32
              checked={checked}
33
              className={getClassNames()}
34
              onClick={submitOnClick && handleOnClick}
35
              type="radio"
36
              {...input}
37
            />
38
          );
39
        }}
40
      />
41
      <span className={'Filter__text'}>{text}</span>
42
    </label>
43
  );
44
}