@retorquere/bibtex-parser 11.0.0 → 12.0.0

package/dist/wasm/index.d.ts

@@ -0,0 +1,122 @@
+import type { InitInput, InitOutput, SyncInitInput } from './bibtex_parser.js'
+
+export type { InitInput, InitOutput, SyncInitInput }
+export { initSync } from './bibtex_parser.js'
+export { default as init } from './bibtex_parser.js'
+export { default } from './bibtex_parser.js'
+
+export type ParseMode = 'creatorlist' | 'title' | 'verbatim' | 'richtext' | 'literallist' | 'literal' | 'verbatimlist'
+
+export interface Creator {
+  name?: string
+  lastName?: string
+  firstName?: string
+  prefix?: string
+  suffix?: string
+  initial?: string
+  useprefix?: boolean
+  juniorcomma?: boolean
+}
+
+export type FieldValue = string | string[] | Creator[]
+
+export interface Entry {
+  type: string
+  key: string
+  fields: Record<string, FieldValue>
+  mode: Record<string, ParseMode>
+  crossref?: Record<string, { parent: string; field: string }>
+  input: string
+}
+
+export interface ParseError {
+  error: string
+  input?: string
+}
+
+export interface JabRefGroup {
+  name: string
+  entries: string[]
+  groups: JabRefGroup[]
+}
+
+export interface JabRefMetadata {
+  root: JabRefGroup[]
+  groups: Record<string, JabRefGroup>
+  fileDirectory?: string
+  groupsversion?: number
+  databaseType?: string
+}
+
+export interface Library {
+  errors: ParseError[]
+  entries: Entry[]
+  comments: string[]
+  strings: Record<string, string>
+  preamble: string[]
+  jabref: JabRefMetadata
+}
+
+export interface SentenceCaseOptions {
+  guess?: boolean
+  subSentence?: boolean
+  preserveQuoted?: boolean
+}
+
+export interface Token {
+  type: 'word' | 'domain' | 'whitespace' | 'number' | 'email' | 'handle' | 'website' | 'markup' | 'other' | 'punctuation'
+  subtype: '' | 'preposition' | 'acronym' | 'contraction' | 'ordinal' | 'word' | 'end' | 'colon' | 'ellipsis'
+  text: string
+  start: number
+  end: number
+  shape: string
+  sentenceStart: boolean
+  subSentenceStart: boolean
+  hyphenated?: Token[]
+}
+
+export interface Options {
+  english?: string[] | boolean
+  languageAsLangid?: boolean
+  sentenceCase?: false | SentenceCaseOptions
+  caseProtection?: 'as-needed' | 'strict' | boolean
+  unsupported?: 'ignore' | 'keep' | 'throw'
+  verbatimFields?: (string | RegExp)[]
+  removeOuterBraces?: string[]
+  fieldMode?: Record<string, ParseMode>
+  raw?: boolean
+  strings?: Record<string, string> | string
+  applyCrossRef?: boolean
+}
+
+export interface ParserOptions {
+  maxEntries?: number
+  strings?: Record<string, string> | string
+  stringsSource?: string
+}
+
+export interface VerbatimEntry {
+  input: string
+  type: string
+  key: string
+  fields: Record<string, string>
+}
+
+export interface VerbatimLibrary {
+  entries: VerbatimEntry[]
+  strings: Record<string, string>
+  comments: string[]
+  errors: ParseError[]
+  preambles: string[]
+}
+
+export function parseVerbatim(input: string, options?: ParserOptions): VerbatimLibrary
+export function parseNormalized(input: string, options?: Options): Library
+export function parse(input: string, options?: Options): Library
+export function parseAsync(input: string, options?: Options): Promise<Library>
+export function toSentenceCase(input: string, options?: {
+  preserveQuoted?: boolean
+  subSentenceCapitalization?: boolean
+  guess?: boolean
+}): string
+export function tokenize(input: string, markup?: RegExp): Token[]

package/dist/wasm/index.js

