@retorquere/bibtex-parser 12.1.10 → 12.1.11

package/dist/types/jabref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jabref.d.ts","sourceRoot":"","sources":["../../jabref.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IAEjB;;OAEG;IACH,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,IAAI,EAAE,KAAK,EAAE,CAAA;IAEb;;;;OAIG;IACH,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAA;IAEhC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAqFxF"}
+{"version":3,"file":"jabref.d.ts","sourceRoot":"","sources":["../../jabref.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IAEjB;;OAEG;IACH,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB;AAED,qBAAa,cAAc;;IAGzB;;OAEG;IACH,IAAI,EAAE,KAAK,EAAE,CAAK;IAElB;;OAEG;IACK,aAAa,CAAC,EAAE,MAAM,CAAA;IAE9B;;OAEG;IACK,aAAa,CAAC,EAAE,MAAM,CAAA;IAE9B;;OAEG;IACK,YAAY,CAAC,EAAE,MAAM,CAAA;gBAEjB,IAAI,GAAE,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe,GAAG,eAAe,GAAG,cAAc,CAAC,CAAM;IAcjH,wGAAwG;IACxG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;CAM7C;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAgFxF"}

package/dist/wasm/index.d.ts

@@ -1,5 +1,8 @@
 /** @module wasm */
 import init, { initSync } from './bibtex_parser.js';
+import { JabRefMetadata } from './jabref.js';
+export { JabRefMetadata };
+export type { Group as JabRefGroup } from './jabref.js';
 export type { InitInput, InitOutput, SyncInitInput } from './bibtex_parser.js';
 /** Initializes the WebAssembly parser; await this before using its exports. */
 export { init, initSync };
@@ -60,20 +63,6 @@ export interface ParseError {
     error: string;
     input?: string;
 }
-/** A group in JabRef's nested group hierarchy. */
-export interface JabRefGroup {
-    name: string;
-    entries: string[];
-    groups: JabRefGroup[];
-}
-/** JabRef metadata extracted from a BibTeX library. */
-export interface JabRefMetadata {
-    root: JabRefGroup[];
-    groups: Record<string, JabRefGroup>;
-    fileDirectory?: string;
-    groupsversion?: number;
-    databaseType?: string;
-}
 /** The parsed contents of a BibTeX library. */
 export interface Library {
     errors: ParseError[];

package/dist/wasm/index.js

@@ -1,5 +1,7 @@
 /** @module wasm */
 import init, { initSync, parse as parseWasm, parseAsync as parseAsyncWasm, parseVerbatim as parseVerbatimWasm, parseVerbatimAsync as parseVerbatimAsyncWasm, tokenize as tokenizeWasm, toSentenceCase as toSentenceCaseWasm } from './bibtex_parser.js';
+import { JabRefMetadata } from './jabref.js';
+export { JabRefMetadata };
 /** Initializes the WebAssembly parser; await this before using its exports. */
 export { init, initSync };
 export default init;
@@ -57,20 +59,24 @@ function throwOnUnsupported(result) {
         throw new Error(unsupported.error);
     return result;
 }
+function withJabRef(result) {
+    result.jabref = new JabRefMetadata(result.jabref);
+    return result;
+}
 /** Parses BibTeX while leaving field contents uninterpreted. */
 export function parseVerbatim(input, options = {}) {
     const prepared = prepare(input, options);
-    return parseVerbatimWasm(prepared.input, prepared.options);
+    return withJabRef(parseVerbatimWasm(prepared.input, prepared.options));
 }
 /** Asynchronous variant of {@link parseVerbatim}. */
 export async function parseVerbatimAsync(input, options = {}) {
     const prepared = prepare(input, options);
-    return await parseVerbatimAsyncWasm(prepared.input, prepared.options);
+    return withJabRef(await parseVerbatimAsyncWasm(prepared.input, prepared.options));
 }
 /** Parses BibTeX or BibLaTeX source into a normalized library. */
 export function parse(input, options = {}) {
     const prepared = prepare(input, options);
-    const result = parseWasm(prepared.input, prepared.options);
+    const result = withJabRef(parseWasm(prepared.input, prepared.options));
     if (options.unsupported === 'throw')
         return throwOnUnsupported(result);
     return result;
@@ -78,7 +84,7 @@ export function parse(input, options = {}) {
 /** Asynchronous variant of {@link parse}, yielding during large parses. */
 export async function parseAsync(input, options = {}) {
     const prepared = prepare(input, options);
-    const result = await parseAsyncWasm(prepared.input, prepared.options);
+    const result = withJabRef(await parseAsyncWasm(prepared.input, prepared.options));
     if (options.unsupported === 'throw')
         return throwOnUnsupported(result);
     return result;

package/dist/wasm/jabref.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A JabRef group.
+ */
+export interface Group {
+    /**
+     * the group name
+     */
+    name: string;
+    /**
+     * The citation keys which are specified to belong to this group, after intersection calculation has been applied
+     */
+    entries: string[];
+    /**
+     * Sub-groups under this group
+     */
+    groups: Group[];
+}
+export declare class JabRefMetadata {
+    #private;
+    /**
+     * The root groups. You can find the nested groups in their `groups` property
+     */
+    root: Group[];
+    /**
+     * The base path for file paths
+     */
+    fileDirectory?: string;
+    /**
+     * The JabRef metadata format version
+     */
+    groupsversion?: number;
+    /**
+     * The JabRef metadata database type
+     */
+    databaseType?: string;
+    constructor(data?: Partial<Pick<JabRefMetadata, 'root' | 'fileDirectory' | 'groupsversion' | 'databaseType'>>);
+    /** Populates JabRef 3.8+ memberships in `root` by group name; duplicate names select the first node. */
+    addEntry(name: string, key: string): boolean;
+}
+/**
+ * Import the JabRef groups from the `@string` comments in which they were stored. You would typically pass the comments parsed by [[bibtex.parse]] in here.
+ *
+ * JabRef knows several group types, and this parser parses most, but not all of them:
+ *
+ * * independent group: the keys listed in the group are the entries that are considered to belong to it
+ * * intersection: the keys listed in the group are considered to belong to the group if they're also in the parent group
+ * * union: the keys listed in the group are considered to belong to the group, and also the keys that are in the parent group
+ * * query: not supported by this parser
+ */
+export declare function parse(comments: string[]): {
+    comments: string[];
+    jabref: JabRefMetadata;
+};

package/dist/wasm/jabref.js

@@ -0,0 +1,133 @@
+function decode(s = '', sep = ';') {
+    s = s.replace(/\r?\n/g, '');
+    let pos = 0;
+    const records = [''];
+    while (pos < s.length) {
+        switch (s[pos]) {
+            case '\\':
+                pos++;
+                records[0] += s[pos];
+                break;
+            case sep:
+                records.unshift('');
+                break;
+            default:
+                records[0] += s[pos];
+        }
+        pos++;
+    }
+    return records.reverse().filter(record => record);
+}
+export class JabRefMetadata {
+    #groups = new Map();
+    /**
+     * The root groups. You can find the nested groups in their `groups` property
+     */
+    root = [];
+    constructor(data = {}) {
+        this.root = data.root ?? [];
+        for (const field of ['fileDirectory', 'groupsversion', 'databaseType']) {
+            if (data[field] !== undefined)
+                Object.assign(this, { [field]: data[field] });
+        }
+        const index = (groups) => {
+            for (const group of groups) {
+                if (!this.#groups.has(group.name))
+                    this.#groups.set(group.name, group);
+                index(group.groups);
+            }
+        };
+        index(this.root);
+    }
+    /** Populates JabRef 3.8+ memberships in `root` by group name; duplicate names select the first node. */
+    addEntry(name, key) {
+        const group = this.#groups.get(name);
+        if (!group)
+            return false;
+        if (!group.entries.includes(key))
+            group.entries.push(key);
+        return true;
+    }
+}
+/**
+ * Import the JabRef groups from the `@string` comments in which they were stored. You would typically pass the comments parsed by [[bibtex.parse]] in here.
+ *
+ * JabRef knows several group types, and this parser parses most, but not all of them:
+ *
+ * * independent group: the keys listed in the group are the entries that are considered to belong to it
+ * * intersection: the keys listed in the group are considered to belong to the group if they're also in the parent group
+ * * union: the keys listed in the group are considered to belong to the group, and also the keys that are in the parent group
+ * * query: not supported by this parser
+ */
+export function parse(comments) {
+    const result = new JabRefMetadata();
+    const levels = [];
+    const decoded = {
+        fileDirectory: null,
+        groupsversion: null,
+        groupstree: null,
+        grouping: null,
+        databaseType: null,
+    };
+    comments = comments.filter(comment => {
+        const m = comment.match(/^jabref-meta:\s*([^:]+):([\s\S]*)/); // use \s\S because mozilla doesn't understand /s
+        if (m) {
+            decoded[m[1]] = decode(m[2]);
+            return false;
+        }
+        return true;
+    });
+    if (decoded.groupsversion)
+        result.groupsversion = parseInt(decoded.groupsversion[0].trim()); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    if (decoded.fileDirectory)
+        result.fileDirectory = decoded.fileDirectory[0];
+    if (decoded.databaseType)
+        result.databaseType = decoded.databaseType[0];
+    for (const tree of ['groupstree', 'grouping']) {
+        if (!decoded[tree])
+            continue;
+        for (const encoded of decoded[tree]) {
+            const fields = decode(encoded);
+            const level_type_name = decode(fields.shift(), ':');
+            const m = /^([0-9]+) (.+)/.exec(level_type_name[0]);
+            if (!m)
+                break;
+            const level = parseInt(m[1]);
+            const type = m[2]; // test for StaticGroup?
+            if (type === 'AllEntriesGroup')
+                continue; // root
+            const name = level_type_name[1];
+            const intersection = decode(fields.shift())[0];
+            const keys = tree === 'grouping' ? [] : fields.map(field => decode(field)[0]);
+            const group = {
+                name,
+                entries: keys,
+                groups: [],
+            };
+            if (levels.length < level) {
+                levels.push(group);
+            }
+            else {
+                levels[level - 1] = group;
+            }
+            if (level === 1) {
+                result.root.push(group);
+            }
+            else {
+                const parent = levels[level - 2];
+                switch (intersection) {
+                    case '0': // independent
+                        break;
+                    case '1': // intersect
+                        group.entries = group.entries.filter(key => parent.entries.includes(key));
+                        break;
+                    case '2': // union
+                        group.entries = group.entries.concat(parent.entries.filter(key => !group.entries.includes(key)));
+                        break;
+                }
+                levels[level - 2].groups.push(group);
+            }
+        }
+    }
+    return { comments, jabref: new JabRefMetadata(result) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "12.1.10",
+  "version": "12.1.11",
   "description": "BibTeX parser",
   "type": "module",
   "main": "./dist/cjs/index.js",