view-ignored 0.2.2 → 0.3.0

package/out/src/config.d.ts

@@ -1,103 +1,199 @@
-import { ColorSupportLevel } from "chalk";
-import { FilterName, Sorting, Styling } from "./browser/index.js";
-import { Command, Option } from "commander";
-/**
- * Contains all color level names.
- */
-export declare const colorTypeList: readonly [0, 1, 2, 3];
-/**
- * Contains all color level names as a type.
- */
-export type ColorType = ColorSupportLevel;
-/**
- * Checks if the value is the {@link ColorType}.
- */
-export declare function isColorType(value: unknown): value is ColorType;
+import { type ChalkInstance } from 'chalk';
+import { type Command, type Option } from 'commander';
+import { type DecorName, type StyleName } from './styling.js';
+import { type ConfigCheckMap } from './errors.js';
+import { type SortName } from './browser/sorting.js';
+import { type FilterName } from './browser/filtering.js';
 /**
  * The full config file name - `".view-ignored"`.
+ * @public
  */
 export declare const configFileName = ".view-ignored";
-/**
- * The user's home directory + the config file name.
- * @see {@link os.homedir}
- */
-export declare const configFilePath: string;
 /**
  * Command-line configuration property list.
+ * @public
  */
-export declare const configKeyList: readonly ["color", "target", "filter", "sort", "style", "decor", "depth", "showSources", "plugins", "parsable"];
+export declare const configKeyList: readonly ["posix", "noColor", "target", "filter", "sort", "style", "decor", "depth", "showSources", "plugins", "parsable", "concurrency"];
 /**
- * Command-line configuration's key type.
+ * Command-line configuration's property type.
+ * @public
  */
 export type ConfigKey = typeof configKeyList[number] & keyof Config;
 /**
- * Checks if the value is the {@link ConfigKey}.
+ * @public
  */
-export declare function isConfigKey(value: unknown): value is ConfigKey;
 export type ConfigValue<KeyT extends ConfigKey = ConfigKey> = Config[KeyT];
+/**
+ * @public
+ */
 export type ShowSourcesType = boolean;
-export declare function isShowSources(value: unknown): value is ShowSourcesType;
 /**
- * Checks if the value is the {@link Config} value for the specific {@link ConfigKey}.
+ * @public
  */
-export declare function isConfigValue<T extends ConfigKey>(key: T, value: unknown): value is Config[T];
+export declare function isShowSources(value: unknown): value is ShowSourcesType;
 /**
  * Represents array with the key nad the value.
+ * @public
  */
 export type ConfigPair<KeyT extends ConfigKey = ConfigKey> = [key: KeyT, value: ConfigValue<KeyT>];
 /**
  * Command-line configuration structure.
  * @see {@link configKeyList} Before adding new properties.
+ * @public
  */
 export type Config = {
+    [key: string]: unknown;
     parsable: boolean;
+    noColor: boolean;
+    posix: boolean;
     plugins: string[];
-    color: ColorType;
     target: string;
     filter: FilterName;
-    sort: Sorting.SortName;
-    style: Styling.StyleName;
-    decor: Styling.DecorName;
+    sort: SortName;
+    style: StyleName;
+    decor: DecorName;
     depth: number;
     showSources: ShowSourcesType;
+    concurrency: number;
 };
 /**
  * Command-line default config values.
+ * @public
  */
 export declare const configDefault: Readonly<Config>;
 /**
- * @returns `true`, if the value can be used as a configuration.
+ * @returns Error message and parsed value.
+ * @public
+ */
+export type ConfigValidator = ((value: unknown) => string | undefined) & {
+    typeName: string;
+};
+/**
+ * @public
+ */
+export declare const configValueArray: <T extends ConfigValidator>(type?: T) => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueLiteral: (choices: readonly unknown[]) => ConfigValidator;
+/**
+ * @public
+ */
+export declare const switchTrueValues: string[];
+/**
+ * @public
+ */
+export declare const switchFalseValues: string[];
+/**
+ * @public
+ */
+export declare const booleanValues: string[];
+/**
+ * @public
+ */
+export declare const configValueSwitch: () => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueBoolean: () => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueObject: () => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueString: () => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueNumber: () => ConfigValidator;
+/**
+ * @public
+ */
+export declare const configValueInteger: () => ConfigValidator;
+/**
+ * @public
  */
-export declare function isConfigPartial(cfg: unknown): cfg is Partial<Config>;
-export declare const trueValues: string[];
-export declare const falseValues: string[];
-export declare const boolValues: string[];
+export type ConfigManagerGetOptions = {
+    /**
+     * Use default value as fallback.
+     * @default true
+     */
+    real?: boolean;
+};
 /**
- * @returns available values or requirement message for the specified property.
- * @param key The config property.
- * @param fallbackDefault If `true`, the default value will be used when the value is `undefined`. Default `true`.
+ * @public
  */
