_resolveScaleType()

in src/utils/resolveXYScales.js [134:232]
79 lines of code
22 McCabe index (conditional complexity)

    _resolveScaleType(props, Component) {
      let { xScaleType, yScaleType } = props;

      const isDone = () => areValidScaleTypes([xScaleType, yScaleType]);

      // short-circuit if both scale types provided
      if (isDone()) return { xScaleType, yScaleType };

      // if Component provides a custom static getScaleType method
      // use it to determine remaining scale types
      if (isFunction(Component.getScaleType)) {
        const componentScaleTypes = omitNullUndefined(
          Component.getScaleType(props),
        );
        ({ xScaleType, yScaleType } = Object.assign(
          componentScaleTypes,
          omitNullUndefined({ xScaleType, yScaleType }),
        ));
        if (isDone()) return { xScaleType, yScaleType };
      }

      // if component has domain props,
      // infer the data type, & use that to get scale type
      if (!isValidScaleType(xScaleType) && isValidDomain(props.xDomain)) {
        xScaleType = scaleTypeFromDataType(
          inferDataTypeFromDomain(props.xDomain),
        );
      }
      if (!isValidScaleType(yScaleType) && isValidDomain(props.yDomain)) {
        yScaleType = scaleTypeFromDataType(
          inferDataTypeFromDomain(props.yDomain),
        );
      }
      if (isDone()) return { xScaleType, yScaleType };

      // if Component has data or datasets props,
      // infer the data type, & use that to get scale type
      if (Array.isArray(props.data) || Array.isArray(props.datasets)) {
        const datasets = Array.isArray(props.datasets)
          ? props.datasets
          : [props.data];

        if (!isValidScaleType(xScaleType)) {
          xScaleType = scaleTypeFromDataType(
            inferDatasetsType(datasets, makeAccessor2(props.x)),
          );
        }
        if (!isValidScaleType(yScaleType)) {
          yScaleType = scaleTypeFromDataType(
            inferDatasetsType(datasets, makeAccessor2(props.y)),
          );
        }
        if (isDone()) return { xScaleType, yScaleType };
      }

      // if Component has children,
      // recurse through descendants to resolve their scale types the same way
      if (React.Children.count(props.children)) {
        const childrenScaleTypes = mapOverChildren(
          props.children,
          this._resolveScaleType.bind(this),
        );

        if (!isValidScaleType(xScaleType)) {
          const childXScaleTypes = compact(
            uniq(
              childrenScaleTypes.map(
                childScaleTypes => childScaleTypes.xScaleType,
              ),
            ),
          );
          if (!childXScaleTypes.length === 1)
            console.warn(
              "Multiple children with different X scale types found - defaulting to 'ordinal'",
            );
          xScaleType =
            childXScaleTypes.length === 1 ? childXScaleTypes[0] : 'ordinal';
        }
        if (!isValidScaleType(yScaleType)) {
          const childYScaleTypes = compact(
            uniq(
              childrenScaleTypes.map(
                childScaleTypes => childScaleTypes.yScaleType,
              ),
            ),
          );
          if (!childYScaleTypes.length === 1)
            console.warn(
              "Multiple children with different Y scale types found - defaulting to 'ordinal'",
            );
          yScaleType =
            childYScaleTypes.length === 1 ? childYScaleTypes[0] : 'ordinal';
        }
      }

      // if(!isDone()) console.warn(`resolveXYScales was unable to resolve both scale types. xScaleType: ${xScaleType}, yScaleType: ${yScaleType}`);

      return { xScaleType, yScaleType };
    }