view-ignored 0.1.1 → 0.2.1

package/{lib → out/src}/browser/styling.js

@@ -1,55 +1,80 @@
-import { stdout } from "process";
 import { default as tree } from "treeify";
 import jsonifyPaths from "jsonify-paths";
 import path from "path";
-export const styleNameList = ['tree', 'paths', 'treeEmoji', 'treeNerd'];
-const printTree = function (oc, files, styleName) {
-    const pathsAsObject = jsonifyPaths.from(files.map(f => f.toString({ styleName, usePrefix: true, chalk: oc }, false)), { delimiter: "/" });
+import boxen from "boxen";
+import { stripVTControlCharacters } from "util";
+/**
+ * @returns Prints a readable file list. Here is '\n' ending.
+ */
+export function formatFiles(files, options) {
+    const { showSources = false, chalk, decor = "normal", style } = options ?? {};
+    const isPaths = style === "paths";
+    const paths = files.map(f => f.toString({ fileIcon: decor, usePrefix: true, chalk: chalk, source: showSources, entire: isPaths }));
+    if (isPaths) {
+        return paths.join('\n') + '\n';
+    }
+    // isTree
+    const pathsAsObject = jsonifyPaths.from(paths, { delimiter: "/" });
     const pathsAsTree = tree.asTree(pathsAsObject, true, true);
-    stdout.write(pathsAsTree);
-};
-export const Styles = {
-    paths(oc, files, styleName) {
-        stdout.write(files.map(f => `${f.toString({ styleName, usePrefix: true, chalk: oc })}`)
-            .join('\n') + "\n");
-    },
-    tree: printTree,
-    treeEmoji: printTree,
-    treeNerd: printTree
-};
+    return pathsAsTree;
+}
+/**
+ * Contains all style names.
+ */
+export const styleNameList = ['tree', 'paths'];
+/**
+ * Checks if the value is the {@link StyleName}.
+ */
+export function isStyleName(value) {
+    return typeof value === "string" && styleNameList.includes(value);
+}
+/**
+ * Contains all decor names.
+ */
+export const decorNameList = ['normal', 'emoji', 'nerdfonts'];
+/**
+ * Checks if the value is the {@link DecorName}.
+ */
+export function isDecorName(value) {
+    return typeof value === "string" && decorNameList.includes(value);
+}
 /**
  * Formats the string for specific style types.
- * @param styleName The style name.
+ * @param decor The decor name.
  * @param condition Formatting options.
  */
