gatsby-transformer-remark-plaintext/extend-node-type.js

Creates a new graphql field `plainText` on every MarkdownRemark node

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

const Remark = require(`remark`);

const strip = require(`strip-markdown`);

const _require = require(`gatsby/graphql`),
      GraphQLString = _require.GraphQLString;

const Promise = require(`bluebird`);

let pathPrefixCacheStr = ``;

const plainTextCacheKey = node => `transformer-remark-markdown-plaintext-${node.internal.contentDigest}-${pathPrefixCacheStr}`;

module.exports = ({
  type,
  pathPrefix,
  cache
}) => {
  if (type.name !== `MarkdownRemark`) {
    return {};
  }

  pathPrefixCacheStr = pathPrefix || ``;
  return new Promise((resolve, reject) => {
    function getPlainText(_x) {
      return _getPlainText.apply(this, arguments);
    }

    function _getPlainText() {
      _getPlainText = (0, _asyncToGenerator2.default)(function* (markdownNode) {
        const cacheKey = plainTextCacheKey(markdownNode);
        let plainText = yield cache.get(cacheKey);

        if (typeof plainText === 'undefined') {
          plainText = ``;

          if (markdownNode.rawMarkdownBody) {
            try {
              const result = yield Remark().use(strip).process(markdownNode.rawMarkdownBody);
              plainText = result.contents && String(result.contents) || String(result);
              cache.set(cacheKey, plainText);
            } catch (e) {}
          }
        }

        return plainText;
      });
      return _getPlainText.apply(this, arguments);
    }

    return resolve({
      plainText: {
        type: GraphQLString,

        resolve(markdownNode) {
          return getPlainText(markdownNode);
        }

      }
    });
  });
};