@jbrowse/cli 3.6.5 → 4.0.0

package/dist/commands/shared/validators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileArgument = validateFileArgument;
+exports.validateRequiredCommands = validateRequiredCommands;
+const command_exists_1 = require("command-exists");
+function validateFileArgument(file, commandName, fileType) {
+    if (!file && process.stdin.isTTY) {
+        throw new Error(`Missing required argument: file\n` +
+            `Usage: jbrowse ${commandName} <file>\n` +
+            `       OR pipe data via stdin: cat file.${fileType} | jbrowse ${commandName}`);
+    }
+}
+function validateRequiredCommands(requiredCommands) {
+    const missingCommands = requiredCommands.filter(cmd => !(0, command_exists_1.sync)(cmd));
+    if (missingCommands.length > 0) {
+        throw new Error(`Unable to run command, requires unix type environment with: ${requiredCommands.join(', ')}`);
+    }
+}

package/dist/commands/sort-bed.js

@@ -2,11 +2,10 @@
 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");
+const utils_ts_1 = require("../utils.js");
+const process_utils_ts_1 = require("./process-utils.js");
+const sort_utils_ts_1 = require("./shared/sort-utils.js");
+const validators_ts_1 = require("./shared/validators.js");
 async function run(args) {
     const options = {
         help: {
@@ -19,31 +18,21 @@ async function run(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,
+        (0, utils_ts_1.printHelp)({
+            description: sort_utils_ts_1.BED_CONFIG.description,
+            examples: sort_utils_ts_1.BED_CONFIG.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);
+    (0, validators_ts_1.validateFileArgument)(file, 'sort-bed', 'bed');
+    (0, validators_ts_1.validateRequiredCommands)(['sh', 'sort', 'grep']);
+    const child = (0, sort_utils_ts_1.spawnSortProcess)(file, sort_utils_ts_1.BED_CONFIG.sortColumn);
+    const exitCode = await (0, process_utils_ts_1.waitForProcessClose)(child);
+    if (exitCode !== 0) {
+        throw new Error(`Sort process exited with code ${exitCode}`);
     }
 }

package/dist/commands/sort-gff.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const util_1 = require("util");
-const utils_1 = require("../utils");
-const constants_1 = require("./sort-gff-utils/constants");
-const process_utils_1 = require("./sort-gff-utils/process-utils");
-const sort_utils_1 = require("./sort-gff-utils/sort-utils");
-const validators_1 = require("./sort-gff-utils/validators");
+const utils_ts_1 = require("../utils.js");
+const process_utils_ts_1 = require("./process-utils.js");
+const sort_utils_ts_1 = require("./shared/sort-utils.js");
+const validators_ts_1 = require("./shared/validators.js");
 async function run(args) {
     const options = {
         help: {
@@ -19,31 +18,21 @@ async function run(args) {
         options,
         allowPositionals: true,
     });
-    const description = constants_1.SORT_GFF_DESCRIPTION;
-    const examples = constants_1.SORT_GFF_EXAMPLES;
     if (flags.help) {
-        (0, utils_1.printHelp)({
-            description,
-            examples,
+        (0, utils_ts_1.printHelp)({
+            description: sort_utils_ts_1.GFF_CONFIG.description,
+            examples: sort_utils_ts_1.GFF_CONFIG.examples,
             usage: 'jbrowse sort-gff [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);
+    (0, validators_ts_1.validateFileArgument)(file, 'sort-gff', 'gff');
+    (0, validators_ts_1.validateRequiredCommands)(['sh', 'sort', 'grep']);
+    const child = (0, sort_utils_ts_1.spawnSortProcess)(file, sort_utils_ts_1.GFF_CONFIG.sortColumn);
+    const exitCode = await (0, process_utils_ts_1.waitForProcessClose)(child);
+    if (exitCode !== 0) {
+        throw new Error(`Sort process exited with code ${exitCode}`);
     }
 }

package/dist/commands/text-index/adapter-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoc = getLoc;
+exports.createTrixAdapter = createTrixAdapter;
+exports.getAdapterLocation = getAdapterLocation;
+const config_utils_ts_1 = require("./config-utils.js");
+function getLoc(elt) {
+    return elt.locationType === 'LocalPathLocation' ? elt.localPath : elt.uri;
+}
+function createTrixAdapter(name, assemblyNames, idSuffix = 'index') {
+    const safeName = (0, config_utils_ts_1.sanitizeNameForPath)(name);
+    return {
+        type: 'TrixTextSearchAdapter',
+        textSearchAdapterId: `${safeName}-${idSuffix}`,
+        ixFilePath: {
+            uri: `trix/${safeName}.ix`,
+            locationType: 'UriLocation',
+        },
+        ixxFilePath: {
+            uri: `trix/${safeName}.ixx`,
+            locationType: 'UriLocation',
+        },
+        metaFilePath: {
+            uri: `trix/${safeName}_meta.json`,
+            locationType: 'UriLocation',
+        },
+        assemblyNames,
+    };
+}
+const ADAPTER_LOCATION_KEYS = {
+    Gff3TabixAdapter: 'gffGzLocation',
+    Gff3Adapter: 'gffLocation',
+    VcfAdapter: 'vcfLocation',
+    VcfTabixAdapter: 'vcfGzLocation',
+};
+function getAdapterLocation(adapter) {
+    const key = ADAPTER_LOCATION_KEYS[adapter?.type ?? ''];
+    return key
+        ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            (adapter?.[key] ??
+                adapter)
+        : undefined;
+}

package/dist/commands/text-index/aggregate.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateIndex = aggregateIndex;
+const adapter_utils_ts_1 = require("./adapter-utils.js");
+const config_utils_ts_1 = require("./config-utils.js");
+const indexing_utils_ts_1 = require("./indexing-utils.js");
+const utils_ts_1 = require("../../utils.js");
+async function aggregateIndex(flags) {
+    const { out, target, tracks, excludeTracks, assemblies, attributes, quiet, force, exclude, dryrun, prefixSize, } = flags;
+    const { config, configPath, outLocation } = await (0, config_utils_ts_1.loadConfigForIndexing)(target, out, utils_ts_1.resolveConfigPath);
+    const aggregateTextSearchAdapters = config.aggregateTextSearchAdapters || [];
+    const asms = (0, config_utils_ts_1.getAssemblyNames)(config, assemblies);
+    for (const asm of asms) {
+        const trackConfigs = (0, config_utils_ts_1.getTrackConfigs)(config, (0, config_utils_ts_1.parseCommaSeparatedString)(tracks), asm, (0, config_utils_ts_1.parseCommaSeparatedString)(excludeTracks));
+        if (!trackConfigs.length) {
+            console.log(`Indexing assembly ${asm}...(no tracks found)...`);
+            continue;
+        }
+        console.log(`Indexing assembly ${asm}...`);
+        if (dryrun) {
+            console.log(trackConfigs.map(e => `${e.trackId}	${e.adapter?.type}`).join('\n'));
+        }
+        else {
+            const id = `${asm}-index`;
+            const idx = aggregateTextSearchAdapters.findIndex(x => x.textSearchAdapterId === id);
+            if (idx !== -1 && !force) {
+                console.log(`Note: ${asm} has already been indexed with this configuration, use --force to overwrite this assembly. Skipping for now`);
+                continue;
+            }
+            await (0, indexing_utils_ts_1.indexDriver)({
+                trackConfigs,
+                outLocation,
+                name: asm,
+                assemblyNames: [asm],
+                ...(0, config_utils_ts_1.prepareIndexDriverFlags)({ attributes, exclude, quiet, prefixSize }),
+            });
+            const trixConf = (0, adapter_utils_ts_1.createTrixAdapter)(asm, [asm]);
+            if (idx === -1) {
+                aggregateTextSearchAdapters.push(trixConf);
+            }
+            else {
+                aggregateTextSearchAdapters[idx] = trixConf;
+            }
+        }
+    }
+    if (!dryrun) {
+        (0, config_utils_ts_1.writeConf)({
+            ...config,
+            aggregateTextSearchAdapters,
+        }, configPath);
+    }
+}

package/dist/commands/{text-index.js → text-index/command.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const util_1 = require("util");
-const utils_1 = require("../utils");
-const index_1 = require("./text-index-utils/index");
+const index_ts_1 = require("./index.js");
+const utils_ts_1 = require("../../utils.js");
 async function run(args) {
     const options = {
         help: {
@@ -15,6 +15,10 @@ async function run(args) {
             type: 'string',
             description: 'Specific tracks to index, formatted as comma separated trackIds. If unspecified, indexes all available tracks',
         },
+        excludeTracks: {
+            type: 'string',
+            description: 'Specific tracks to exclude from indexing, formatted as comma separated trackIds',
+        },
         target: {
             type: 'string',
             description: 'Path to config file in JB2 installation directory to read from.',
@@ -82,6 +86,9 @@ async function run(args) {
         "# indexes specific trackIds that it can find in the current directory's config.json",
         '$ jbrowse text-index --tracks=track1,track2,track3',
         '',
+        '# indexes all tracks except specific trackIds',
+        '$ jbrowse text-index --exclude-tracks=track1,track2,track3',
+        '',
         "# indexes all tracks in a directory's config.json or in a specific config file",
         '$ jbrowse text-index --out /path/to/jb2/',
         '',
@@ -92,7 +99,7 @@ async function run(args) {
         '$ jbrowse text-index --file myfile.gff3.gz --file myfile.vcfgz --out indexes',
     ];
     if (flags.help) {
-        (0, utils_1.printHelp)({
+        (0, utils_ts_1.printHelp)({
             description,
             examples,
             usage: 'jbrowse text-index [options]',
@@ -102,12 +109,12 @@ async function run(args) {
     }
     const { perTrack, file } = flags;
     if (file) {
-        await (0, index_1.indexFileList)(flags);
+        await (0, index_ts_1.indexFileList)(flags);
     }
     else if (perTrack) {
-        await (0, index_1.perTrackIndex)(flags);
+        await (0, index_ts_1.perTrackIndex)(flags);
     }
     else {
-        await (0, index_1.aggregateIndex)(flags);
+        await (0, index_ts_1.aggregateIndex)(flags);
     }
 }

package/dist/commands/text-index/config-utils.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommaSeparatedString = parseCommaSeparatedString;
+exports.sanitizeNameForPath = sanitizeNameForPath;
+exports.validatePrefixSize = validatePrefixSize;
+exports.prepareIndexDriverFlags = prepareIndexDriverFlags;
+exports.readConf = readConf;
+exports.writeConf = writeConf;
+exports.loadConfigForIndexing = loadConfigForIndexing;
+exports.ensureTrixDir = ensureTrixDir;
+exports.getAssemblyNames = getAssemblyNames;
+exports.getTrackConfigs = getTrackConfigs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const common_ts_1 = require("../../types/common.js");
+/**
+ * Parses a comma-separated string into an array of trimmed, non-empty strings
+ */
+function parseCommaSeparatedString(value) {
+    return (value
+        ?.split(',')
+        .map(s => s.trim())
+        .filter(Boolean) ?? []);
+}
+/**
+ * Sanitizes a name for use in file paths by replacing invalid characters
+ * Replaces characters that are problematic in file paths: / \ : * ? " < > |
+ */
+function sanitizeNameForPath(name) {
+    return name.replace(/[/\\:*?"<>|]/g, '_');
+}
+/**
+ * Validates and parses a prefix size value
+ */
+function validatePrefixSize(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = typeof value === 'number' ? value : parseInt(value, 10);
+    if (isNaN(parsed) || parsed < 0) {
+        throw new Error(`Invalid prefixSize: "${value}". Must be a positive number.`);
+    }
+    return parsed;
+}
+/**
+ * Prepares common indexDriver parameters from raw flag values
+ */
+function prepareIndexDriverFlags(flags) {
+    return {
+        attributes: parseCommaSeparatedString(flags.attributes),
+        typesToExclude: parseCommaSeparatedString(flags.exclude),
+        quiet: flags.quiet ?? false,
+        prefixSize: validatePrefixSize(flags.prefixSize),
+    };
+}
+function readConf(configPath) {
+    return JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+}
+function writeConf(obj, configPath) {
+    fs_1.default.writeFileSync(configPath, JSON.stringify(obj, null, 2));
+}
+/**
+ * Loads config and prepares output location for indexing
+ */
+async function loadConfigForIndexing(target, out, resolveConfigPath) {
+    const configPath = await resolveConfigPath(target, out);
+    const outLocation = path_1.default.dirname(configPath);
+    const config = readConf(configPath);
+    ensureTrixDir(outLocation);
+    return { config, configPath, outLocation };
+}
+function ensureTrixDir(outLocation) {
+    const trixDir = path_1.default.join(outLocation, 'trix');
+    if (!fs_1.default.existsSync(trixDir)) {
+        fs_1.default.mkdirSync(trixDir);
+    }
+    return trixDir;
+}
+/**
+ * Extracts all assembly names from a config object
+ * Handles both single assembly (config.assembly) and multiple assemblies (config.assemblies)
+ */
+function extractAssemblyNamesFromConfig(config) {
+    if (config.assemblies) {
+        return config.assemblies.map(a => a.name);
+    }
+    if (config.assembly) {
+        return [config.assembly.name];
+    }
+    return [];
+}
+function getAssemblyNames(config, assemblies) {
+    const asms = assemblies
+        ? parseCommaSeparatedString(assemblies)
+        : extractAssemblyNamesFromConfig(config);
+    if (!asms.length) {
+        throw new Error('No assemblies found');
+    }
+    return asms;
+}
+function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
+    const { tracks } = config;
+    if (!tracks) {
+        return [];
+    }
+    const trackIdsToIndex = trackIds || tracks.map(track => track.trackId);
+    const excludeSet = new Set(excludeTrackIds || []);
+    return trackIdsToIndex
+        .map(trackId => {
+        const currentTrack = tracks.find(t => trackId === t.trackId);
+        if (!currentTrack) {
+            throw new Error(`Track not found in config.json for trackId ${trackId}, please add track configuration before indexing.`);
+        }
+        return currentTrack;
+    })
+        .filter(track => {
+        if (excludeSet.has(track.trackId)) {
+            console.log(`Skipping ${track.trackId}: excluded via --exclude-tracks`);
+            return false;
+        }
+        if (!(0, common_ts_1.supported)(track.adapter?.type)) {
+            console.log(`Skipping ${track.trackId}: unsupported adapter type '${track.adapter?.type}'`);
+            return false;
+        }
+        if (assemblyName && !track.assemblyNames.includes(assemblyName)) {
+            console.log(`Skipping ${track.trackId}: not in assembly '${assemblyName}'`);
+            return false;
+        }
+        return true;
+    });
+}

package/dist/commands/{text-index-utils → text-index}/file-list.js

@@ -4,28 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexFileList = indexFileList;
-const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const indexing_utils_1 = require("./indexing-utils");
-const validators_1 = require("./validators");
+const config_utils_ts_1 = require("./config-utils.js");
+const indexing_utils_ts_1 = require("./indexing-utils.js");
+const validators_ts_1 = require("./validators.js");
 async function indexFileList(flags) {
     const { out, target, fileId, file, attributes, quiet, exclude, prefixSize } = flags;
-    (0, validators_1.validateFileInput)(file);
+    (0, validators_ts_1.validateFileInput)(file);
     const outFlag = target || out || '.';
-    const trixDir = path_1.default.join(outFlag, 'trix');
-    if (!fs_1.default.existsSync(trixDir)) {
-        fs_1.default.mkdirSync(trixDir);
-    }
-    const trackConfigs = (0, indexing_utils_1.prepareFileTrackConfigs)(file, fileId);
-    await (0, indexing_utils_1.indexDriver)({
+    (0, config_utils_ts_1.ensureTrixDir)(outFlag);
+    const trackConfigs = (0, indexing_utils_ts_1.prepareFileTrackConfigs)(file, fileId);
+    const name = trackConfigs.length > 1
+        ? 'aggregate'
+        : (0, config_utils_ts_1.sanitizeNameForPath)(path_1.default.basename(file[0]));
+    await (0, indexing_utils_ts_1.indexDriver)({
         trackConfigs,
         outLocation: outFlag,
-        name: trackConfigs.length > 1 ? 'aggregate' : path_1.default.basename(file[0]),
-        quiet,
-        attributes: attributes.split(','),
-        typesToExclude: exclude.split(','),
+        name,
         assemblyNames: [],
-        prefixSize,
+        ...(0, config_utils_ts_1.prepareIndexDriverFlags)({ attributes, exclude, quiet, prefixSize }),
     });
     console.log('Successfully created index for these files. See https://jbrowse.org/storybook/lgv/main/?path=/story/text-searching--page for info about usage');
 }

package/dist/commands/text-index/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.indexFileList = exports.perTrackIndex = exports.aggregateIndex = void 0;
+var aggregate_ts_1 = require("./aggregate.js");
+Object.defineProperty(exports, "aggregateIndex", { enumerable: true, get: function () { return aggregate_ts_1.aggregateIndex; } });
+var per_track_ts_1 = require("./per-track.js");
+Object.defineProperty(exports, "perTrackIndex", { enumerable: true, get: function () { return per_track_ts_1.perTrackIndex; } });
+var file_list_ts_1 = require("./file-list.js");
+Object.defineProperty(exports, "indexFileList", { enumerable: true, get: function () { return file_list_ts_1.indexFileList; } });
+var command_ts_1 = require("./command.js");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_ts_1.run; } });

package/dist/commands/{text-index-utils → text-index}/indexing-utils.js

@@ -9,38 +9,47 @@ exports.indexDriver = indexDriver;
 exports.prepareFileTrackConfigs = prepareFileTrackConfigs;
 const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
+const cli_progress_1 = require("cli-progress");
 const ixixx_1 = require("ixixx");
-const adapter_utils_1 = require("./adapter-utils");
-const common_1 = require("../../types/common");
-const gff3Adapter_1 = require("../../types/gff3Adapter");
-const vcfAdapter_1 = require("../../types/vcfAdapter");
-async function runIxIxx({ readStream, outLocation, name, prefixSize, }) {
+const adapter_utils_ts_1 = require("./adapter-utils.js");
+const common_ts_1 = require("../../types/common.js");
+const gff3Adapter_ts_1 = require("../../types/gff3Adapter.js");
+const vcfAdapter_ts_1 = require("../../types/vcfAdapter.js");
+async function runIxIxx({ readStream, outLocation, name, prefixSize, quiet, }) {
+    const progressBar = new cli_progress_1.SingleBar({ format: '{bar} Sorting and writing index...', etaBuffer: 2000 }, cli_progress_1.Presets.shades_classic);
+    if (!quiet) {
+        progressBar.start(1, 0);
+    }
     await (0, ixixx_1.ixIxxStream)(readStream, path_1.default.join(outLocation, 'trix', `${name}.ix`), path_1.default.join(outLocation, 'trix', `${name}.ixx`), prefixSize);
+    if (!quiet) {
+        progressBar.update(1);
+        progressBar.stop();
+    }
 }
 async function* indexFiles({ trackConfigs, attributes, outLocation, quiet, typesToExclude, }) {
     for (const config of trackConfigs) {
         const { adapter, textSearching } = config;
         const { type } = adapter || {};
         const { indexingFeatureTypesToExclude = typesToExclude, indexingAttributes = attributes, } = textSearching || {};
-        const loc = (0, adapter_utils_1.getAdapterLocation)(adapter);
+        const loc = (0, adapter_utils_ts_1.getAdapterLocation)(adapter);
         if (!loc) {
             continue;
         }
         if (type === 'Gff3TabixAdapter' || type === 'Gff3Adapter') {
-            yield* (0, gff3Adapter_1.indexGff3)({
+            yield* (0, gff3Adapter_ts_1.indexGff3)({
                 config,
                 attributesToIndex: indexingAttributes,
-                inLocation: (0, adapter_utils_1.getLoc)(loc),
+                inLocation: (0, adapter_utils_ts_1.getLoc)(loc),
                 outLocation,
                 typesToExclude: indexingFeatureTypesToExclude,
                 quiet,
             });
         }
         else if (type === 'VcfTabixAdapter' || type === 'VcfAdapter') {
-            yield* (0, vcfAdapter_1.indexVcf)({
+            yield* (0, vcfAdapter_ts_1.indexVcf)({
                 config,
                 attributesToIndex: indexingAttributes,
-                inLocation: (0, adapter_utils_1.getLoc)(loc),
+                inLocation: (0, adapter_utils_ts_1.getLoc)(loc),
                 outLocation,
                 typesToExclude: indexingFeatureTypesToExclude,
                 quiet,
@@ -60,9 +69,10 @@ async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet,
         readStream,
         outLocation,
         name,
-        prefixSize: typeof prefixSize === 'string' ? parseInt(prefixSize) : prefixSize,
+        prefixSize,
+        quiet,
     });
-    await (0, common_1.generateMeta)({
+    await (0, common_ts_1.generateMeta)({
         trackConfigs,
         attributes,
         outLocation,
@@ -72,13 +82,13 @@ async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet,
     });
 }
 function prepareFileTrackConfigs(files, fileIds) {
-    const trackConfigs = files
-        .map(file => (0, common_1.guessAdapterFromFileName)(file))
-        .filter(fileConfig => (0, common_1.supported)(fileConfig.adapter?.type));
-    if (fileIds?.length) {
-        for (const [i, element] of fileIds.entries()) {
-            trackConfigs[i].trackId = element;
+    return files
+        .map((file, i) => {
+        const config = (0, common_ts_1.guessAdapterFromFileName)(file);
+        if (fileIds?.[i]) {
+            config.trackId = fileIds[i];
         }
-    }
-    return trackConfigs;
+        return config;
+    })
+        .filter(fileConfig => (0, common_ts_1.supported)(fileConfig.adapter?.type));
 }

package/dist/commands/text-index/per-track.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perTrackIndex = perTrackIndex;
+const adapter_utils_ts_1 = require("./adapter-utils.js");
+const config_utils_ts_1 = require("./config-utils.js");
+const indexing_utils_ts_1 = require("./indexing-utils.js");
+const validators_ts_1 = require("./validators.js");
+const utils_ts_1 = require("../../utils.js");
+async function perTrackIndex(flags) {
+    const { out, target, tracks, excludeTracks, assemblies, attributes, quiet, force, exclude, prefixSize, } = flags;
+    const { config, configPath, outLocation } = await (0, config_utils_ts_1.loadConfigForIndexing)(target, out, utils_ts_1.resolveConfigPath);
+    const configTracks = config.tracks || [];
+    (0, validators_ts_1.validateAssembliesForPerTrack)(assemblies);
+    const confs = (0, config_utils_ts_1.getTrackConfigs)(config, (0, config_utils_ts_1.parseCommaSeparatedString)(tracks), undefined, (0, config_utils_ts_1.parseCommaSeparatedString)(excludeTracks));
+    if (!confs.length) {
+        throw new Error('Tracks not found in config.json, please add track configurations before indexing.');
+    }
+    let hasChanges = false;
+    for (const trackConfig of confs) {
+        const { textSearching, trackId, assemblyNames } = trackConfig;
+        if (textSearching?.textSearchAdapter && !force) {
+            console.log(`Note: ${trackId} has already been indexed with this configuration, use --force to overwrite this track. Skipping for now`);
+            continue;
+        }
+        console.log(`Indexing track ${trackId}...`);
+        await (0, indexing_utils_ts_1.indexDriver)({
+            trackConfigs: [trackConfig],
+            outLocation,
+            name: trackId,
+            assemblyNames,
+            ...(0, config_utils_ts_1.prepareIndexDriverFlags)({ attributes, exclude, quiet, prefixSize }),
+        });
+        if (!textSearching?.textSearchAdapter) {
+            // modifies track with new text search adapter
+            const index = configTracks.findIndex(track => trackId === track.trackId);
+            if (index !== -1) {
+                configTracks[index] = {
+                    ...trackConfig,
+                    textSearching: {
+                        ...textSearching,
+                        textSearchAdapter: (0, adapter_utils_ts_1.createTrixAdapter)(trackId, assemblyNames),
+                    },
+                };
+                hasChanges = true;
+            }
+            else {
+                console.warn(`Warning: can't find trackId ${trackId}`);
+            }
+        }
+    }
+    if (hasChanges) {
+        (0, config_utils_ts_1.writeConf)({ ...config, tracks: configTracks }, configPath);
+    }
+}