@retorquere/bibtex-parser 8.0.5 → 8.0.7

package/index.d.ts

@@ -1,7 +1,43 @@
 import { Node } from '@unified-latex/unified-latex-types';
 import * as bibtex from './verbatim';
 import * as JabRef from './jabref';
+export { JabRefMetadata } from './jabref';
 export { toSentenceCase } from './sentence-case';
+type CreatorFields = {
+    author?: Creator[];
+    bookauthor?: Creator[];
+    collaborator?: Creator[];
+    commentator?: Creator[];
+    director?: Creator[];
+    editor?: Creator[];
+    editora?: Creator[];
+    editorb?: Creator[];
+    editors?: Creator[];
+    holder?: Creator[];
+    scriptwriter?: Creator[];
+    translator?: Creator[];
+};
+type ArrayFields = {
+    keywords?: string[];
+    institution?: string[];
+    publisher?: string[];
+    origpublisher?: string[];
+    organization?: string[];
+    location?: string[];
+    origlocation?: string[];
+};
+type NumberFields = {
+    year?: number | string;
+    month?: number | string;
+};
+type TypedFields = CreatorFields & ArrayFields & NumberFields;
+type Fields = TypedFields & Omit<Record<string, string>, keyof TypedFields>;
+export type Entry = {
+    type: string;
+    key: string;
+    fields: Fields;
+    input: string;
+};
 export interface Bibliography {
     /**
      * errors found while parsing
@@ -134,38 +170,11 @@ export interface Creator {
     useprefix?: boolean;
     juniorcomma?: boolean;
 }
-export interface Entry {
-    type: string;
-    key: string;
-    fields: {
-        author?: Creator[];
-        bookauthor?: Creator[];
-        collaborator?: Creator[];
-        commentator?: Creator[];
-        director?: Creator[];
-        editor?: Creator[];
-        editora?: Creator[];
-        editorb?: Creator[];
-        editors?: Creator[];
-        holder?: Creator[];
-        scriptwriter?: Creator[];
-        translator?: Creator[];
-        keywords?: string[];
-        institution?: string[];
-        publisher?: string[];
-        origpublisher?: string[];
-        organization?: string[];
-        location?: string[];
-        origlocation?: string[];
-        [key: string]: number | string | string[] | Creator[];
-    };
-}
 export declare const FieldMode: {
     creator: string[];
     title: string[];
     verbatim: (string | RegExp)[];
     richtext: string[];
-    commalist: string[];
     literallist: string[];
 };
 type ParseMode = keyof typeof FieldMode | 'literal';

package/index.js

@@ -76,6 +76,31 @@ for (const tag of ['i', 'b', 'sc', 'nc', 'ncx', 'br', 'p', 'li', 'code']) {
     close[tag] = `\x0E/${tag}\x0F`;
 }
 const collapsable = /\x0E\/([a-z]+)\x0F(\s*)\x0E\1\x0F/ig;
+const Month = {
+    jan: 1,
+    january: 1,
+    feb: 2,
+    february: 2,
+    mar: 3,
+    march: 3,
+    apr: 4,
+    april: 4,
+    may: 5,
+    jun: 6,
+    june: 6,
+    jul: 7,
+    july: 7,
+    aug: 8,
+    august: 8,
+    sep: 9,
+    september: 9,
+    oct: 10,
+    october: 10,
+    nov: 11,
+    november: 11,
+    dec: 12,
+    december: 12,
+};
 exports.FieldMode = {
     creator: [
         'author',
@@ -114,6 +139,7 @@ exports.FieldMode = {
         'verba',
         'verbb',
         'verbc',
+        /^keywords([+]duplicate-\d+)?$/,
         /^citeulike-linkout-[0-9]+$/,
         /^bdsk-url-[0-9]+$/,
     ],
@@ -125,9 +151,6 @@ exports.FieldMode = {
         'notes',
         'note',
     ],
-    commalist: [
-        'keywords',
-    ],
     literallist: [
         'institution',
         'publisher',
@@ -250,6 +273,7 @@ function asyncGenerator(array) {
 class BibTeXParser {
     constructor() {
         this.newcommands = {};
+        this.unhandled = new Set;
     }
     split(ast, sep, split) {
         const roots = [];
@@ -412,19 +436,30 @@ class BibTeXParser {
     }
     unsupported(node) {
         var _a;
+        const tex = (0, unified_latex_util_print_raw_1.printRaw)(node);
         if (this.fallback)
-            return (_a = this.fallback(node, (0, unified_latex_util_print_raw_1.printRaw)(node), this.current)) !== null && _a !== void 0 ? _a : '';
+            return (_a = this.fallback(node, tex, this.current)) !== null && _a !== void 0 ? _a : '';
+        let id;
         switch (node.type) {
             case 'macro':
-                this.bib.errors.push({ error: `unhandled ${node.type} ${node.content} (${(0, unified_latex_util_print_raw_1.printRaw)(node)})`, input: (0, unified_latex_util_print_raw_1.printRaw)(node) });
+                id = `${node.type}.${node.content}`;
+                if (!this.unhandled.has(id)) {
+                    this.unhandled.add(id);
+                    this.bib.errors.push({ error: `unhandled ${node.type} ${(0, unified_latex_util_print_raw_1.printRaw)(node)}`, input: (0, unified_latex_util_print_raw_1.printRaw)(node) });
+                }
                 break;
             case 'environment':
-                this.bib.errors.push({ error: `unhandled ${node.type} ${node.env} (${(0, unified_latex_util_print_raw_1.printRaw)(node)})`, input: (0, unified_latex_util_print_raw_1.printRaw)(node) });
+                id = `${node.type}.${node.env}`;
+                if (!this.unhandled.has(id)) {
+                    this.unhandled.add(id);
+                    this.bib.errors.push({ error: `unhandled ${node.type} ${node.env} (${(0, unified_latex_util_print_raw_1.printRaw)(node)})`, input: (0, unified_latex_util_print_raw_1.printRaw)(node) });
+                }
                 break;
             default:
                 this.bib.errors.push({ error: `unhandled ${node.type} (${(0, unified_latex_util_print_raw_1.printRaw)(node)})`, input: (0, unified_latex_util_print_raw_1.printRaw)(node) });
                 break;
         }
+        return tex;
     }
     wrap(text, tag, wrap = true) {
         if (!text || !wrap)
@@ -878,15 +913,16 @@ class BibTeXParser {
         });
         switch (mode) {
             case 'creator':
-                entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map(cr => this.parseCreator(cr)).filter(cr => Object.keys(cr).length);
-                break;
-            case 'commalist':
-                entry.fields[field] = this.split(ast, /^[;,]$/, /(&)/).map(elt => this.stringify(elt, { mode: 'literal' }).trim());
+                entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/)
+                    .map(cr => this.parseCreator(cr))
+                    .filter(cr => Object.keys(cr).length); // pacify typescript
                 break;
             case 'literallist':
-                entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map(elt => this.stringify(elt, { mode: 'literal' }).trim());
+                entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/)
+                    .map(elt => this.stringify(elt, { mode: 'literal' }).trim()); // pacify typescript
                 break;
             default:
+                // can be number or string, but typescript cannot know this
                 entry.fields[field] = this.stringField(field, this.stringify(ast, { mode }), sentenceCase, mode);
                 break;
         }
@@ -937,31 +973,41 @@ class BibTeXParser {
             jabref: null,
         };
     }
-    reparse(entry) {
-        let langid = (entry.fields.langid || entry.fields.hyphenation || '').toLowerCase();
-        if (!langid && this.options.sentenceCase.language && entry.fields.language)
-            langid = entry.fields.language.toLowerCase();
+    reparse(verbatim) {
+        let langid = (verbatim.fields.langid || verbatim.fields.hyphenation || '').toLowerCase();
+        if (!langid && this.options.sentenceCase.language && verbatim.fields.language)
+            langid = verbatim.fields.language.toLowerCase();
         const sentenceCase = this.options.sentenceCase.langids.includes(langid);
-        this.current = entry;
+        const entry = this.current = {
+            type: verbatim.type,
+            key: verbatim.key,
+            fields: {},
+            input: verbatim.input,
+        };
         let keywords = []; // OMG #783
         try {
-            for (const [field, value] of Object.entries(entry.fields)) {
-                if (!value.trim()) {
-                    delete entry.fields[field];
+            for (let [field, value] of Object.entries(verbatim.fields)) {
+                if (!value.trim())
                     continue;
-                }
-                if (this.options.raw)
+                if (this.options.raw) {
+                    entry.fields[field] = value.trim();
                     continue;
+                }
+                if (field.match(/^keywords([+]duplicate-\d+)?$/))
+                    field = 'keywords'; // #873
                 this.field(entry, field, value, sentenceCase);
-                if (field.match(/^keywords\[\d+\]$/)) {
-                    keywords = [...keywords, entry.fields[field]];
-                    delete entry.fields[field];
+                if (field === 'keywords') { // #873
+                    keywords = [...keywords, ...entry.fields.keywords.split(/\s*[,;]\s*/)].map((k) => k.trim()).filter(k => k);
+                    delete entry.fields.keywords;
                 }
