@jbrowse/img 4.1.1 → 4.1.4

package/esm/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/esm/bin.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { convert, parseArgv, renderRegion, setupEnv, standardizeArgv, } from './index.js';
+const trackTypes = [
+    'bam',
+    'cram',
+    'bigwig',
+    'vcfgz',
+    'gffgz',
+    'hic',
+    'bigbed',
+    'bedgz',
+];
+const knownOptions = new Set([
+    ...trackTypes,
+    'fasta',
+    'aliases',
+    'assembly',
+    'config',
+    'session',
+    'loc',
+    'out',
+    'width',
+    'noRasterize',
+    'defaultSession',
+    'tracks',
+    'cytobands',
+    'help',
+    'version',
+]);
+const yargsInstance = yargs(hideBin(process.argv))
+    .scriptName('jb2export')
+    .usage('$0 [options]')
+    .option('fasta', {
+    type: 'string',
+    description: 'Path to indexed FASTA file',
+})
+    .option('aliases', {
+    type: 'string',
+    description: 'Path to reference name aliases file',
+})
+    .option('assembly', {
+    type: 'string',
+    description: 'Path to assembly JSON or name in config',
+})
+    .option('config', {
+    type: 'string',
+    description: 'Path to JBrowse config.json',
+})
+    .option('session', {
+    type: 'string',
+    description: 'Path to session JSON',
+})
+    .option('loc', {
+    type: 'string',
+    description: 'Location to render (e.g., chr1:1-1000 or "all")',
+})
+    .option('out', {
+    type: 'string',
+    description: 'Output file path (SVG or PNG)',
+})
+    .option('width', {
+    type: 'number',
+    description: 'Width of output in pixels',
+    default: 1500,
+})
+    .option('noRasterize', {
+    type: 'boolean',
+    description: 'Disable rasterization of pileup/coverage',
+    default: false,
+})
+    .option('defaultSession', {
+    type: 'boolean',
+    description: 'Use default session from config',
+    default: false,
+})
+    .example('$0 --fasta ref.fa --bam reads.bam --loc chr1:1-10000 --out out.svg', 'Render BAM alignments')
+    .example('$0 --fasta ref.fa --vcfgz variants.vcf.gz --loc chr1:1-50000 --out out.png', 'Render VCF variants')
+    .epilogue('Track options: --bam, --cram, --bigwig, --vcfgz, --gffgz, --hic, --bigbed, --bedgz')
+    .strict(false)
+    .help();
+async function main() {
+    const argv = await yargsInstance.argv;
+    setupEnv();
+    const args = process.argv.slice(2);
+    const parsed = parseArgv(args);
+    const standardized = standardizeArgv(parsed, trackTypes);
+    for (const [key] of parsed) {
+        if (!knownOptions.has(key)) {
+            console.warn(`Warning: unknown option "--${key}"`);
+        }
+    }
+    const opts = {
+        fasta: argv.fasta,
+        aliases: argv.aliases,
+        assembly: argv.assembly,
+        config: argv.config,
+        session: argv.session,
+        loc: argv.loc,
+        width: argv.width,
+        noRasterize: argv.noRasterize,
+        defaultSession: argv.defaultSession ? 'true' : undefined,
+        trackList: standardized.trackList,
+    };
+    const result = await renderRegion(opts);
+    const outFile = argv.out || standardized.out;
+    if (!outFile) {
+        console.log(result);
+    }
+    else if (outFile.endsWith('.png')) {
+        convert(result, { out: outFile, pngwidth: String(argv.width || 2048) });
+    }
+    else {
+        fs.writeFileSync(outFile, result);
+    }
+}
+await main();

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export { renderRegion } from './renderRegion.tsx';
+export { setupEnv } from './setupEnv.ts';
+export { convert } from './util.ts';
+export { parseArgv, standardizeArgv } from './parseArgv.ts';
+export type { Opts } from './renderRegion.tsx';

package/esm/index.js

@@ -0,0 +1,4 @@
+export { renderRegion } from "./renderRegion.js";
+export { setupEnv } from "./setupEnv.js";
+export { convert } from "./util.js";
+export { parseArgv, standardizeArgv } from "./parseArgv.js";

