gatsby-plugin-excerpts/gatsby-node.js

A powerful way to extract excerpts from content

"use strict";

var __extends = void 0 && (void 0).__extends || function () {
  var extendStatics = function (d, b) {
    extendStatics = Object.setPrototypeOf || {
      __proto__: []
    } instanceof Array && function (d, b) {
      d.__proto__ = b;
    } || function (d, b) {
      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    };

    return extendStatics(d, b);
  };

  return function (d, b) {
    extendStatics(d, b);

    function __() {
      this.constructor = d;
    }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
}();

var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }

    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }

    function step(result) {
      result.done ? resolve(result.value) : new P(function (resolve) {
        resolve(result.value);
      }).then(fulfilled, rejected);
    }

    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};

var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
  var _ = {
    label: 0,
    sent: function () {
      if (t[0] & 1) throw t[1];
      return t[1];
    },
    trys: [],
    ops: []
  },
      f,
      y,
      t,
      g;
  return g = {
    next: verb(0),
    "throw": verb(1),
    "return": verb(2)
  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
    return this;
  }), g;

  function verb(n) {
    return function (v) {
      return step([n, v]);
    };
  }

  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");

    while (_) try {
      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
      if (y = 0, t) op = [op[0] & 2, t.value];

      switch (op[0]) {
        case 0:
        case 1:
          t = op;
          break;

        case 4:
          _.label++;
          return {
            value: op[1],
            done: false
          };

        case 5:
          _.label++;
          y = op[1];
          op = [0];
          continue;

        case 7:
          op = _.ops.pop();

          _.trys.pop();

          continue;

        default:
          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
            _ = 0;
            continue;
          }

          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
            _.label = op[1];
            break;
          }

          if (op[0] === 6 && _.label < t[1]) {
            _.label = t[1];
            t = op;
            break;
          }

          if (t && _.label < t[2]) {
            _.label = t[2];

            _.ops.push(op);

            break;
          }

          if (t[2]) _.ops.pop();

          _.trys.pop();

          continue;
      }

      op = body.call(thisArg, _);
    } catch (e) {
      op = [6, e];
      y = 0;
    } finally {
      f = t = 0;
    }

    if (op[0] & 5) throw op[1];
    return {
      value: op[0] ? op[1] : void 0,
      done: true
    };
  }
};

var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
  return mod && mod.__esModule ? mod : {
    "default": mod
  };
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

var graphql_1 = require("gatsby/graphql");

var cheerio_1 = __importDefault(require("cheerio"));

var truncate_html_1 = __importDefault(require("truncate-html"));

var config = {
  sources: {},
  sourceSets: {},
  excerpts: {}
};

function onPreInit(_, configuration) {
  config = configuration;
}

exports.onPreInit = onPreInit;

var SourceType =
/** @class */
function () {
  function SourceType(settings) {}

  return SourceType;
}();

var HtmlQuery =
/** @class */
function (_super) {
  __extends(HtmlQuery, _super);

  function HtmlQuery(settings) {
    var _this = _super.call(this, settings) || this;

    _this.outputConverters = {
      html: function (o) {
        return o.html();
      },
      text: function (o) {
        return o.text();
      }
    };
    _this.settings = settings;
    return _this;
  }

  HtmlQuery.prototype.search = function (fieldContents) {
    var $ = cheerio_1.default.load(fieldContents);
    var $outputContainer = $("<div>");
    $(this.settings.excerptSelector).appendTo($outputContainer);
    $outputContainer.find(this.settings.ignoreSelector).remove();
    $outputContainer.find(this.settings.stripSelector).each(function (index, element) {
      var $element = $(element);
      $element.replaceWith(element.childNodes);
    });
    this.settings.elementReplacements.forEach(function (replacement) {
      $outputContainer.find(replacement.selector).each(function (index, element) {
        element.tagName = replacement.replaceWith;
      });
    });

    if ($outputContainer.children().length < 1) {
      return null;
    }

    if (this.settings.truncate) {
      return cheerio_1.default.load(truncate_html_1.default($outputContainer.html(), this.settings.truncate)).root();
    } else {
      return $outputContainer;
    }

    ;
  };

  return HtmlQuery;
}(SourceType);

var excerptSourceTypes = {
  htmlQuery: HtmlQuery
};

