@jbrowse/cli 3.6.0 → 3.6.1

package/dist/commands/create.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs_1 = __importDefault(require("fs"));
+const util_1 = require("util");
+const decompress_1 = __importDefault(require("decompress"));
+const fetchWithProxy_1 = __importDefault(require("../fetchWithProxy"));
+const utils_1 = require("../utils");
+const fsPromises = fs_1.default.promises;
+const description = 'Downloads and installs the latest JBrowse 2 release';
+const examples = [
+    '# Download latest release from github, and put in specific path',
+    '$ jbrowse create /path/to/new/installation',
+    '',
+    '# Download latest release from github and force overwrite existing contents at path',
+    '$ jbrowse create /path/to/new/installation --force',
+    '',
+    '# Download latest release from a specific URL',
+    '$ jbrowse create /path/to/new/installation --url url.com/directjbrowselink.zip',
+    '',
+    '# Download a specific tag from github',
+    '$ jbrowse create /path/to/new/installation --tag v1.0.0',
+    '',
+    '# List available versions',
+    '$ jbrowse create --listVersions',
+];
+const options = {
+    help: {
+        type: 'boolean',
+        short: 'h',
+        description: 'Show help',
+    },
+    force: {
+        type: 'boolean',
+        short: 'f',
+        description: 'Overwrites existing JBrowse 2 installation if present in path',
+    },
+    listVersions: {
+        type: 'boolean',
+        short: 'l',
+        description: 'Lists out all versions of JBrowse 2',
+    },
+    branch: {
+        type: 'string',
+        description: 'Download a development build from a named git branch',
+    },
+    nightly: {
+        type: 'boolean',
+        description: 'Download the latest development build from the main branch',
+    },
+    url: {
+        type: 'string',
+        short: 'u',
+        description: 'A direct URL to a JBrowse 2 release',
+    },
+    tag: {
+        type: 'string',
+        short: 't',
+        description: 'Version of JBrowse 2 to install. Format is v1.0.0.\nDefaults to latest',
+    },
+};
+async function run(args) {
+    const { positionals, values: runFlags } = (0, util_1.parseArgs)({
+        options,
+        allowPositionals: true,
+        args,
+    });
+    if (runFlags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse create [localPath] [options]',
+            options,
+        });
+        return;
+    }
+    const argsPath = positionals[0];
+    if (!argsPath && !runFlags.listVersions) {
+        console.error(`Missing 1 required arg:
+    localPath  Location where JBrowse 2 will be installed
+    See more help with --help`);
+        return;
+    }
+    const { force, url, listVersions, tag, branch, nightly } = runFlags;
+    if (listVersions) {
+        const versions = (await (0, utils_1.fetchGithubVersions)()).map(version => version.tag_name);
+        console.log(`All JBrowse versions:\n${versions.join('\n')}`);
+        process.exit(0);
+    }
+    // mkdir will do nothing if dir exists
+    await fsPromises.mkdir(argsPath, { recursive: true });
+    if (!force) {
+        await checkPath(argsPath);
+    }
+    const locationUrl = url ||
+        (nightly ? await (0, utils_1.getBranch)('main') : '') ||
+        (branch ? await (0, utils_1.getBranch)(branch) : '') ||
+        (tag ? await (0, utils_1.getTag)(tag) : await (0, utils_1.getLatest)());
+    console.log(`Fetching ${locationUrl}...`);
+    const response = await (0, fetchWithProxy_1.default)(locationUrl);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} fetching ${locationUrl}: ${response.statusText}`);
+    }
+    const type = response.headers.get('content-type');
+    if (url &&
+        type !== 'application/zip' &&
+        type !== 'application/octet-stream') {
+        throw new Error('The URL provided does not seem to be a JBrowse installation URL');
+    }
+    await (0, decompress_1.default)(Buffer.from(await response.arrayBuffer()), argsPath);
+    console.log(`Unpacked ${locationUrl} at ${argsPath}`);
+}
+async function checkPath(userPath) {
+    const allFiles = await fsPromises.readdir(userPath);
+    if (allFiles.length > 0) {
+        throw new Error(`This directory (${userPath}) has existing files and could cause conflicts with create. Please choose another directory or use the force flag to overwrite existing files`);
+    }
+}

package/dist/commands/make-pif-utils/cigar-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCigar = parseCigar;
+exports.flipCigar = flipCigar;
+exports.swapIndelCigar = swapIndelCigar;
+const cigarRegex = new RegExp(/([MIDNSHPX=])/);
+function parseCigar(cigar = '') {
+    return cigar.split(cigarRegex).slice(0, -1);
+}
+function flipCigar(cigar) {
+    const arr = [];
+    for (let i = cigar.length - 2; i >= 0; i -= 2) {
+        arr.push(cigar[i]);
+        const op = cigar[i + 1];
+        if (op === 'D') {
+            arr.push('I');
+        }
+        else if (op === 'I') {
+            arr.push('D');
+        }
+        else {
+            arr.push(op);
+        }
+    }
+    return arr;
+}
+function swapIndelCigar(cigar) {
+    return cigar.replaceAll('D', 'K').replaceAll('I', 'D').replaceAll('K', 'I');
+}

package/dist/commands/make-pif-utils/file-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadline = getReadline;
+exports.getStdReadline = getStdReadline;
+exports.createWriteWithBackpressure = createWriteWithBackpressure;
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const zlib_1 = require("zlib");
+function getReadline(filename) {
+    const stream = fs_1.default.createReadStream(filename);
+    return readline_1.default.createInterface({
+        input: /.b?gz$/.exec(filename) ? stream.pipe((0, zlib_1.createGunzip)()) : stream,
+    });
+}
+function getStdReadline() {
+    return readline_1.default.createInterface({
+        input: process.stdin,
+    });
+}
+function createWriteWithBackpressure(stream) {
+    return (data) => {
+        // If the stream buffer is full (write returns false), we need to wait for drain
+        if (!stream.write(data)) {
+            return new Promise(resolve => {
+                const drainHandler = () => {
+                    stream.removeListener?.('drain', drainHandler);
+                    resolve();
+                };
+                stream.once?.('drain', drainHandler);
+            });
+        }
+        // If write returns true, the buffer is not full, so we can continue immediately
+        return Promise.resolve();
+    };
+}

package/dist/commands/make-pif-utils/pif-generator.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPIF = createPIF;
+exports.spawnSortProcess = spawnSortProcess;
+exports.getOutputFilename = getOutputFilename;
+exports.waitForProcessClose = waitForProcessClose;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const cigar_utils_1 = require("./cigar-utils");
+const file_utils_1 = require("./file-utils");
+async function createPIF(filename, stream) {
+    const rl1 = filename ? (0, file_utils_1.getReadline)(filename) : (0, file_utils_1.getStdReadline)();
+    const writeWithBackpressure = (0, file_utils_1.createWriteWithBackpressure)(stream);
+    // Process the file line by line with backpressure handling
+    try {
+        for await (const line of rl1) {
+            const [c1, l1, s1, e1, strand, c2, l2, s2, e2, ...rest] = line.split('\t');
+            // Write the first line and handle backpressure
+            await writeWithBackpressure(`${[`t${c2}`, l2, s2, e2, strand, c1, l1, s1, e1, ...rest].join('\t')}\n`);
+            const cigarIdx = rest.findIndex(f => f.startsWith('cg:Z'));
+            const CIGAR = rest[cigarIdx];
+            if (CIGAR) {
+                rest[cigarIdx] = `cg:Z:${strand === '-'
+                    ? (0, cigar_utils_1.flipCigar)((0, cigar_utils_1.parseCigar)(CIGAR.slice(5))).join('')
+                    : (0, cigar_utils_1.swapIndelCigar)(CIGAR.slice(5))}`;
+            }
+            // Write the second line and handle backpressure
+            await writeWithBackpressure(`${[`q${c1}`, l1, s1, e1, strand, c2, l2, s2, e2, ...rest].join('\t')}\n`);
+        }
+    }
+    catch (error) {
+        console.error('Error processing PAF file:', error);
+        throw error;
+    }
+    finally {
+        rl1.close();
+    }
+}
+function spawnSortProcess(outputFile, useCsi) {
+    // Use a more portable approach to avoid E2BIG errors
+    const sortCmd = `sort -t"\`printf '\\t'\`" -k1,1 -k3,3n`;
+    const bgzipCommand = `bgzip > "${outputFile}"`;
+    const tabixCommand = `tabix ${useCsi ? '-C ' : ''}-s1 -b3 -e4 -0 "${outputFile}"`;
+    const fullCommand = `${sortCmd} | ${bgzipCommand}; ${tabixCommand}`;
+    const minimalEnv = {
+        ...process.env,
+        LC_ALL: 'C',
+    };
+    return (0, child_process_1.spawn)('sh', ['-c', fullCommand], {
+        env: minimalEnv,
+        stdio: ['pipe', process.stdout, process.stderr],
+    });
+}
+function getOutputFilename(file, out) {
+    return out || `${path_1.default.basename(file || 'output', '.paf')}.pif.gz`;
+}
+async function waitForProcessClose(child) {
+    return new Promise(resolve => {
+        child.on('close', resolve);
+    });
+}

package/dist/commands/make-pif-utils/validators.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileArgument = validateFileArgument;
+exports.validateRequiredCommands = validateRequiredCommands;
+const command_exists_1 = require("command-exists");
+function validateFileArgument(file) {
+    // Allow no file argument for stdin input
+    if (!file && process.stdin.isTTY) {
+        console.error('Error: Missing required argument: file');
+        console.error('Usage: jbrowse make-pif <file> [options]');
+        console.error('       OR pipe data via stdin: cat file.paf | jbrowse make-pif');
+        process.exit(1);
+    }
+}
+function validateRequiredCommands() {
+    const requiredCommands = ['sh', 'sort', 'grep', 'tabix', 'bgzip'];
+    const missingCommands = requiredCommands.filter(cmd => !(0, command_exists_1.sync)(cmd));
+    if (missingCommands.length > 0) {
+        console.error('Error: Unable to sort, requires unix type environment with sort, grep, bgzip, tabix');
+        process.exit(1);
+    }
+}

package/dist/commands/make-pif.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const pif_generator_1 = require("./make-pif-utils/pif-generator");
+const validators_1 = require("./make-pif-utils/validators");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+        out: {
+            type: 'string',
+            description: 'Where to write the output file. will write ${file}.pif.gz and ${file}.pif.gz.tbi',
+        },
+        csi: {
+            type: 'boolean',
+            description: 'Create a CSI index for the PIF file instead of TBI',
+        },
+    };
+    const { values: flags, positionals } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = 'creates pairwise indexed PAF (PIF), with bgzip and tabix';
+    const examples = [
+        '$ jbrowse make-pif input.paf # creates input.pif.gz in same directory',
+        '',
+        '$ jbrowse make-pif input.paf --out output.pif.gz # specify output file, creates output.pif.gz.tbi also',
+    ];
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse make-pif <file> [options]',
+            options,
+        });
+        return;
+    }
+    const file = positionals[0];
+    (0, validators_1.validateFileArgument)(file);
+    (0, validators_1.validateRequiredCommands)();
+    const { out, csi = false } = flags;
+    const outputFile = (0, pif_generator_1.getOutputFilename)(file, out);
+    try {
+        const child = (0, pif_generator_1.spawnSortProcess)(outputFile, csi);
+        await (0, pif_generator_1.createPIF)(file, child.stdin);
+        child.stdin.end();
+        await (0, pif_generator_1.waitForProcessClose)(child);
+    }
+    catch (error) {
+        console.error('Error during PIF creation:', error);
+        process.exit(1);
+    }
+}

package/dist/commands/remove-track.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs_1 = require("fs");
+const util_1 = require("util");
+const utils_1 = require("../utils");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+        target: {
+            type: 'string',
+            description: 'Path to config file in JB2 installation directory to write out to',
+        },
+        out: {
+            type: 'string',
+            description: 'Synonym for target',
+        },
+    };
+    const { values: flags, positionals } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = 'Remove a track configuration from a JBrowse 2 configuration. Be aware that this can cause crashes in saved sessions that refer to this track!';
+    const examples = ['$ jbrowse remove-track trackId'];
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse remove-track <trackId> [options]',
+            options,
+        });
+        return;
+    }
+    const trackId = positionals[0];
+    if (!trackId) {
+        console.error('Error: Missing required argument: trackId');
+        console.error('Usage: jbrowse remove-track <trackId> [options]');
+        process.exit(1);
+    }
+    const output = flags.target || flags.out || '.';
+    const isDir = (await fs_1.promises.lstat(output)).isDirectory();
+    const target = isDir ? `${output}/config.json` : output;
+    const config = await (0, utils_1.readJsonFile)(target);
+    const originalLength = config.tracks?.length || 0;
+    config.tracks = config.tracks?.filter(({ trackId: id }) => id !== trackId);
+    const newLength = config.tracks?.length || 0;
+    if (originalLength === newLength) {
+        console.log(`No track found with trackId: ${trackId}`);
+    }
+    else {
+        await (0, utils_1.writeJsonFile)(target, config);
+        console.log(`Removed track with trackId: ${trackId} from ${target}`);
+    }
+}

package/dist/commands/set-default-session.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs_1 = __importDefault(require("fs"));
+const util_1 = require("util");
+const json_parse_better_errors_1 = __importDefault(require("json-parse-better-errors"));
+const utils_1 = require("../utils");
+const fsPromises = fs_1.default.promises;
+const description = 'Set a default session with views and tracks';
+const examples = [
+    '# set default session for the config.json in your current directory',
+    '$ jbrowse set-default-session --session /path/to/default/session.json',
+    '',
+    '# make session.json the defaultSession on the specified target config.json file',
+    '$ jbrowse set-default-session --target /path/to/jb2/installation/config.json --session session.json',
+    '',
+    '# print current default session',
+    '$ jbrowse set-default-session --currentSession # Prints out current default session',
+];
+const options = {
+    session: {
+        type: 'string',
+        short: 's',
+        description: 'set path to a file containing session in json format (required, unless using delete/currentSession flags)',
+    },
+    name: {
+        type: 'string',
+        short: 'n',
+        description: 'Give a name for the default session',
+        default: 'New Default Session',
+    },
+    currentSession: {
+        type: 'boolean',
+        short: 'c',
+        description: 'List out the current default session',
+    },
+    target: {
+        type: 'string',
+        description: 'path to config file in JB2 installation directory to write out to',
+    },
+    out: { type: 'string', description: 'synonym for target' },
+    delete: {
+        type: 'boolean',
+        description: 'Delete any existing default session.',
+    },
+    help: { type: 'boolean', short: 'h', description: 'Show help' },
+};
+async function run(args) {
+    const { values: runFlags } = (0, util_1.parseArgs)({ options, args });
+    if (runFlags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse add-track <track> [options]',
+            options,
+        });
+        return;
+    }
+    const { session, currentSession, delete: deleteDefaultSession } = runFlags;
+    const output = runFlags.target || runFlags.out || '.';
+    const isDir = (await fsPromises.lstat(output)).isDirectory();
+    const target = isDir ? `${output}/config.json` : output;
+    const configContents = await (0, utils_1.readJsonFile)(target);
+    if (deleteDefaultSession) {
+        configContents.defaultSession = undefined;
+        await (0, utils_1.writeJsonFile)(target, configContents);
+    }
+    else if (currentSession) {
+        console.log(`The current default session is ${JSON.stringify(configContents.defaultSession)}`);
+        process.exit();
+    }
+    else if (!session) {
+        throw new Error('Please provide a --session file');
+    }
+    else if (session) {
+        await (0, utils_1.writeJsonFile)(target, {
+            ...configContents,
+            defaultSession: await readDefaultSessionFile(session),
+        });
+    }
+}
+async function readDefaultSessionFile(defaultSessionFile) {
+    let defaultSessionJson;
+    try {
+        defaultSessionJson = await fsPromises.readFile(defaultSessionFile, {
+            encoding: 'utf8',
+        });
+    }
+    catch (error) {
+        throw new Error('Could not read the provided file');
+    }
+    try {
+        const session = (0, json_parse_better_errors_1.default)(defaultSessionJson);
+        // return top-level "session" if it exists, such as in files created by
+        // "File -> Export session"
+        return session.session || session;
+    }
+    catch (error) {
+        throw new Error('Could not parse the given default session file');
+    }
+}

package/dist/commands/sort-bed-utils/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_COMMANDS = exports.SORT_BED_EXAMPLES = exports.SORT_BED_DESCRIPTION = void 0;
+exports.SORT_BED_DESCRIPTION = 'Helper utility to sort BED files for tabix. Moves all lines starting with # to the top of the file, and sort by refname and start position using unix utilities sort and grep';
+exports.SORT_BED_EXAMPLES = [
+    '# sort bed and pipe to bgzip',
+    '$ jbrowse sort-bed input.bed | bgzip > sorted.bed.gz',
+    '$ tabix sorted.bed.gz',
+    '',
+    '# OR pipe data via stdin: cat file.bed | jbrowse sort-bed | bgzip > sorted.bed.gz',
+];
+exports.REQUIRED_COMMANDS = ['sh', 'sort', 'grep'];

package/dist/commands/sort-bed-utils/process-utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForProcessClose = waitForProcessClose;
+exports.handleProcessError = handleProcessError;
+async function waitForProcessClose(child) {
+    return new Promise((resolve, reject) => {
+        child.on('close', code => {
+            resolve(code);
+        });
+        child.on('error', err => {
+            reject(err);
+        });
+    });
+}
+function handleProcessError(error) {
+    if (error instanceof Error) {
+        console.error(`Process error: ${error.message}`);
+    }
+    else {
+        console.error('Unknown process error:', error);
+    }
+    process.exit(1);
+}

package/dist/commands/sort-bed-utils/sort-utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinimalEnvironment = getMinimalEnvironment;
+exports.createSortCommandForFile = createSortCommandForFile;
+exports.spawnSortProcess = spawnSortProcess;
+const child_process_1 = require("child_process");
+function getMinimalEnvironment() {
+    return {
+        ...process.env,
+        LC_ALL: 'C',
+    };
+}
+function createSortCommandForFile(file) {
+    // BED files use columns 1,2 (0-based) for chromosome and start position
+    return `(grep "^#" "${file}"; grep -v "^#" "${file}" | sort -t"\`printf '\\t'\`" -k1,1 -k2,2n)`;
+}
+function spawnSortProcess(options) {
+    const command = createSortCommandForFile(options.file);
+    const env = getMinimalEnvironment();
+    return (0, child_process_1.spawn)('sh', ['-c', command], {
+        env,
+        stdio: 'inherit',
+    });
+}

package/dist/commands/sort-bed-utils/validators.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileArgument = validateFileArgument;
+exports.validateRequiredCommands = validateRequiredCommands;
+const command_exists_1 = require("command-exists");
+function validateFileArgument(file) {
+    // Allow no file argument for stdin input
+    if (!file && process.stdin.isTTY) {
+        console.error('Error: Missing required argument: file');
+        console.error('Usage: jbrowse sort-bed <file>');
+        console.error('       OR pipe data via stdin: cat file.bed | jbrowse sort-bed');
+        process.exit(1);
+    }
+}
+function validateRequiredCommands() {
+    const requiredCommands = ['sh', 'sort', 'grep'];
+    const missingCommands = requiredCommands.filter(cmd => !(0, command_exists_1.sync)(cmd));
+    if (missingCommands.length > 0) {
+        console.error('Error: Unable to sort, requires unix type environment with sort, grep');
+        process.exit(1);
+    }
+}

package/dist/commands/sort-bed.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const constants_1 = require("./sort-bed-utils/constants");
+const process_utils_1 = require("./sort-bed-utils/process-utils");
+const sort_utils_1 = require("./sort-bed-utils/sort-utils");
+const validators_1 = require("./sort-bed-utils/validators");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+    };
+    const { values: flags, positionals } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = constants_1.SORT_BED_DESCRIPTION;
+    const examples = constants_1.SORT_BED_EXAMPLES;
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse sort-bed [file] [options]',
+            options,
+        });
+        return;
+    }
+    const file = positionals[0];
+    if (file) {
+        (0, validators_1.validateFileArgument)(file);
+    }
+    (0, validators_1.validateRequiredCommands)();
+    try {
+        const child = (0, sort_utils_1.spawnSortProcess)({ file: file || '-' });
+        const exitCode = await (0, process_utils_1.waitForProcessClose)(child);
+        if (exitCode !== 0) {
+            console.error(`Sort process exited with code ${exitCode}`);
+            process.exit(exitCode || 1);
+        }
+    }
+    catch (error) {
+        (0, process_utils_1.handleProcessError)(error);
+    }
+}

package/dist/commands/sort-gff-utils/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_COMMANDS = exports.SORT_GFF_EXAMPLES = exports.SORT_GFF_DESCRIPTION = void 0;
+exports.SORT_GFF_DESCRIPTION = 'Helper utility to sort GFF files for tabix. Moves all lines starting with # to the top of the file, and sort by refname and start position using unix utilities sort and grep';
+exports.SORT_GFF_EXAMPLES = [
+    '# sort gff and pipe to bgzip',
+    '$ jbrowse sort-gff input.gff | bgzip > sorted.gff.gz',
+    '$ tabix sorted.gff.gz',
+    '',
+    '# sort gff from stdin',
+    '$ cat input.gff | jbrowse sort-gff | bgzip > sorted.gff.gz',
+];
+exports.REQUIRED_COMMANDS = ['sh', 'sort', 'grep'];

package/dist/commands/sort-gff-utils/process-utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForProcessClose = waitForProcessClose;
+exports.handleProcessError = handleProcessError;
+async function waitForProcessClose(child) {
+    return new Promise((resolve, reject) => {
+        child.on('close', code => {
+            resolve(code);
+        });
+        child.on('error', err => {
+            reject(err);
+        });
+    });
+}
+function handleProcessError(error) {
+    if (error instanceof Error) {
+        console.error(`Process error: ${error.message}`);
+    }
+    else {
+        console.error('Unknown process error:', error);
+    }
+    process.exit(1);
+}