@cenk1cenk2/oclif-common 3.9.8 → 3.9.10

package/dist/index.d.ts

@@ -1,54 +1,425 @@
-export { C as Command, a as ConfigService } from './base.command-d3038122.js';
-export { ConfigCommand } from './commands/config.command.js';
-export { FileConstants } from './constants/file.constants.js';
-export { CLI_FLAGS } from './constants/global-flags.constants.js';
-export { HelpGroups } from './constants/help-groups.constants.js';
-export { notFoundHook } from './hooks/not-found.hook.js';
-export { updateNotifierHook } from './hooks/update-notifier.hook.js';
-export { storeHook } from './hooks/store.hook.js';
-export { ClassType } from './interfaces/class.interface.js';
-export { ConfigCommandChoices, ConfigCommandSetup } from './interfaces/config-command.interface.js';
-export { InferArgs, InferFlags } from './interfaces/oclif.interface.js';
-export { DeepPartial } from './interfaces/type-helper.interface.js';
-export { ConfigIterator, GlobalConfig } from './lib/config/config.interface.js';
-export { FileSystemService } from './lib/fs/filesystem.service.js';
-export { CommonLockerData, LockData, LockableData, UnlockData } from './lib/locker/locker.interface.js';
-export { LockerService } from './lib/locker/locker.service.js';
-export { EnvironmentVariableParser } from './lib/parser/env-parser.service.js';
-export { GenericParser } from './lib/parser/parser.interface.js';
-export { ParserService } from './lib/parser/parser.service.js';
-export { YamlParser } from './lib/parser/yaml-parser.service.js';
-export { JsonParser } from './lib/parser/json-parser.service.js';
-export { DataStore } from './lib/store/store.interface.js';
-export { StoreService } from './lib/store/store.service.js';
-export { ValidatorServiceOptions } from './lib/validator/validator.interface.js';
-export { ValidatorService } from './lib/validator/validator.service.js';
-export { setup } from './lib/setup.js';
-export { ListrLogger } from './utils/logger/listr-logger.js';
-export { pipeProcessThroughListr } from './utils/logger/pipe/pipe-process-to-listr.js';
-export { pipeProcessToLogger } from './utils/logger/pipe/pipe-process-to-logger.js';
-export { PipeProcessToLoggerOptions } from './utils/logger/pipe/pipe-process-to-logger.interface.js';
-export { LogFieldStatus, LogLevels } from './utils/logger/logger.constants.js';
-export { LoggerFormat, LoggerOptions, Winston } from './utils/logger/logger.interface.js';
-export { Logger } from './utils/logger/logger.js';
-export { color } from './utils/color.js';
-export { isDebug, isSilent, isVerbose } from './utils/environment.js';
-export { MergeStrategy } from './utils/merge.constants.js';
-export { merge, uniqueFilter } from './utils/merge.js';
-export { SetCtxAssignOptions, SetCtxDefaultsOptions, setCtxAssign, setCtxDefaults } from './utils/defaults.js';
+import { Command as Command$1, CliUx, Hook } from '@oclif/core';
 export { CliUx, Flags } from '@oclif/core';
-export { Arg, ArgInput, Flag, FlagInput, InferredFlags } from '@oclif/core/lib/interfaces';
+import { ExecaChildProcess } from 'execa';
+import { Logger as Logger$2, ListrTaskWrapper, ListrContext, Manager, PromptOptions } from 'listr2';
+import { Logger as Logger$1, LeveledLogMethod } from 'winston';
+import fs from 'fs-extra';
 export { default as fs } from 'fs-extra';
