astrocite-bibtex
Version:
Parser and AST for converting BibTeX to CSL JSON
213 lines (212 loc) • 7.7 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
var astrocite_core_1 = require("astrocite-core");
var _1 = require("./");
var constants_1 = require("./constants");
var curriedDate = function () { return function (first) {
if (first === void 0) { first = { value: '' }; }
return function (second) {
if (second === void 0) { second = { value: '' }; }
if (!first.kind)
return;
return first.kind === 'year'
? { issued: { 'date-parts': [[first.value, second.value, '']] } }
: { issued: { 'date-parts': [[second.value, first.value, '']] } };
};
}; };
function parseArgument(arg, macros) {
switch (arg.kind) {
case 'OptionalArgument':
return arg.value;
case 'RequiredArgument':
return parseValue(arg.value, macros);
break;
default:
return '';
}
}
function parseRegularCommand(cmd, macros) {
switch (cmd.value) {
case 'url':
return cmd.arguments
.map(function (arg) { return parseArgument(arg, macros); })
.join('');
case 'emph':
return ('<i>' +
cmd.arguments.map(function (arg) { return parseArgument(arg, macros); }).join('') +
'</i>');
default:
return constants_1.KNOWN_COMMANDS.get(cmd.value) || '';
}
}
var parseValue = function (value, macros) {
var e_1, _a;
var output = '';
var input = Array.isArray(value) ? value : [value];
try {
for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
var v = input_1_1.value;
switch (v.kind) {
case 'Text':
case 'Number':
output += v.value;
break;
case 'String':
output += macros.get(v.value) || '';
break;
case 'NestedLiteral':
output += parseValue(v.value, macros);
break;
case 'RegularCommand':
output += parseRegularCommand(v, macros);
break;
case 'SymbolCommand':
output += "" + (constants_1.KNOWN_COMMANDS.get(v.value) || '');
break;
case 'DicraticalCommand':
output += "" + v.character + constants_1.DICRATICS.get(v.mark);
break;
case 'SuperscriptCommand':
case 'SubscriptCommand':
output += v.value;
break;
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
}
finally { if (e_1) throw e_1.error; }
}
return output;
};
var parseEntry = function (node, macros) {
var e_2, _a, _b, _c, _d;
var entry = {
id: node.id,
type: constants_1.TYPE_MAP.get(node.type) || 'article',
};
var date = curriedDate();
var keys = node.properties.map(function (property) { return property.key; });
try {
for (var _e = __values(node.properties), _f = _e.next(); !_f.done; _f = _e.next()) {
var property = _f.value;
switch (property.key) {
case 'year':
case 'month': {
date = date({
kind: property.key,
value: parseValue(property.value, macros),
});
break;
}
case 'author':
case 'editor': {
entry = __assign(__assign({}, entry), (_b = {}, _b[property.key] = parseValue(property.value, macros)
.split(/ and (?:others)?/g)
.filter(Boolean)
.map(astrocite_core_1.parseName), _b));
break;
}
case 'number': {
// map "number" to "issue" unless there's an "issue" field
var field = keys.includes('issue') ? 'number' : 'issue';
entry = __assign(__assign({}, entry), (_c = {}, _c[field] = parseValue(property.value, macros), _c));
break;
}
default: {
var field = constants_1.FIELD_MAP.get(property.key);
if (field) {
entry = __assign(__assign({}, entry), (_d = {}, _d[field] = parseValue(property.value, macros), _d));
}
break;
}
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
}
finally { if (e_2) throw e_2.error; }
}
while (typeof date === 'function') {
date = date();
}
return __assign(__assign({}, entry), (date ? date : {}));
};
function parseCSL(source) {
var e_3, _a;
var STRINGS_MAP = new Map(constants_1.KNOWN_MACROS);
var children = _1.AST.parse(source).children;
var csl = [];
try {
for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
var node = children_1_1.value;
switch (node.kind) {
case 'StringExpression':
STRINGS_MAP.set(node.key, parseValue(node.value, STRINGS_MAP));
break;
case 'Entry':
csl = __spread(csl, [parseEntry(node, STRINGS_MAP)]);
break;
default:
continue;
}
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
}
finally { if (e_3) throw e_3.error; }
}
return csl;
}
exports.default = parseCSL;