@citation-js/plugin-isbn/lib/open-library.js

Citation.js plugin to fetch ISBN metadata

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.format = format;
exports.parse = parse;
var _core = require("@citation-js/core");
var name = _interopRequireWildcard(require("@citation-js/name"));
var date = _interopRequireWildcard(require("@citation-js/date"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
const CONVERT_ARRAY_OF_OBJECTS = {
  toTarget: ([{
    name
  }]) => name,
  toSource: name => [{
    name
  }]
};
const OL_PROPS = [{
  target: 'type',
  convert: {
    toTarget: () => 'book'
  }
}, {
  source: 'authors',
  target: 'author',
  convert: {
    toTarget(authors) {
      return authors.map(({
        name: author,
        url
      }) => {
        author = name.parse(author);
        author._url = url;
        return author;
      });
    },
    toSource: authors => authors.map(author => ({
      name: name.format(author)
    }))
  }
}, {
  source: 'identifiers',
  target: ['ISBN', 'ISSN', 'DOI', 'PMID', 'PMCID'],
  convert: {
    toTarget: identifiers => identifiers.isbn_13 || identifiers.isbn_10,
    toSource(...identifiers) {
      const ids = [identifiers[0] && `isbn_${identifiers[0].length}`, 'issn', 'doi', 'pmid', 'pmcid'];
      return identifiers.reduce((acc, id, i) => {
        if (id) {
          acc[ids[i]] = id;
        }
        return acc;
      }, {});
    }
  }
}, {
  source: 'number_of_pages',
  target: 'number-of-pages'
}, {
  source: 'publishers',
  target: 'publisher',
  convert: CONVERT_ARRAY_OF_OBJECTS
}, {
  source: 'publish_date',
  target: 'issued',
  convert: {
    toTarget: date.parse,
    toSource: date.format
  }
}, {
  source: 'publish_places',
  target: 'publisher-place',
  convert: CONVERT_ARRAY_OF_OBJECTS
}, {
  source: ['subjects', 'subject_places', 'subject_people', 'subject_times'],
  target: 'keyword',
  convert: {
    toTarget: (...subjects) => [].concat(...subjects).filter(Boolean).map(({
      name
    }) => name).join(),
    toSource: keywords => [keywords.split(',').map(name => ({
      name,
      url: 'https://openlibrary.org/subjects/' + name.toLowerCase().replace(/\W+/g, '_')
    }))]
  }
}, 'title', {
  source: 'url',
  target: 'URL'
}];
const translator = new _core.util.Translator(OL_PROPS);
function parse(response) {
  return Object.keys(response).map(id => {
    return translator.convertToTarget(response[id]);
  });
}
function format(records) {
  const output = {};
  var _iterator = _createForOfIteratorHelper(records),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      const record = _step.value;
      if (!record.ISBN) {
        output[`ISBN:${record.ISBN}`] = translator.convertToSource(record);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return output;
}