jats-cli 0.0.0

package/dist/parse.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import type { ISession } from 'myst-cli-utils';
+import { type ResolutionOptions } from 'jats-fetch';
+import { Jats } from 'jats-xml';
+export declare function parseJats(session: ISession, file: string, opts?: ResolutionOptions): Promise<Jats>;
+export declare function addDownloadCLI(program: Command): void;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAS/C,OAAO,EAA0C,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAAE,IAAI,EAAiB,MAAM,UAAU,CAAC;AA+C/C,wBAAsB,SAAS,CAC7B,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,iBAAoD,GACzD,OAAO,CAAC,IAAI,CAAC,CAef;AA2JD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAI9C"}

package/dist/parse.js

@@ -0,0 +1,198 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import { extname } from 'path';
+import { clirun, getSession, isUrl, tic, writeFileToFolder } from 'myst-cli-utils';
+import { doi } from 'doi-utils';
+import chalk from 'chalk';
+import { formatPrinciples, highlightFAIR } from 'fair-principles';
+import { formatDate, toDate } from 'jats-utils';
+import { Tags } from 'jats-tags';
+import { toText } from 'myst-common';
+import { select, selectAll } from 'unist-util-select';
+import { downloadJatsFromUrl, DEFAULT_RESOLVERS } from 'jats-fetch';
+import { Jats, findArticleId } from 'jats-xml';
+function hasValidExtension(output) {
+    return ['.xml', '.jats'].includes(extname(output).toLowerCase());
+}
+async function downloadAndSaveJats(session, urlOrDoi, output, opts = { resolvers: DEFAULT_RESOLVERS }) {
+    if (fs.existsSync(urlOrDoi)) {
+        throw new Error(`File "${urlOrDoi}" is local and cannot be downloaded!`);
+    }
+    if (!(doi.validate(urlOrDoi) || isUrl(urlOrDoi))) {
+        throw new Error(`Path must be a URL or DOI, not "${urlOrDoi}"`);
+    }
+    if (!hasValidExtension(output)) {
+        session.log.warn(`The extension ${extname(output)} is not a valid extension for JATS, try using ".xml" or ".jats"`);
+    }
+    const { success, data, source } = await downloadJatsFromUrl(session, urlOrDoi, opts);
+    if (!success || !data) {
+        logAboutJatsFailing(session, [source]);
+        process.exit(1);
+    }
+    writeFileToFolder(output, data);
+    return data;
+}
+function logAboutJatsFailing(session, jatsUrls) {
+    session.log.warn('⛔️ JATS may not be Open Access 😭, you should petition your local representative 🪧');
+    session.log.info(`${chalk.green(`\nThe XML ${chalk.bold('should')} be here:\n\n${jatsUrls.join('\n')}`)}\n`);
+    const FAIR = highlightFAIR('A', { chalk });
+    session.log.info(`Some publishers aggressively block programmatic access, which isn't ${FAIR}.`);
+    session.log.debug(formatPrinciples('A*', { chalk }));
+    session.log.info(`\n${chalk.blue('The link may work in a browser.')}\n`);
+}
+export async function parseJats(session, file, opts = { resolvers: DEFAULT_RESOLVERS }) {
+    const toc = tic();
+    if (fs.existsSync(file)) {
+        session.log.debug(`Found ${file} locally, parsing`);
+        const data = fs.readFileSync(file).toString();
+        return new Jats(data, { log: session.log });
+    }
+    const { success, source, data } = await downloadJatsFromUrl(session, file, opts);
+    if (!success || !data) {
+        logAboutJatsFailing(session, [source]);
+        process.exit(1);
+    }
+    const jats = new Jats(data, { source, log: session.log });
+    session.log.debug(toc(`Downloaded and parsed JATS file in %s`));
+    return jats;
+}
+function formatLongString(data, offset = 0, length = 88 - offset) {
+    const out = [data.slice(0, length)];
+    let left = data.slice(length);
+    while (left.length > length) {
+        out.push(left.slice(0, length).trim());
+        left = left.slice(length);
+    }
+    if (left)
+        out.push(left.trim());
+    return out.join(`\n${' '.repeat(offset)}`);
+}
+function formatDictionary(dict, opts) {
+    const maxLabel = Object.keys(dict).reduce((a, b) => Math.max(a, b.length), 0);
+    return Object.entries(dict)
+        .map(([k, t]) => {
+        var _a;
+        if (!t)
+            return null;
+        let wrap = typeof (opts === null || opts === void 0 ? void 0 : opts.wrap) === 'boolean' ? opts.wrap : true;
+        let value = t;
+        let color = chalk.yellow.bold;
+        if (t && typeof t === 'object') {
+            if (!t.value)
+                return null;
+            color = (_a = t.label) !== null && _a !== void 0 ? _a : color;
+            value = t.value;
+            wrap = typeof t.wrap === 'boolean' ? t.wrap : wrap;
+        }
+        const wrapped = wrap ? formatLongString(String(value), maxLabel + 2) : String(value);
+        return `${color(k)}:${' '.repeat(maxLabel - k.length + 1)}${wrapped}`;
+    })
+        .filter((o) => !!o)
+        .join('\n');
+}
+async function jatsSummaryCLI(session, file) {
+    var _a, _b, _c;
+    const jats = await parseJats(session, file);
+    const summary = {
+        Source: { value: jats.source, wrap: false },
+        DOI: jats.doi ? { value: doi.buildUrl(jats.doi), wrap: false } : null,
+        Title: (_a = toText(jats.articleTitle)) === null || _a === void 0 ? void 0 : _a.replace(/\n/g, ' '),
+        Date: formatDate(toDate(jats.publicationDate)),
+        Authors: jats.articleAuthors
+            .map((a) => `${toText(select(Tags.givenNames, a))} ${toText(select(Tags.surname, a))}`)
+            .join(', '),
+        Abstract: (_b = toText(jats.abstract)) === null || _b === void 0 ? void 0 : _b.replace(/\n/g, ' '),
+        Keywords: jats.keywords.map((k) => toText(k)).join(', '),
+        License: (_c = jats.license) === null || _c === void 0 ? void 0 : _c['xlink:href'],
+    };
+    if (jats.body) {
+        summary.Figures = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.fig, jats.body).length),
+        };
+        summary.Equations = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.dispFormula, jats.body).length),
+        };
+        summary.Tables = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.table, jats.body).length),
+        };
+        summary.Code = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.code, jats.body).length),
+        };
+        summary.Sections = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.sec, jats.body).length),
+        };
+        summary.Paragraphs = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.p, jats.body).length),
+        };
+        summary.Citations = { label: chalk.blue.bold, value: String(jats.references.length) };
+        summary['Cross-References'] = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.xref, jats.body).length),
+        };
+        summary['Sub Articles'] = { label: chalk.blue.bold, value: String(jats.subArticles.length) };
+    }
+    session.log.info(formatDictionary(summary));
+    if (!jats.body) {
+        session.log.warn('\nThis is a partial JATS record that does not have <body>.');
+    }
+}
+async function jatsReferencesCLI(session, file) {
+    const jats = await parseJats(session, file);
+    const sorted = jats.references
+        .map((ref) => {
+        const doiString = findArticleId(ref, 'doi');
+        const title = toText(select(Tags.articleTitle, ref));
+        const year = toText(select(Tags.year, ref));
+        const surnames = selectAll(Tags.surname, ref);
+        const short = surnames.length > 2
+            ? toText(surnames[0]) + ' et al.'
+            : surnames.length === 2
+                ? toText(surnames[0]) + ' and ' + toText(surnames[1])
+                : toText(surnames[0]);
+        const s = selectAll(`[rid=${ref.id}]`, jats.body);
+        return {
+            Citation: `${short} (${year})`,
+            Title: title,
+            DOI: doiString ? doi.buildUrl(doiString) : null,
+            Count: s.length,
+        };
+    })
+        .sort((a, b) => b.Count - a.Count);
+    sorted.forEach((r) => {
+        session.log.info(formatDictionary(r, { wrap: false }) + '\n');
+    });
+}
+function makeSummaryCLI(program) {
+    const command = new Command('summary')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<jats>', 'The JATS file or remote URL to be parsed')
+        .action(clirun(jatsSummaryCLI, { program, getSession }));
+    return command;
+}
+function makeReferencesCLI(program) {
+    const command = new Command('refs')
+        .alias('references')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<jats>', 'The JATS file or remote URL to be parsed')
+        .action(clirun(jatsReferencesCLI, { program, getSession }));
+    return command;
+}
+function makeDownloadCLI(program) {
+    const command = new Command('download')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<url>', 'The JATS url or a DOI')
+        .argument('<output>', 'The JATS output file')
+        .action(clirun(downloadAndSaveJats, { program, getSession }));
+    return command;
+}
+export function addDownloadCLI(program) {
+    program.addCommand(makeDownloadCLI(program));
+    program.addCommand(makeSummaryCLI(program));
+    program.addCommand(makeReferencesCLI(program));
+}

