@gypsy-js/cli/dist/lib/types/index.d.ts

cli

/**
 * @file cli typedef.
 * @author qivmvip AT gmail DOT com
 * @date 2022-03-01
 */

declare type MessageStyle = Partial<{
  color: string;
  bgColor: string;
  bold: boolean;
  italic: boolean;
  underline: boolean;
}>

declare type Message = {
  text: string;
  style?: MessageStyle;
}

declare type MessageBuilder = {
  text(text: string): MessageBuilder;
  color(color: string): MessageBuilder;
  bgColor(bgColor: string): MessageBuilder;
  bold(bold: boolean): MessageBuilder;
  italic(italic: boolean): MessageBuilder;
  underline(underline: boolean): MessageBuilder;
}

declare type MessagesBuilderFn = {
  (text: string): MessageBuilder
}
declare type MessagesRawFn = {
  (text: string): MessageBuilder
}
declare type MessagesColorizeFn = {
  (text: string, color: string): MessageBuilder
}
declare type Messages= Readonly<{
  builder: MessagesBuilderFn;
  raw: MessagesRawFn;
  colorize: MessagesColorizeFn;
}>;
declare const messages: MessagesNamespace;

declare type LoggerColors = Readonly<{
  dbg: string,
  log: string,
  inf: string,
  wrn: string,
  err: string,
}>
declare type IndicatorColors = Readonly<{
  exec: string,
  info: string,
  warn: string,
  succ: string,
  fail: string,
}>
declare type SpinnerColors = Readonly<{
  spin: string,
  updt: string,
  succ: string,
  fail: string,
}>
declare type Colors = Readonly<{
  logger: LoggerColors;
  indicator: LoggerColors;
  spinner: SpinColors;
}>;
declare const colors: Colors;

declare type SymbolsGetOptions = {
  unicode: boolean;
  colorized: boolean;
}
declare type LoggerSymbols = Readonly<{
  get: (
    verb: 'dbg' | 'log' | 'inf' | 'wrn' | 'err', options: SymbolsGetOptions
  ) => Message;
}>
declare type IndicatorSymbols = Readonly<{
  get: (
    verb: 'exec' | 'info' | 'warn' | 'succ' | 'fail', options: SymbolsGetOptions
  ) => Message;
}>
declare type SpinnerSymbols = Readonly<{
  get: (
    verb: 'spin' | 'updt' | 'succ' | 'fail', options: SymbolsGetOptions
  ) => Message;
}>
declare type Symbols = Readonly<{
  logger: LoggerSymbols;
  indicator: IndicatorSymbols;
  spinner: SpinnerSymbols;
}>;
declare const symbols: Symbols;

declare type ContextArgs = Partial<{
  argv: string[];
  options: {
    [key: string]: {
      arg: string;
      index: number;
      values: string[];
      follows: string[];
    };
  };
}>
declare type ContextI18n = Partial<{
  lang: string;
}>
declare type Context = Partial<{
  cwd: string;
  env: string[];
  args: ContextArgs;
  i18n: ContextI18n;
}>

declare type Output = {
  date: Date;
  instance: string;
  verb: string;
  symbol: Message;
  messages: Message[];
}

declare type Sink = {
  pour(output: Output): void;
}

declare type Sinks = Partial<{
  logger: Sink[];
  indicator: Sink[];
  spinner: Sink[];
}>

declare type DefaultSinks = Partial<{
  console: Sinks;
  devtools: Partial<{
    common: Sinks;
    chrome: Sinks;
    firefox: Sinks;
  }>;
  html: Sinks;
}>

declare type Defaults = Readonly<{
  context: Readonly<Context>;
  sinks: Readonly<Sinks>;
}>;
declare const defaults: Defaults

declare type Configs = {
  configure(context?: Context, sinks?: Sinks): void;
}
declare const configs: Configs;

declare type CliMessages = (string | Message)[];

declare type Logger = {
  dbg: (...messages: CliMessages) => Logger;
  log: (...messages: CliMessages) => Logger;
  wrn: (...messages: CliMessages) => Logger;
  err: (...messages: CliMessages) => Logger;
}
declare const logger: Logger;

declare type Indicator = {
  exec: (...messages: CliMessages) => Indicator;
  info: (...messages: CliMessages) => Indicator;
  succ: (...messages: CliMessages) => Indicator;
  fail: (...messages: CliMessages) => Indicator;
}
declare const indicator: Indicator;

declare type Spinner = {
  spin: (...messages: CliMessages) => Spinner;
  updt: (...messages: CliMessages) => Spinner;
  succ: (...messages: CliMessages) => Spinner;
  fail: (...messages: CliMessages) => Spinner;
}
declare const spinner: Spinner;