@retorquere/bibtex-parser 8.0.6 → 8.0.8

package/README.md

@@ -8,4 +8,4 @@ While parsing, the parser will apply markup for commands such as `\textbf`, `\te
 
 BibTeX is a reference management program that makes it easy for users of TeX and LaTeX to generate bibliographies for books and journal articles. When possible, it is usually stylized in the TeX font the way TeX and LaTeX are. LaTeX was first created in 1985 by Leslie Lamport and Oren Patashnik.
 
-Documenation is available at [http://retorque.re/bibtex-parser/](http://retorque.re/bibtex-parser/).
+Documenation is available at [https://retorque.re/bibtex-parser/](https://retorque.re/bibtex-parser/).

package/index.d.ts

@@ -2,7 +2,47 @@ import { Node } from '@unified-latex/unified-latex-types';
 import * as bibtex from './verbatim';
 import * as JabRef from './jabref';
 export { JabRefMetadata } from './jabref';
+export { ParseError } from './verbatim';
 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;
+    crossref?: {
+        inherited: string[];
+        donated: [];
+    };
+    input: string;
+};
 export interface Bibliography {
     /**
      * errors found while parsing
@@ -135,38 +175,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',
@@ -180,6 +203,9 @@ const FieldAction = {
         'year',
         'month',
     ],
+    noCrossRef: [
+        'file',
+    ],
 };
 const narguments = {
     advance: 1,
@@ -250,6 +276,7 @@ function asyncGenerator(array) {
 class BibTeXParser {
     constructor() {
         this.newcommands = {};
+        this.unhandled = new Set;
     }
     split(ast, sep, split) {
         const roots = [];
@@ -412,19 +439,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 +916,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 +976,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 +1018,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;
     }
@@ -1006,24 +1055,41 @@ class BibTeXParser {
                 if (!order.includes(key))
                     order.push(key);
             }
+            const add = (obj, kind, field) => {
+                obj[kind] = [...(new Set([...obj[kind], field]))].sort();
+            };
             for (const key of order) {
                 const child = entries[key.toUpperCase()];
                 const parent = entries[(_a = child.fields.crossref) === null || _a === void 0 ? void 0 : _a.toUpperCase()];
                 if (!parent)
                     continue;
+                child.crossref = child.crossref || { donated: [], inherited: [] };
+                parent.crossref = parent.crossref || { donated: [], inherited: [] };
                 for (const mappings of [crossref_json_1.default[child.type], crossref_json_1.default['*']].filter(m => m)) {
                     for (const mapping of [mappings[parent.type], mappings['*']].filter(m => m)) {
                         for (const [childfield, parentfield] of Object.entries(mapping)) {
-                            if (!child.fields[childfield] && parent.fields[parentfield])
+                            if (!child.fields[childfield] && parent.fields[parentfield]) {
                                 child.fields[childfield] = parent.fields[parentfield];
+                                add(child.crossref, 'inherited', childfield);
+                                add(parent.crossref, 'donated', parentfield);
+                            }
                         }
                         for (const field of (fields_json_1.default[child.type] || [])) {
-                            if (!child.fields[field] && parent.fields[field])
+                            if (FieldAction.noCrossRef.includes(field))
+                                continue;
+                            if (!child.fields[field] && parent.fields[field]) {
                                 child.fields[field] = parent.fields[field];
+                                add(child.crossref, 'inherited', field);
+                                add(parent.crossref, 'donated', field);
+                            }
                         }
                     }
                 }
             }
+            for (const entry of this.bib.entries) {
+                if (entry.crossref && !entry.crossref.donated.length && !entry.crossref.inherited.length)
+                    delete entry.crossref;
+            }
         }
         const { comments, jabref } = JabRef.parse(base.comments);
         this.bib.comments = comments;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "8.0.6",
+  "version": "8.0.8",
   "description": "BibTeX parser",
   "main": "index.js",
   "typings": "./index.d.ts",
@@ -9,24 +9,21 @@
     "lint": "eslint . --ext .ts --cache --cache-location .eslintcache/",
     "prestart": "npm run lint",
     "start": "npm run tsc",
-    "tsc": "peggy grammar.peggy && tsc -d",
+    "tsc": "tsc -d",
     "pretest": "npm start",
     "test": "tap --timeout 0 --disable-coverage --allow-empty-coverage",
     "snap": "npm test --snapshot",
     "snap:big": "npm test --snapshot --big",
-    "minitest": "peggy grammar.peggy && ./build/crossref.py && tsc -d && node i.js",
+    "minitest": "./build/crossref.py && tsc -d && node i.js",
     "list": "tar tvf $(npm pack)",
     "prepublishOnly": "npm start",
     "abbr": "./build/abbr.py",
     "preversion": "./console.py r && npm run abbr && npm run test",
     "postversion": "git push --follow-tags",
     "update-cases": "curl -s https://raw.githubusercontent.com/retorquere/zotero-better-bibtex/master/test/loaded.json | jq -r '.[] | select(test(\"\\\\.bib((la)?tex)?$\"))' | rsync -av --delete -m --files-from=- ../better-bibtex/test/fixtures/ test/better-bibtex/",
-    "x-docs": "rm -rf docs temp && typedoc --name 'BibTeX parser' index.ts && touch docs/.nojekyll",
     "predocs": "npm start",
-    "docs": "mkdir -p etc temp && npm run api-extractor && npm run api-documenter",
-    "ncu": "./build/submodules.py && ./build/crossref.py && ncu -u && npm i && git add package.json package-lock.json && npm audit fix && git commit -m ncu",
-    "api-documenter": "api-documenter markdown --input temp --output docs",
-    "api-extractor": "api-extractor run --local --verbose"
+    "docs": "typedoc",
+    "ncu": "./build/submodules.py && ./build/crossref.py && ncu -u && npm i && git add package.json package-lock.json && npm audit fix && git commit -m ncu"
   },
   "repository": {
     "type": "git",
@@ -38,8 +35,6 @@
   "author": "Emiliano Heyns",
   "license": "ISC",
   "devDependencies": {
-    "@microsoft/api-documenter": "^7.24.1",
-    "@microsoft/api-extractor": "^7.43.0",
     "@types/node": "^20.12.2",
     "@typescript-eslint/eslint-plugin": "^7.4.0",
     "@typescript-eslint/parser": "^7.4.0",
@@ -54,12 +49,12 @@
     "glob": "^10.3.12",
     "mkdirp": "^3.0.1",
     "node-fetch": "^3.3.2",
-    "peggy": "^4.0.2",
     "piscina": "^4.4.0",
     "slug": "^9.0.0",
     "tap": "^18.7.2",
     "ts-node": "^10.9.2",
     "tslib": "^2.6.2",
+    "typedoc": "^0.25.12",
     "typescript": "^5.4.3"
   },
   "dependencies": {

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;
         }