package/esm/parseArgv.d.ts

@@ -0,0 +1,8 @@
+export type Entry = [string, string[]];
+export declare function parseArgv(argv: string[]): Entry[];
+export declare function standardizeArgv(args: Entry[], trackTypes: string[]): {
+    [key: string]: unknown;
+    trackList: Entry[];
+    out?: string;
+    pngwidth?: string;
+};

package/esm/parseArgv.js

@@ -0,0 +1,29 @@
+export function parseArgv(argv) {
+    const map = [];
+    while (argv.length) {
+        const val = argv[0].slice(2);
+        argv = argv.slice(1);
+        const next = argv.findIndex(arg => arg.startsWith('-'));
+        if (next !== -1) {
+            map.push([val, argv.slice(0, next)]);
+            argv = argv.slice(next);
+        }
+        else {
+            map.push([val, argv]);
+            break;
+        }
+    }
+    return map;
+}
+export function standardizeArgv(args, trackTypes) {
+    const result = { trackList: [] };
+    for (const arg of args) {
+        if (trackTypes.includes(arg[0])) {
+            result.trackList.push(arg);
+        }
+        else {
+            result[arg[0]] = arg[1][0] || true;
+        }
+    }
+    return result;
+}

package/esm/renderRegion.d.ts

@@ -0,0 +1,34 @@
+import type { Entry } from './parseArgv.ts';
+export interface Opts {
+    noRasterize?: boolean;
+    loc?: string;
+    width?: number;
+    session?: string;
+    assembly?: string;
+    config?: string;
+    fasta?: string;
+    aliases?: string;
+    cytobands?: string;
+    defaultSession?: string;
+    trackList?: Entry[];
+    tracks?: string;
+}
+interface Assembly {
+    name: string;
+    sequence: Record<string, unknown>;
+    refNameAliases?: Record<string, unknown>;
+    cytobands?: Record<string, unknown>;
+}
+interface Track {
+    trackId: string;
+    [key: string]: unknown;
+}
+interface Config {
+    assemblies: Assembly[];
+    assembly: Assembly;
+    tracks: Track[];
+    [key: string]: unknown;
+}
+export declare function readData({ assembly: asm, config, session, fasta, aliases, cytobands, defaultSession, tracks, trackList, }: Opts): Config;
+export declare function renderRegion(opts: Opts): Promise<string>;
+export {};

package/esm/renderRegion.js

