name: selectLocalizedContent()

in src/amo/reducers/versions.js [144:262]

• 79 lines of code
• 5 McCabe index (conditional complexity)

          name: selectLocalizedContent(version.license.name, lang),
          text:
            version.license.text === undefined
              ? undefined
              : selectLocalizedContent(version.license.text, lang),
          url: version.license.url,
        }
      : null,
    file: version.file,
    releaseNotes: selectLocalizedContent(version.release_notes, lang),
    version: version.version,
  };
};

type FetchVersionParams = {|
  errorHandlerId: string,
  slug: string,
  versionId: VersionIdType,
|};

export type FetchVersionAction = {|
  type: typeof FETCH_VERSION,
  payload: FetchVersionParams,
|};

export const fetchVersion = ({
  errorHandlerId,
  slug,
  versionId,
}: FetchVersionParams): FetchVersionAction => {
  invariant(errorHandlerId, 'errorHandlerId is required');
  invariant(slug, 'slug is required');
  invariant(versionId, 'versionId is required');

  return {
    type: FETCH_VERSION,
    payload: { errorHandlerId, slug, versionId },
  };
};

type FetchVersionsParams = {|
  errorHandlerId: string,
  page?: string,
  slug: string,
|};

export type FetchVersionsAction = {|
  type: typeof FETCH_VERSIONS,
  payload: FetchVersionsParams,
|};

export const fetchVersions = ({
  errorHandlerId,
  page = '1',
  slug,
}: FetchVersionsParams): FetchVersionsAction => {
  invariant(errorHandlerId, 'errorHandlerId is required');
  invariant(slug, 'slug is required');

  return {
    type: FETCH_VERSIONS,
    payload: { errorHandlerId, page, slug },
  };
};

type LoadVersionsParams = {|
  slug: string,
  versions: Array<ExternalAddonVersionType>,
|};

type LoadVersionsAction = {|
  type: typeof LOAD_VERSIONS,
  payload: LoadVersionsParams,
|};

export const loadVersions = ({
  slug,
  versions,
}: LoadVersionsParams): LoadVersionsAction => {
  invariant(slug, 'slug is required');
  invariant(versions, 'versions is required');

  return {
    type: LOAD_VERSIONS,
    payload: { slug, versions },
  };
};

type GetVersionByIdParams = {|
  id: VersionIdType,
  state: VersionsState,
|};

export const getVersionById = ({
  id,
  state,
}: GetVersionByIdParams): AddonVersionType | null => {
  invariant(id, 'id is required');
  invariant(state, 'state is required');

  const version = state.byId[id];
  return version || null;
};

type GetBySlugParams = {|
  slug: string,
  state: VersionsState,
|};

export const getVersionsBySlug = ({
  slug,
  state,
}: GetBySlugParams): Array<AddonVersionType> | null => {
  invariant(slug, 'slug is required');
  invariant(state, 'state is required');

  const infoForSlug = state.bySlug[slug];
  if (infoForSlug && infoForSlug.versionIds) {
    return infoForSlug.versionIds.map((versionId) => {