@larsgw/formica 0.8.8 → 0.9.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.9.0](https://github.com/identification-resources/formica/compare/v0.8.8...v0.9.0) (2026-02-04)
+
+
+### Bug Fixes
+
+* **resources:** improve taxonomic status ([0ea8fd2](https://github.com/identification-resources/formica/commit/0ea8fd220571f5f6ff05f517069aba10148c6888))
+
+
+### Features
+
+* **resources:** include cluster data in DwC files ([60a28ac](https://github.com/identification-resources/formica/commit/60a28ace18b0760696735ca416a2e8d014d1c928))
+* **resources:** include uncertainty of synonymy in DwC if specified ([03b6734](https://github.com/identification-resources/formica/commit/03b6734851dc9c331ec88fab21e90ad3f0303c3c))
+
+
+
 ## [0.8.8](https://github.com/identification-resources/formica/compare/v0.8.7...v0.8.8) (2025-12-25)
 
 

package/lib/bin/process-resources.js

@@ -82,6 +82,7 @@ const DWC_FIELDS = [
     'subgenus',
     'higherClassification',
     'verbatimIdentification',
+    'dynamicProperties',
     'colTaxonID',
     'gbifTaxonID',
     'colAcceptedTaxonID',

package/lib/resources/parse-name.js

@@ -43,7 +43,7 @@ exports.RANKS = [
 ];
 const TAXONOMIC_STATUS = {
     '>': 'incorrect',
-    '+': 'heterotypic synonym',
+    '+': 'proparte synonym',
     '=': 'synonym'
 };
 const RANK_LABELS = {
@@ -113,6 +113,7 @@ const SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/;
  *     $2c intergeneric hybrid: [A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+
  */
 const BINAME_PATTERN = /^(?:((?:x )?[A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?(x [a-z-]+|[a-z-][^\s.]+(?: x [a-z-]+)?|[A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+)(?= |$)/;
+const CLUSTER_PATTERN = /^\[(_|\d+)\] /;
 function compareRanks(a, b) {
     return exports.RANKS.indexOf(a) - exports.RANKS.indexOf(b);
 }
@@ -158,15 +159,21 @@ function parseName(name, rank, parent) {
     const isSynonym = /^[+=>] /.test(name);
     if (isSynonym) {
         item.taxonomicStatus = TAXONOMIC_STATUS[name[0]];
-        name = name.replace(/^[+=>] (\? ?)?/, '');
+        name = name.slice(2);
+        if (/^\? ?/.test(name)) {
+            item.dynamicProperties = '{"synonymUncertain":true}';
+            name = name.replace(/^\? ?/, '');
+        }
         rank = getSynonymRank(name, parent.taxonRank);
     }
     else {
         item.taxonomicStatus = 'accepted';
     }
     // Clusters
-    if (/^\[(_|\d+)\] /.test(name)) {
-        name = name.replace(/^\[(_|\d+)\] /, '');
+    if (CLUSTER_PATTERN.test(name)) {
+        const [match, cluster] = name.match(CLUSTER_PATTERN);
+        item.cluster = cluster;
+        name = name.slice(match.length);
     }
     // Set verbatim identification after subsequent syntax is removed.
     item.verbatimIdentification = name.replace(/(?<=^| )x(?=$| )/g, HYBRID_SIGN).replace(/_/g, ' ');
@@ -351,5 +358,8 @@ function parseName(name, rank, parent) {
     if (item.scientificNameAuthorship) {
         item.scientificName += ` ${item.scientificNameAuthorship}`;
     }
+    if (isSynonym && /^auctt?\./.test(item.taxonRemarks)) {
+        item.taxonomicStatus = 'misapplied';
+    }
     return item;
 }

package/lib/resources/parse-text.js

@@ -153,6 +153,32 @@ function parseResource(resource) {
     const offsetLine = resource.offsetLine + (header + _).split('\n').length - 1;
     return [config, { content, offsetLine }];
 }
+function getTaxonChildren(parent, taxa) {
+    const children = [];
+    for (const id in taxa) {
+        if (taxa[id].parentNameUsageID === parent) {
+            children.push(taxa[id]);
+        }
+    }
+    return children;
+}
+function processClusters(taxa) {
+    for (const id in taxa) {
+        const taxon = taxa[id];
+        if (taxon.taxonomicStatus !== 'accepted' || !taxon.cluster) {
+            continue;
+        }
+        const dynamicProperties = taxon.dynamicProperties ? JSON.parse(taxon.dynamicProperties) : {};
+        if (taxon.cluster === '_') {
+            dynamicProperties.identifiable = false;
+        }
+        else {
+            const siblings = getTaxonChildren(taxon.parentNameUsageID, taxa).filter(sibling => sibling.scientificNameID !== id);
+            dynamicProperties.indistinguishableFrom = siblings.filter(sibling => sibling.cluster === taxon.cluster).map(sibling => sibling.scientificNameID);
+        }
+        taxon.dynamicProperties = JSON.stringify(dynamicProperties);
+    }
+}
 function parseResourceContent(content, resource, oldIds, offsetLine) {
     var _a, _b;
     const leafTaxonIndex = resource.metadata.levels.reduce((last, rank, i) => MAIN_RANKS.includes(rank) ? i : last, 0);
@@ -311,6 +337,7 @@ function parseResourceContent(content, resource, oldIds, offsetLine) {
     if (errors.length) {
         throw mergeParserErrors(errors);
     }
+    processClusters(data);
     return resource;
 }
 function splitResources(file) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larsgw/formica",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "description": "SDK and tools for data from the Library of Identification Resources",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/bin/process-resources.ts

@@ -44,6 +44,8 @@ const DWC_FIELDS: (keyof AmendedTaxon)[] = [
     'higherClassification',
     'verbatimIdentification',
 
+    'dynamicProperties',
+
     'colTaxonID',
     'gbifTaxonID',
     'colAcceptedTaxonID',

package/src/module.d.ts

@@ -56,12 +56,14 @@ interface TaxonBase {
     subgenus?: string,
     higherClassification?: string,
     verbatimIdentification?: string,
+    dynamicProperties?: string,
 }
 
 interface WorkingTaxon extends TaxonBase {
     // Non-standard
     scientificNameOnly?: string,
-    incorrect?: WorkingTaxon
+    incorrect?: WorkingTaxon,
+    cluster?: string
 }
 
 interface Taxon extends TaxonBase {

package/src/resources/parse-name.ts

@@ -42,7 +42,7 @@ export const RANKS: Rank[] = [
 
 const TAXONOMIC_STATUS: Record<string, TaxonStatus> = {
     '>': 'incorrect',
-    '+': 'heterotypic synonym',
+    '+': 'proparte synonym',
     '=': 'synonym'
 }
 
@@ -123,6 +123,8 @@ const SUBGENUS_PATTERN = /^([A-Z]\S+) (?:\(([A-Z]\S+?)\))(?= |$)/
  */
 const BINAME_PATTERN = /^(?:((?:x )?[A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?(x [a-z-]+|[a-z-][^\s.]+(?: x [a-z-]+)?|[A-Z][a-z]+_[a-z-]+ x [A-Z][a-z]+_[a-z-]+)(?= |$)/
 
+const CLUSTER_PATTERN = /^\[(_|\d+)\] /
+
 function compareRanks (a: Rank, b: Rank): number {
     return RANKS.indexOf(a) - RANKS.indexOf(b)
 }
@@ -173,15 +175,21 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
     const isSynonym = /^[+=>] /.test(name)
     if (isSynonym) {
         item.taxonomicStatus = TAXONOMIC_STATUS[name[0]]
-        name = name.replace(/^[+=>] (\? ?)?/, '')
+        name = name.slice(2)
+        if (/^\? ?/.test(name)) {
+            item.dynamicProperties = '{"synonymUncertain":true}'
+            name = name.replace(/^\? ?/, '')
+        }
         rank = getSynonymRank(name, parent.taxonRank as Rank)
     } else {
         item.taxonomicStatus = 'accepted'
     }
 
     // Clusters
-    if (/^\[(_|\d+)\] /.test(name)) {
-        name = name.replace(/^\[(_|\d+)\] /, '')
+    if (CLUSTER_PATTERN.test(name)) {
+        const [match, cluster] = name.match(CLUSTER_PATTERN) as string[]
+        item.cluster = cluster
+        name = name.slice(match.length)
     }
 
     // Set verbatim identification after subsequent syntax is removed.
@@ -376,5 +384,9 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         item.scientificName += ` ${item.scientificNameAuthorship}`
     }
 
+    if (isSynonym && /^auctt?\./.test(item.taxonRemarks)) {
+        item.taxonomicStatus = 'misapplied'
+    }
+
     return item
 }

package/src/resources/parse-text.ts

@@ -134,6 +134,36 @@ function parseResource (resource: FilePart): [ResourceMetadata, FilePart] {
     return [config, { content, offsetLine }]
 }
 
+function getTaxonChildren (parent: TaxonId|undefined, taxa: Record<TaxonId, WorkingTaxon>): WorkingTaxon[] {
+    const children = []
+    for (const id in taxa) {
+        if (taxa[id].parentNameUsageID === parent) {
+            children.push(taxa[id])
+        }
+    }
+    return children
+}
+
+function processClusters (taxa: Record<TaxonId, WorkingTaxon>) {
+    for (const id in taxa) {
+        const taxon = taxa[id]
+        if (taxon.taxonomicStatus !== 'accepted' || !taxon.cluster) {
+            continue
+        }
+
+        const dynamicProperties = taxon.dynamicProperties ? JSON.parse(taxon.dynamicProperties) : {}
+
+        if (taxon.cluster === '_') {
+            dynamicProperties.identifiable = false
+        } else {
+            const siblings = getTaxonChildren(taxon.parentNameUsageID, taxa).filter(sibling => sibling.scientificNameID !== id)
+            dynamicProperties.indistinguishableFrom = siblings.filter(sibling => sibling.cluster === taxon.cluster).map(sibling => sibling.scientificNameID)
+        }
+
+        taxon.dynamicProperties = JSON.stringify(dynamicProperties)
+    }
+}
+
 function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds: number[], offsetLine: number): Resource {
     const leafTaxonIndex = resource.metadata.levels.reduce((last, rank, i) => MAIN_RANKS.includes(rank) ? i : last, 0)
     const data = resource.taxa as Record<TaxonId, WorkingTaxon>
@@ -307,6 +337,8 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         throw mergeParserErrors(errors)
     }
 
+    processClusters(data)
+
     return resource
 }
 

package/test/resources.js

@@ -166,6 +166,27 @@ Polistes Latreille, 1802
         assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Polistes')
     })
 
+    test('handles clusters', () => {
+        const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
+---
+
+Eurydema Laporte, 1833
+  oleracea (Linnaeus, 1758)
+  [1] rotundicollis (Dohrn, 1860)
+  [1] fieberi Schummel, 1837
+  [2] ornata (Linnaeus, 1758)
+  [2] ventralis Kolenati, 1846
+  [_] eckerleini Josifov, 1961
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:2'].dynamicProperties, undefined)
+        assert.strictEqual(resource.taxa['T1:1:3'].dynamicProperties, '{"indistinguishableFrom":["T1:1:4"]}')
+        assert.strictEqual(resource.taxa['T1:1:4'].dynamicProperties, '{"indistinguishableFrom":["T1:1:3"]}')
+        assert.strictEqual(resource.taxa['T1:1:5'].dynamicProperties, '{"indistinguishableFrom":["T1:1:6"]}')
+        assert.strictEqual(resource.taxa['T1:1:6'].dynamicProperties, '{"indistinguishableFrom":["T1:1:5"]}')
+        assert.strictEqual(resource.taxa['T1:1:7'].dynamicProperties, '{"identifiable":false}')
+    })
+
     suite('leaf taxa checks', () => {
         test('errors for missing leaf taxa', () => {
             assert.throws(() => {