@@ -0,0 +1,377 @@
+import fs from 'fs';
+import path from 'path';
+import { renderToSvg } from '@jbrowse/plugin-linear-genome-view';
+import { createViewState } from '@jbrowse/react-linear-genome-view2';
+import { booleanize } from "./util.js";
+function read(file) {
+    let res;
+    try {
+        res = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new Error(`Failed to parse ${file} as JSON, use --fasta if you mean to pass a FASTA file`, { cause: e });
+    }
+    return res;
+}
+function makeLocation(file) {
+    return file.startsWith('http') ? { uri: file } : { localPath: file };
+}
+function addRelativePaths(config, configPath) {
+    if (typeof config === 'object') {
+        for (const key of Object.keys(config)) {
+            if (typeof config[key] === 'object') {
+                addRelativePaths(config[key], configPath);
+            }
+            else if (key === 'localPath') {
+                config.localPath = path.resolve(configPath, config.localPath);
+            }
+        }
+    }
+}
+export function readData({ assembly: asm, config, session, fasta, aliases, cytobands, defaultSession, tracks, trackList = [], }) {
+    const assemblyData = asm && fs.existsSync(asm) ? read(asm) : undefined;
+    const tracksData = tracks ? read(tracks) : undefined;
+    const configData = config ? read(config) : {};
+    let sessionData = session
+        ? read(session)
+        : undefined;
+    if (config) {
+        addRelativePaths(configData, path.dirname(path.resolve(config)));
+    }
+    if (sessionData?.session) {
+        sessionData = sessionData.session;
+    }
+    if (sessionData?.views) {
+        sessionData.view = sessionData.views[0];
+    }
+    if (assemblyData) {
+        configData.assembly = assemblyData;
+    }
+    else if (configData.assemblies?.length) {
+        configData.assemblies.find(entry => entry.name === asm);
+        if (asm) {
+            const assembly = configData.assemblies.find(entry => entry.name === asm);
+            if (!assembly) {
+                throw new Error(`assembly ${asm} not found in config`);
+            }
+            configData.assembly = assembly;
+        }
+        else {
+            configData.assembly = configData.assemblies[0];
+        }
+    }
+    else if (fasta) {
+        const bgzip = fasta.endsWith('gz');
+        configData.assembly = {
+            name: path.basename(fasta),
+            sequence: {
+                type: 'ReferenceSequenceTrack',
+                trackId: 'refseq',
+                adapter: {
+                    type: bgzip ? 'BgzipFastaAdapter' : 'IndexedFastaAdapter',
+                    fastaLocation: makeLocation(fasta),
+                    faiLocation: makeLocation(`${fasta}.fai`),
+                    gziLocation: bgzip ? makeLocation(`${fasta}.gzi`) : undefined,
+                },
+            },
+        };
+        if (aliases) {
+            configData.assembly.refNameAliases = {
+                adapter: {
+                    type: 'RefNameAliasAdapter',
+                    location: makeLocation(aliases),
+                },
+            };
+        }
+        if (cytobands) {
+            configData.assembly.cytobands = {
+                adapter: {
+                    type: 'CytobandAdapter',
+                    location: makeLocation(cytobands),
+                },
+            };
+        }
+    }
+    if (!configData.assembly) {
+        throw new Error('no assembly specified, use --fasta to supply an indexed FASTA file (generated with samtools faidx yourfile.fa). see README for alternatives with --assembly and --config');
+    }
+    if (tracksData) {
+        configData.tracks = tracksData;
+    }
+    else if (!configData.tracks) {
+        configData.tracks = [];
+    }
+    for (const track of trackList) {
+        const [type, opts] = track;
+        const [file, ...rest] = opts;
+        const index = rest.find(r => r.startsWith('index:'))?.replace('index:', '');
+        if (!file) {
+            throw new Error('no file specified');
+        }
+        if (type === 'bam') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'AlignmentsTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'BamAdapter',
+                        bamLocation: makeLocation(file),
+                        index: {
+                            location: makeLocation(index || `${file}.bai`),
+                            indexType: index?.endsWith('.csi') ? 'CSI' : 'BAI',
+                        },
+                        sequenceAdapter: configData.assembly.sequence.adapter,
+                    },
+                    ...(opts.includes('snpcov')
+                        ? {
+                            displays: [
+                                {
+                                    type: 'LinearSNPCoverageDisplay',
+                                    displayId: `${path.basename(file)}-${Math.random()}`,
+                                },
+                            ],
+                        }
+                        : {}),
+                },
+            ];
+        }
+        if (type === 'cram') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'AlignmentsTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'CramAdapter',
+                        cramLocation: makeLocation(file),
+                        craiLocation: makeLocation(index || `${file}.crai`),
+                        sequenceAdapter: configData.assembly.sequence.adapter,
+                    },
+                    ...(opts.includes('snpcov')
+                        ? {
+                            displays: [
+                                {
+                                    type: 'LinearSNPCoverageDisplay',
+                                    displayId: `${path.basename(file)}-${Math.random()}`,
+                                },
+                            ],
+                        }
+                        : {}),
+                },
+            ];
+        }
+        if (type === 'bigwig') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'QuantitativeTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'BigWigAdapter',
+                        bigWigLocation: makeLocation(file),
+                    },
+                },
+            ];
+        }
+        if (type === 'vcfgz') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'VariantTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'VcfTabixAdapter',
+                        vcfGzLocation: makeLocation(file),
+                        index: {
+                            location: makeLocation(index || `${file}.tbi`),
+                            indexType: index?.endsWith('.csi') ? 'CSI' : 'TBI',
+                        },
+                    },
+                },
+            ];
+        }
+        if (type === 'gffgz') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'FeatureTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'Gff3TabixAdapter',
+                        gffGzLocation: makeLocation(file),
+                        index: {
+                            location: makeLocation(index || `${file}.tbi`),
+                            indexType: index?.endsWith('.csi') ? 'CSI' : 'TBI',
+                        },
+                    },
+                },
+            ];
+        }
+        if (type === 'hic') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'HicTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'HicAdapter',
+                        hicLocation: makeLocation(file),
+                    },
+                },
+            ];
+        }
+        if (type === 'bigbed') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'FeatureTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'BigBedAdapter',
+                        bigBedLocation: makeLocation(file),
+                    },
+                },
+            ];
+        }
+        if (type === 'bedgz') {
+            configData.tracks = [
+                ...configData.tracks,
+                {
+                    type: 'FeatureTrack',
+                    trackId: path.basename(file),
+                    name: path.basename(file),
+                    assemblyNames: [configData.assembly.name],
+                    adapter: {
+                        type: 'BedTabixAdapter',
+                        bedGzLocation: makeLocation(file),
+                        index: {
+                            location: makeLocation(index || `${file}.tbi`),
+                            indexType: index?.endsWith('.csi') ? 'CSI' : 'TBI',
+                        },
+                    },
+                },
+            ];
+        }
+    }
+    if (!defaultSession) {
+        configData.defaultSession = undefined;
+    }
+    if (sessionData) {
+        configData.defaultSession = sessionData;
+    }
+    return configData;
+}
+function process(trackEntry, view, extra = c => c) {
+    const [, [track, ...opts]] = trackEntry;
+    if (!track) {
+        throw new Error('invalid command line args');
+    }
+    const currentTrack = view.showTrack(extra(track));
+    const display = currentTrack.displays[0];
+    for (const opt of opts) {
+        if (opt.startsWith('height:')) {
+            const [, height] = opt.split(':');
+            if (height) {
+                display.setHeight(+height);
+            }
+        }
+        else if (opt.startsWith('sort:')) {
+            const [, type, tag] = opt.split(':');
+            display.PileupDisplay.setSortedBy(type, tag);
+        }
+        else if (opt.startsWith('color:')) {
+            const [, type, tag] = opt.split(':');
+            if (display.PileupDisplay) {
+                display.PileupDisplay.setColorScheme({ type, tag });
+            }
+            else {
+                display.setColor(type);
+            }
+        }
+        else if (opt.startsWith('force:')) {
+            const [, force] = opt.split(':');
+            if (force) {
+                display.setFeatureDensityStatsLimit({ bytes: Number.MAX_VALUE });
+            }
+        }
+        else if (opt.startsWith('autoscale:')) {
+            const [, autoscale] = opt.split(':');
+            display.setAutoscale(autoscale);
+        }
+        else if (opt.startsWith('minmax:')) {
+            const [, min, max] = opt.split(':');
+            if (min) {
+                display.setMinScore(+min);
+            }
+            if (max) {
+                display.setMaxScore(+max);
+            }
+        }
+        else if (opt.startsWith('scaletype:')) {
+            const [, scaletype] = opt.split(':');
+            display.setScaleType(scaletype);
+        }
+        else if (opt.startsWith('crosshatch:')) {
+            const [, val = 'false'] = opt.split(':');
+            display.setCrossHatches(booleanize(val));
+        }
+        else if (opt.startsWith('fill:')) {
+            const [, val = 'true'] = opt.split(':');
+            display.setFill(booleanize(val));
+        }
+        else if (opt.startsWith('resolution:')) {
+            let [, val = 1] = opt.split(':');
+            if (val === 'fine') {
+                val = '10';
+            }
+            else if (val === 'superfine') {
+                val = '100';
+            }
+            display.setResolution(+val);
+        }
+    }
+}
+export async function renderRegion(opts) {
+    const model = createViewState({
+        ...readData(opts),
+    });
+    const { loc, width = 1500, trackList = [], session: sessionParam, defaultSession, } = opts;
+    const { session } = model;
+    const { view } = session;
+    const { assemblyManager } = model;
+    view.setWidth(width);
+    if (loc) {
+        const { name } = assemblyManager.assemblies[0];
+        if (loc === 'all') {
+            view.showAllRegionsInAssembly(name);
+        }
+        else {
+            await view.navToLocString(loc, name);
+        }
+    }
+    else if (!sessionParam && !defaultSession) {
+        console.warn('No loc specified');
+    }
+    for (const track of trackList) {
+        process(track, view, extra => path.basename(extra));
+    }
+    return renderToSvg(view, {
+        rasterizeLayers: !opts.noRasterize,
+        ...opts,
+    });
+}

