@types/color

  • Version 3.0.6
  • Published
  • 6.95 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 hexa

                                                  hexa: { (): 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 | undefined } & { [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 | undefined;
                                                                                                                    };

                                                                                                                      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>