@larsgw/formica 0.7.2 → 0.8.0

package/src/bin/process-resources-index.ts

@@ -39,7 +39,7 @@ async function main (args: string[]): Promise<void> {
 
     const gbifIndex: Record<string, TaxonId[]> = {}
     const colIndex: Record<string, TaxonId[]> = {}
-    const resourceIndex: Record<TaxonId, AmendedResourceMetadata> = {}
+    const resourceIndex: Record<ResourceId, AmendedResourceMetadata> = {}
 
     await Promise.all(files.map(async function (fileName) {
         if (!fileName.endsWith('.txt')) { return }

package/src/catalog/entity.ts

@@ -18,10 +18,8 @@ export class Entity {
         this.derivedFields = {}
     }
 
-    /* eslint-disable @typescript-eslint/no-empty-function */
     deriveFields () {
     }
-    /* eslint-enable @typescript-eslint/no-empty-function */
 
     get (key: string): Value | undefined {
         if (key in this.fields) {

package/src/catalog/tables/author.ts

@@ -4,10 +4,12 @@ import { Entity } from '../entity'
 export class Author extends Entity {
     constructor (values: Record<string, string>) {
         super(values, {
-            name: { required: true, multiple: false },
+            name: { required: true, multiple: true },
+            id: { required: true, multiple: false, format: FORMATS.AUTHOR_ID },
             qid: { required: false, multiple: false, format: FORMATS.QID },
-            main_full_name: { required: false, multiple: false },
-            full_names: { required: false, multiple: true }
+            display_name: { required: false, multiple: false },
+            full_names: { required: false, multiple: true },
+            duplicate_of: { required: false, multiple: false, format: FORMATS.AUTHOR_ID }
         })
     }
 }

package/src/catalog/tables/index.ts

@@ -6,9 +6,9 @@ import { Taxon } from './taxon'
 import { Work } from './work'
 
 export const TYPE_INFO: Record<string, [typeof Entity, string]> = {
-    authors: [Author, 'name'],
-    publishers: [Publisher, 'name'],
-    places: [Place, 'name'],
-    taxa: [Taxon, 'name'],
+    authors: [Author, 'id'],
+    publishers: [Publisher, 'id'],
+    places: [Place, 'id'],
+    taxa: [Taxon, 'id'],
     catalog: [Work, 'id']
 }

package/src/catalog/tables/place.ts

@@ -5,8 +5,10 @@ export class Place extends Entity {
     constructor (values: Record<string, string>) {
         super(values, {
             name: { required: true, multiple: false },
+            id: { required: true, multiple: false, format: FORMATS.PLACE_ID },
             qid: { required: false, multiple: false, format: FORMATS.QID },
-            display_name: { required: false, multiple: false }
+            display_name: { required: false, multiple: false },
+            duplicate_of: { required: false, multiple: false, format: FORMATS.PLACE_ID }
         })
     }
 }

package/src/catalog/tables/publisher.ts

@@ -4,10 +4,12 @@ import { Entity } from '../entity'
 export class Publisher extends Entity {
     constructor (values: Record<string, string>) {
         super(values, {
-            name: { required: true, multiple: false },
+            name: { required: true, multiple: true },
+            id: { required: true, multiple: false, format: FORMATS.PUBLISHER_ID },
             qid: { required: false, multiple: false, format: FORMATS.QID },
-            full_name: { required: false, multiple: false },
-            long_name: { required: false, multiple: true }
+            display_name: { required: false, multiple: false },
+            full_names: { required: false, multiple: true },
+            duplicate_of: { required: false, multiple: false, format: FORMATS.PUBLISHER_ID }
         })
     }
 }

package/src/catalog/tables/taxon.ts

@@ -5,11 +5,13 @@ export class Taxon extends Entity {
     constructor (values: Record<string, string>) {
         super(values, {
             name: { required: true, multiple: false },
+            id: { required: true, multiple: false, format: FORMATS.TAXON_ID },
             qid: { required: false, multiple: false, format: FORMATS.QID },
             rank: { required: false, multiple: false },
             gbif: { required: false, multiple: false, format: FORMATS.INTEGER },
             children_gbif: { required: false, multiple: true, format: FORMATS.INTEGER },
-            ancestors_gbif: { required: false, multiple: true, format: FORMATS.INTEGER }
+            ancestors_gbif: { required: false, multiple: true, format: FORMATS.INTEGER },
+            duplicate_of: { required: false, multiple: false, format: FORMATS.TAXON_ID }
         })
     }
 }

package/src/catalog/tables/work.ts

@@ -4,7 +4,7 @@ import { Entity } from '../entity'
 export class Work extends Entity {
     constructor (values: Record<string, string>) {
         super(values, {
-            id: { required: true, multiple: false, format: FORMATS.ID },
+            id: { required: true, multiple: false, format: FORMATS.WORK_ID },
             title: { required: true, multiple: CHECK.MULTILANG },
             author: { required: false, multiple: true },
             url: { required: false, multiple: true, format: FORMATS.URL },
@@ -31,10 +31,10 @@ export class Work extends Entity {
             region: { required: true, multiple: true },
             complete: { required: false, multiple: false, format: FORMATS.COMPLETE },
             target_taxa: { required: false, multiple: true },
-            listed_in: { required: false, multiple: true, format: FORMATS.ID },
-            part_of: { required: false, multiple: true, format: FORMATS.ID },
-            version_of: { required: false, multiple: true, format: FORMATS.ID },
-            duplicate_of: { required: false, multiple: false, format: FORMATS.ID }
+            listed_in: { required: false, multiple: true, format: FORMATS.WORK_ID },
+            part_of: { required: false, multiple: true, format: FORMATS.WORK_ID },
+            version_of: { required: false, multiple: true, format: FORMATS.WORK_ID },
+            duplicate_of: { required: false, multiple: false, format: FORMATS.WORK_ID }
         })
     }
 

package/src/catalog/value.ts

@@ -1,7 +1,5 @@
-import spdxLicenseList = require('spdx-license-list')
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import ietfTagListFactory = require('ietf-language-tag-regex')
+import spdxLicenseList from 'spdx-license-list'
+import ietfTagListFactory from 'ietf-language-tag-regex'
 
 const ietfTagList = ietfTagListFactory()
 
@@ -10,7 +8,11 @@ export const FORMATS = {
     KEY_TYPE: ['key', 'matrix', 'reference', 'gallery', 'checklist', 'supplement', 'collection', 'algorithm'],
     COMPLETE: ['TRUE', 'FALSE'],
 
-    ID: /^B\d+$/,
+    WORK_ID: /^B[1-9]\d*$/,
+    AUTHOR_ID: /^A[1-9]\d*$/,
+    PLACE_ID: /^G[1-9]\d*$/,
+    PUBLISHER_ID: /^P[1-9]\d*$/,
+    TAXON_ID: /^T[1-9]\d*$/,
     EDTF_0: /^(\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}:\d{2}(Z|[-+]\d{2}(:\d{2})?))?)?)?|\d{4}(-\d{2}(-\d{2})?)?\/(\d{4}(-\d{2}(-\d{2})?)?|\.\.))$/,
     ISSN_L: /^[0-9]{4}-[0-9]{3}[0-9X]$/,
     ISBN: /^(\d{13}|\d{9}[0-9X])$/,

package/src/module.d.ts

@@ -139,3 +139,8 @@ interface ResourceProcessorConfig {
     update: boolean,
     updateMappings: boolean
 }
+
+declare module 'ietf-language-tag-regex' {
+    function createLanguageTagRegex(): RegExp
+    export = createLanguageTagRegex
+}

package/src/resources/diff-resource.ts

@@ -36,7 +36,8 @@ function LCS (X: string[], Y: string[]): DiffPart[] {
                 text: X[i - 1],
                 type: ResourceDiffType.Unchanged
             })
-            i--, j--
+            i--
+            j--
         } else if (i !== 0 && (j === 0 || C[i - 1][j] > C[i][j - 1])) {
             diff.unshift({
                 text: X[i - 1],

package/src/resources/parse-text.ts

@@ -294,6 +294,7 @@ function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxo
     item.taxonRemarks = notes
     item.taxonRank = rank
 
+    // @ts-expect-error TS1501: This regular expression flag is only available when targeting 'es6' or later.
     if (/[^\p{L}0-9\u{00D7}\- ]/u.test(taxon)) {
         throw new Error(`Taxon name contains unexpected characters: "${taxon}"`)
     }

package/tsconfig.json

@@ -5,7 +5,8 @@
 
     "noImplicitAny": true,
     "strictNullChecks": true,
-    "noImplicitThis": true
+    "noImplicitThis": true,
+    "esModuleInterop": true
   },
   "include": ["./src/**/*"]
 }

package/.eslintrc.js

@@ -1,16 +0,0 @@
-module.exports = {
-  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint'],
-  root: true,
-
-  rules: {
-    indent: ['error', 4, { SwitchCase: 1 }],
-    'no-unused-vars': 'off',
-    '@typescript-eslint/no-unused-vars': ['warn', {
-      argsIgnorePattern: '^_',
-      varsIgnorePattern: '^_',
-      caughtErrorsIgnorePattern: '^_'
-    }]
-  }
-}

package/src/bin/clean-links.ts

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-import { promises as fs } from 'fs'
-import * as path from 'path'
-import * as util from 'util'
-
-import { catalog, csv } from '../index'
-
-const LINKS: Record<string, { sheet: string, cleanField: string }> = {
-    author: { sheet: 'authors', cleanField: 'main_full_name' },
-    publisher: { sheet: 'publishers', cleanField: 'full_name' },
-}
-
-function replaceLink (value: string, data: catalog.Entities, cleanField: string): string {
-    const entity = data.get(value)
-    return entity.get(cleanField) as string ?? value
-}
-
-function save (sheet: catalog.Entities, path: string): Promise<void> {
-    return fs.writeFile(path, csv.formatCsv(sheet.toTable()))
-}
-
-async function main (): Promise<void> {
-    const args = util.parseArgs({ allowPositionals: true })
-
-    const files: Record<string, { path: string, sheet: catalog.Entities }> = {}
-    for (const arg of args.positionals) {
-        const filePath = path.resolve(arg)
-        const file = await fs.readFile(filePath, 'utf8')
-        const sheet = path.basename(filePath, '.csv')
-        files[sheet] = {
-            path: filePath,
-            sheet: catalog.loadData(file, sheet),
-        }
-    }
-
-    if (!files.catalog) {
-        throw new Error('Catalog file must be provided')
-    }
-
-    for (const field in LINKS) {
-        const { sheet, cleanField } = LINKS[field]
-        const indexField = catalog.getTypeInfo(sheet)[1]
-        const used = new Set()
-
-        if (!files[sheet]) {
-            continue
-        }
-
-        // Update works
-        for (const work of files.catalog.sheet.entities) {
-            const value = work.get(field)
-
-            if (value === undefined) {
-                continue
-            } else if (Array.isArray(value)) {
-                work.fields[field] = value.map(value => {
-                    value = replaceLink(value, files[sheet].sheet, cleanField)
-                    used.add(value)
-                    return value
-                })
-            } else {
-                work.fields[field] = replaceLink(value, files[sheet].sheet, cleanField)
-                used.add(work.fields[field])
-            }
-        }
-
-        // Filter unused values
-        const entities = []
-        for (const entity of files[sheet].sheet.entities) {
-            const oldKey = entity.get(indexField) as string
-
-            if (entity.has(cleanField)) {
-                entity.fields[indexField] = entity.get(cleanField) as Value
-                delete entity.fields[cleanField]
-            }
-
-            const newKey = entity.get(indexField) as string
-
-            if (used.has(newKey) && (newKey === oldKey || !files[sheet].sheet.index[newKey])) {
-                entities.push(entity)
-            }
-        }
-
-        // Save new file
-        await save(new catalog.Entities(entities, indexField), files[sheet].path)
-    }
-
-    // Save catalog
-    await save(files.catalog.sheet, files.catalog.path)
-}
-
-main().catch((error: Error) => {
-    console.error(error)
-    process.exit(1)
-})