How to use the figures.line function in figures

constructor() {
        this.colors = chalk_1.default;
        this.figures = figures;
        this.symbolPointer = figures.pointerSmall;
        this.symbolItem = figures.line;
        this.symbolSuccess = logSymbols.success;
        this.symbolError = logSymbols.error;
        this.symbolWarning = logSymbols.warning;
        this.symbolInfo = logSymbols.info;
        this.colorSuccess = this.colors.greenBright; // this.colors.rgb(0, 255, 0);
        this.colorError = this.colors.redBright; // this.colors.rgb(255, 0, 0);
        this.colorWarning = this.colors.yellow;
        this.colorInfo = this.colors.gray;
        this.colorHighlight = this.colors.yellowBright; // this.colors.rgb(255, 242, 0);
        this.colorText = this.colors.white;
        this.bgSuccess = this.colors.bgGreenBright;
        this.bgError = this.colors.bgRedBright;
        this.bgWarning = this.colors.bgYellow;
        this.bgInfo = this.colors.bgBlackBright; // bgGray does not exist in chalk
        this.bgHighlight = this.colors.bgYellowBright;
        this.bgText = this.colors.bgWhiteBright;

}
        return this.bgSuccess;
    }

    properSymbol( hasErrors: boolean, hasWarnings: boolean ): any {
        if ( hasErrors ) {
            return this.symbolError;
        }
        if ( hasWarnings ) {
            return this.symbolWarning;
        }
        return this.symbolSuccess;
    }

    readonly symbolPointer = figures.pointerSmall;
    readonly symbolItem = figures.line;
    readonly symbolSuccess = logSymbols.success;
    readonly symbolError = logSymbols.error;
    readonly symbolWarning = logSymbols.warning;
    readonly symbolInfo = logSymbols.info;

    readonly colorSuccess = this.colors.greenBright; // this.colors.rgb(0, 255, 0);
    readonly colorError = this.colors.redBright; // this.colors.rgb(255, 0, 0);
    readonly colorWarning = this.colors.yellow;
    readonly colorInfo = this.colors.gray;
    readonly colorHighlight = this.colors.yellowBright; // this.colors.rgb(255, 242, 0);
    readonly colorText = this.colors.white;

    readonly bgSuccess = this.colors.bgGreenBright;
    readonly bgError = this.colors.bgRedBright;
    readonly bgWarning = this.colors.bgYellow;
    readonly bgInfo = this.colors.bgBlackBright; // bgGray does not exist in chalk

print(data) {
        console.log(chalk.bgWhite.black(padRight(' Sorted by grouping (aggregate of all thread)', process.stdout.columns || 80)));
        this._print(data, [1]);

        console.log(chalk.bgWhite.black(padRight(' Sorted by subgroup', process.stdout.columns || 80)));
        this._print(data, [1, 2]);

        console.log(chalk.bgWhite.black(padRight(' Sorted by pid', process.stdout.columns || 80)));
        this._print(data, [0]);

        console.log((new Array((process.stdout.columns || 80) + 1)).join(figure.line));
        console.log(chalk.white(`Process finished in ${chalk.bold(prettyMs(Date.now() - this.processStart))}.`));
    }
}

if (cleanlyInitialized.length || overwritten.length) {
        console.log(`\nInitialized ${cleanlyInitialized.length + overwritten.length} config(s) successfully:\n`)
        for (const { filename, isOverwritten } of [...cleanlyInitialized, ...overwritten]) {
            console.log(
                `    ${chalk.green(figures.tick)} ${filename}${
                    isOverwritten ? ` ${chalk.yellow(`${figures.warning} overwritten`)}` : ''
                }`
            )
        }
    }

    if (!overwrite && existed.length) {
        console.log('\n')
        process.stdout.write(`\rSkipped ${existed.length} already existing config(s):\n`)
        for (const { filename } of existed) {
            console.log(`    ${chalk.blue(figures.line)} ${filename}`)
        }
        console.log('\nUse -o/--overwrite to force re-initialization of an already existing file.')
    }
}

function printBlockHeader(row) {
  console.log()
  console.log(colors.subtle(`${figures.line} ${row.path}`))
}

force: props.force,
    }
    t.options = {
      ...(t.options || null),
      ...(props.options || null),
    }
    let depsTree = this.resolveDependencyTree(t)
    let loading = this.isLoading(t, props)
    let cliLoading = new CliLoading({
      depsTree,
      indent: defaults(props.indent, this.globalOptions.indent),
    })
    if (loading) {
      cliLoading.start()
    } else {
      cliLoading.props.symbolMap = { [TaskState.waiting]: figures.line }
      cliLoading.props.grayState = []
      console.log(chalk.yellow(`DependencyGraph for task [${t.name}]:`))
      console.log(cliLoading.renderDepsTree(depsTree).join('\n') + '\n')
    }
    try {
      let ret = await this.runDepsTree(depsTree, props)
      return ret
    } finally {
      if (loading) {
        cliLoading.stop()
      }
    }
  }
}

constructor(line) {
    this.type = 'separator';
    this.line = chalk.dim(line || new Array(15).join(figures.line));
  }

const symbol = Theme.getValueBy(symbols, type, (): string => {
            if (type === IndicationType.Active) return frame();
            if (type === IndicationType.Success) return Figures.tick;
            if (type === IndicationType.Skip) return Figures.arrowDown;
            if (type === IndicationType.Error) return Figures.cross;
            if (type === IndicationType.Message) return Figures.line;
            if (type === IndicationType.Info) return Figures.info;
            if (type === IndicationType.Warning) return Figures.warning;
            if (type === IndicationType.Subtask) return Figures.pointerSmall;
            if (type === IndicationType.List) return Figures.pointer;

            return symbols.get(IndicationType.Default) || this.symbol(IndicationType.Subtask);
        });