@larsgw/formica 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,66 @@
+# [0.3.0](https://github.com/identification-resources/formica/compare/v0.2.1...v0.3.0) (2023-08-20)
+
+
+### Features
+
+* **resources:** add accepted ids to dwc and index ([1b5aba8](https://github.com/identification-resources/formica/commit/1b5aba8ff07bba32fc1bbf49927fef7a880eb35e))
+* **resources:** allow updates of just mappings ([0ea62c1](https://github.com/identification-resources/formica/commit/0ea62c143a49129709960de123c0037973356487))
+* **resources:** improve prefix selection heuristics ([7c2e0c9](https://github.com/identification-resources/formica/commit/7c2e0c99d9de7490314f971e8b4e9e5e190a81c2))
+* **resources:** improve taxon name matching ([78ff480](https://github.com/identification-resources/formica/commit/78ff480485ca42bd1d1f2893f230e61db6cb6be8)), closes [#2](https://github.com/identification-resources/formica/issues/2)
+* **resources:** test for rank mismatch ([0e69b7f](https://github.com/identification-resources/formica/commit/0e69b7f0a6654fa5255e797be7516cd06edb4df3)), closes [#2](https://github.com/identification-resources/formica/issues/2)
+
+
+
+## [0.2.1](https://github.com/identification-resources/formica/compare/v0.2.0...v0.2.1) (2023-08-10)
+
+
+### Bug Fixes
+
+* **resources:** do not validate old versions ([1a8dd2e](https://github.com/identification-resources/formica/commit/1a8dd2e0e373489e287d1fd89dbb7443245c5214))
+* **resources:** fix check for missing leaf taxa ([035f1ad](https://github.com/identification-resources/formica/commit/035f1ad20efa80b388ec3828d4ace4518c7b344e))
+
+
+
+# [0.2.0](https://github.com/identification-resources/formica/compare/v0.1.1...v0.2.0) (2023-08-09)
+
+
+### Features
+
+* **catalog:** add taxon_scope column ([6a06c37](https://github.com/identification-resources/formica/commit/6a06c37ec0640a8ffbc258ad6a4d81d84d35fee9))
+* **resources:** check for missing leaf taxa ([387c47d](https://github.com/identification-resources/formica/commit/387c47d10bb7f1fb09a68c10dfa869bb924b7633))
+
+
+
+## [0.1.1](https://github.com/identification-resources/formica/compare/v0.1.0...v0.1.1) (2023-05-10)
+
+
+### Bug Fixes
+
+* **processor:** add Node hashbang ([51dee57](https://github.com/identification-resources/formica/commit/51dee57b8547afba449b2b846bd7d65e7927368f))
+
+
+
+# [0.1.0](https://github.com/identification-resources/formica/compare/fed91fd6f350c47bd067d221a4d0e2278a199dae...v0.1.0) (2023-03-01)
+
+
+### Bug Fixes
+
+* **resources:** fix typo in taxon name pattern ([8f1b6cf](https://github.com/identification-resources/formica/commit/8f1b6cfa3858edb83c0aee589b84ad760ab815af))
+* **resources:** improve name parsing heuristics ([a40642e](https://github.com/identification-resources/formica/commit/a40642e9bdaeaae363584712e45f218809a5754b))
+
+
+### Features
+
+* **catalog:** add SDK for catalog data ([fed91fd](https://github.com/identification-resources/formica/commit/fed91fd6f350c47bd067d221a4d0e2278a199dae))
+* **csv:** allow custom delims in output ([b523614](https://github.com/identification-resources/formica/commit/b523614171b0ff96347cb876a08106df413c4032))
+* **processor:** processor for DwC creation ([0e6f21d](https://github.com/identification-resources/formica/commit/0e6f21dfe00a2892348a4ab04fcaf3d6c8324a91))
+* **processor:** processor for DwC indexing ([279773b](https://github.com/identification-resources/formica/commit/279773b085676cf7cb3eb4d81496ad219ac85bce))
+* **resources:** add SDK for resource text files ([0acd36d](https://github.com/identification-resources/formica/commit/0acd36dde04cc1240cb8be97d48812b201b2685a))
+* **resources:** add support for cluster markings ([112315c](https://github.com/identification-resources/formica/commit/112315c7ebd7151c4e2cc77ab20e0cec3f579db6))
+* **resources:** add support for diffs as input ([9751627](https://github.com/identification-resources/formica/commit/9751627a916f47552661596048f1f0d44d89b102))
+* **resources:** add support for hybrids ([e49e96a](https://github.com/identification-resources/formica/commit/e49e96af9c3958bab2a3b0508b1fc8a018b80716))
+* **validate:** add catalog validation script ([4cdf785](https://github.com/identification-resources/formica/commit/4cdf785afb2c77320cd9b5b76483e3464c0f1cff))
+* **validate:** add script to validate resources ([246fb5d](https://github.com/identification-resources/formica/commit/246fb5dd8da03e736884850874cc51a11be9985c))
+
+
+

package/lib/bin/process-resources-index.js

@@ -62,6 +62,13 @@ function sortObject(object) {
     return sorted;
 }
 /* eslint-enable @typescript-eslint/no-explicit-any */
+function addTaxon(gbifIndex, gbifId, taxon) {
+    if (!(gbifId in gbifIndex)) {
+        gbifIndex[gbifId] = [];
+    }
+    gbifIndex[gbifId].push(taxon[0]);
+    gbifIndex[gbifId].sort(util_1.numericSort);
+}
 function main(args) {
     return __awaiter(this, void 0, void 0, function () {
         var REPO_ROOT, files, gbifIndex, resourceIndex;
@@ -106,11 +113,10 @@ function main(args) {
                                                                         taxon = dwc_1[_i];
                                                                         gbifId = taxon[25];
                                                                         if (gbifId) {
-                                                                            if (!(gbifId in gbifIndex)) {
-                                                                                gbifIndex[gbifId] = [];
+                                                                            addTaxon(gbifIndex, gbifId, taxon);
+                                                                            if (taxon[27] !== taxon[25]) {
+                                                                                addTaxon(gbifIndex, taxon[27], taxon);
                                                                             }
-                                                                            gbifIndex[gbifId].push(taxon[0]);
-                                                                            gbifIndex[gbifId].sort(util_1.numericSort);
                                                                         }
                                                                         amendedResource.taxonCount += 1;
                                                                     }

package/lib/bin/process-resources.js

@@ -80,7 +80,9 @@ var DWC_FIELDS = [
     'subgenus',
     'higherClassification',
     'colTaxonID',
-    'gbifTaxonID'
+    'gbifTaxonID',
+    'colAcceptedTaxonID',
+    'gbifAcceptedTaxonID'
 ];
 var DISPLAY_FIELDS = [
     'scientificNameID',
@@ -102,16 +104,9 @@ var GBIF_RANKS = [
     'subspecies',
     'variety'
 ];
-var VALID_COMMON_PREFIXES = [
-    'Plantae|Tracheophyta',
-    'Fungi',
-    'Fungi|Ascomycota',
-    'Fungi|Basidiomycota',
-    'Fungi|Zygomycota'
-];
 function runGnverifier(names) {
     return new Promise(function (resolve, reject) {
-        var proc = (0, child_process_1.spawn)('gnverifier', ['-s', '1,11', '-M']);
+        var proc = (0, child_process_1.spawn)('gnverifier', ['-s', '1,11', '-f', 'compact', '-M']);
         var stdout = '';
         proc.stdout.on('data', function (data) { stdout += data; });
         proc.stderr.pipe(process.stdout);
@@ -241,6 +236,34 @@ var ResourceProcessor = /** @class */ (function () {
             });
         });
     };
+    ResourceProcessor.prototype.runMappingsUpdate = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var input, ids, _i, ids_2, id;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fs_1.promises.readdir(this.DIR_TXT)];
+                    case 1:
+                        input = _a.sent();
+                        ids = input
+                            .map(function (file) { return path.basename(file, '.txt'); })
+                            .sort(function (a, b) { return parseInt(a.slice(1)) - parseInt(b.slice(1)); });
+                        _i = 0, ids_2 = ids;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < ids_2.length)) return [3 /*break*/, 5];
+                        id = ids_2[_i];
+                        return [4 /*yield*/, this.processWork(id, true)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     ResourceProcessor.prototype.processWork = function (id, update) {
         return __awaiter(this, void 0, void 0, function () {
             var resources;
@@ -271,79 +294,61 @@ var ResourceProcessor = /** @class */ (function () {
     };
     ResourceProcessor.prototype.processResources = function (id, update) {
         return __awaiter(this, void 0, void 0, function () {
-            var resources, amendedResources, _i, resources_1, resource, _a, results, classifications, _b, _c, _d, _e, source, skip, correct, choice, _f, reason;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var resources, amendedResources, _i, resources_1, resource, results, skip, correct, choice, _a, reason;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0: return [4 /*yield*/, this.processResourceText(id, update)];
                     case 1:
-                        resources = _g.sent();
+                        resources = _b.sent();
                         amendedResources = [];
                         _i = 0, resources_1 = resources;
-                        _g.label = 2;
+                        _b.label = 2;
                     case 2:
-                        if (!(_i < resources_1.length)) return [3 /*break*/, 15];
+                        if (!(_i < resources_1.length)) return [3 /*break*/, 11];
                         resource = resources_1[_i];
                         return [4 /*yield*/, this.processResourceDwc(resource)];
                     case 3:
-                        _a = _g.sent(), results = _a[0], classifications = _a[1];
-                        _b = classifications;
-                        _c = [];
-                        for (_d in _b)
-                            _c.push(_d);
-                        _e = 0;
-                        _g.label = 4;
+                        results = _b.sent();
+                        return [4 /*yield*/, this.shouldBeSkipped(resource.id)];
                     case 4:
-                        if (!(_e < _c.length)) return [3 /*break*/, 7];
-                        _d = _c[_e];
-                        if (!(_d in _b)) return [3 /*break*/, 6];
-                        source = _d;
-                        return [4 /*yield*/, this.checkPrefix(resource, classifications, source)];
-                    case 5:
-                        _g.sent();
-                        _g.label = 6;
-                    case 6:
-                        _e++;
-                        return [3 /*break*/, 4];
-                    case 7: return [4 /*yield*/, this.shouldBeSkipped(resource.id)];
-                    case 8:
-                        skip = _g.sent();
-                        if (!!skip) return [3 /*break*/, 13];
+                        skip = _b.sent();
+                        if (!!skip) return [3 /*break*/, 9];
                         correct = this.checkResults(results);
-                        if (!!correct) return [3 /*break*/, 13];
+                        if (!!correct) return [3 /*break*/, 9];
                         return [4 /*yield*/, (0, util_1.promptForAnswers)("".concat(resource.workId, ": problems found in ").concat(resource.id, ". Skip or retry (s/r)? "), ['s', 'S', 'r', 'R'])];
-                    case 9:
-                        choice = _g.sent();
-                        _f = choice;
-                        switch (_f) {
-                            case 's': return [3 /*break*/, 10];
-                            case 'S': return [3 /*break*/, 10];
-                            case 'r': return [3 /*break*/, 12];
-                            case 'R': return [3 /*break*/, 12];
+                    case 5:
+                        choice = _b.sent();
+                        _a = choice;
+                        switch (_a) {
+                            case 's': return [3 /*break*/, 6];
+                            case 'S': return [3 /*break*/, 6];
+                            case 'r': return [3 /*break*/, 8];
+                            case 'R': return [3 /*break*/, 8];
                         }
-                        return [3 /*break*/, 13];
-                    case 10: return [4 /*yield*/, (0, util_1.prompt)('Reason for skipping? ')];
-                    case 11:
-                        reason = _g.sent();
+                        return [3 /*break*/, 9];
+                    case 6: return [4 /*yield*/, (0, util_1.prompt)('Reason for skipping? ')];
+                    case 7:
+                        reason = _b.sent();
                         fs_1.promises.appendFile(this.FILE_PROBLEMS, index_1.csv.formatCsv([[
                                 resource.workId,
                                 resource.id,
                                 reason
                             ]]));
                         console.log("".concat(resource.workId, ": skipping ").concat(resource.id));
-                        return [3 /*break*/, 13];
-                    case 12:
+                        return [3 /*break*/, 9];
+                    case 8:
                         {
                             console.log("".concat(resource.workId, ": retrying ").concat(resource.id));
                             return [2 /*return*/, this.processResources(id, update)];
                         }
-                        _g.label = 13;
-                    case 13:
+                        _b.label = 9;
+                    case 9:
                         amendedResources.push(results);
-                        _g.label = 14;
-                    case 14:
+                        _b.label = 10;
+                    case 10:
                         _i++;
                         return [3 /*break*/, 2];
-                    case 15: return [2 /*return*/, amendedResources];
+                    case 11: return [2 /*return*/, amendedResources];
                 }
             });
         });
@@ -415,119 +420,174 @@ var ResourceProcessor = /** @class */ (function () {
     };
     ResourceProcessor.prototype.processResourceDwc = function (resource) {
         return __awaiter(this, void 0, void 0, function () {
-            var taxa, names, id, name_1, result, classifications, _a, header, matches, _i, matches_1, match, name_2, source, id, classification, loirId, taxon, results;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var filteredResults, taxonNames, names, id, name_1, result, _i, _a, results, _b, name_2, matches, _c, matches_1, match, source, currentRank, _d, _e, loirId, taxon, _f, amendResource, groupNameMatches, groupedNameMatches, amendedResource, _g, _h, _j, _k, source, matches;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
                     case 0:
                         console.log("".concat(resource.workId, ": matching ").concat(resource.id));
-                        taxa = {};
-                        names = [];
+                        filteredResults = {};
+                        taxonNames = {};
+                        names = new Set();
                         for (id in resource.taxa) {
                             name_1 = resource.taxa[id].scientificName;
-                            if (!taxa[name_1]) {
-                                taxa[name_1] = {};
+                            if (!taxonNames[name_1]) {
+                                taxonNames[name_1] = [];
                             }
-                            taxa[name_1][id] = __assign({}, resource.taxa[id]);
-                            names.push(name_1);
+                            taxonNames[name_1].push(id);
+                            names.add(name_1);
+                            filteredResults[id] = [];
                         }
-                        return [4 /*yield*/, runGnverifier(names.join('\n'))];
+                        return [4 /*yield*/, runGnverifier(Array.from(names).join('\n'))];
                     case 1:
-                        result = _b.sent();
-                        classifications = { '1': [], '11': [] };
-                        _a = index_1.csv.parseCsv(result), header = _a[0], matches = _a.slice(1);
-                        for (_i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
-                            match = matches_1[_i];
-                            name_2 = match[header.indexOf('ScientificName')];
-                            source = match[header.indexOf('DataSourceId')];
-                            id = match[header.indexOf('TaxonId')];
-                            classification = match[header.indexOf('ClassificationPath')];
-                            for (loirId in taxa[name_2]) {
-                                taxon = taxa[name_2][loirId];
-                                if (source === '1' && !taxon.colTaxonID) {
-                                    taxon.colTaxonID = id;
-                                    classifications[source].push([taxon, classification]);
+                        result = _l.sent();
+                        for (_i = 0, _a = result.trim().split('\n'); _i < _a.length; _i++) {
+                            results = _a[_i];
+                            _b = JSON.parse(results), name_2 = _b.name, matches = _b.results;
+                            if (!matches) {
+                                continue;
+                            }
+                            for (_c = 0, matches_1 = matches; _c < matches_1.length; _c++) {
+                                match = matches_1[_c];
+                                source = match.dataSourceId;
+                                currentRank = match.classificationRanks.split('|').pop();
+                                if (match.scoreDetails.cardinalityScore === 0) {
+                                    // Rank mismatch
+                                    continue;
+                                }
+                                else if (source === 11 && currentRank === 'species' && match.classificationPath.endsWith(' spec')) {
+                                    // GBIF species like "Nomada spec"
+                                    continue;
                                 }
-                                if (source === '11' && GBIF_RANKS.includes(taxon.taxonRank) && !taxon.gbifTaxonID) {
-                                    taxon.gbifTaxonID = id;
-                                    classifications[source].push([taxon, classification]);
+                                for (_d = 0, _e = taxonNames[name_2]; _d < _e.length; _d++) {
+                                    loirId = _e[_d];
+                                    taxon = resource.taxa[loirId];
+                                    if (source === 11 && !GBIF_RANKS.includes(taxon.taxonRank)) {
+                                        // Exclude GBIF matches for ranks that are not in GBIF
+                                        continue;
+                                    }
+                                    else if (source === 11 && !match.isSynonym && currentRank !== taxon.taxonRank) {
+                                        // Exclude matches with rank mismatches (only possible
+                                        // for non-synonyms).
+                                        continue;
+                                    }
+                                    if (!filteredResults[loirId]) {
+                                        filteredResults[loirId] = [];
+                                    }
+                                    filteredResults[loirId].push({
+                                        source: source,
+                                        id: match.recordId,
+                                        currentId: match.currentRecordId,
+                                        classificationPath: match.classificationPath.split('|')
+                                    });
                                 }
                             }
                         }
-                        results = __assign(__assign({}, resource), { taxa: Object.fromEntries(Object.values(resource.taxa).map(function (taxon) { return [
-                                taxon.scientificNameID,
-                                taxa[taxon.scientificName][taxon.scientificNameID]
-                            ]; })) });
-                        return [2 /*return*/, [results, classifications]];
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require('../index'); })];
+                    case 2:
+                        _f = (_l.sent()).taxonNames, amendResource = _f.amendResource, groupNameMatches = _f.groupNameMatches;
+                        groupedNameMatches = groupNameMatches(filteredResults);
+                        amendedResource = __assign(__assign({}, resource), { taxa: __assign({}, resource.taxa) });
+                        _g = groupedNameMatches;
+                        _h = [];
+                        for (_j in _g)
+                            _h.push(_j);
+                        _k = 0;
+                        _l.label = 3;
+                    case 3:
+                        if (!(_k < _h.length)) return [3 /*break*/, 6];
+                        _j = _h[_k];
+                        if (!(_j in _g)) return [3 /*break*/, 5];
+                        source = _j;
+                        return [4 /*yield*/, this.selectPrefixes(resource, groupedNameMatches, source)];
+                    case 4:
+                        matches = _l.sent();
+                        amendResource(amendedResource, source, matches);
+                        _l.label = 5;
+                    case 5:
+                        _k++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/, amendedResource];
                 }
             });
         });
     };
-    ResourceProcessor.prototype.checkPrefix = function (resource, classifications, source) {
+    ResourceProcessor.prototype.selectPrefixes = function (resource, groupedNameMatches, source) {
         return __awaiter(this, void 0, void 0, function () {
-            var lists, prefix, _i, _a, _b, taxon, list, parts, i, choice;
+            var prefixes, mappedTaxa, _i, prefixes_1, prefix, taxon, missedTaxonCount, choice, i, prefix, taxa, taxonIds, j, taxonId, taxon, match, matches, _a, _b, i, prefix, taxa, id;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        lists = classifications[source];
-                        if (!lists.length) {
-                            return [2 /*return*/];
+                        prefixes = Object.keys(groupedNameMatches[source]);
+                        if (prefixes.length === 0) {
+                            return [2 /*return*/, {}];
                         }
-                        prefix = lists[0][1].split('|');
-                        _i = 0, _a = lists.slice(1);
-                        _c.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 9];
-                        _b = _a[_i], taxon = _b[0], list = _b[1];
-                        parts = list.split('|');
-                        i = 0;
-                        _c.label = 2;
-                    case 2:
-                        if (!(i < parts.length)) return [3 /*break*/, 8];
-                        if (!(parts[i] !== prefix[i] && i < 3)) return [3 /*break*/, 7];
-                        choice = void 0;
-                        if (!(source === '1' || taxon.taxonomicStatus !== 'accepted')) return [3 /*break*/, 3];
-                        choice = 'd';
+                        else if (prefixes.length === 1) {
+                            return [2 /*return*/, groupedNameMatches[source][prefixes[0]]];
+                        }
+                        mappedTaxa = {};
+                        for (_i = 0, prefixes_1 = prefixes; _i < prefixes_1.length; _i++) {
+                            prefix = prefixes_1[_i];
+                            for (taxon in groupedNameMatches[source][prefix]) {
+                                mappedTaxa[taxon] = true;
+                            }
+                        }
+                        missedTaxonCount = Object.keys(mappedTaxa).length - Object.keys(groupedNameMatches[source][prefixes[0]]).length;
+                        if (missedTaxonCount === 0) {
+                            // Multiple prefixes but the first one maps all taxa (not counting that are unmapped in all prefixes)
+                            return [2 /*return*/, groupedNameMatches[source][prefixes[0]]];
+                        }
+                        console.error("".concat(resource.workId, ": source ").concat(source, " results in multiple prefixes"));
+                        if (!(missedTaxonCount <= 5)) return [3 /*break*/, 1];
+                        console.error("  Most common prefix misses ".concat(missedTaxonCount, " taxa: automatically selecting most common prefix..."));
+                        choice = '1';
                         return [3 /*break*/, 6];
-                    case 3:
-                        if (!VALID_COMMON_PREFIXES.includes(prefix.slice(0, i).join('|'))) return [3 /*break*/, 4];
-                        choice = 'k';
+                    case 1:
+                        if (!(source === '1')) return [3 /*break*/, 2];
+                        console.error("  Catalogue of Life: automatically selecting most common prefix...");
+                        choice = '1';
                         return [3 /*break*/, 6];
+                    case 2:
+                        for (i = 0; i < prefixes.length; i++) {
+                            prefix = prefixes[i];
+                            taxa = groupedNameMatches[source][prefix];
+                            taxonIds = Object.keys(taxa);
+                            console.error("  [".concat(i + 1, "] ").concat(prefix, " (").concat(taxonIds.length, " taxa)"));
+                            for (j = 0; j < Math.min(9, taxonIds.length); j++) {
+                                taxonId = taxonIds[j];
+                                taxon = resource.taxa[taxonId];
+                                match = taxa[taxonId];
+                                console.error("      taxon: ".concat(taxonId, " \"").concat(taxon.scientificName, "\" - ").concat(match.classificationPath.join('|')));
+                            }
+                            if (taxonIds.length > 9) {
+                                console.error("      ...");
+                            }
+                        }
+                        _c.label = 3;
+                    case 3: return [4 /*yield*/, (0, util_1.prompt)("  Select prefixes (1-".concat(prefixes.length, ")? "))];
                     case 4:
-                        console.log("".concat(resource.workId, ": source ").concat(source, " results in short prefix \"").concat(prefix.slice(0, i).join('|'), "\" (").concat(i, " taxa)"));
-                        console.log("  taxon: ".concat(taxon.scientificNameID, " \"").concat(taxon.scientificName, "\""));
-                        console.log("  class: ".concat(parts.join('|')));
-                        console.log("  prefx: ".concat(prefix.join('|')));
-                        return [4 /*yield*/, (0, util_1.promptForAnswers)("  Keep or delete (k/d)? ", ['k', 'K', 'd', 'D'])];
-                    case 5:
                         choice = _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        if (!/^(|\d+(,\d+)*)$/.test(choice)) return [3 /*break*/, 3];
                         _c.label = 6;
                     case 6:
-                        switch (choice) {
-                            case 'k':
-                            case 'K': {
-                                console.log("  keeping...");
-                                break;
-                            }
-                            case 'd':
-                            case 'D': {
-                                console.log("  deleting...");
-                                if (source === '1') {
-                                    delete taxon.colTaxonID;
-                                }
-                                else if (source === '11') {
-                                    delete taxon.gbifTaxonID;
+                        console.error("  Applying selection...");
+                        if (choice === '') {
+                            return [2 /*return*/, {}];
+                        }
+                        matches = {};
+                        for (_a = 0, _b = choice.split(','); _a < _b.length; _a++) {
+                            i = _b[_a];
+                            prefix = prefixes[parseInt(i) - 1];
+                            taxa = groupedNameMatches[source][prefix];
+                            for (id in taxa) {
+                                if (id in matches) {
+                                    continue;
                                 }
-                                break;
+                                matches[id] = taxa[id];
                             }
                         }
-                        return [3 /*break*/, 8];
-                    case 7:
-                        i++;
-                        return [3 /*break*/, 2];
-                    case 8:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/];
+                        return [2 /*return*/, matches];
                 }
             });
         });
@@ -578,6 +638,9 @@ function main() {
             update: {
                 type: 'boolean',
                 short: 'u'
+            },
+            'update-mappings': {
+                type: 'boolean'
             }
         },
         allowPositionals: true
@@ -586,7 +649,16 @@ function main() {
     process.on('exit', function () {
         process.stdout.write('\n');
     });
-    var task = args.values.update ? processor.runUpdate() : processor.run();
+    var task;
+    if (args.values.update) {
+        task = processor.runUpdate();
+    }
+    else if (args.values['update-mappings']) {
+        task = processor.runMappingsUpdate();
+    }
+    else {
+        task = processor.run();
+    }
     task.catch(function (error) {
         console.error(error);
         process.exit(1);

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * as catalog from './catalog/index';
 export * as resources from './resources/index';
+export * as taxonNames from './taxon-names/index';
 export * as csv from './csv';

package/lib/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.csv = exports.resources = exports.catalog = void 0;
+exports.csv = exports.taxonNames = exports.resources = exports.catalog = void 0;
 exports.catalog = require("./catalog/index");
 exports.resources = require("./resources/index");
+exports.taxonNames = require("./taxon-names/index");
 exports.csv = require("./csv");