@uniweb/scholar 0.2.0 → 0.2.2

package/src/bibliography/parsers/bibtex.js

@@ -1,405 +0,0 @@
-/**
- * BibTeX Parser
- *
- * Parses BibTeX format into normalized publication objects and exports
- * publication objects back to BibTeX format.
- *
- * @module @uniweb/scholar/bibliography/parsers/bibtex
- */
-
-import { parseAuthorString } from '../utils/authors.js'
-
-/**
- * Parse a BibTeX field value, handling braces and quotes
- *
- * @param {string} value - Raw field value
- * @returns {string} Cleaned value
- */
-function parseFieldValue(value) {
-  if (!value) return ''
-
-  let cleaned = value.trim()
-
-  // Remove outer braces or quotes
-  if (
-    (cleaned.startsWith('{') && cleaned.endsWith('}')) ||
-    (cleaned.startsWith('"') && cleaned.endsWith('"'))
-  ) {
-    cleaned = cleaned.slice(1, -1)
-  }
-
-  // Remove nested braces (used for preserving case)
-  cleaned = cleaned.replace(/\{([^{}]*)\}/g, '$1')
-
-  // Handle common LaTeX commands
-  cleaned = cleaned
-    .replace(/\\&/g, '&')
-    .replace(/\\\$/g, '$')
-    .replace(/\\%/g, '%')
-    .replace(/\\_/g, '_')
-    .replace(/\\#/g, '#')
-    .replace(/~/g, ' ')
-    .replace(/--/g, '–')
-    .replace(/``/g, '"')
-    .replace(/''/g, '"')
-
-  return cleaned.trim()
-}
-
-/**
- * Parse a single BibTeX entry
- *
- * @param {string} entryStr - BibTeX entry string
- * @returns {Object|null} Parsed publication object
- */
-function parseEntry(entryStr) {
-  // Match @type{key, ...}
-  const headerMatch = entryStr.match(/@(\w+)\s*\{\s*([^,\s]*)\s*,/)
-  if (!headerMatch) return null
-
-  const entryType = headerMatch[1].toLowerCase()
-  const citationKey = headerMatch[2]
-
-  // Extract fields
-  const fieldsStr = entryStr.slice(headerMatch[0].length)
-  const fields = {}
-
-  // Parse fields using a state machine approach
-  let currentField = ''
-  let currentValue = ''
-  let braceDepth = 0
-  let inQuotes = false
-  let inField = false
-
-  for (let i = 0; i < fieldsStr.length; i++) {
-    const char = fieldsStr[i]
-    const prevChar = i > 0 ? fieldsStr[i - 1] : ''
-
-    if (!inField) {
-      // Looking for field name
-      if (char === '=') {
-        currentField = currentValue.trim().toLowerCase()
-        currentValue = ''
-        inField = true
-      } else if (char !== ',' && char !== '}') {
-        currentValue += char
-      }
-    } else {
-      // Parsing field value
-      if (char === '{' && !inQuotes) {
-        braceDepth++
-        currentValue += char
-      } else if (char === '}' && !inQuotes) {
-        if (braceDepth > 0) {
-          braceDepth--
-          currentValue += char
-        } else {
-          // End of entry
-          if (currentField) {
-            fields[currentField] = parseFieldValue(currentValue)
-          }
-          break
-        }
-      } else if (char === '"' && prevChar !== '\\') {
-        inQuotes = !inQuotes
-        currentValue += char
-      } else if (char === ',' && braceDepth === 0 && !inQuotes) {
-        // End of field
-        if (currentField) {
-          fields[currentField] = parseFieldValue(currentValue)
-        }
-        currentField = ''
-        currentValue = ''
-        inField = false
-      } else {
-        currentValue += char
-      }
-    }
-  }
-
-  // Save last field if any
-  if (currentField && currentValue) {
-    fields[currentField] = parseFieldValue(currentValue)
-  }
-
-  // Normalize to standard publication object
-  const pub = {
-    id: citationKey,
-    type: entryType,
-    ...normalizeFields(fields, entryType),
-  }
-
-  return pub
-}
-
-/**
- * Normalize BibTeX fields to standard publication object
- *
- * @param {Object} fields - Raw BibTeX fields
- * @param {string} entryType - BibTeX entry type
- * @returns {Object} Normalized fields
- */
-function normalizeFields(fields, entryType) {
-  const normalized = {}
-
-  // Title
-  if (fields.title) {
-    normalized.title = fields.title
-  }
-
-  // Authors
-  if (fields.author) {
-    normalized.authors = parseAuthorString(fields.author)
-  }
-
-  // Editors
-  if (fields.editor) {
-    normalized.editors = parseAuthorString(fields.editor)
-  }
-
-  // Year
-  if (fields.year) {
-    normalized.year = parseInt(fields.year, 10) || fields.year
-  }
-
-  // Journal/booktitle
-  if (fields.journal) {
-    normalized.journal = fields.journal
-  }
-  if (fields.booktitle) {
-    normalized.bookTitle = fields.booktitle
-  }
-
-  // Volume, issue, pages
-  if (fields.volume) normalized.volume = fields.volume
-  if (fields.number) normalized.issue = fields.number
-  if (fields.pages) normalized.pages = fields.pages.replace('--', '–')
-
-  // Publisher info
-  if (fields.publisher) normalized.publisher = fields.publisher
-  if (fields.address) normalized.address = fields.address
-
-  // DOI and URL
-  if (fields.doi) {
-    normalized.doi = fields.doi.replace(/^https?:\/\/doi\.org\//, '')
-  }
-  if (fields.url) normalized.url = fields.url
-
-  // ISBN/ISSN
-  if (fields.isbn) normalized.isbn = fields.isbn
-  if (fields.issn) normalized.issn = fields.issn
-
-  // Abstract and keywords
-  if (fields.abstract) normalized.abstract = fields.abstract
-  if (fields.keywords) {
-    normalized.keywords = fields.keywords.split(/[,;]/).map((k) => k.trim())
-  }
-
-  // Thesis-specific
-  if (fields.school) normalized.school = fields.school
-  if (fields.institution) normalized.institution = fields.institution
-
-  // Edition
-  if (fields.edition) normalized.edition = fields.edition
-
-  // Note
-  if (fields.note) normalized.note = fields.note
-
-  return normalized
-}
-
-/**
- * Parse BibTeX string into array of publication objects
- *
- * @param {string} bibtex - BibTeX string
- * @returns {Array<Object>} Array of publication objects
- *
- * @example
- * const refs = parseBibtex(`
- *   @article{smith2024,
- *     author = {Smith, John and Doe, Jane},
- *     title = {A Study},
- *     journal = {Journal of Studies},
- *     year = {2024}
- *   }
- * `)
- */
-export function parseBibtex(bibtex) {
-  if (!bibtex || typeof bibtex !== 'string') {
-    return []
-  }
-
-  const results = []
-
-  // Find all entries (@ followed by type and opening brace)
-  const entryPattern = /@(\w+)\s*\{/g
-  let match
-  const entryStarts = []
-
-  while ((match = entryPattern.exec(bibtex)) !== null) {
-    entryStarts.push(match.index)
-  }
-
-  // Parse each entry
-  for (let i = 0; i < entryStarts.length; i++) {
-    const start = entryStarts[i]
-    const end = i < entryStarts.length - 1 ? entryStarts[i + 1] : bibtex.length
-
-    const entryStr = bibtex.slice(start, end)
-    const parsed = parseEntry(entryStr)
-
-    if (parsed) {
-      results.push(parsed)
-    }
-  }
-
-  return results
-}
-
-/**
- * Escape a string for BibTeX
- *
- * @param {string} str - String to escape
- * @returns {string} Escaped string
- */
-function escapeBibtex(str) {
-  if (!str) return ''
-  return String(str)
-    .replace(/&/g, '\\&')
-    .replace(/%/g, '\\%')
-    .replace(/_/g, '\\_')
-    .replace(/#/g, '\\#')
-    .replace(/\$/g, '\\$')
-}
-
-/**
- * Format authors for BibTeX
- *
- * @param {Array} authors - Array of author objects
- * @returns {string} BibTeX author string
- */
-function formatBibtexAuthors(authors) {
-  if (!authors?.length) return ''
-
-  return authors
-    .map((a) => {
-      if (typeof a === 'string') return a
-      const suffix = a.suffix ? `, ${a.suffix}` : ''
-      return a.given ? `${a.family}${suffix}, ${a.given}` : a.family + suffix
-    })
-    .join(' and ')
-}
-
-/**
- * Export a publication object to BibTeX format
- *
- * @param {Object} pub - Publication object
- * @returns {string} BibTeX string
- *
- * @example
- * const bibtex = exportBibtex({
- *   id: 'smith2024',
- *   type: 'article',
- *   authors: [{ family: 'Smith', given: 'John' }],
- *   title: 'A Study',
- *   journal: 'Journal of Studies',
- *   year: 2024
- * })
- */
-export function exportBibtex(pub) {
-  if (!pub) return ''
-
-  const type = pub.type || pub.entryType || 'misc'
-  const key = pub.id || pub.citationKey || generateKey(pub)
-
-  const fields = []
-
-  // Authors
-  if (pub.authors?.length) {
-    fields.push(`  author = {${formatBibtexAuthors(pub.authors)}}`)
-  } else if (pub.author) {
-    fields.push(`  author = {${escapeBibtex(pub.author)}}`)
-  }
-
-  // Editors
-  if (pub.editors?.length) {
-    fields.push(`  editor = {${formatBibtexAuthors(pub.editors)}}`)
-  }
-
-  // Title
-  if (pub.title) {
-    fields.push(`  title = {${escapeBibtex(pub.title)}}`)
-  }
-
-  // Journal/booktitle
-  if (pub.journal) {
-    fields.push(`  journal = {${escapeBibtex(pub.journal)}}`)
-  }
-  if (pub.bookTitle) {
-    fields.push(`  booktitle = {${escapeBibtex(pub.bookTitle)}}`)
-  }
-
-  // Year
-  if (pub.year) {
-    fields.push(`  year = {${pub.year}}`)
-  }
-
-  // Volume, number, pages
-  if (pub.volume) fields.push(`  volume = {${pub.volume}}`)
-  if (pub.issue) fields.push(`  number = {${pub.issue}}`)
-  if (pub.pages) fields.push(`  pages = {${pub.pages.replace('–', '--')}}`)
-
-  // Publisher
-  if (pub.publisher) {
-    fields.push(`  publisher = {${escapeBibtex(pub.publisher)}}`)
-  }
-  if (pub.address) {
-    fields.push(`  address = {${escapeBibtex(pub.address)}}`)
-  }
-
-  // DOI and URL
-  if (pub.doi) fields.push(`  doi = {${pub.doi}}`)
-  if (pub.url) fields.push(`  url = {${pub.url}}`)
-
-  // ISBN/ISSN
-  if (pub.isbn) fields.push(`  isbn = {${pub.isbn}}`)
-  if (pub.issn) fields.push(`  issn = {${pub.issn}}`)
-
-  // Abstract
-  if (pub.abstract) {
-    fields.push(`  abstract = {${escapeBibtex(pub.abstract)}}`)
-  }
-
-  // Keywords
-  if (pub.keywords?.length) {
-    fields.push(`  keywords = {${pub.keywords.join(', ')}}`)
-  }
-
-  // School (for thesis)
-  if (pub.school) {
-    fields.push(`  school = {${escapeBibtex(pub.school)}}`)
-  }
-
-  // Edition
-  if (pub.edition) {
-    fields.push(`  edition = {${pub.edition}}`)
-  }
-
-  return `@${type}{${key},\n${fields.join(',\n')}\n}`
-}
-
-/**
- * Generate a citation key from publication data
- *
- * @param {Object} pub - Publication object
- * @returns {string} Generated key
- */
-function generateKey(pub) {
-  const author =
-    pub.authors?.[0]?.family ||
-    (typeof pub.author === 'string' ? pub.author.split(/[,\s]/)[0] : 'unknown')
-  const year = pub.year || 'nd'
-  const title = pub.title?.split(/\s+/)[0]?.toLowerCase() || ''
-
-  return `${author.toLowerCase()}${year}${title}`.replace(/[^a-z0-9]/gi, '')
-}

package/src/bibliography/utils/authors.js

@@ -1,277 +0,0 @@
-/**
- * Author Name Utilities
- *
- * Functions for parsing and formatting author names in various citation styles.
- *
- * @module @uniweb/scholar/bibliography/utils/authors
- */
-
-/**
- * Parse a single author name string into structured parts
- *
- * @param {string} name - Author name (e.g., "Smith, John A." or "John A. Smith")
- * @returns {{ family: string, given: string, suffix?: string }}
- */
-export function parseAuthorName(name) {
-  if (!name || typeof name !== 'string') {
-    return { family: '', given: '' }
-  }
-
-  const trimmed = name.trim()
-
-  // Check for "Last, First" format
-  if (trimmed.includes(',')) {
-    const parts = trimmed.split(',').map((p) => p.trim())
-    const family = parts[0]
-    const givenAndSuffix = parts.slice(1).join(' ').trim()
-
-    // Check for suffix (Jr., Sr., III, etc.)
-    const suffixMatch = givenAndSuffix.match(/\s+(Jr\.?|Sr\.?|III?|IV|V)$/i)
-    if (suffixMatch) {
-      return {
-        family,
-        given: givenAndSuffix.slice(0, suffixMatch.index).trim(),
-        suffix: suffixMatch[1],
-      }
-    }
-
-    return { family, given: givenAndSuffix }
-  }
-
-  // "First Last" format - last word is family name
-  const words = trimmed.split(/\s+/)
-  if (words.length === 1) {
-    return { family: words[0], given: '' }
-  }
-
-  // Check if last word is a suffix
-  const lastWord = words[words.length - 1]
-  if (/^(Jr\.?|Sr\.?|III?|IV|V)$/i.test(lastWord)) {
-    return {
-      family: words[words.length - 2] || '',
-      given: words.slice(0, -2).join(' '),
-      suffix: lastWord,
-    }
-  }
-
-  return {
-    family: words[words.length - 1],
-    given: words.slice(0, -1).join(' '),
-  }
-}
-
-/**
- * Parse a string of multiple authors
- *
- * @param {string} authorString - Authors separated by "and", ";", or "&"
- * @returns {Array<{ family: string, given: string, suffix?: string }>}
- */
-export function parseAuthorString(authorString) {
-  if (!authorString || typeof authorString !== 'string') {
-    return []
-  }
-
-  // Split by "and", ";", or "&"
-  const authors = authorString
-    .split(/\s+and\s+|;\s*|&\s*/i)
-    .map((a) => a.trim())
-    .filter(Boolean)
-
-  return authors.map(parseAuthorName)
-}
-
-/**
- * Get author initials
- *
- * @param {string} given - Given name(s)
- * @param {Object} [options]
- * @param {boolean} [options.periods=true] - Include periods after initials
- * @param {boolean} [options.spaces=true] - Include spaces between initials
- * @returns {string}
- */
-export function getInitials(given, options = {}) {
-  const { periods = true, spaces = true } = options
-
-  if (!given) return ''
-
-  const names = given.split(/\s+/)
-  const initials = names
-    .map((name) => name.charAt(0).toUpperCase())
-    .map((initial) => (periods ? `${initial}.` : initial))
-
-  return initials.join(spaces ? ' ' : '')
-}
-
-/**
- * Format authors for APA style
- *
- * @param {Array} authors - Array of parsed author objects
- * @param {number} [maxAuthors=20] - Maximum authors before using et al.
- * @returns {string}
- */
-export function formatApaAuthors(authors, maxAuthors = 20) {
-  if (!authors?.length) return ''
-
-  const formatOne = (author) => {
-    const initials = getInitials(author.given, { periods: true, spaces: true })
-    const suffix = author.suffix ? `, ${author.suffix}` : ''
-    return initials
-      ? `${author.family}${suffix}, ${initials}`
-      : author.family + suffix
-  }
-
-  if (authors.length === 1) {
-    return formatOne(authors[0])
-  }
-
-  if (authors.length === 2) {
-    return `${formatOne(authors[0])} & ${formatOne(authors[1])}`
-  }
-
-  if (authors.length <= maxAuthors) {
-    const allButLast = authors.slice(0, -1).map(formatOne).join(', ')
-    return `${allButLast}, & ${formatOne(authors[authors.length - 1])}`
-  }
-
-  // More than maxAuthors: first 19, ..., last
-  const first19 = authors.slice(0, 19).map(formatOne).join(', ')
-  return `${first19}, ... ${formatOne(authors[authors.length - 1])}`
-}
-
-/**
- * Format authors for MLA style
- *
- * @param {Array} authors - Array of parsed author objects
- * @returns {string}
- */
-export function formatMlaAuthors(authors) {
-  if (!authors?.length) return ''
-
-  const formatFirst = (author) => {
-    const suffix = author.suffix ? `, ${author.suffix}` : ''
-    return author.given
-      ? `${author.family}${suffix}, ${author.given}`
-      : author.family + suffix
-  }
-
-  const formatSubsequent = (author) => {
-    const suffix = author.suffix ? `, ${author.suffix}` : ''
-    return author.given
-      ? `${author.given} ${author.family}${suffix}`
-      : author.family + suffix
-  }
-
-  if (authors.length === 1) {
-    return formatFirst(authors[0])
-  }
-
-  if (authors.length === 2) {
-    return `${formatFirst(authors[0])}, and ${formatSubsequent(authors[1])}`
-  }
-
-  if (authors.length === 3) {
-    return `${formatFirst(authors[0])}, ${formatSubsequent(authors[1])}, and ${formatSubsequent(authors[2])}`
-  }
-
-  // 4+ authors: first author et al.
-  return `${formatFirst(authors[0])}, et al.`
-}
-
-/**
- * Format authors for Chicago style (author-date)
- *
- * @param {Array} authors - Array of parsed author objects
- * @returns {string}
- */
-export function formatChicagoAuthors(authors) {
-  if (!authors?.length) return ''
-
-  const formatOne = (author, isFirst = false) => {
-    const suffix = author.suffix ? `, ${author.suffix}` : ''
-    if (isFirst) {
-      return author.given
-        ? `${author.family}${suffix}, ${author.given}`
-        : author.family + suffix
-    }
-    return author.given
-      ? `${author.given} ${author.family}${suffix}`
-      : author.family + suffix
-  }
-
-  if (authors.length === 1) {
-    return formatOne(authors[0], true)
-  }
-
-  if (authors.length === 2) {
-    return `${formatOne(authors[0], true)} and ${formatOne(authors[1])}`
-  }
-
-  if (authors.length === 3) {
-    return `${formatOne(authors[0], true)}, ${formatOne(authors[1])}, and ${formatOne(authors[2])}`
-  }
-
-  // 4+ authors: first author et al.
-  return `${formatOne(authors[0], true)} et al.`
-}
-
-/**
- * Format authors for IEEE style
- *
- * @param {Array} authors - Array of parsed author objects
- * @returns {string}
- */
-export function formatIeeeAuthors(authors) {
-  if (!authors?.length) return ''
-
-  const formatOne = (author) => {
-    const initials = getInitials(author.given, { periods: true, spaces: true })
-    const suffix = author.suffix ? ` ${author.suffix}` : ''
-    return initials
-      ? `${initials} ${author.family}${suffix}`
-      : author.family + suffix
-  }
-
-  if (authors.length === 1) {
-    return formatOne(authors[0])
-  }
-
-  if (authors.length === 2) {
-    return `${formatOne(authors[0])} and ${formatOne(authors[1])}`
-  }
-
-  // 3+ authors in IEEE: first author et al. in citations, all in references
-  const allButLast = authors.slice(0, -1).map(formatOne).join(', ')
-  return `${allButLast}, and ${formatOne(authors[authors.length - 1])}`
-}
-
-/**
- * Format authors for a specific style
- *
- * @param {Array|string} authors - Authors array or string
- * @param {Object} [options]
- * @param {string} [options.style='apa'] - Citation style
- * @param {number} [options.max=20] - Max authors before et al.
- * @returns {string}
- */
-export function formatAuthors(authors, options = {}) {
-  const { style = 'apa', max = 20 } = options
-
-  // Parse if string
-  const parsed =
-    typeof authors === 'string' ? parseAuthorString(authors) : authors
-
-  if (!parsed?.length) return ''
-
-  switch (style) {
-    case 'apa':
-      return formatApaAuthors(parsed, max)
-    case 'mla':
-      return formatMlaAuthors(parsed)
-    case 'chicago':
-      return formatChicagoAuthors(parsed)
-    case 'ieee':
-      return formatIeeeAuthors(parsed)
-    default:
-      return formatApaAuthors(parsed, max)
-  }
-}