@@ -0,0 +1,122 @@
+import init, {
+  initSync,
+  parseNormalized as parseNormalizedWasm,
+  parseVerbatim as parseVerbatimWasm,
+  tokenize as tokenizeWasm,
+  toSentenceCase as toSentenceCaseWasm,
+} from './bibtex_parser.js'
+
+export { init, initSync }
+export default init
+
+const english = [
+  '', 'american', 'british', 'canadian', 'english', 'australian', 'newzealand',
+  'usenglish', 'ukenglish', 'en', 'eng', 'en-au', 'en-bz', 'en-ca', 'en-cb',
+  'en-gb', 'en-ie', 'en-jm', 'en-nz', 'en-ph', 'en-tt', 'en-us', 'en-za', 'en-zw', 'anglais',
+]
+
+function rustOptions(options = {}) {
+  const rust = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
+
+  if (rust.unsupported !== undefined && typeof rust.unsupported !== 'string') {
+    throw new TypeError('unsupported must be ignore, keep, or throw')
+  }
+  if (rust.unsupported !== undefined && !['ignore', 'keep', 'throw'].includes(rust.unsupported)) {
+    throw new TypeError('unsupported must be ignore, keep, or throw')
+  }
+
+  if (typeof rust.strings === 'string') {
+    rust.stringsSource = rust.strings
+    delete rust.strings
+  }
+  else if (!rust.strings) {
+    delete rust.strings
+  }
+  if (typeof rust.english === 'boolean') {
+    rust.english = rust.english ? english : []
+  }
+  else if (Array.isArray(rust.english)) {
+    const configured = rust.english
+    rust.english = [...english]
+    configured.forEach((language, index) => {
+      rust.english[index] = language
+    })
+  }
+  if (rust.sentenceCase === false) {
+    rust.english = []
+    rust.sentenceCase = { guess: false, subSentence: false, preserveQuoted: false }
+  }
+  if (rust.caseProtection === false) rust.caseProtection = 'off'
+  if (rust.caseProtection === true) rust.caseProtection = 'as-needed'
+  if (Array.isArray(rust.verbatimFields)) {
+    rust.verbatimFields = rust.verbatimFields.filter(field => typeof field === 'string')
+  }
+  if (rust.unsupported === 'ignore') rust.ignoreUnsupported = true
+  delete rust.unsupported
+  return rust
+}
+
+function library(result) {
+  if (Array.isArray(result.preambles)) {
+    result.preamble = result.preambles
+    delete result.preambles
+  }
+  return result
+}
+
+function throwOnUnsupported(result) {
+  const unsupported = result.errors.find(error => error.error.startsWith('unhandled macro ') || error.error.startsWith('unhandled environment '))
+  if (unsupported) throw new Error(unsupported.error)
+  return result
+}
+
+export function parseVerbatim(input, options = {}) {
+  const result = parseVerbatimWasm(input, rustOptions(options))
+  delete result.jabref
+  return result
+}
+
+export function parseNormalized(input, options = {}) {
+  const selectors = options.verbatimFields || []
+  const patterns = selectors.filter(selector => selector instanceof RegExp)
+  let normalizedOptions = options
+  if (patterns.length) {
+    const exactFields = new Set(selectors.filter(selector => typeof selector === 'string'))
+    const raw = parseVerbatimWasm(input, rustOptions({
+      ...options,
+      verbatimFields: [...exactFields],
+    }))
+    for (const entry of raw.entries) {
+      for (const field of Object.keys(entry.fields)) {
+        if (patterns.some(pattern => field.match(new RegExp(
+          pattern.source,
+          pattern.flags.includes('i') ? pattern.flags : `${pattern.flags}i`,
+        )))) {
+          exactFields.add(field)
+        }
+      }
+    }
+    normalizedOptions = { ...options, verbatimFields: [...exactFields] }
+  }
+  const result = library(parseNormalizedWasm(input, rustOptions(normalizedOptions)))
+  if (options.unsupported === 'throw') return throwOnUnsupported(result)
+  return result
+}
+
+export function parse(input, options = {}) {
+  return parseNormalized(input, options)
+}
+
+export async function parseAsync(input, options = {}) {
+  return parseNormalized(input, options)
+}
+
+export function toSentenceCase(input, options = {}) {
+  return toSentenceCaseWasm(input, options)
+}
+
+export function tokenize(input, markup) {
+  if (!(markup instanceof RegExp)) return tokenizeWasm(input)
+  const masked = input.replace(markup, match => '\u2060'.repeat(match.length))
+  return tokenizeWasm(masked)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "11.0.0",
+  "version": "12.0.0",
   "description": "BibTeX parser",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -16,7 +16,12 @@
         "types": "./dist/types/index.d.ts",
         "default": "./dist/cjs/index.js"
       }
-    }
+    },
+    "./wasm": {
+      "types": "./dist/wasm/index.d.ts",
+      "import": "./dist/wasm/index.js"
+    },
+    "./wasm/bibtex_parser_bg.wasm": "./dist/wasm/bibtex_parser_bg.wasm"
   },
   "typings": "./index.d.ts",
   "scripts": {
@@ -27,10 +32,13 @@
     "build:esm": "rm -rf dist/esm && esbuild *.ts --outdir=dist/esm --format=esm --sourcemap --target=es2020 --loader:.ts=ts",
     "build:cjs": "rm -rf dist/cjs && esbuild *.ts --outdir=dist/cjs --format=cjs --sourcemap --target=node16 --loader:.ts=ts",
     "build:types": "rm -rf dist/esm dist/types && tsc -d -p tsconfig.esm.json",
+    "build:ts": "npm run build:types && npm run build:cjs && npm run build:esm",
+    "build:wasm": "node rust/build-wasm.mjs",
     "prebuild": "rm -rf dist && mkdir -p dist/data && cp data/*.json dist/data && ./build/abbr.py && ./build/prepositions.py",
-    "build": "npm run build:types && npm run build:cjs && npm run build:esm",
+    "build": "npm run build:ts && npm run build:wasm",
     "pretest": "npm start",
     "test": "node test/run.js",
+    "test:package": "npm run build && node --test test/package.test.js",
     "minitest": "./build/crossref.py && npm run build && node i.js",
     "list": "tar tvf $(npm pack)",
     "prepublishOnly": "npm start",
@@ -41,6 +49,7 @@
     "predocs": "npm start",
     "docs": "typedoc --tsconfig tsconfig.cjs.json",
     "modules": "git submodule update --init --recursive",
+    "wasm:test": "npm run build:wasm && node --test test/wasm.js test/rust-wasm-parity.test.js",
     "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": {