Function runVectorizeCommand

cli/index.mjs:78–124

(inputPath, outputPath, options, command)

});

async function runVectorizeCommand(inputPath, outputPath, options, command) {
  if (options.print && outputPath) {
    console.error(pc.yellow('Warning: Output path is ignored when using --print flag'));
  }

  await assertReadable(inputPath, 'Input file');

  const finalOutputPath = outputPath || inputPath.replace(/\.[^.]+$/, '.svg');
  const inputBuffer = await fs.readFile(inputPath);
  const config = buildVectorizeConfig(options, command);
  const rawArgs = options.raw ? parseRawSize(options.raw) : null;

  console.error(pc.blue(`Converting ${pc.underline(inputPath)} to SVG`));

  const vectorizeStart = performance.now();
  const printChunks = options.print && !options.optimize;
  const collectOptions = {
    printChunks,
    showProgress: !options.print,
  };
  const svg = rawArgs
    ? await collectVectorizeChunks(
        (callback) => vectorizeRawToCallback(inputBuffer, rawArgs, config, callback),
        collectOptions,
      )
    : await collectVectorizeChunks((callback) => vectorizeToCallback(inputBuffer, config, callback), collectOptions);
  const vectorizeDuration = performance.now() - vectorizeStart;

  if (printChunks) {
    console.error(pc.blue(`Vectorized in ${vectorizeDuration.toFixed(2)}ms`));
    return;
  }

  const outputSvg = options.optimize
    ? await optimizeWithTiming(svg, buildOptimizeOptions(options, 'optimize'), 'Optimized generated SVG')
    : svg;

  if (options.print) {
    process.stdout.write(outputSvg);
    console.error(pc.blue(`Vectorized in ${vectorizeDuration.toFixed(2)}ms`));
    return;
  }

  await fs.writeFile(finalOutputPath, outputSvg, 'utf8');
  console.error(pc.green(`Wrote ${finalOutputPath}`));
  console.error(pc.blue(`Vectorized in ${vectorizeDuration.toFixed(2)}ms`));
}

async function runOptimizeCommand(inputPath, outputPath, options) {
  if (options.print && outputPath) {