package/esm/setupEnv.d.ts

@@ -0,0 +1 @@
+export declare function setupEnv(): void;

package/esm/setupEnv.js

@@ -0,0 +1,26 @@
+import { TextDecoder, TextEncoder } from 'util';
+import { Image, createCanvas } from 'canvas';
+import { JSDOM } from 'jsdom';
+export function setupEnv() {
+    addGlobalCanvasUtils();
+    addGlobalTextUtils();
+    addGlobalDocument();
+}
+function addGlobalCanvasUtils() {
+    global.nodeImage = Image;
+    global.nodeCreateCanvas = createCanvas;
+}
+function addGlobalTextUtils() {
+    global.TextEncoder = TextEncoder;
+    global.TextDecoder = TextDecoder;
+}
+function addGlobalDocument() {
+    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+        url: 'http://localhost/',
+        pretendToBeVisual: true,
+        resources: 'usable',
+    });
+    global.window = dom.window;
+    global.document = window.document;
+    global.localStorage = window.localStorage;
+}

package/esm/util.d.ts

@@ -0,0 +1,5 @@
+export declare function booleanize(str: string): boolean;
+export declare function convert(result: string, args: {
+    out: string;
+    pngwidth?: string;
+}, spawnArgs?: string[]): void;

package/esm/util.js

