TypeScript ramda.prop函數代碼示例

export function list(address: string, limit = 100): Promise<Array<T_TX>> {
    return request({ url: `${configGet('node')}/transactions/address/${address}/limit/${limit}` })
        .then(pipe(
            prop('0'),
            uniqBy(prop('id')) as any,
        ))
        .then(transactions => parseTx(transactions as any, false));
}

export const pageDTO = (page: Page): PageDTO => {
  const translations = R.map(
    R.prop('value'),
    R.indexBy(R.prop('field'), page.translations),
  );

  return {
    alias: page.alias,
    title: translations.title,
    content: translations.content,
  }
}

  /**
   * Return a sorted array of records
   *
   * Example:
   *
   * ```
   * res = (res) ? Array.sort('invoiceCode', 'number', 'desc', res) : undefined;
   * ```
   */
  static sort(prop, type, order = 'asc', array) {
    const sortBy = R.sortBy(R.prop(prop));

    if ('string' === type) {
      const sortBy = R.sortBy(R.compose(R.toLower, R.prop(prop)));
    }

    if (order === 'desc') {
      return R.reverse(sortBy(array));
    }

    return sortBy(array);
  }

export const associationDecorator = ({ modelName, fields }: { modelName: string; fields }) => {
  const TAG = '[associationDecorator]';
  logger.log(TAG, { fields });

  // prettier-ignore
  const associationFields = R.filter(R.compose(R.not, R.isNil, R.prop('associations')))(fields);
  logger.log(TAG, { associationFields }, R.not(R.isEmpty(associationFields)));
  if (R.not(R.isEmpty(associationFields))) {
    const wrapForeignOpt = R.map(opt => ({
      ...opt,
      association: AppContext.adapters.models.getAssociationConfigs(opt.modelName),
    }));
    const withAssociations = R.mapObjIndexed(field => ({
      ...field,
      foreignOpts: wrapForeignOpt(field.foreignOpts),
    }))(associationFields);
    logger.debug(TAG, { withAssociations, wrapForeignOpt });

    const wrappedFields = R.mergeDeepRight(fields, withAssociations);
    logger.debug(TAG, { wrappedFields });

    return { modelName, fields: wrappedFields };
  }

  return { modelName, fields };
};

const extractItemsBy = primaryKey =>
  R.compose(
    R.uniqBy(R.prop(primaryKey)),
    R.flatten,
    R.map(R.path(['data', 'items'])),
    R.flatten,
  );

export const categoryDTO = (category: Category): CategoryDTO => {
  const translations = R.map(
    R.prop('value'),
    R.indexBy(R.prop('field'), category.translations),
  );
  const children = category.children || [];

  return {
    name: category.name,
    date: category.date,
    title: translations.title,
    featured: category.featured && category.featured.src,
    description: translations.description,
    children: children.map(categoryDTO),
  }
}

export const photoDTO = (photo: Photo): PhotoDTO => {
  const translations = R.map(
    R.prop('value'),
    R.indexBy(R.prop('field'), photo.translations),
  );

  return {
    src: photo.src,
    views: photo.views,
    width: photo.width,
    height: photo.height,
    group: photo.group,
    datetime: photo.datetime,
    description: translations.description,
  }
}

const excludeUnique = xs => {
    const primary = 'xmlUrl';

    const keyCounts = countBy(identity, (xs.map(prop(primary))));

    // console.log({keyCounts});

    const keyCount = flip(prop)(keyCounts);

    const notUnique = compose(
        lt(1),
        keyCount,
        prop(primary)
    );

    return filter(notUnique, xs)
};

/** returns list of detected browsers */
function detectBrowsers(): Bluebird<Browser[]> {
  // we can detect same browser under different aliases
  // tell them apart by the full version property
  const removeDuplicates = uniqBy(prop('version'))
  return Bluebird.mapSeries(browsers, checkOneBrowser)
    .then(_.compact)
    .then(removeDuplicates) as Bluebird<Browser[]>
}

export default async () => {
  const pages = await fetch(`${host}${basename}/page`, options).then(res => res.json());

  const pages$ = await Promise.all(
    pages.map((page: any) => fetch(
      `${host}${basename}/page/${page.alias}`,
      options,
    )
    .then(res => res.json())
    )
  );

  const categories = await fetch(`${host}${basename}/category`, options).then(res => res.json());

  const categories$ = await Promise.all(
    categories.map((category: any) => fetch(
      `${host}${basename}/category/${category.name}`,
      options,
    )
    .then(res => res.json())
    .catch(e=> {
      console.log(e);
    })
    )
  );

  const photos = await Promise.all(
    categories.map((category: any) => fetch(
      `${host}${basename}/category/${category.name}/photo`,
      options,
    )
    .then(res => res.json())
    .catch(() => [])
    .then(photos => photos.map((photo: any) => ({
      ...photo,
      category: category.name,
    })))
    )
  );

  const photos$ = R.pipe(
    R.unnest,
    R.groupBy(R.prop('id')),
    // @ts-ignore
    R.map((photoList: Photo[]) => ({
      ...R.head(photoList),
      category: R.map(R.prop('category'), photoList)
    })),
    R.values,
  )(photos);

  return {
    pages: pages$.filter(Boolean),
    categories: categories$.filter(Boolean),
    photos: photos$.filter(Boolean),
  } as any;
};