-export function styleCondition(styleName, condition) {
-    var _a, _b, _c, _d, _e;
-    if (styleName === undefined) {
-        return '';
-    }
-    const isNerd = styleName.toLowerCase().includes('nerd');
-    const isEmoji = styleName.toLowerCase().includes('emoji');
-    let result = '';
-    if (isEmoji) {
-        result = (_a = condition.ifEmoji) !== null && _a !== void 0 ? _a : result;
-    }
-    else if (isNerd) {
-        result = (_b = condition.ifNerd) !== null && _b !== void 0 ? _b : result;
+export function decorCondition(decor, condition) {
+    let result = condition.ifNormal ?? '';
+    if (decor === 'emoji') {
+        result = condition.ifEmoji ?? result;
     }
-    else {
-        result = (_c = condition.ifAny) !== null && _c !== void 0 ? _c : result;
+    else if (decor === 'nerdfonts') {
+        result = condition.ifNerd ?? result;
     }
     if (result !== '') {
-        result = ((_d = condition.prefix) !== null && _d !== void 0 ? _d : '') + result + ((_e = condition.postfix) !== null && _e !== void 0 ? _e : '');
+        result = (condition.prefix ?? '') + result + (condition.postfix ?? '');
+    }
+    return result;
+}
+export function boxError(message, options) {
+    let result = ('\n' + boxen(message, {
+        titleAlignment: "left",
+        padding: { left: 2, right: 2 },
+        borderColor: "redBright",
+        borderStyle: "round",
+        ...options,
+    }));
+    if (options?.noColor) {
+        result = stripVTControlCharacters(result);
     }
     return result;
 }
 /**
- * Adds the file icon prefix to the string.
- * @param styleName The style name.
+ * Returns file icon for the file name & extension.
+ * @param decor The decor name.
  * @param filePath The full file path.
  */
-export function styleConditionFile(styleName, filePath) {
+export function decorFile(decor, filePath) {
     const parsed = path.parse(filePath);
     let icon = '';
     switch (parsed.ext.toLocaleLowerCase()) {
@@ -117,10 +142,12 @@ export function styleConditionFile(styleName, filePath) {
         default:
             break;
     }
-    return styleCondition(styleName, {
+    if (!decor) {
+        return '';
+    }
+    return decorCondition(decor, {
         ifEmoji: '📄',
         ifNerd: icon,
         postfix: ' '
     });
 }
-//# sourceMappingURL=styling.js.map

package/out/src/cli.d.ts

@@ -0,0 +1,92 @@
+import { ChalkInstance, ColorSupportLevel } from "chalk";
+import { Argument, Option, Command } from "commander";
+import * as Config from "./config.js";
+import { DecorName, StyleName } from "./browser/styling.js";
+import { SortName } from "./browser/sorting.js";
+import { FilterName } from "./lib.js";
+import { BoxOptions } from "./styling.js";
+export declare const version: string;
+export declare function logError(message: string, options?: BoxOptions): void;
+/**
+ * Use it instead of {@link program}.parse()
+ */
+export declare function programInit(): Promise<void>;
+/** Chalk, but configured by view-ignored cli. */
+export declare function getColorLevel(flags: ProgramFlags): ColorSupportLevel;
+/** Chalk, but configured by view-ignored cli. */
+export declare function getChalk(flags: ProgramFlags): ChalkInstance;
+/**
+ * Command-line entire program flags.
+ */
+export interface ProgramFlags {
+    plugins: string[];
+    noColor: boolean;
+    color: string;
+    decor: DecorName;
+}
+/**
+ * Command-line 'scan' command flags.
+ */
+export interface ScanFlags {
+    target: string;
+    filter: FilterName;
+    sort: SortName;
+    style: StyleName;
+    showSources: boolean;
+    depth: number;
+    parsable: boolean;
+}
+/**
+ * Command-line 'cfg get' command flags.
+ */
+export interface ConfigGetFlags {
+    real: boolean;
+}
+/**
+ * `view-ignored` command-line programl
+ */
+export declare const program: Command;
+/**
+ * Command-line 'scan' command.
+ */
+export declare const scanProgram: Command;
+/**
+* Command-line 'config' command.
+*/
+export declare const cfgProgram: Command;
+/**
+ * Command-line argument: key=value pair.
+ * @see {@link parseArgKeyVal}
+ */
+export declare const argConfigKeyVal: Argument;
+/**
+ * Command-line argument: config property.
+ * @see {@link Config.configKeyList}
+ */
+export declare const argConfigKey: Argument;
+export declare const cfgGetOption: Option;
+export declare function parseArgArrStr(arg: string): string[];
+export declare function parseArgBool(arg: string): boolean;
+export declare function parseArgInt(arg: string): number;
+export declare function parseArgKey(key: string): Config.ConfigKey;
+export declare function parseArgKeyVal(pair: string): Config.ConfigPair;
+/**
+ * Command-line 'scan' command action.
+ */
+export declare function actionScan(): Promise<void>;
+/**
+ * Command-line 'config path' command action.
+ */
+export declare function actionCfgPath(): void;
+/**
+ * Command-line 'config set' command action
+ */
+export declare function actionCfgSet(pair?: Config.ConfigPair): void;
+/**
+ * Command-line 'config unset' command action
+ */
+export declare function actionCfgUnset(key: Config.ConfigKey | undefined): void;
+/**
+ * Command-line 'config unset' command action
+ */
+export declare function actionCfgGet(key: Config.ConfigKey | undefined, options: ConfigGetFlags): void;

package/out/src/cli.js

@@ -0,0 +1,249 @@
+import fs from "fs";
+import { Chalk } from "chalk";
+import { Argument, InvalidArgumentError, Option, Command } from "commander";
+import * as Config from "./config.js";
+import { BuiltIns, loadPluginsQueue, targetGet } from "./browser/binds/index.js";
+import { decorCondition, formatFiles } from "./browser/styling.js";
+import { ErrorNoSources, scanProject, Sorting } from "./lib.js";
+import { boxError, formatConfigConflicts } from "./styling.js";
+import ora from "ora";
+import packageJSON from "../package.json" with { type: "json" };
+import { format } from "util";
+export const { version } = packageJSON;
+export function logError(message, options) {
+    console.log(boxError(message, { noColor: getColorLevel(program.opts()) === 0, ...options }));
+}
+/**
+ * Use it instead of {@link program}.parse()
+ */
+export async function programInit() {
+    Config.configManager.load();
+    program.version('v' + version, '-v');
+    program.addOption(new Option("--no-color", 'force disable colors').default(false));
+    Config.configValueLinkCliOption("plugins", program, new Option('--plugins <modules...>', 'import modules to modify behavior'), parseArgArrStr);
+    Config.configValueLinkCliOption("color", program, new Option("--color <level>", 'the interface color level'), parseArgInt);
+    Config.configValueLinkCliOption("decor", program, new Option("--decor <decor>", "the interface decorations"));
+    Config.configValueLinkCliOption("parsable", scanProgram, new Option('-p, --parsable [parsable]', "print parsable text"), parseArgBool);
+    Config.configValueLinkCliOption("target", scanProgram, new Option("-t, --target <ignorer>", 'the scan target'));
+    Config.configValueLinkCliOption("filter", scanProgram, new Option("--filter <filter>", 'filter results'));
+    Config.configValueLinkCliOption("sort", scanProgram, new Option("--sort <sorter>", 'sort results'));
+    Config.configValueLinkCliOption("style", scanProgram, new Option("--style <style>", 'results view mode'));
+    Config.configValueLinkCliOption("depth", scanProgram, new Option("--depth <depth>", 'the max results depth'), parseArgInt);
+    Config.configValueLinkCliOption("showSources", scanProgram, new Option("--show-sources [show]", 'show scan sources'), parseArgBool);
+    program.parseOptions(process.argv);
+    const flags = program.opts();
+    const chalk = getChalk(flags);
+    try {
+        Config.configManager.load();
+    }
+    catch (error) {
+        formatConfigConflicts(chalk, flags.decor, error);
+        return;
+    }
+    try {
+        await BuiltIns;
+        const configPlugins = Config.configManager.get('plugins');
+        const loaded = await loadPluginsQueue(flags.plugins);
+        for (const load of loaded) {
+            if (!load.isLoaded) {
+                logError(format(load.exports), {
+                    title: `Unable to load plugin '${load.moduleName}' ` + (configPlugins.includes(load.moduleName)
+                        ? '(imported by ' + Config.configManager.filePath + ')'
+                        : '(imported by --plugins option)')
+                });
+            }
+        }
+    }
+    catch (reason) {
+        logError(format(reason));
+        process.exit(1);
+    }
+    program.parse();
+}
+/** Chalk, but configured by view-ignored cli. */
+export function getColorLevel(flags) {
+    const colorLevel = (flags.noColor ? 0 : Math.max(0, Math.min(Number(flags.color ?? 3), 3)));
+    return colorLevel;
+}
+/** Chalk, but configured by view-ignored cli. */
+export function getChalk(flags) {
+    const chalk = new Chalk({ level: getColorLevel(flags) });
+    return chalk;
+}
+/**
+ * `view-ignored` command-line programl
+ */
+export const program = new Command();
+/**
+ * Command-line 'scan' command.
+ */
+export const scanProgram = program
+    .command("scan")
+    .aliases(['sc'])
+    .description('get ignored/included paths')
+    .action(actionScan);
+/**
+* Command-line 'config' command.
+*/
+export const cfgProgram = program
+    .command("config")
+    .alias('cfg')
+    .description('cli config manipulation');
+/**
+ * Command-line argument: key=value pair.
+ * @see {@link parseArgKeyVal}
+ */
+export const argConfigKeyVal = new Argument('[pair]', "the configuration entry key=value'").argParser(parseArgKeyVal);
+/**
+ * Command-line argument: config property.
+ * @see {@link Config.configKeyList}
+ */
+export const argConfigKey = new Argument('[key]', 'the configuration setting name').choices(Config.configKeyList);
+export const cfgGetOption = new Option('--real', 'use default value(s) as fallback').default(false);
+cfgProgram
+    .command('path').description('print the config file path')
+    .action(actionCfgPath);
+cfgProgram
+    .command('set').description("set config property using syntax 'key=value'")
+    .addArgument(argConfigKeyVal)
+    .action(actionCfgSet);
+cfgProgram
+    .command('unset').description("delete configuration value if cpecified, otherwise delete entire config")
+    .addArgument(argConfigKey)
+    .action(actionCfgUnset);
+cfgProgram
+    .command('get').description('print configuration value(s). You can use --real option to view real values')
+    .addOption(cfgGetOption)
+    .addArgument(argConfigKey)
+    .action(actionCfgGet);
+export function parseArgArrStr(arg) {
+    return arg.split(/[ ,|]/).filter(Boolean);
+}
+export function parseArgBool(arg) {
+    if (!Config.boolValues.includes(arg)) {
+        throw new InvalidArgumentError(`Got invalid value '${arg}'. Should be a boolean.`);
+    }
+    return Config.trueValues.includes(arg);
+}
+export function parseArgInt(arg) {
+    const num = parseInt(arg);
+    if (!Number.isInteger(num)) {
+        throw new InvalidArgumentError(`Got invalid value '${num}'. Should be an integer.`);
+    }
+    return num;
+}
+export function parseArgKey(key) {
+    if (!Config.isConfigKey(key)) {
+        throw new InvalidArgumentError(`Got invalid key '${key}'. Allowed config keys are ${Config.configKeyList.join(', ')}.`);
+    }
+    return key;
+}
+export function parseArgKeyVal(pair) {
+    const result = pair.split('=');
+    const [key] = result;
+    if (result.length !== 2) {
+        throw new InvalidArgumentError(`Expected 'key=value'.`);
+    }
+    if (!Config.isConfigKey(key)) {
+        throw new InvalidArgumentError(`Got invalid key '${key}'. Allowed config keys are ${Config.configKeyList.join(', ')}.`);
+    }
+    const option = Config.configValueGetCliOption(key);
+    const val = option.parseArg?.(result[1], undefined) ?? result[1];
+    if (!Config.isConfigValue(key, val)) {
+        const list = Config.configValueList(key);
+        if (list === undefined) {
+            throw new InvalidArgumentError(`Invalid value '${val}' for the key '${key}'.`);
+        }
+        if (Array.isArray(list)) {
+            throw new InvalidArgumentError(`Invalid value '${val}' for the key '${key}'. Allowed config values are ${list.join(', ')}`);
+        }
+        throw new InvalidArgumentError(`Invalid value '${val}' for the key '${key}'. ${list}`);
+    }
+    return [key, val];
+}
+/**
+ * Command-line 'scan' command action.
+ */
+export async function actionScan() {
+    const flagsGlobal = scanProgram.optsWithGlobals();
+    const cwd = process.cwd();
+    const start = Date.now();
+    const chalk = getChalk(program.opts());
+    const fileInfoListP = scanProject(flagsGlobal.target, { filter: flagsGlobal.filter, maxDepth: flagsGlobal.depth })
+        .catch((error) => {
+        spinner.stop();
+        spinner.clear();
+        if (!(error instanceof ErrorNoSources)) {
+            throw error;
+        }
+        console.error(`Bad sources for ${flagsGlobal.target}: ${ErrorNoSources.walk(flagsGlobal.target)}`);
+        process.exit(1);
+    });
+    if (flagsGlobal.parsable) {
+        console.log((await fileInfoListP).map(fi => fi.filePath + (flagsGlobal.showSources ? '<' + fi.source.sourcePath : '')).join('|'));
+        return;
+    }
+    const spinner = ora({ text: cwd, color: 'white' });
+    spinner.start();
+    spinner.suffixText = "Generating...";
+    const fileInfoList = await fileInfoListP;
+    const sorter = Sorting[flagsGlobal.sort];
+    const cache = new Map(fileInfoList.map(String).map(filePath => [filePath, fs.statSync(filePath).mtime.getTime()]));
+    const lookedSorted = fileInfoList.sort((a, b) => sorter(a.toString(), b.toString(), cache));
+    const files = formatFiles(lookedSorted, { chalk, style: flagsGlobal.style, decor: flagsGlobal.decor, showSources: flagsGlobal.showSources });
+    const checkSymbol = decorCondition(flagsGlobal.decor, { ifEmoji: '✅', ifNerd: '\uf00c', postfix: ' ' });
+    const fastSymbol = decorCondition(flagsGlobal.decor, { ifEmoji: '⚡', ifNerd: '\udb85\udc0c' });
+    const bind = targetGet(flagsGlobal.target);
+    const name = typeof bind.name === "string" ? bind.name : decorCondition(flagsGlobal.decor, bind.name);
+    const infoSymbol = decorCondition(flagsGlobal.decor, { ifEmoji: 'ℹ️', ifNerd: '\ue66a', postfix: ' ' });
+    const time = Date.now() - start;
+    let message = '';
+    message += files;
+    message += '\n';
+    message += `${chalk.green(checkSymbol)}Done in ${time < 400 ? chalk.yellow(fastSymbol) : ''}${time}ms.`;
+    message += '\n';
+    message += `${fileInfoList.length} files listed for ${name} (${flagsGlobal.filter}).`;
+    message += '\n';
+    if (bind.testCommand) {
+        message += '\n';
+        message += `${chalk.blue(infoSymbol)}You can use '${chalk.magenta(bind.testCommand)}' to check if the list is valid.`;
+    }
+    message += '\n';
+    spinner.stop();
+    spinner.clear();
+    console.log(cwd + '\n' + message);
+}
+/**
+ * Command-line 'config path' command action.
+ */
+export function actionCfgPath() {
+    console.log(Config.configFilePath);
+}
+/**
+ * Command-line 'config set' command action
+ */
+export function actionCfgSet(pair) {
+    if (pair === undefined) {
+        console.log(`Allowed config keys are ${Config.configKeyList.join(', ')}.`);
+        return;
+    }
+    const [key, val] = pair;
+    Config.configManager.set(key, val).save();
+    console.log(Config.configManager.getPairString(key));
+}
+/**
+ * Command-line 'config unset' command action
+ */
+export function actionCfgUnset(key) {
+    if (key === undefined) {
+        console.log('Configuration file has been completely deleted.');
+    }
+    Config.configManager.unset(key).save();
+    console.log(Config.configManager.getPairString(key));
+}
+/**
+ * Command-line 'config unset' command action
+ */
+export function actionCfgGet(key, options) {
+    console.log(Config.configManager.getPairString(key, options.real));
+}

package/out/src/config.d.ts

@@ -0,0 +1,141 @@
+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;
+/**
+ * The full config file name - `".view-ignored"`.
+ */
+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.
+ */
+export declare const configKeyList: readonly ["color", "target", "filter", "sort", "style", "decor", "depth", "showSources", "plugins", "parsable"];
+/**
+ * Command-line configuration's key type.
+ */
+export type ConfigKey = typeof configKeyList[number] & keyof Config;
+/**
+ * Checks if the value is the {@link ConfigKey}.
+ */
+export declare function isConfigKey(value: unknown): value is ConfigKey;
+export type ConfigValue<KeyT extends ConfigKey = ConfigKey> = Config[KeyT];
+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}.
+ */
+export declare function isConfigValue<T extends ConfigKey>(key: T, value: unknown): value is Config[T];
+/**
+ * Represents array with the key nad the value.
+ */
+export type ConfigPair<KeyT extends ConfigKey = ConfigKey> = [key: KeyT, value: ConfigValue<KeyT>];
+/**
+ * Command-line configuration structure.
+ * @see {@link configKeyList} Before adding new properties.
+ */
+export type Config = {
+    parsable: boolean;
+    plugins: string[];
+    color: ColorType;
+    target: string;
+    filter: FilterName;
+    sort: Sorting.SortName;
+    style: Styling.StyleName;
+    decor: Styling.DecorName;
+    depth: number;
+    showSources: ShowSourcesType;
+};
+/**
+ * Command-line default config values.
+ */
+export declare const configDefault: Readonly<Config>;
+/**
+ * @returns `true`, if the value can be used as a configuration.
+ */
+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[];
+/**
+ * @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`.
+ */
+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;
+/**
+ * File-specific actions container.
+ */
+export declare class ConfigManager {
+    readonly filePath: string;
+    constructor(filePath: string);
+    /**
+     * Do not change this value directly.
+     * @see {@link configManager}.
+     */
+    private data;
+    dataRaw(): unknown;
+    entries(): [string, any][] | 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.
+     */
+    load(): this | undefined;
+    /**
+     * Saves the partial config to the file. If there are no settings, the file will be deleted, if exists.
+     */
+    save(): 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<T extends ConfigKey>(key: T, value: Config[T]): 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<T extends ConfigKey>(key?: T): this;
+    /**
+     * @returns An array of properties which defined in the configuration file.
+     */
+    definedKeys(): ConfigKey[];
+    /**
+     * @param key The config property.
+     * @param defs If `true`, the default value will be used when the value is `undefined`. Default `true`.
+     * @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;
+}
+/**
+ * File-specific actions container. Contains get, set, unset, save, load and other configuration actions.
+ */
+export declare const configManager: ConfigManager;