function getExcerpt(excerptName, nodeType, node, info, ctx) {
  return __awaiter(this, void 0, void 0, function () {
    var excerptSettings, sourceSetName, sourceSet, err, fieldCache, i, sourceName, source, err, _a, _b, ex_1, sourceFieldValue, searcher, results;

    return __generator(this, function (_c) {
      switch (_c.label) {
        case 0:
          excerptSettings = config.excerpts[excerptName];
          sourceSetName = excerptSettings.nodeTypeSourceSet[nodeType] || excerptSettings.nodeTypeSourceSet["*"];
          sourceSet = config.sourceSets[sourceSetName];

          if (!sourceSet) {
            err = "[gatsby-plugin-excerpts] Source Set " + sourceSetName + " is referenced by excerpt " + excerptName + " but does not exist.";
            console.error(err);
            throw new Error(err);
          }

          fieldCache = {};
          i = 0;
          _c.label = 1;

        case 1:
          if (!(i < sourceSet.length)) return [3
          /*break*/
          , 11];
          sourceName = sourceSet[i];
          source = config.sources[sourceName];

          if (!source) {
            err = "[gatsby-plugin-excerpts] Source " + sourceName + " is referenced by Source Set " + sourceSetName + " but does not exist.";
            console.error(err);
            throw new Error(err);
          }

          if (!!fieldCache[source.sourceField]) return [3
          /*break*/
          , 9];
          if (!info.parentType._fields[source.sourceField]) return [3
          /*break*/
          , 8];
          _c.label = 2;

        case 2:
          _c.trys.push([2, 6,, 7]);

          if (!info.parentType._fields[source.sourceField].resolve) return [3
          /*break*/
          , 4];
          _a = fieldCache;
          _b = source.sourceField;
          return [4
          /*yield*/
          , Promise.resolve(info.parentType._fields[source.sourceField].resolve.call(this, node, {}, ctx, info))];

        case 3:
          _a[_b] = _c.sent();
          return [3
          /*break*/
          , 5];

        case 4:
          fieldCache[source.sourceField] = node[source.sourceField];
          _c.label = 5;

        case 5:
          return [3
          /*break*/
          , 7];

        case 6:
          ex_1 = _c.sent();
          console.warn("[gatsby-plugin-excerpts] Failed to retrieve field", source.sourceField, "for source", sourceName, "on node", JSON.stringify(node), ". Error: ", ex_1);
          return [3
          /*break*/
          , 7];

        case 7:
          return [3
          /*break*/
          , 9];

        case 8:
          console.log("[gatsby-plugin-excerpts] Attempted to retrieve non-existent field", source.sourceField, "for source", sourceName, "in excerpt", excerptName, "with node of type", nodeType, ". Ignoring.");
          _c.label = 9;

        case 9:
          sourceFieldValue = fieldCache[source.sourceField];

          if (sourceFieldValue !== undefined) {
            searcher = new excerptSourceTypes[source.type](source);
            results = searcher.search(sourceFieldValue);

            if (results) {
              return [2
              /*return*/
              , searcher.outputConverters[excerptSettings.type](results)];
            }
          }

          _c.label = 10;

        case 10:
          i++;
          return [3
          /*break*/
          , 1];

        case 11:
          return [2
          /*return*/
          ];
      }
    });
  });
}

;

function setFieldsOnGraphQLNodeType(_a) {
  var type = _a.type;
  return __awaiter(this, void 0, void 0, function () {
    var fields, _loop_1, excerptName;

    return __generator(this, function (_b) {
      fields = {};

      _loop_1 = function (excerptName) {
        var excerpt = config.excerpts[excerptName];
        var sourceSetName = excerpt.nodeTypeSourceSet[type.name] || excerpt.nodeTypeSourceSet["*"];

        if (sourceSetName) {
          fields[excerptName] = {
            type: graphql_1.GraphQLString,
            resolve: function (node, args, ctx, info) {
              return getExcerpt(excerptName, type.name, node, info, ctx);
            }
          };
        }
      };

      for (excerptName in config.excerpts) {
        _loop_1(excerptName);
      }

      return [2
      /*return*/
      , fields];
    });
  });
}

exports.setFieldsOnGraphQLNodeType = setFieldsOnGraphQLNodeType;