-export declare function configValueList<T extends ConfigKey>(key: T): readonly string[] | string;
-export declare function configValueLinkCliOption<T extends ConfigKey>(key: T, command: Command, option: Option, parseArg?: (arg: string) => unknown): Option;
-export declare function configValueGetCliOption<T extends ConfigKey>(key: T): Option | undefined;
+export type ConfigManagerGetPairStringOptions = ConfigManagerGetOptions & {
+    /**
+     * Add the type postfix.
+     * @default true
+     */
+    types?: boolean;
+    /**
+     * Determine the colors behavior.
+     * @default undefined
+     */
+    chalk?: ChalkInstance;
+    /**
+     * Use parsable format. If enabled, `chalk` option ignored.
+     * @default false
+     */
+    parsable?: boolean;
+};
 /**
  * File-specific actions container.
+ * @public
  */
-export declare class ConfigManager {
-    readonly filePath: string;
-    constructor(filePath: string);
+export declare class ConfigManager<ConfigType extends Config = Config> {
+    readonly path: string;
     /**
      * Do not change this value directly.
      * @see {@link configManager}.
      */
     private data;
-    dataRaw(): unknown;
-    entries(): [string, any][] | undefined;
+    private readonly configValidation;
+    private readonly cliOptionLinkMap;
+    private readonly dataDefault;
+    constructor(path: string);
+    dataCheck(data: unknown): ConfigCheckMap | string;
+    /**
+     * Get type name for the key.
+     */
+    getType<T extends keyof ConfigType>(key: T): string;
+    getType(key: string): string;
+    /**
+     * Get type checker for the key.
+     */
+    keyGetValidator<T extends keyof ConfigType>(key: T): ConfigValidator | undefined;
+    /**
+     * Define type checker for the key.
+     */
+    keySetValidator<T extends keyof ConfigType & string>(key: T, defaultValue: ConfigType[T], type: ConfigValidator): this;
+    /**
+     * Checks if the key is defined.
+     * @returns Error message if the key is not defined.
+     */
+    checkKey(key: string): string | undefined;
+    /**
+     * Call the type checker for the key.
+     */
+    checkValue<T extends keyof ConfigType>(key: T, value: unknown): string | undefined;
+    /**
+     * Link a configuration property with a command-line option.
+     */
+    setOption<T extends keyof ConfigType>(key: T, command: Command, option: Option, parseArgument?: (argument: string) => unknown): this;
+    /**
+     * Get a command-line option for the configuration property.
+     */
+    getOption<T extends keyof ConfigType>(key: T): Option | undefined;
+    getOption(key: string): Option | undefined;
     /**
-     * Loads the config from the file to {@link configManager.data}. If the data is not valid, throws an error without loading.
-     * @returns `undefined` if the config file does not exist.
+     * Loads the config from the file to {@link configManager.data}.
+     * @returns The error message for each invalid property.
      */
-    load(): this | undefined;
+    load(): ConfigCheckMap | string | undefined;
     /**
      * Saves the partial config to the file. If there are no settings, the file will be deleted, if exists.
      */
@@ -108,34 +204,36 @@ export declare class ConfigManager {
      * @param key The name of the config property.
      * @param value The new value for the config property.
      */
-    set<T extends ConfigKey>(key: T, value: Config[T]): this;
+    set<T extends keyof ConfigType>(key: T, value: ConfigType[T]): string | undefined;
+    set(key: string, value: unknown): string | undefined;
     /**
      * Deletes the specified property from the config.
      * If the property is not specified, then all properties will be deleted.
      * @param key The config property.
      */
-    unset<T extends ConfigKey>(key?: T): this;
+    unset<T extends keyof ConfigType>(key?: T): this;
+    unset(key?: string): this;
     /**
      * @returns An array of properties which defined in the configuration file.
      */
-    definedKeys(): ConfigKey[];
+    keyList(real?: boolean): Array<keyof ConfigType>;
     /**
      * @param key The config property.
-     * @param defs If `true`, the default value will be used when the value is `undefined`. Default `true`.
+     * @param real The options.
      * @returns The value for the specified property.
      */
-    get<KeyT extends ConfigKey>(key: KeyT, defs: false): ConfigValue<KeyT> | undefined;
-    get<KeyT extends ConfigKey>(key: KeyT, defs?: true): ConfigValue<KeyT>;
-    get<KeyT extends ConfigKey>(key: KeyT, defs: boolean): ConfigValue<KeyT> | undefined;
-    /**
-     * @param key The config property.
-     * @param defs If `true`, the default value will be used when the value is `undefined`. Default `true`.
-     * @returns A string in the `"key=value"` format, if the property is specified.
-     * Otherwise in format `"key=value\nkey=value\n..."` without the '\n' ending.
-     */
-    getPairString<KeyT extends ConfigKey>(key?: KeyT, defs?: boolean): string;
+    get<T extends keyof ConfigType>(key: T, options: ConfigManagerGetOptions & {
+        real?: false;
+    }): ConfigType[T] | undefined;
+    get<T extends keyof ConfigType>(key: T, options?: ConfigManagerGetOptions & {
+        real: true;
+    }): ConfigType[T];
+    get(key: string, options?: ConfigManagerGetOptions): unknown;
+    getPairString<T extends keyof ConfigType>(keys?: T | T[], options?: ConfigManagerGetPairStringOptions): string;
+    getPairString(keys?: string | string[], options?: ConfigManagerGetPairStringOptions): string;
 }
 /**
  * File-specific actions container. Contains get, set, unset, save, load and other configuration actions.
+ * @public
  */
-export declare const configManager: ConfigManager;
+export declare const configManager: ConfigManager<Config>;