@@ -0,0 +1,23 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import tmp from 'tmp';
+export function booleanize(str) {
+    return str === 'false' ? false : !!str;
+}
+function createTmp() {
+    return tmp.fileSync({
+        mode: 0o644,
+        prefix: 'prefix-',
+        postfix: '.svg',
+    });
+}
+export function convert(result, args, spawnArgs = []) {
+    const { name } = createTmp();
+    const { pngwidth = '2048', out } = args;
+    fs.writeFileSync(name, result);
+    const a = ['-w', pngwidth, name, '-o', out, ...spawnArgs];
+    const ls = spawnSync('rsvg-convert', a);
+    console.error(`rsvg-convert stderr: ${ls.stderr.toString()}`);
+    console.log(`rsvg-convert stdout: ${ls.stdout.toString()}`);
+    fs.unlinkSync(name);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/img",
-  "version": "4.1.1",
+  "version": "4.1.4",
   "main": "esm/index.js",
   "types": "esm/index.d.ts",
   "type": "module",
@@ -13,10 +13,10 @@
   "author": "JBrowse Team",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=23"
   },
   "bin": {
-    "jb2export": "./esm/index.js"
+    "jb2export": "./esm/bin.js"
   },
   "files": [
     "esm"
@@ -25,17 +25,16 @@
   "dependencies": {
     "@emotion/cache": "^11.14.0",
     "@emotion/react": "^11.14.0",
-    "@types/jsdom": "^21.1.7",
+    "@types/jsdom": "^27.0.0",
     "@types/yargs": "^17.0.35",
     "canvas": "^3.2.1",
-    "jsdom": "27.0.0",
-    "node-fetch": "^2.7.0",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
+    "jsdom": "28.0.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "tmp": "^0.2.5",
     "yargs": "^18.0.0",
-    "@jbrowse/plugin-linear-genome-view": "^4.1.1",
-    "@jbrowse/react-linear-genome-view2": "^4.1.1"
+    "@jbrowse/plugin-linear-genome-view": "^4.1.4",
+    "@jbrowse/react-linear-genome-view2": "^4.1.4"
   },
   "publishConfig": {
     "access": "public"