-import 'listr2';
-import '@oclif/core/lib/cli-ux/styled/progress';
-import '@oclif/core/lib/cli-ux/open';
-import '@oclif/core/lib/cli-ux/styled/tree';
-import '@oclif/core/lib/cli-ux/styled/json';
-import '@oclif/core/lib/cli-ux/styled/header';
-import '@oclif/core/lib/cli-ux/prompt';
-import '@oclif/core/lib/errors';
-import 'class-transformer';
-import 'class-validator';
-import 'execa';
-import 'winston';
-import 'colorette';
+import { ClassTransformOptions } from 'class-transformer';
+import { ValidatorOptions } from 'class-validator';
+import { InferredFlags, FlagInput } from '@oclif/core/lib/interfaces';
+export { Arg, ArgInput, Flag, FlagInput, InferredFlags } from '@oclif/core/lib/interfaces';
+import * as _oclif_core_lib_cli_ux_styled_progress from '@oclif/core/lib/cli-ux/styled/progress';
+import * as _oclif_core_lib_cli_ux_open from '@oclif/core/lib/cli-ux/open';
+import * as _oclif_core_lib_cli_ux_styled_tree from '@oclif/core/lib/cli-ux/styled/tree';
+import * as _oclif_core_lib_cli_ux_styled_json from '@oclif/core/lib/cli-ux/styled/json';
+import * as _oclif_core_lib_cli_ux_styled_header from '@oclif/core/lib/cli-ux/styled/header';
+import * as _oclif_core_lib_cli_ux_prompt from '@oclif/core/lib/cli-ux/prompt';
+import * as _oclif_core_lib_errors from '@oclif/core/lib/errors';
+import * as colorette from 'colorette';
+
+type ClassType<T> = new (...args: any[]) => T;
+
+declare enum LogLevels {
+    SILENT = "SILENT",
+    DIRECT = "DIRECT",
+    FATAL = "FATAL",
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    VERBOSE = "VERBOSE",
+    DEBUG = "DEBUG",
+    TRACE = "TRACE"
+}
+declare enum LogFieldStatus {
+    RUN = "run",
+    END = "end",
+    STAGE = "stage",
+    EXIT = "exit",
+    TERMINATE = "terminate"
+}
+
+interface LoggerOptions {
+    useIcons?: boolean;
+    level?: LogLevels;
+}
+interface LoggerFormat {
+    level: LogLevels;
+    message: string;
+    context: string;
+    status: string;
+}
+type Winston = Logger$1 & Record<keyof typeof LogLevels, LeveledLogMethod>;
+
+/**
+ * A general logger for the the CLI applications.
+ */
+declare class Logger {
+    private context?;
+    private options?;
+    static instance: Winston;
+    private logger;
+    constructor(context?: string, options?: LoggerOptions);
+    log(level: LogLevels, data: string | Buffer, ...args: any): void;
+    direct(data: string | Buffer, ...args: any): void;
+    fatal(data: string | Buffer, ...args: any): void;
+    error(data: string | Buffer, ...args: any): void;
+    warn(data: string | Buffer, ...args: any): void;
+    info(data: string | Buffer, ...args: any): void;
+    debug(data: string | Buffer, ...args: any): void;
+    verbose(data: string | Buffer, ...args: any): void;
+    trace(data: string | Buffer, ...args: any): void;
+    run(data: string | Buffer, ...args: any): void;
+    end(data: string | Buffer, ...args: any): void;
+    stage(data: string | Buffer, ...args: any): void;
+    private initiateLogger;
+    private parseMessage;
+    private logColoring;
+}
+
+declare class ListrLogger extends Logger$2 {
+    logger: Logger;
+    constructor(context?: string);
+    fail(message: string): void;
+    skip(message: string): void;
+    success(message: string): void;
+    data(message: string): void;
+    start(message: string): void;
+    title(message: string): void;
+    retry(message: string): void;
+    rollback(message: string): void;
+}
+
+declare function pipeProcessThroughListr(task: ListrTaskWrapper<any, any>, instance: ExecaChildProcess): ExecaChildProcess;
+
+interface PipeProcessToLoggerOptions {
+    /** Will log the command when the process starts. */
+    start?: LogLevels;
+    /** Will log the command when the process ends. */
+    end?: LogLevels;
+    /** enable/disable stdout */
+    stdout?: LogLevels;
+    /** enable/disable stderrr */
+    stderr?: LogLevels;
+    /** will callback on error in the instance */
+    callback?: (error?: Error) => void;
+    /** context for logger */
+    context?: string;
+}
+
+/**
+ * Given the instance it will pipe process output through the logger to append prefixes such as the application name.
+ */
+declare function pipeProcessToLogger(logger: Logger, instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
+
+interface GlobalConfig {
+    logLevel: LogLevels;
+    ci: boolean;
+    json: boolean;
+}
+interface ConfigIterator {
+    key: (string | number)[];
+    env: string;
+    parser?: string;
+    extensions?: ConfigIterator[];
+}
+
+declare const color: colorette.Colorette;
+
+declare function isVerbose(logLevel: LogLevels): boolean;
+declare function isDebug(logLevel: LogLevels): boolean;
+declare function isSilent(logLevel: LogLevels): boolean;
+
+declare enum MergeStrategy {
+    OVERWRITE = "OVERWRITE",
+    EXTEND = "EXTEND"
+}
+
+/** Merge objects deep from overwriting the properties from source to target.
+ * Does not mutate the object */
+declare function merge<T extends Record<PropertyKey, any> | any[]>(strategy: MergeStrategy, ...source: Partial<T>[]): T;
+declare function uniqueFilter(value: any, index: any, self: string | any[]): boolean;
+
+type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
+interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
+    from: K;
+    keys: (keyof K)[];
+}
+declare function setCtxDefaults<T extends ListrContext = ListrContext>(ctx: T, ...defaults: SetCtxDefaultsOptions<T>[]): void;
+declare function setCtxAssign<T extends ListrContext = ListrContext, K = Record<PropertyKey, any>>(ctx: T, ...assigns: SetCtxAssignOptions<K>[]): void;
+
+interface CommonLockerData {
+    path?: string | string[];
+    enabled?: boolean;
+    root?: boolean;
+}
+type LockableData = any;
+interface LockData<T extends LockableData = LockableData> extends Partial<CommonLockerData> {
+    data: T;
+    merge?: MergeStrategy;
+}
+interface UnlockData extends CommonLockerData {
+    path: string | string[];
+}
+
+declare class GenericParser {
+    static extensions: string[];
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class LockerService<LockFile extends LockableData = LockableData> {
+    private file;
+    private parser?;
+    private root?;
+    private toLock;
+    private toUnlock;
+    private logger;
+    private fs;
+    constructor(file: string, parser?: GenericParser, root?: string[], context?: string);
+    hasLock(): boolean;
+    hasUnlock(): boolean;
+    addLock<T extends LockableData = LockableData>(...data: LockData<T>[]): void;
+    addUnlock(...data: UnlockData[]): void;
+    lockAll(): Promise<void>;
+    unlockAll(): Promise<void>;
+    all(): Promise<void>;
+    lock<T extends LockableData = LockableData>(...data: LockData<T>[]): Promise<void>;
+    unlock(...data: UnlockData[]): Promise<void>;
+    read(): Promise<LockFile>;
+    tryRead(): Promise<LockFile | undefined>;
+    write(data: LockFile): Promise<void>;
+    private buildPath;
+    private normalizePath;
+}
+
+declare class ParserService {
+    private static instance;
+    parsers: ClassType<GenericParser>[];
+    private logger;
+    private fs;
+    constructor(parsers?: ClassType<GenericParser>[]);
+    getParser(file: string): GenericParser;
+    setParsers(...parsers: ClassType<GenericParser>[]): void;
+    addParsers(...parsers: ClassType<GenericParser>[]): void;
+    read<T = unknown>(file: string): Promise<T>;
+    write<T = LockableData>(file: string, data: T): Promise<void>;
+    parse<T = unknown>(file: string, data: string | Buffer): T;
+    stringify<T = any>(file: string, data: T): string | Promise<string>;
+}
+
+declare class ConfigService implements GlobalConfig {
+    oclif: Command['config'];
+    command: Command['ctor'];
+    private static instance;
+    defaults: string;
+    root: string;
+    parser: ParserService;
+    logLevel: LogLevels;
+    isVerbose: boolean;
+    isDebug: boolean;
+    isSilent: boolean;
+    ci: boolean;
+    json: boolean;
+    private logger;
+    constructor(oclif: Command['config'], command: Command['ctor'], config: GlobalConfig);
+    read<T extends LockableData = LockableData>(path: string): Promise<T>;
+    extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
+    merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
+    env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
+    write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
+    private recalculate;
+}
+
+declare class FileSystemService {
+    private static instance;
+    private logger;
+    constructor();
+    exists(path: string): boolean;
+    stats(path: string): fs.Stats;
+    dirname(path: string): string;
+    extname(path: string): string;
+    read(file: string): Promise<string>;
+    readSync(file: string): string;
+    write(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+    writeSync(file: string, data: string | Buffer, options?: fs.WriteFileOptions): void;
+    append(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+    appendSync(file: string, data: string | Buffer): void;
+    remove(file: string, options?: fs.RmOptions): Promise<void>;
+    removeSync(file: string, options?: fs.RmOptions): void;
+    emptyDir(directory: string): Promise<void>;
+    emptyDirSync(directory: string): void;
+    removeDir(directory: string): Promise<void>;
+    removeDirSync(directory: string): void;
+    mkdir(directory: string): Promise<void>;
+    mkdirSync(directory: string): void;
+}
+
+declare class EnvironmentVariableParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    private LINE;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class YamlParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+declare class JsonParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+type DataStore<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> = {
+    logo?: string;
+} & T;
+
+declare class StoreService<T extends Record<PropertyKey, any> = Record<PropertyKey, any>> {
+    private static instance;
+    private store;
+    constructor();
+    has<K extends keyof DataStore<T>>(key: K): boolean;
+    get<K extends keyof DataStore<T>>(key: K): DataStore<T>[K];
+    set<K extends keyof DataStore<T>>(key: K, data: DataStore<T>[K]): DataStore<T>[K];
+}
+
+interface ValidatorServiceOptions {
+    validator?: ValidatorOptions;
+    transformer?: ClassTransformOptions;
+}
+
+declare class ValidatorService {
+    options?: ValidatorServiceOptions;
+    private static instance;
+    private logger;
+    constructor(options?: ValidatorServiceOptions);
+    validate<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): Promise<T>;
+    validateSync<T extends Record<PropertyKey, any>>(classType: ClassType<T>, object: T, options?: ValidatorServiceOptions): T;
+    private logValidationError;
+}
+
+declare function setup(): void;
+
+type ConfigCommandChoices<T extends string> = Record<T, () => void | Promise<void>>;
+interface ConfigCommandSetup<T extends string = string, LockFile = any> {
+    choices: ConfigCommandChoices<T>;
+    locker?: LockerService<LockFile>;
+}
+
+type InferFlags<T extends typeof Command$1> = InferredFlags<T['globalFlags'] & T['flags']>;
+type InferArgs<T extends typeof Command$1> = Record<T['args'][number]['name'], string>;
+
+/**
+ * Makes the object deep partial.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+
+declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof Command>, Args extends Record<PropertyKey, any> = InferArgs<typeof Command>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command$1 {
+    context: string;
+    logger: Logger;
+    tasks: Manager<Ctx, 'default' | 'verbose' | 'silent' | 'simple'>;
+    validator: ValidatorService;
+    cs: ConfigService;
+    parser: ParserService;
+    fs: FileSystemService;
+    store: StoreService<Store>;
+    flags: Flags;
+    args: Args;
+    /**
+     * Construct the class if you dont want to extend init or constructor.
+     */
+    shouldRunBefore(): void | Promise<void>;
+    /**
+     * Deconstruct the class if you dont want to extend finally or catch.
+     */
+    shouldRunAfter(_ctx?: Ctx): void | Promise<void>;
+    run(): Promise<any>;
+    _run<T>(): Promise<T | undefined>;
+    exit(code?: number): void;
+    /** Run all tasks from task manager. */
+    runTasks<C extends Ctx = Ctx>(): Promise<C>;
+    /** Gets prompt from user. */
+    prompt<T = any>(options: PromptOptions): Promise<T>;
+    protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
+    protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
+    protected pipeProcessToLogger(instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
+    protected pipeProcessThroughListr(task: ListrTaskWrapper<any, any>, instance: ExecaChildProcess): ExecaChildProcess;
+    /** Initial functions / constructor */
+    protected init(): Promise<void>;
+    /** Tasks to run before end of the command. */
+    protected finally<C extends Ctx = Ctx>(): Promise<{
+        ctx: C;
+    }>;
+    /** Catch any error occurred during command. */
+    protected catch(e: Error, exit?: number): Promise<void>;
+    private greet;
+}
+
+declare class ConfigCommand<CommandChoices extends string = string, LockFile = any, Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof ConfigCommand>, Args extends Record<PropertyKey, any> = InferArgs<typeof ConfigCommand>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command<Ctx, Flags, Args, Store> {
+    choices: ConfigCommandChoices<CommandChoices>;
+    locker: LockerService<LockFile>;
+    protected ux: {
+        config: CliUx.Config;
+        warn: typeof _oclif_core_lib_errors.warn;
+        error: typeof _oclif_core_lib_errors.error;
+        exit: typeof _oclif_core_lib_errors.exit;
+        readonly prompt: typeof _oclif_core_lib_cli_ux_prompt.prompt;
+        readonly anykey: typeof _oclif_core_lib_cli_ux_prompt.anykey;
+        readonly confirm: typeof _oclif_core_lib_cli_ux_prompt.confirm;
+        readonly action: CliUx.ActionBase;
+        readonly prideAction: CliUx.ActionBase;
+        styledObject(obj: any, keys?: string[]): void;
+        readonly styledHeader: typeof _oclif_core_lib_cli_ux_styled_header.default;
+        readonly styledJSON: typeof _oclif_core_lib_cli_ux_styled_json.default;
+        readonly table: typeof CliUx.Table.table;
+        readonly tree: typeof _oclif_core_lib_cli_ux_styled_tree.default;
+        readonly open: typeof _oclif_core_lib_cli_ux_open.default;
+        readonly wait: (ms?: number) => Promise<unknown>;
+        readonly progress: typeof _oclif_core_lib_cli_ux_styled_progress.default;
+        done(): Promise<void>;
+        trace(format: string, ...args: string[]): void;
+        debug(format: string, ...args: string[]): void;
+        info(format: string, ...args: string[]): void;
+        log(format?: string, ...args: string[]): void;
+        url(text: string, uri: string, params?: {}): void;
+        annotation(text: string, annotation: string): void;
+        flush(ms?: number): Promise<void>;
+    };
+    run(): Promise<any>;
+    setup(): ConfigCommandSetup<CommandChoices, LockFile> | Promise<ConfigCommandSetup<CommandChoices, LockFile>>;
+    protected table(...options: Parameters<typeof CliUx.ux.table>): void;
+    protected select(): Promise<string>;
+}
+
+declare enum FileConstants {
+    CONFIG_SERVICE_DEFAULTS_DIR = "config"
+}
+
+declare const CLI_FLAGS: FlagInput;
+
+declare enum HelpGroups {
+    CLI = "CLI"
+}
+
+declare const notFoundHook: Hook<'command_not_found'>;
+
+declare const updateNotifierHook: Hook<'init'>;
+
+declare const storeHook: <T extends Record<PropertyKey, any> = Record<PropertyKey, any>>(cb: (opts: any, store: StoreService<T>) => void) => Hook<'init'>;
+
+export { CLI_FLAGS, ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigIterator, ConfigService, DataStore, DeepPartial, EnvironmentVariableParser, FileConstants, FileSystemService, GenericParser, GlobalConfig, HelpGroups, InferArgs, InferFlags, JsonParser, ListrLogger, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, StoreService, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, color, isDebug, isSilent, isVerbose, merge, notFoundHook, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, storeHook, uniqueFilter, updateNotifierHook };