package/dist/validate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function addValidateCLI(program: Command): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AA6C5C,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAE9C"}

package/dist/validate.js

@@ -0,0 +1,24 @@
+import { Command, Option } from 'commander';
+import { validateJatsAgainstDtdWrapper } from 'jats-xml';
+import { clirun, getSession } from 'myst-cli-utils';
+function makeValidateCLI(program) {
+    const command = new Command('validate')
+        .description(`
+      Validate JATS file against DTD schema.
+
+      The JATS DTD schema file is fetched from nih.gov ftp server if not available locally.
+      This will attempt to infer the specific JATS DTD version, library, etc from the file header,
+      but options are available to override the inferred values.
+      `)
+        .argument('<file>', 'JATS file to validate')
+        .addOption(new Option('--library <value>', 'JATS library - archiving, publishing, or authoring (default: archiving, if value cannot be inferred from file)'))
+        .addOption(new Option('--jats <version>', 'JATS version, must be 1.1 or later (default: 1.3, if value cannot be inferred from file)'))
+        .addOption(new Option('--mathml <version>', 'MathML version, 2 or 3 (default: 3, if value cannot be inferred from file)'))
+        .addOption(new Option('--oasis', 'Use OASIS table model (default: false, if value cannot be inferred from file)'))
+        .addOption(new Option('--directory <value>', 'Directory to save DTD file'))
+        .action(clirun(validateJatsAgainstDtdWrapper, { program, getSession }));
+    return command;
+}
+export function addValidateCLI(program) {
+    program.addCommand(makeValidateCLI(program));
+}

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+declare const version = "0.0.0";
+export default version;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,OAAO,UAAU,CAAC;AACxB,eAAe,OAAO,CAAC"}

