diff --git a/index.d.ts b/index.d.ts index 7e22c45..533f5b7 100644 --- a/index.d.ts +++ b/index.d.ts @@ -132,6 +132,15 @@ declare namespace chalk { } interface ChalkFunction { + /** + Use a string. + + @remarks Template literals are unsupported for nested calls (see [issue #341](https://github.com/chalk/chalk/issues/341)) + */ + (text: string): string; + } + + interface ChalkTemplateFunction { /** Use a template string. @@ -153,7 +162,7 @@ declare namespace chalk { (...text: unknown[]): string; } - interface Chalk extends ChalkFunction { + interface ChalkObject { /** Return a new Chalk instance. */ @@ -291,105 +300,109 @@ declare namespace chalk { /** Modifier: Resets the current color chain. */ - readonly reset: Chalk; + readonly reset: ChalkProperty; /** Modifier: Make text bold. */ - readonly bold: Chalk; + readonly bold: ChalkProperty; /** Modifier: Emitting only a small amount of light. */ - readonly dim: Chalk; + readonly dim: ChalkProperty; /** Modifier: Make text italic. (Not widely supported) */ - readonly italic: Chalk; + readonly italic: ChalkProperty; /** Modifier: Make text underline. (Not widely supported) */ - readonly underline: Chalk; + readonly underline: ChalkProperty; /** Modifier: Inverse background and foreground colors. */ - readonly inverse: Chalk; + readonly inverse: ChalkProperty; /** Modifier: Prints the text, but makes it invisible. */ - readonly hidden: Chalk; + readonly hidden: ChalkProperty; /** Modifier: Puts a horizontal line through the center of the text. (Not widely supported) */ - readonly strikethrough: Chalk; + readonly strikethrough: ChalkProperty; /** Modifier: Prints the text only when Chalk has a color support level > 0. Can be useful for things that are purely cosmetic. */ - readonly visible: Chalk; + readonly visible: ChalkProperty; - readonly black: Chalk; - readonly red: Chalk; - readonly green: Chalk; - readonly yellow: Chalk; - readonly blue: Chalk; - readonly magenta: Chalk; - readonly cyan: Chalk; - readonly white: Chalk; + readonly black: ChalkProperty; + readonly red: ChalkProperty; + readonly green: ChalkProperty; + readonly yellow: ChalkProperty; + readonly blue: ChalkProperty; + readonly magenta: ChalkProperty; + readonly cyan: ChalkProperty; + readonly white: ChalkProperty; /* Alias for `blackBright`. */ - readonly gray: Chalk; + readonly gray: ChalkProperty; /* Alias for `blackBright`. */ - readonly grey: Chalk; + readonly grey: ChalkProperty; - readonly blackBright: Chalk; - readonly redBright: Chalk; - readonly greenBright: Chalk; - readonly yellowBright: Chalk; - readonly blueBright: Chalk; - readonly magentaBright: Chalk; - readonly cyanBright: Chalk; - readonly whiteBright: Chalk; + readonly blackBright: ChalkProperty; + readonly redBright: ChalkProperty; + readonly greenBright: ChalkProperty; + readonly yellowBright: ChalkProperty; + readonly blueBright: ChalkProperty; + readonly magentaBright: ChalkProperty; + readonly cyanBright: ChalkProperty; + readonly whiteBright: ChalkProperty; - readonly bgBlack: Chalk; - readonly bgRed: Chalk; - readonly bgGreen: Chalk; - readonly bgYellow: Chalk; - readonly bgBlue: Chalk; - readonly bgMagenta: Chalk; - readonly bgCyan: Chalk; - readonly bgWhite: Chalk; + readonly bgBlack: ChalkProperty; + readonly bgRed: ChalkProperty; + readonly bgGreen: ChalkProperty; + readonly bgYellow: ChalkProperty; + readonly bgBlue: ChalkProperty; + readonly bgMagenta: ChalkProperty; + readonly bgCyan: ChalkProperty; + readonly bgWhite: ChalkProperty; /* Alias for `bgBlackBright`. */ - readonly bgGray: Chalk; + readonly bgGray: ChalkProperty; /* Alias for `bgBlackBright`. */ - readonly bgGrey: Chalk; + readonly bgGrey: ChalkProperty; - readonly bgBlackBright: Chalk; - readonly bgRedBright: Chalk; - readonly bgGreenBright: Chalk; - readonly bgYellowBright: Chalk; - readonly bgBlueBright: Chalk; - readonly bgMagentaBright: Chalk; - readonly bgCyanBright: Chalk; - readonly bgWhiteBright: Chalk; + readonly bgBlackBright: ChalkProperty; + readonly bgRedBright: ChalkProperty; + readonly bgGreenBright: ChalkProperty; + readonly bgYellowBright: ChalkProperty; + readonly bgBlueBright: ChalkProperty; + readonly bgMagentaBright: ChalkProperty; + readonly bgCyanBright: ChalkProperty; + readonly bgWhiteBright: ChalkProperty; } + + interface ChalkProperty extends ChalkObject, ChalkFunction {} + + interface Chalk extends ChalkObject, ChalkFunction, ChalkTemplateFunction {} } /** @@ -398,7 +411,7 @@ Call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`. */ -declare const chalk: chalk.Chalk & chalk.ChalkFunction & { +declare const chalk: chalk.Chalk & chalk.ChalkFunction & chalk.ChalkTemplateFunction & { supportsColor: chalk.ColorSupport | false; Level: typeof LevelEnum; Color: Color; diff --git a/index.test-d.ts b/index.test-d.ts index 177d6de..672033d 100644 --- a/index.test-d.ts +++ b/index.test-d.ts @@ -42,6 +42,10 @@ const name = 'John'; expectType(chalk`Hello {bold.red ${name}}`); expectType(chalk`Works with numbers {bold.red ${1}}`); +// -- Members of the Chalk interface do not support template literals (#341) -- +expectError(chalk.bold`Hello {bold.red ${name}}`); +expectError(chalk.bold`Works with numbers {bold.red ${1}}`); + // -- Color methods -- expectType(chalk.hex('#DEADED')); expectType(chalk.keyword('orange')); @@ -70,15 +74,15 @@ expectType(chalk.inverse('foo')); expectType(chalk.hidden('foo')); expectType(chalk.strikethrough('foo')); expectType(chalk.visible('foo')); -expectType(chalk.reset`foo`); -expectType(chalk.bold`foo`); -expectType(chalk.dim`foo`); -expectType(chalk.italic`foo`); -expectType(chalk.underline`foo`); -expectType(chalk.inverse`foo`); -expectType(chalk.hidden`foo`); -expectType(chalk.strikethrough`foo`); -expectType(chalk.visible`foo`); +expectError(chalk.reset`foo`); +expectError(chalk.bold`foo`); +expectError(chalk.dim`foo`); +expectError(chalk.italic`foo`); +expectError(chalk.underline`foo`); +expectError(chalk.inverse`foo`); +expectError(chalk.hidden`foo`); +expectError(chalk.strikethrough`foo`); +expectError(chalk.visible`foo`); // -- Colors -- expectType(chalk.black('foo')); @@ -115,40 +119,40 @@ expectType(chalk.bgBlueBright('foo')); expectType(chalk.bgMagentaBright('foo')); expectType(chalk.bgCyanBright('foo')); expectType(chalk.bgWhiteBright('foo')); -expectType(chalk.black`foo`); -expectType(chalk.red`foo`); -expectType(chalk.green`foo`); -expectType(chalk.yellow`foo`); -expectType(chalk.blue`foo`); -expectType(chalk.magenta`foo`); -expectType(chalk.cyan`foo`); -expectType(chalk.white`foo`); -expectType(chalk.gray`foo`); -expectType(chalk.grey`foo`); -expectType(chalk.blackBright`foo`); -expectType(chalk.redBright`foo`); -expectType(chalk.greenBright`foo`); -expectType(chalk.yellowBright`foo`); -expectType(chalk.blueBright`foo`); -expectType(chalk.magentaBright`foo`); -expectType(chalk.cyanBright`foo`); -expectType(chalk.whiteBright`foo`); -expectType(chalk.bgBlack`foo`); -expectType(chalk.bgRed`foo`); -expectType(chalk.bgGreen`foo`); -expectType(chalk.bgYellow`foo`); -expectType(chalk.bgBlue`foo`); -expectType(chalk.bgMagenta`foo`); -expectType(chalk.bgCyan`foo`); -expectType(chalk.bgWhite`foo`); -expectType(chalk.bgBlackBright`foo`); -expectType(chalk.bgRedBright`foo`); -expectType(chalk.bgGreenBright`foo`); -expectType(chalk.bgYellowBright`foo`); -expectType(chalk.bgBlueBright`foo`); -expectType(chalk.bgMagentaBright`foo`); -expectType(chalk.bgCyanBright`foo`); -expectType(chalk.bgWhiteBright`foo`); +expectError(chalk.black`foo`); +expectError(chalk.red`foo`); +expectError(chalk.green`foo`); +expectError(chalk.yellow`foo`); +expectError(chalk.blue`foo`); +expectError(chalk.magenta`foo`); +expectError(chalk.cyan`foo`); +expectError(chalk.white`foo`); +expectError(chalk.gray`foo`); +expectError(chalk.grey`foo`); +expectError(chalk.blackBright`foo`); +expectError(chalk.redBright`foo`); +expectError(chalk.greenBright`foo`); +expectError(chalk.yellowBright`foo`); +expectError(chalk.blueBright`foo`); +expectError(chalk.magentaBright`foo`); +expectError(chalk.cyanBright`foo`); +expectError(chalk.whiteBright`foo`); +expectError(chalk.bgBlack`foo`); +expectError(chalk.bgRed`foo`); +expectError(chalk.bgGreen`foo`); +expectError(chalk.bgYellow`foo`); +expectError(chalk.bgBlue`foo`); +expectError(chalk.bgMagenta`foo`); +expectError(chalk.bgCyan`foo`); +expectError(chalk.bgWhite`foo`); +expectError(chalk.bgBlackBright`foo`); +expectError(chalk.bgRedBright`foo`); +expectError(chalk.bgGreenBright`foo`); +expectError(chalk.bgYellowBright`foo`); +expectError(chalk.bgBlueBright`foo`); +expectError(chalk.bgMagentaBright`foo`); +expectError(chalk.bgCyanBright`foo`); +expectError(chalk.bgWhiteBright`foo`); // -- Complex -- expectType(chalk.red.bgGreen.underline('foo'));