view-ignored 0.2.2 → 0.3.0

package/out/src/config.js

@@ -1,257 +1,371 @@
-import { filterNameList, isFilterName, Plugins, Sorting, Styling } from "./browser/index.js";
-import * as os from "os";
-import * as yaml from "yaml";
-import path from "path";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
-/**
- * Contains all color level names.
- */
-export const colorTypeList = [0, 1, 2, 3];
-/**
- * Checks if the value is the {@link ColorType}.
- */
-export function isColorType(value) {
-    const num = Number(value);
-    return Number.isFinite(num) && colorTypeList.includes(num);
-}
+import * as os from 'node:os';
+import path from 'node:path';
+import { existsSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { format } from 'node:util';
+import * as yaml from 'yaml';
+import { decorNameList, highlight, styleNameList, } from './styling.js';
+import { sortNameList } from './browser/sorting.js';
+import { filterNameList } from './browser/filtering.js';
 /**
  * The full config file name - `".view-ignored"`.
+ * @public
  */
-export const configFileName = ".view-ignored";
+export const configFileName = '.view-ignored';
 /**
  * The user's home directory + the config file name.
  * @see {@link os.homedir}
+ * @private
  */
-export const configFilePath = path.join(os.homedir(), configFileName);
+const configFilePath = path.join(os.homedir(), configFileName);
 /**
  * Command-line configuration property list.
+ * @public
  */
-export const configKeyList = ["color", "target", "filter", "sort", "style", "decor", "depth", "showSources", "plugins", "parsable"];
+export const configKeyList = ['posix', 'noColor', 'target', 'filter', 'sort', 'style', 'decor', 'depth', 'showSources', 'plugins', 'parsable', 'concurrency'];
 /**
- * Checks if the value is the {@link ConfigKey}.
+ * @public
  */
-export function isConfigKey(value) {
-    return typeof value === "string" && configKeyList.includes(value);
-}
 export function isShowSources(value) {
-    return typeof value === "boolean";
-}
-/**
- * Checks if the value is the {@link Config} value for the specific {@link ConfigKey}.
- */
-export function isConfigValue(key, value) {
-    const c = {
-        parsable: v => typeof v === "boolean",
-        plugins: v => Array.isArray(v) && v.every(p => typeof p === "string"),
-        color: isColorType,
-        target: t => Plugins.isTargetId(t) && Plugins.targetGet(t) !== undefined,
-        filter: isFilterName,
-        sort: Sorting.isSortName,
-        style: Styling.isStyleName,
-        decor: Styling.isDecorName,
-        depth: Number.isInteger,
-        showSources: isShowSources
-    };
-    const check = c[key];
-    return check(value);
+    return typeof value === 'boolean';
 }
 /**
  * Command-line default config values.
+ * @public
  */
 export const configDefault = {
     parsable: false,
+    noColor: false,
+    posix: false,
     plugins: [],
-    color: 3,
-    target: "git",
-    filter: "included",
-    sort: "firstFolders",
-    style: "tree",
-    decor: "normal",
+    target: 'git',
+    filter: 'included',
+    sort: 'firstFolders',
+    style: 'tree',
+    decor: 'normal',
     depth: Infinity,
-    showSources: false
+    showSources: false,
+    concurrency: 8,
 };
 /**
- * @returns `true`, if the value can be used as a configuration.
+ * @public
  */
-export function isConfigPartial(cfg) {
-    if (cfg?.constructor !== Object) {
-        return false;
-    }
-    const jsonobj = cfg;
-    return Object.entries(jsonobj).every(([key, value]) => isConfigKey(key)
-        ? isConfigValue(key, value)
-        : true);
-}
-export const trueValues = ['true', 'on', 'yes', 'y', 'enable', 'enabled', '1'];
-export const falseValues = ['false', 'off', 'no', 'n', 'disable', 'disabled', '0'];
-export const boolValues = trueValues.concat(falseValues);
+export const configValueArray = (type) => {
+    const validator = value => {
+        if (Array.isArray(value)) {
+            if (type === undefined) {
+                return;
+            }
+            const badElementList = value.map(element => type(element)).filter(element => element !== undefined);
+            if (badElementList.length > 0) {
+                const list = badElementList.map((element, index) => `${index}: ${element}`).join('\n');
+                return `The value should be a typed array. Found bad elements:\n${list}`;
+            }
+            return;
+        }
+        return 'The value should be an array.';
+    };
+    validator.typeName = `${type?.typeName ?? 'any'}[]`;
+    return validator;
+};
 /**
- * @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 function configValueList(key) {
-    const msg = {
-        int: 'The value should be an integer.',
-        bool: `The value should be a boolean. Available bool literals: ${boolValues.join(', ')}`,
-        arrStr: `The value should be an array of a strings.`,
+export const configValueLiteral = (choices) => {
+    const validator = value => {
+        if (choices.includes(value)) {
+            return;
+        }
+        return `The value is invalid. Choices: ${choices.map(String).join(', ')}.`;
     };
-    /**
-     * Represents allowed values for each config property.
-     */
-    const configAvailable = {
-        color: colorTypeList,
-        filter: filterNameList,
-        target: Plugins.targetList,
-        sort: Sorting.sortNameList,
-        style: Styling.styleNameList,
-        decor: Styling.decorNameList,
-        depth: msg.int,
-        parsable: msg.bool,
-        plugins: msg.arrStr,
-        showSources: msg.bool,
+    validator.typeName = choices.map(choice => format('%o', choice)).join('|');
+    return validator;
+};
+/**
+ * @public
+ */
+export const switchTrueValues = ['true', 'on', 'yes', 'y', 'enable', 'enabled', '1'];
+/**
+ * @public
+ */
+export const switchFalseValues = ['false', 'off', 'no', 'n', 'disable', 'disabled', '0'];
+/**
+ * @public
+ */
+export const booleanValues = switchTrueValues.concat(switchFalseValues);
+/**
+ * @public
+ */
+export const configValueSwitch = () => {
+    const validator = value => {
+        if (booleanValues.includes(value)) {
+            return;
+        }
+        return `The value should be a boolean. Available boolean literals: ${booleanValues.join(', ')}.`;
     };
-    const val = configAvailable[key];
-    const choices = (typeof val === "function" ? val() : val);
-    return choices;
-}
-const configCliOptMap = new Map;
-export function configValueLinkCliOption(key, command, option, parseArg) {
-    const list = configValueList(key);
-    if (Array.isArray(list)) {
-        option.choices(list);
-    }
-    if (parseArg) {
-        option.argParser(parseArg);
-    }
-    option.default(configManager.get(key));
-    command.addOption(option);
-    configCliOptMap.set(key, option);
-    return option;
-}
-export function configValueGetCliOption(key) {
-    return configCliOptMap.get(key);
-}
+    validator.typeName = 'switch';
+    return validator;
+};
+/**
+ * @public
+ */
+export const configValueBoolean = () => {
+    const validator = value => {
+        if (typeof value === 'boolean') {
+            return;
+        }
+        return 'The value should be a boolean.';
+    };
+    validator.typeName = 'boolean';
+    return validator;
+};
+/**
+ * @public
+ */
+export const configValueObject = () => {
+    const validator = value => {
+        if (value?.constructor === Object) {
+            return;
+        }
+        return 'The value should be an object.';
+    };
+    validator.typeName = 'object';
+    return validator;
+};
+/**
+ * @public
+ */
+export const configValueString = () => {
+    const validator = value => {
+        if (typeof value === 'string') {
+            return;
+        }
+        return 'The value should be a string.';
+    };
+    validator.typeName = 'string';
+    return validator;
+};
+/**
+ * @public
+ */
+export const configValueNumber = () => {
+    const validator = value => {
+        if (typeof value === 'number') {
+            return;
+        }
+        return 'The value should be a number.';
+    };
+    validator.typeName = 'number';
+    return validator;
+};
+/**
+ * @public
+ */
+export const configValueInteger = () => {
+    const validator = value => {
+        if (typeof value === 'number' && (Number.isSafeInteger(value) || Math.abs(value) === Infinity)) {
+            return;
+        }
+        return 'The value should be an integer.';
+    };
+    validator.typeName = 'integer';
+    return validator;
+};
 /**
  * File-specific actions container.
+ * @public
  */
 export class ConfigManager {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
+    path;
     /**
      * Do not change this value directly.
      * @see {@link configManager}.
      */
     data = {};
-    dataRaw() {
-        return structuredClone(this.data);
+    configValidation = new Map();
+    cliOptionLinkMap = new Map();
+    dataDefault = {};
+    constructor(path) {
+        this.path = path;
+        this.keySetValidator('parsable', configDefault.parsable, configValueBoolean());
+        this.keySetValidator('noColor', configDefault.noColor, configValueBoolean());
+        this.keySetValidator('posix', configDefault.posix, configValueBoolean());
+        this.keySetValidator('filter', configDefault.filter, configValueLiteral(filterNameList));
+        this.keySetValidator('sort', configDefault.sort, configValueLiteral(sortNameList));
+        this.keySetValidator('style', configDefault.style, configValueLiteral(styleNameList));
+        this.keySetValidator('decor', configDefault.decor, configValueLiteral(decorNameList));
+        this.keySetValidator('depth', configDefault.depth, configValueInteger());
+        this.keySetValidator('showSources', configDefault.showSources, configValueBoolean());
+        this.keySetValidator('concurrency', configDefault.concurrency, configValueInteger());
+    }
+    dataCheck(data) {
+        const propertyStack = new Map();
+        const object = data;
+        if (object?.constructor !== Object) {
+            return configValueObject()(object);
+        }
+        for (const key in object) {
+            if (!Object.hasOwn(object, key)) {
+                continue;
+            }
+            const value = object[key];
+            const message = this.checkValue(key, value);
+            if (message === undefined) {
+                continue;
+            }
+            propertyStack.set(key, message);
+        }
+        return propertyStack;
+    }
+    getType(key) {
+        return this.configValidation.get(key)?.typeName ?? 'any';
     }
-    entries() {
-        const obj = this.dataRaw();
-        if (obj?.constructor !== Object) {
+    keyGetValidator(key) {
+        return this.configValidation.get(key);
+    }
+    /**
+     * Define type checker for the key.
+     */
+    keySetValidator(key, defaultValue, type) {
+        this.configValidation.set(key, type);
+        const errorMessage = type(defaultValue);
+        if (errorMessage !== undefined) {
+            throw new TypeError(`Invalid default value preset for configuration key ${format(key)} - ${errorMessage}`);
+        }
+        this.dataDefault[key] = defaultValue;
+        return this;
+    }
+    /**
+     * Checks if the key is defined.
+     * @returns Error message if the key is not defined.
+     */
+    checkKey(key) {
+        if (this.configValidation.has(key)) {
             return;
         }
-        return Object.entries(obj);
+        return `Unknown config key '${key}'. Choices: ${Array.from(this.configValidation.keys()).join(', ')}`;
+    }
+    checkValue(key, value) {
+        const validate = this.configValidation.get(key);
+        if (validate === undefined) {
+            return;
+        }
+        return validate(value);
+    }
+    setOption(key, command, option, parseArgument) {
+        if (parseArgument) {
+            option.argParser(parseArgument);
+        }
+        const deflt = configManager.get(key);
+        option.default(deflt);
+        command.addOption(option);
+        this.cliOptionLinkMap.set(key, option);
+        return this;
+    }
+    getOption(key) {
+        return this.cliOptionLinkMap.get(key);
     }
     /**
-     * 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() {
-        const parsed = existsSync(this.filePath) ? yaml.parse(readFileSync(this.filePath).toString()) : undefined;
+        const parsed = existsSync(this.path) ? yaml.parse(readFileSync(this.path).toString()) : undefined;
         if (parsed === undefined) {
-            return parsed;
+            return;
         }
-        const obj = parsed;
-        if (obj?.constructor !== Object) {
-            return this;
+        const message = this.dataCheck(parsed);
+        if (typeof message === 'string') {
+            return message;
         }
-        for (const key in obj) {
-            const element = obj[key];
-            if (typeof element !== "string") {
+        const object = parsed;
+        for (const key in object) {
+            if (!Object.hasOwn(object, key) || message.has(key)) {
                 continue;
             }
-            if (element.startsWith('|')) {
-                const array = element.split(',');
-                array.shift();
-                parsed[key] = array;
-            }
-        }
-        if (!isConfigPartial(parsed)) {
-            throw new TypeError(`Invalid config.`, { cause: parsed });
+            const element = object[key];
+            this.data[key] = element;
         }
-        Object.assign(this.data, parsed);
-        return this;
+        return message;
     }
     /**
      * Saves the partial config to the file. If there are no settings, the file will be deleted, if exists.
      */
     save() {
         if (Object.keys(this.data).length === 0) {
-            if (existsSync(this.filePath)) {
-                rmSync(this.filePath);
+            if (existsSync(this.path)) {
+                rmSync(this.path);
             }
             return this;
         }
-        writeFileSync(this.filePath, yaml.stringify(this.data));
+        writeFileSync(this.path, yaml.stringify(this.data));
         return this;
     }
-    /**
-     * Sets a new value for the specified config property.
-     * Expects a valid value.
-     * @param key The name of the config property.
-     * @param value The new value for the config property.
-     */
     set(key, value) {
+        const errorMessage = this.checkValue(key, value);
+        if (errorMessage !== undefined) {
+            return errorMessage;
+        }
         this.data[key] = value;
-        return this;
     }
-    /**
-     * 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(key) {
         if (key === undefined) {
             for (const key of Object.keys(this.data)) {
-                delete this.data[key];
+                delete this.data[key]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
             }
             return this;
         }
-        delete this.data[key];
+        delete this.data[key]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
         return this;
     }
     /**
      * @returns An array of properties which defined in the configuration file.
      */
-    definedKeys() {
-        const keys = Object.keys(this.data);
-        return keys.filter(k => this.data[k] !== undefined);
+    keyList(real = true) {
+        const keys = real ? Array.from(this.configValidation.keys()) : Object.keys(this.data);
+        return keys;
     }
-    get(key, defs = true) {
-        const value = this.data[key];
-        if (defs && value === undefined) {
-            return configDefault[key];
+    get(key, options) {
+        const { real = true } = options ?? {};
+        let value = this.data[key];
+        if (real && value === undefined) {
+            value = this.dataDefault[key];
+            if (value === undefined) {
+                throw new Error(`Excpected default value for config property '${key}'.`);
+            }
         }
         return value;
     }
-    /**
-     * @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(key, defs = true) {
-        if (key === undefined) {
-            return configKeyList.map((key) => this.getPairString(key, defs)).filter(Boolean).join('\n');
+    getPairString(keys, options) {
+        const { real = true, types = true, chalk, parsable } = options ?? {};
+        if (keys === undefined) {
+            return this.getPairString(this.keyList(real), options);
+        }
+        if (typeof keys === 'string') {
+            return this.getPairString([keys], options);
+        }
+        if (parsable) {
+            return keys.map((key) => {
+                const value = format('%o', this.get(key, options));
+                if (types) {
+                    const type = this.getType(key);
+                    return `${key}\n${value}\n${type}`;
+                }
+                return `${key}\n${value}`;
+            }).join('\n');
         }
-        const val = this.get(key, defs);
-        return val === undefined ? '' : `${key}=${val}`;
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const keyMaxLength = keys.reduce((maxLength, key) => Math.max(maxLength, key.length), 0);
+        return keys.map((key) => {
+            const value = format('%o', this.get(key, options));
+            const type = this.getType(key);
+            const pad = keyMaxLength - key.length;
+            const line = types ? format(`${' '.repeat(pad)}%s ${highlight('=', chalk)} %s${highlight(':', chalk)} %s`, (chalk ? chalk.hex('#FFBC42')(key) : key), chalk ? highlight(value, chalk) : value, (chalk ? chalk.dim(highlight(type, chalk)) : type)) : format(`${' '.repeat(pad)}%s ${highlight('=', chalk)} %s`, (chalk ? chalk.hex('#FFBC42')(key) : key), chalk ? highlight(value, chalk) : value);
+            return line;
+        }).join('\n');
     }
 }
 /**
  * File-specific actions container. Contains get, set, unset, save, load and other configuration actions.
+ * @public
  */
 export const configManager = new ConfigManager(configFilePath);

package/out/src/errors.d.ts

@@ -0,0 +1,7 @@
+import { type ConfigKey } from './config.js';
+export * from './browser/errors.js';
+/**
+ * For each property of the configuration we have an error message.
+ * @public
+ */
+export type ConfigCheckMap = Map<string | ConfigKey, string>;

package/out/src/errors.js

@@ -0,0 +1 @@
+export * from './browser/errors.js';

package/out/src/index.d.ts

@@ -1,3 +1,3 @@
-import * as ViewIgnored from "./lib.js";
+import * as ViewIgnored from './lib.js';
 export default ViewIgnored;
-export * from "./lib.js";
+export * from './lib.js';

package/out/src/index.js

@@ -1,3 +1,3 @@
-import * as ViewIgnored from "./lib.js";
+import * as ViewIgnored from './lib.js';
 export default ViewIgnored;
-export * from "./lib.js";
+export * from './lib.js';

package/out/src/lib.d.ts

@@ -1,4 +1,4 @@
-export * from "./browser/lib.js";
-export * as Styling from "./styling.js";
-export * as Cli from "./cli.js";
-export * as Config from "./config.js";
+export * from './browser/lib.js';
+export * as Styling from './styling.js';
+export * as Cli from './cli.js';
+export * as Config from './config.js';

package/out/src/lib.js

@@ -1,4 +1,4 @@
-export * from "./browser/lib.js";
-export * as Styling from "./styling.js";
-export * as Cli from "./cli.js";
-export * as Config from "./config.js";
+export * from './browser/lib.js';
+export * as Styling from './styling.js';
+export * as Cli from './cli.js';
+export * as Config from './config.js';

package/out/src/styling.d.ts

@@ -1,4 +1,10 @@
-import { ChalkInstance } from "chalk";
-import { DecorName } from "./browser/styling.js";
-export * from "./browser/styling.js";
-export declare function formatConfigConflicts(chalk: ChalkInstance, decor: DecorName, error: unknown): void;
+import { type ChalkInstance } from 'chalk';
+export * from './browser/styling.js';
+/**
+ * @public
+ */
+export declare function highlight(text: string, chalk?: ChalkInstance): string;
+/**
+ * @public
+ */
+export declare function stringTime(time: number, chalk: ChalkInstance): string;