package/dist/version.js

@@ -0,0 +1,2 @@
+const version = '0.0.0';
+export default version;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "jats-cli",
+  "version": "0.0.0",
+  "description": "Typescript CLI for with JATS",
+  "author": "Rowan Cockett <rowan@curvenote.com>",
+  "homepage": "https://github.com/curvenote/jats",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "jats",
+    "open-science",
+    "publishing"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/curvenote/jats.git"
+  },
+  "bin": {
+    "jats": "./dist/jats.cjs"
+  },
+  "scripts": {
+    "copy:version": "echo \"const version = '\"$npm_package_version\"';\nexport default version;\" > src/version.ts",
+    "clean": "rm -rf dist",
+    "unlink": "npm uninstall -g jats-cli",
+    "link": "npm run unlink; npm link;",
+    "dev": "npm run copy:version && npm run link && esbuild src/index.ts --bundle --outfile=dist/jats.cjs --platform=node --watch",
+    "test": "npm run copy:version && vitest run",
+    "test:watch": "npm run copy:version && vitest watch",
+    "lint": "eslint \"src/**/*.ts*\" -c ./.eslintrc.cjs",
+    "lint:format": "prettier --check \"src/**/*.{ts,tsx,md}\"",
+    "build:esm": "tsc",
+    "build:cli": "esbuild src/index.ts --bundle --outfile=dist/jats.cjs --platform=node",
+    "build": "npm-run-all -l clean copy:version -p build:esm build:cli"
+  },
+  "bugs": {
+    "url": "https://github.com/curvenote/jats/issues"
+  },
+  "dependencies": {
+    "doi-utils": "^2.0.0",
+    "fair-principles": "^2.0.0",
+    "jats-convert": "^0.0.0",
+    "jats-fetch": "^1.0.9",
+    "jats-tags": "^1.0.9",
+    "jats-utils": "^1.0.9",
+    "jats-xml": "^1.0.9",
+    "js-yaml": "^4.1.0",
+    "unist-util-is": "^5.2.1",
+    "unist-util-select": "^4.0.0"
+  },
+  "peerDependencies": {
+    "chalk": "^5.2.0",
+    "commander": "^10.0.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.5",
+    "chalk": "^5.2.0",
+    "commander": "^10.0.1",
+    "myst-cli-utils": "^2.0.0",
+    "myst-common": "^1.0.0"
+  }
+}