@types/color

  • Version 3.0.1
  • Published
  • 7.21 kB
  • 1 dependency
  • MIT license

Install

npm i @types/color
yarn add @types/color
pnpm add @types/color

Overview

TypeScript definitions for color

Index

Variables

variable Color

const Color: ColorConstructor;

    Interfaces

    interface Color

    interface Color<T extends ColorParam = ColorParam> {}

      method a

      a: { (): number; (val: number): Color<ColorParam> };

        method alpha

        alpha: { (): number; (val: number): Color<ColorParam> };

          method ansi16

          ansi16: (...args: number[]) => Color;

            method ansi256

            ansi256: (...args: number[]) => Color;

              method apple

              apple: (...args: number[]) => Color;

                method array

                array: () => number[];

                  method b

                  b: { (): number; (val: number): Color<ColorParam> };

                    method black

                    black: { (): number; (val: number): Color<ColorParam> };

                      method blacken

                      blacken: (ratio: number) => Color;

                        method blue

                        blue: { (): number; (val: number): Color<ColorParam> };

                          method chroma

                          chroma: { (): number; (val: number): Color<ColorParam> };

                            method cmyk

                            cmyk: (...args: number[]) => Color;

                              method contrast

                              contrast: (color2: Color) => number;

                                method cyan

                                cyan: { (): number; (val: number): Color<ColorParam> };

                                  method darken

                                  darken: (ratio: number) => Color;

                                    method desaturate

                                    desaturate: (ratio: number) => Color;

                                      method fade

                                      fade: (ratio: number) => Color;

                                        method gray

                                        gray: { (): number; (val: number): Color<ColorParam> };

                                          method grayscale

                                          grayscale: () => Color;

                                            method green

                                            green: { (): number; (val: number): Color<ColorParam> };

                                              method hcg

                                              hcg: (...args: number[]) => Color;

                                                method hex

                                                hex: { (): string; <V extends string>(val: V): Color<V> };

                                                  method hsl

                                                  hsl: (...args: number[]) => Color;

                                                    method hsv

                                                    hsv: (...args: number[]) => Color;

                                                      method hue

                                                      hue: { (): number; (val: number): Color<ColorParam> };

                                                        method hwb

                                                        hwb: (...args: number[]) => Color;

                                                          method isDark

                                                          isDark: () => boolean;

                                                            method isLight

                                                            isLight: () => boolean;

                                                              method keyword

                                                              keyword: { (): string; <V extends string>(val: V): Color<V> };

                                                                method l

                                                                l: { (): number; (val: number): Color<ColorParam> };

                                                                  method lab

                                                                  lab: (...args: number[]) => Color;

                                                                    method lch

                                                                    lch: (...args: number[]) => Color;

                                                                      method level

                                                                      level: (color2: Color) => 'AAA' | 'AA' | '';

                                                                        method lighten

                                                                        lighten: (ratio: number) => Color;

                                                                          method lightness

                                                                          lightness: { (): number; (val: number): Color<ColorParam> };

                                                                            method luminosity

                                                                            luminosity: () => number;

                                                                              method magenta

                                                                              magenta: { (): number; (val: number): Color<ColorParam> };

                                                                                method mix

                                                                                mix: (mixinColor: Color, weight?: number) => Color;

                                                                                  method negate

                                                                                  negate: () => Color;

                                                                                    method object

                                                                                    object: () => { alpha?: number } & { [key: string]: number };

                                                                                      method opaquer

                                                                                      opaquer: (ratio: number) => Color;

                                                                                        method percentString

                                                                                        percentString: (places?: number) => string;

                                                                                          method red

                                                                                          red: { (): number; (val: number): Color<ColorParam> };

                                                                                            method rgb

                                                                                            rgb: (...args: number[]) => Color;

                                                                                              method rgbNumber

                                                                                              rgbNumber: () => number;

                                                                                                method rotate

                                                                                                rotate: (degrees: number) => Color;

                                                                                                  method round

                                                                                                  round: (places?: number) => Color;

                                                                                                    method saturate

                                                                                                    saturate: (ratio: number) => Color;

                                                                                                      method saturationl

                                                                                                      saturationl: { (): number; (val: number): Color<ColorParam> };

                                                                                                        method saturationv

                                                                                                        saturationv: { (): number; (val: number): Color<ColorParam> };

                                                                                                          method string

                                                                                                          string: (places?: number) => string;

                                                                                                            method toJSON

                                                                                                            toJSON: () => Color<T>;

                                                                                                              method toString

                                                                                                              toString: () => string;

                                                                                                                method unitArray

                                                                                                                unitArray: () => number[];

                                                                                                                  method unitObject

                                                                                                                  unitObject: () => { r: number; g: number; b: number; alpha?: number };

                                                                                                                    method value

                                                                                                                    value: { (): number; (val: number): Color<ColorParam> };

                                                                                                                      method wblack

                                                                                                                      wblack: { (): number; (val: number): Color<ColorParam> };

                                                                                                                        method white

                                                                                                                        white: { (): number; (val: number): Color<ColorParam> };

                                                                                                                          method whiten

                                                                                                                          whiten: (ratio: number) => Color;

                                                                                                                            method x

                                                                                                                            x: { (): number; (val: number): Color<ColorParam> };

                                                                                                                              method xyz

                                                                                                                              xyz: (...args: number[]) => Color;

                                                                                                                                method y

                                                                                                                                y: { (): number; (val: number): Color<ColorParam> };

                                                                                                                                  method yellow

                                                                                                                                  yellow: { (): number; (val: number): Color<ColorParam> };

                                                                                                                                    method z

                                                                                                                                    z: { (): number; (val: number): Color<ColorParam> };

                                                                                                                                      Package Files (1)

                                                                                                                                      Dependencies (1)

                                                                                                                                      Dev Dependencies (0)

                                                                                                                                      No dev dependencies.

                                                                                                                                      Peer Dependencies (0)

                                                                                                                                      No peer dependencies.

                                                                                                                                      Badge

                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/color.

                                                                                                                                      • Markdown
                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/color)
                                                                                                                                      • HTML
                                                                                                                                        <a href="https://www.jsdocs.io/package/@types/color"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>