@jbrowse/cli 4.0.4 → 4.1.3

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = run;
-const util_1 = require("util");
-const index_ts_1 = require("./index.js");
-const utils_ts_1 = require("../../utils.js");
-async function run(args) {
+import { parseArgs } from 'util';
+import { aggregateIndex, indexFileList, perTrackIndex } from "./index.js";
+import { printHelp } from "../../utils.js";
+export async function run(args) {
     const options = {
         help: {
             type: 'boolean',
@@ -74,7 +71,7 @@ async function run(args) {
             description: 'Just print out tracks that will be indexed by the process, without doing any indexing',
         },
     };
-    const { values: flags } = (0, util_1.parseArgs)({
+    const { values: flags } = parseArgs({
         args,
         options,
     });
@@ -99,7 +96,7 @@ async function run(args) {
         '$ jbrowse text-index --file myfile.gff3.gz --file myfile.vcfgz --out indexes',
     ];
     if (flags.help) {
-        (0, utils_ts_1.printHelp)({
+        printHelp({
             description,
             examples,
             usage: 'jbrowse text-index [options]',
@@ -109,12 +106,12 @@ async function run(args) {
     }
     const { perTrack, file } = flags;
     if (file) {
-        await (0, index_ts_1.indexFileList)(flags);
+        await indexFileList(flags);
     }
     else if (perTrack) {
-        await (0, index_ts_1.perTrackIndex)(flags);
+        await perTrackIndex(flags);
     }
     else {
-        await (0, index_ts_1.aggregateIndex)(flags);
+        await aggregateIndex(flags);
     }
 }

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

@@ -1,25 +1,10 @@
-"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");
+import fs from 'fs';
+import path from 'path';
+import { supported } from "../../types/common.js";
 /**
  * Parses a comma-separated string into an array of trimmed, non-empty strings
  */
-function parseCommaSeparatedString(value) {
+export function parseCommaSeparatedString(value) {
     return (value
         ?.split(',')
         .map(s => s.trim())
@@ -29,13 +14,13 @@ function parseCommaSeparatedString(value) {
  * Sanitizes a name for use in file paths by replacing invalid characters
  * Replaces characters that are problematic in file paths: / \ : * ? " < > |
  */
-function sanitizeNameForPath(name) {
+export function sanitizeNameForPath(name) {
     return name.replace(/[/\\:*?"<>|]/g, '_');
 }
 /**
  * Validates and parses a prefix size value
  */
-function validatePrefixSize(value) {
+export function validatePrefixSize(value) {
     if (!value) {
         return undefined;
     }
@@ -48,7 +33,7 @@ function validatePrefixSize(value) {
 /**
  * Prepares common indexDriver parameters from raw flag values
  */
-function prepareIndexDriverFlags(flags) {
+export function prepareIndexDriverFlags(flags) {
     return {
         attributes: parseCommaSeparatedString(flags.attributes),
         typesToExclude: parseCommaSeparatedString(flags.exclude),
@@ -56,26 +41,26 @@ function prepareIndexDriverFlags(flags) {
         prefixSize: validatePrefixSize(flags.prefixSize),
     };
 }
-function readConf(configPath) {
-    return JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+export function readConf(configPath) {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
 }
-function writeConf(obj, configPath) {
-    fs_1.default.writeFileSync(configPath, JSON.stringify(obj, null, 2));
+export function writeConf(obj, configPath) {
+    fs.writeFileSync(configPath, JSON.stringify(obj, null, 2));
 }
 /**
  * Loads config and prepares output location for indexing
  */
-async function loadConfigForIndexing(target, out, resolveConfigPath) {
+export async function loadConfigForIndexing(target, out, resolveConfigPath) {
     const configPath = await resolveConfigPath(target, out);
-    const outLocation = path_1.default.dirname(configPath);
+    const outLocation = path.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);
+export function ensureTrixDir(outLocation) {
+    const trixDir = path.join(outLocation, 'trix');
+    if (!fs.existsSync(trixDir)) {
+        fs.mkdirSync(trixDir, { recursive: true });
     }
     return trixDir;
 }
@@ -92,7 +77,7 @@ function extractAssemblyNamesFromConfig(config) {
     }
     return [];
 }
-function getAssemblyNames(config, assemblies) {
+export function getAssemblyNames(config, assemblies) {
     const asms = assemblies
         ? parseCommaSeparatedString(assemblies)
         : extractAssemblyNamesFromConfig(config);
@@ -101,12 +86,14 @@ function getAssemblyNames(config, assemblies) {
     }
     return asms;
 }
-function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
+export function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
     const { tracks } = config;
     if (!tracks) {
         return [];
     }
-    const trackIdsToIndex = trackIds || tracks.map(track => track.trackId);
+    const trackIdsToIndex = trackIds?.length
+        ? trackIds
+        : tracks.map(track => track.trackId);
     const excludeSet = new Set(excludeTrackIds || []);
     return trackIdsToIndex
         .map(trackId => {
@@ -118,11 +105,10 @@ function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
     })
         .filter(track => {
         if (excludeSet.has(track.trackId)) {
-            console.log(`Skipping ${track.trackId}: excluded via --exclude-tracks`);
+            // 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}'`);
+        if (!supported(track.adapter?.type)) {
             return false;
         }
         if (assemblyName && !track.assemblyNames.includes(assemblyName)) {

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

@@ -1,28 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexFileList = indexFileList;
-const path_1 = __importDefault(require("path"));
-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) {
+import path from 'path';
+import { ensureTrixDir, prepareIndexDriverFlags, sanitizeNameForPath, } from "./config-utils.js";
+import { indexDriver, prepareFileTrackConfigs } from "./indexing-utils.js";
+import { validateFileInput } from "./validators.js";
+export async function indexFileList(flags) {
     const { out, target, fileId, file, attributes, quiet, exclude, prefixSize } = flags;
-    (0, validators_ts_1.validateFileInput)(file);
+    validateFileInput(file);
     const outFlag = target || out || '.';
-    (0, config_utils_ts_1.ensureTrixDir)(outFlag);
-    const trackConfigs = (0, indexing_utils_ts_1.prepareFileTrackConfigs)(file, fileId);
+    ensureTrixDir(outFlag);
+    const trackConfigs = 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)({
+        : sanitizeNameForPath(path.basename(file[0]));
+    await indexDriver({
         trackConfigs,
         outLocation: outFlag,
         name,
         assemblyNames: [],
-        ...(0, config_utils_ts_1.prepareIndexDriverFlags)({ attributes, exclude, quiet, prefixSize }),
+        ...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

@@ -1,11 +1,4 @@
-"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; } });
+export { aggregateIndex } from "./aggregate.js";
+export { perTrackIndex } from "./per-track.js";
+export { indexFileList } from "./file-list.js";
+export { run } from "./command.js";

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

@@ -1,64 +1,80 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runIxIxx = runIxIxx;
-exports.indexFiles = indexFiles;
-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_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);
+import path from 'path';
+import { Readable } from 'stream';
+import { generateMeta, guessAdapterFromFileName, indexGff3, indexVcf, } from '@jbrowse/text-indexing-core';
+import { Presets, SingleBar } from 'cli-progress';
+import { ixIxxStream } from 'ixixx';
+import { getAdapterLocation, getLoc } from "./adapter-utils.js";
+import { supported } from "../../types/common.js";
+export async function runIxIxx({ readStream, outLocation, name, prefixSize, quiet, }) {
+    const progressBar = new SingleBar({ format: '{bar} Sorting and writing index...', etaBuffer: 2000 }, 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);
+    const ixPath = path.join(outLocation, 'trix', `${name}.ix`);
+    const ixxPath = path.join(outLocation, 'trix', `${name}.ixx`);
+    await ixIxxStream(readStream, ixPath, ixxPath, prefixSize);
     if (!quiet) {
         progressBar.update(1);
         progressBar.stop();
     }
 }
-async function* indexFiles({ trackConfigs, attributes, outLocation, quiet, typesToExclude, }) {
+export async function* indexFiles({ trackConfigs, attributes, outLocation, quiet, typesToExclude, }) {
     for (const config of trackConfigs) {
-        const { adapter, textSearching } = config;
+        const { adapter, textSearching, trackId } = config;
         const { type } = adapter || {};
         const { indexingFeatureTypesToExclude = typesToExclude, indexingAttributes = attributes, } = textSearching || {};
-        const loc = (0, adapter_utils_ts_1.getAdapterLocation)(adapter);
+        const loc = getAdapterLocation(adapter);
         if (!loc) {
             continue;
         }
+        const progressBar = new SingleBar({
+            format: `{bar} ${trackId} {percentage}% | ETA: {eta}s`,
+            etaBuffer: 2000,
+        }, Presets.shades_classic);
         if (type === 'Gff3TabixAdapter' || type === 'Gff3Adapter') {
-            yield* (0, gff3Adapter_ts_1.indexGff3)({
+            yield* indexGff3({
                 config,
                 attributesToIndex: indexingAttributes,
-                inLocation: (0, adapter_utils_ts_1.getLoc)(loc),
-                outLocation,
-                typesToExclude: indexingFeatureTypesToExclude,
-                quiet,
+                inLocation: getLoc(loc),
+                outDir: outLocation,
+                featureTypesToExclude: indexingFeatureTypesToExclude,
+                onStart: totalBytes => {
+                    if (!quiet) {
+                        progressBar.start(totalBytes, 0);
+                    }
+                },
+                onUpdate: receivedBytes => {
+                    if (!quiet) {
+                        progressBar.update(receivedBytes);
+                    }
+                },
             });
         }
         else if (type === 'VcfTabixAdapter' || type === 'VcfAdapter') {
-            yield* (0, vcfAdapter_ts_1.indexVcf)({
+            yield* indexVcf({
                 config,
                 attributesToIndex: indexingAttributes,
-                inLocation: (0, adapter_utils_ts_1.getLoc)(loc),
-                outLocation,
-                typesToExclude: indexingFeatureTypesToExclude,
-                quiet,
+                inLocation: getLoc(loc),
+                outDir: outLocation,
+                onStart: totalBytes => {
+                    if (!quiet) {
+                        progressBar.start(totalBytes, 0);
+                    }
+                },
+                onUpdate: receivedBytes => {
+                    if (!quiet) {
+                        progressBar.update(receivedBytes);
+                    }
+                },
             });
         }
+        if (!quiet) {
+            progressBar.stop();
+        }
     }
 }
-async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet, typesToExclude, assemblyNames, prefixSize, }) {
-    const readStream = stream_1.Readable.from(indexFiles({
+export async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet, typesToExclude, assemblyNames, prefixSize, }) {
+    const readStream = Readable.from(indexFiles({
         trackConfigs,
         attributes,
         outLocation,
@@ -72,23 +88,23 @@ async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet,
         prefixSize,
         quiet,
     });
-    await (0, common_ts_1.generateMeta)({
-        trackConfigs,
-        attributes,
-        outLocation,
+    await generateMeta({
+        configs: trackConfigs,
+        attributesToIndex: attributes,
+        outDir: outLocation,
         name,
-        typesToExclude,
+        featureTypesToExclude: typesToExclude,
         assemblyNames,
     });
 }
-function prepareFileTrackConfigs(files, fileIds) {
+export function prepareFileTrackConfigs(files, fileIds) {
     return files
         .map((file, i) => {
-        const config = (0, common_ts_1.guessAdapterFromFileName)(file);
+        const config = guessAdapterFromFileName(file);
         if (fileIds?.[i]) {
             config.trackId = fileIds[i];
         }
         return config;
     })
-        .filter(fileConfig => (0, common_ts_1.supported)(fileConfig.adapter?.type));
+        .filter(fileConfig => supported(fileConfig.adapter?.type));
 }

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

@@ -1,17 +1,14 @@
-"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) {
+import { createTrixAdapter } from "./adapter-utils.js";
+import { getTrackConfigs, loadConfigForIndexing, parseCommaSeparatedString, prepareIndexDriverFlags, writeConf, } from "./config-utils.js";
+import { indexDriver } from "./indexing-utils.js";
+import { validateAssembliesForPerTrack } from "./validators.js";
+import { resolveConfigPath } from "../../utils.js";
+export 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 { config, configPath, outLocation } = await loadConfigForIndexing(target, out, 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));
+    validateAssembliesForPerTrack(assemblies);
+    const confs = getTrackConfigs(config, parseCommaSeparatedString(tracks), undefined, parseCommaSeparatedString(excludeTracks));
     if (!confs.length) {
         throw new Error('Tracks not found in config.json, please add track configurations before indexing.');
     }
@@ -23,12 +20,12 @@ async function perTrackIndex(flags) {
             continue;
         }
         console.log(`Indexing track ${trackId}...`);
-        await (0, indexing_utils_ts_1.indexDriver)({
+        await indexDriver({
             trackConfigs: [trackConfig],
             outLocation,
             name: trackId,
             assemblyNames,
-            ...(0, config_utils_ts_1.prepareIndexDriverFlags)({ attributes, exclude, quiet, prefixSize }),
+            ...prepareIndexDriverFlags({ attributes, exclude, quiet, prefixSize }),
         });
         if (!textSearching?.textSearchAdapter) {
             // modifies track with new text search adapter
@@ -38,7 +35,7 @@ async function perTrackIndex(flags) {
                     ...trackConfig,
                     textSearching: {
                         ...textSearching,
-                        textSearchAdapter: (0, adapter_utils_ts_1.createTrixAdapter)(trackId, assemblyNames),
+                        textSearchAdapter: createTrixAdapter(trackId, assemblyNames),
                     },
                 };
                 hasChanges = true;
@@ -49,6 +46,6 @@ async function perTrackIndex(flags) {
         }
     }
     if (hasChanges) {
-        (0, config_utils_ts_1.writeConf)({ ...config, tracks: configTracks }, configPath);
+        writeConf({ ...config, tracks: configTracks }, configPath);
     }
 }

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

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTrackConfigs = validateTrackConfigs;
-exports.validateFileInput = validateFileInput;
-exports.validateAssembliesForPerTrack = validateAssembliesForPerTrack;
-function validateTrackConfigs(tracks) {
+export function validateTrackConfigs(tracks) {
     if (!tracks.length) {
         throw new Error('Tracks not found in config.json, please add track configurations before indexing.');
     }
 }
-function validateFileInput(file) {
+export function validateFileInput(file) {
     if (!file) {
         throw new Error('Cannot index file list without files');
     }
 }
-function validateAssembliesForPerTrack(assemblies) {
+export function validateAssembliesForPerTrack(assemblies) {
     if (assemblies) {
         throw new Error(`Can't specify assemblies when indexing per track, remove assemblies flag to continue.`);
     }

package/dist/commands/track-utils.js

@@ -1,29 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadTrackConfig = loadTrackConfig;
-exports.processTrackFiles = processTrackFiles;
-exports.addTrackToConfig = addTrackToConfig;
-exports.saveTrackConfigAndReport = saveTrackConfigAndReport;
-exports.buildTrackParams = buildTrackParams;
-exports.createTrackConfiguration = createTrackConfiguration;
-const path_1 = __importDefault(require("path"));
-const utils_ts_1 = require("../utils.js");
-const adapter_utils_ts_1 = require("./add-track-utils/adapter-utils.js");
-const file_operations_ts_1 = require("./add-track-utils/file-operations.js");
-const track_config_ts_1 = require("./add-track-utils/track-config.js");
-const validators_ts_1 = require("./add-track-utils/validators.js");
-const config_operations_ts_1 = require("./shared/config-operations.js");
-async function loadTrackConfig(targetConfigPath) {
-    return await (0, utils_ts_1.readJsonFile)(targetConfigPath);
+import path from 'path';
+import { readJsonFile } from "../utils.js";
+import { guessFileNames, guessTrackType, } from "./add-track-utils/adapter-utils.js";
+import { loadFile } from "./add-track-utils/file-operations.js";
+import { buildTrackConfig } from "./add-track-utils/track-config.js";
+import { validateTrackId } from "./add-track-utils/validators.js";
+import { findAndUpdateOrAdd, saveConfigAndReport as saveConfigAndReportBase, } from "./shared/config-operations.js";
+export async function loadTrackConfig(targetConfigPath) {
+    return await readJsonFile(targetConfigPath);
 }
-async function processTrackFiles({ location, index, bed1, bed2, load, configDir, subDir, force, }) {
+export async function processTrackFiles({ location, index, bed1, bed2, load, configDir, subDir, force, }) {
     if (load) {
-        await Promise.all(Object.values((0, adapter_utils_ts_1.guessFileNames)({ location, index, bed1, bed2 }))
+        await Promise.all(Object.values(guessFileNames({ location, index, bed1, bed2 }))
             .filter(f => !!f)
-            .map(src => (0, file_operations_ts_1.loadFile)({
+            .map(src => loadFile({
             src,
             destDir: configDir,
             mode: load,
@@ -32,9 +21,9 @@ async function processTrackFiles({ location, index, bed1, bed2, load, configDir,
         })));
     }
 }
-function addTrackToConfig({ configContents, trackConfig, trackId, force, overwrite, }) {
-    (0, validators_ts_1.validateTrackId)(configContents, trackId, force, overwrite);
-    const { updatedItems, wasOverwritten } = (0, config_operations_ts_1.findAndUpdateOrAdd)({
+export function addTrackToConfig({ configContents, trackConfig, trackId, force, overwrite, }) {
+    validateTrackId(configContents, trackId, force, overwrite);
+    const { updatedItems, wasOverwritten } = findAndUpdateOrAdd({
         items: configContents.tracks || [],
         newItem: trackConfig,
         idField: 'trackId',
@@ -47,8 +36,8 @@ function addTrackToConfig({ configContents, trackConfig, trackId, force, overwri
         wasOverwritten,
     };
 }
-async function saveTrackConfigAndReport({ config, targetConfigPath, name, trackId, wasOverwritten, }) {
-    await (0, config_operations_ts_1.saveConfigAndReport)({
+export async function saveTrackConfigAndReport({ config, targetConfigPath, name, trackId, wasOverwritten, }) {
+    await saveConfigAndReportBase({
         config,
         target: targetConfigPath,
         itemType: 'track',
@@ -57,9 +46,9 @@ async function saveTrackConfigAndReport({ config, targetConfigPath, name, trackI
         wasOverwritten,
     });
 }
-function buildTrackParams({ flags, location, adapter, configContents, }) {
-    const trackType = flags.trackType || (0, adapter_utils_ts_1.guessTrackType)(adapter.type);
-    const trackId = flags.trackId || path_1.default.basename(location, path_1.default.extname(location));
+export function buildTrackParams({ flags, location, adapter, configContents, }) {
+    const trackType = flags.trackType || guessTrackType(adapter.type);
+    const trackId = flags.trackId || path.basename(location, path.extname(location));
     const name = flags.name || trackId;
     const assemblyNames = flags.assemblyNames || configContents.assemblies?.[0]?.name || '';
     return {
@@ -69,8 +58,8 @@ function buildTrackParams({ flags, location, adapter, configContents, }) {
         assemblyNames,
     };
 }
-function createTrackConfiguration({ location, trackParams, flags, adapter, configContents, }) {
-    return (0, track_config_ts_1.buildTrackConfig)({
+export function createTrackConfiguration({ location, trackParams, flags, adapter, configContents, }) {
+    return buildTrackConfig({
         location,
         trackType: trackParams.trackType,
         trackId: trackParams.trackId,