-                if (typeof entry.fields[field] === 'string')
+                if (typeof entry.fields[field] === 'string') {
                     entry.fields[field] = entry.fields[field].trim();
+                    if (field === 'month')
+                        entry.fields[field] = Month[entry.fields[field].toLowerCase()] || entry.fields[field];
+                }
             }
             if (keywords.length)
-                entry.fields.keywords = [...(new Set([...(entry.fields.keywords || []), ...keywords]))].sort();
+                entry.fields.keywords = [...(new Set(keywords))].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
             this.bib.entries.push(entry);
         }
         catch (err) {
@@ -969,7 +1015,7 @@ class BibTeXParser {
         }
     }
     content(tex) {
-        const entry = { key: '', type: '', fields: {} };
+        const entry = { key: '', type: '', fields: {}, input: tex };
         this.field(entry, 'tex', tex, false);
         return entry.fields.tex;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "8.0.5",
+  "version": "8.0.7",
   "description": "BibTeX parser",
   "main": "index.js",
   "typings": "./index.d.ts",

package/verbatim.d.ts

@@ -34,7 +34,6 @@ declare class Parser {
     private linebreaks;
     private input;
     private max_entries;
-    private keywords;
     constructor(input: string, options?: ParserOptions);
     parse(): void;
     parseAsync(): Promise<void>;

package/verbatim.js

@@ -85,7 +85,6 @@ class Parser {
         this.max_entries = options.max_entries || 0;
         this.input = input;
         this.parsing = null;
-        this.keywords = 0;
         if (typeof options.strings === 'string') {
             this.input = options.strings + '\n' + input; // eslint-disable-line prefer-template
         }
@@ -271,10 +270,10 @@ class Parser {
             this.strings[key.toUpperCase()] = val;
         }
         else {
-            key = key.toLowerCase();
-            if (key.toLowerCase() === 'keywords' && this.entries[0].fields.keywords) { // #873... the things people do with bibtex
-                this.keywords++;
-                key = `keywords[${this.keywords}]`;
+            const bare = key.toLowerCase();
+            let postfix = 0;
+            while (typeof this.entries[0].fields[key = (postfix ? `${bare}+duplicate-${postfix}` : bare)] === 'string') {
+                postfix++;
             }
             this.entries[0].fields[key] = val;
         }