view-ignored 0.1.0 → 0.2.0

package/out/src/browser/fileinfo.d.ts

@@ -0,0 +1,82 @@
+import { ChalkInstance } from "chalk";
+import { DecorName } from "./styling.js";
+import { FilterName, Scanner, SourceInfo } from "./lib.js";
+/**
+ * @see {@link FileInfo.prototype.toString}
+ */
+export interface FileInfoToStringOptions {
+    /**
+     * The appearance behavior of the file icon.
+     * @default undefined
+     */
+    fileIcon?: DecorName;
+    /**
+     * Show the scanner's source after the file path.
+     * @default false
+     */
+    source?: boolean;
+    /**
+     * The appearance behavior of the prefix.
+     * `"+"` for included, `"!"` for excluded.
+     * @default false
+     */
+    usePrefix?: boolean;
+    /**
+     * The behavior of colors.
+     * @default undefined
+     */
+    chalk?: ChalkInstance;
+    /**
+     * Determines if the path's base or the entire path should be formatted.
+     * @default true
+     */
+    entire?: boolean;
+}
+/**
+ * The result of the file path scan.
+ */
+export declare class FileInfo {
+    /**
+     * Relative path to the file.
+    */
+    readonly filePath: string;
+    /**
+     * Source of patterns, used by {@link scanner}.
+     */
+    readonly source: SourceInfo;
+    /**
+     * The pattern parser.
+     */
+    readonly scanner: Scanner;
+    constructor(
+    /**
+     * Relative path to the file.
+    */
+    filePath: string, 
+    /**
+     * Source of patterns, used by {@link scanner}.
+     */
+    source: SourceInfo);
+    /**
+     * Determines if ignored file is ignored or not.
+     */
+    isIgnored(): boolean;
+    /**
+     * Creates new {@link FileInfo} from each file path.
+     */
+    static from(filePathList: string[], sourceInfo: SourceInfo): FileInfo[];
+    /**
+     * Creates new {@link FileInfo} from the file path.
+     */
+    static from(filePath: string, sourceInfo: SourceInfo): FileInfo;
+    /**
+     * @param options Styling options.
+     * @returns Relative file path. Optionally formatted.
+     */
+    toString(options?: FileInfoToStringOptions): string;
+    /**
+     * @param filter The group name. Default: `"all"`
+     * @returns `true`, if the file is contained by the filter.
+     */
+    isIncludedBy(filter?: FilterName | ((fileInfo: FileInfo) => boolean)): boolean;
+}

package/out/src/browser/fileinfo.js

@@ -0,0 +1,78 @@
+import { decorFile } from "./styling.js";
+import path from "path";
+/**
+ * The result of the file path scan.
+ */
+export class FileInfo {
+    filePath;
+    source;
+    /**
+     * The pattern parser.
+     */
+    scanner;
+    constructor(
+    /**
+     * Relative path to the file.
+    */
+    filePath, 
+    /**
+     * Source of patterns, used by {@link scanner}.
+     */
+    source) {
+        this.filePath = filePath;
+        this.source = source;
+        this.scanner = this.source.scanner;
+    }
+    /**
+     * Determines if ignored file is ignored or not.
+     */
+    isIgnored() {
+        return this.scanner.matches(this.filePath);
+    }
+    static from(arg, sourceInfo) {
+        if (Array.isArray(arg)) {
+            return arg.map(path => FileInfo.from(path, sourceInfo));
+        }
+        return new FileInfo(arg, sourceInfo);
+    }
+    /**
+     * @param options Styling options.
+     * @returns Relative file path. Optionally formatted.
+     */
+    toString(options) {
+        const { fileIcon, chalk, usePrefix = false, source: useSource = false, entire = true } = options ?? {};
+        const parsed = path.parse(this.filePath);
+        const fIcon = decorFile(fileIcon, this.filePath);
+        const ignored = this.isIgnored();
+        let prefix = usePrefix ? (ignored ? '!' : '+') : '';
+        let postfix = useSource ? " << " + this.source.toString() : '';
+        if (chalk) {
+            prefix = chalk.dim(prefix);
+            postfix = chalk.dim(postfix);
+            const clr = chalk[ignored ? "red" : "green"];
+            if (entire) {
+                return fIcon + clr(prefix + this.filePath + postfix);
+            }
+            return parsed.dir + '/' + fIcon + clr(prefix + parsed.base + postfix);
+        }
+        if (entire) {
+            return prefix + this.filePath + postfix;
+        }
+        return parsed.dir + '/' + fIcon + prefix + parsed.base + postfix;
+    }
+    /**
+     * @param filter The group name. Default: `"all"`
+     * @returns `true`, if the file is contained by the filter.
+     */
+    isIncludedBy(filter) {
+        if (typeof filter === "function") {
+            return filter(this);
+        }
+        filter ??= "all";
+        const filterIgnore = (filter === "ignored") && this.isIgnored();
+        const filterInclude = (filter === "included") && !this.isIgnored();
+        const filterAll = filter === "all";
+        const result = filterIgnore || filterInclude || filterAll;
+        return result;
+    }
+}

package/{lib → out/src/browser}/index.d.ts

@@ -1,4 +1,3 @@
 import * as ViewIgnored from "./lib.js";
 export default ViewIgnored;
 export * from "./lib.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +1,3 @@
 import * as ViewIgnored from "./lib.js";
 export default ViewIgnored;
 export * from "./lib.js";
-//# sourceMappingURL=index.js.map

package/out/src/browser/lib.d.ts

@@ -0,0 +1,141 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PatternType } from "./scanner.js";
+import { FSOption } from "glob";
+import { FileInfo } from "./fileinfo.js";
+import { SourceInfo } from "./sourceinfo.js";
+import * as FS from "fs";
+export * from "./errors.js";
+export * from "./scanner.js";
+export * from "./fileinfo.js";
+export * from "./sourceinfo.js";
+export * as Styling from "./styling.js";
+export * as Sorting from "./sorting.js";
+export * as Plugins from "./binds/index.js";
+/**
+ * Contains all filter names.
+ */
+export declare const filterNameList: readonly ["ignored", "included", "all"];
+/**
+ * Contains all filter names as a type.
+ */
+export type FilterName = typeof filterNameList[number];
+/**
+ * Checks if the value is the {@link FilterName}.
+ */
+export declare function isFilterName(value: unknown): value is FilterName;
+/**
+ * Uses `readFileSync` and `readFile`.
+ * @extends glob.FileSystemAdapter
+ */
+export interface FileSystemAdapter extends FSOption {
+    readFileSync?: typeof FS.readFileSync;
+    readdirSync?: typeof FS.readdirSync;
+    statSync?: typeof FS.statSync;
+}
+/**
+ * Also can write rules to the {@link Scanner}.
+ * @returns `true`, if the given source is valid.
+ */
+export type ScanMethod = (sourceInfo: SourceInfo) => boolean;
+/**
+ * Represents the methodology for reading the target's source.
+ */
+export interface Methodology {
+    /**
+     * Git configuration property.
+     * @see {@link https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreignoreCase|git-config ignorecase}.
+     * @default false
+     */
+    ignoreCase?: boolean;
+    /**
+     * The parser for the patterns.
+     * @default "gitignore"
+     */
+    matcher: PatternType;
+    /**
+     * Use the patterns for including instead of excluding/ignoring.
+     * @default false
+     */
+    matcherNegated?: boolean;
+    /**
+     * Additional patterns for files, provided by the {@link pattern}.
+     *
+     * Example: You have the '.gitignore' file. You want to scan patterns from it and add additional patterns. Use this property.
+     * @default []
+     */
+    matcherAdd?: string[];
+    /**
+     * Force ignore patterns.
+     * Takes precedence over {@link matcherAdd}.
+     * @default []
+     */
+    matcherExclude?: string[];
+    /**
+     * Force include patterns.
+     * Takes precedence over {@link matcherExclude}.
+     * @default []
+     */
+    matcherInclude?: string[];
+    /**
+     * First valid source will be used as {@link Scanner}.
+     */
+    pattern: SourceInfo[] | string[] | SourceInfo | string;
+    /**
+     * Scanner function. Should return `true`, if the given source is valid and also add patterns to the {@link FileInfo.scanner}.
+     */
+    scan: ScanMethod;
+}
+/**
+ * Checks if the value is the {@link Methodology}.
+ */
+export declare function isMethodology(value: unknown): value is Methodology;
+/**
+ * File scanning options.
+ * @see {@link ScanFolderOptions}
+ */
+export interface ScanFileOptions {
+    /**
+     * Custom implementation of methods for working with the file system.
+     * @default import * as FS from "fs"
+     */
+    fsa?: FileSystemAdapter;
+    /**
+     * The current working directory in which to search.
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Specifies the maximum number of concurrent requests from a reader to read
+     * directories.
+     * @default os.cpus().length
+     */
+    concurrency?: number;
+    /**
+     * Specifies the maximum depth of a read directory relative to the start
+     * directory.
+     * @default Infinity
+     */
+    maxDepth?: number;
+}
+/**
+ * Folder deep scanning options.
+ * @see {@link ScanFileOptions}
+ */
+export interface ScanFolderOptions extends ScanFileOptions {
+    /**
+     * Filter output.
+     * @default "included"
+     */
+    filter?: FilterName | ((fileInfo: FileInfo) => boolean);
+}
+/**
+ * Gets info about the file: it is ignored or not.
+ * @throws {ErrorNoSources} if the source is bad.
+ */
+export declare function scanFile(filePath: string, sources: Methodology[], options: ScanFileOptions): Promise<FileInfo>;
+/**
+ * Scans project's directory paths to determine whether they are being ignored.
+ * @throws {ErrorNoSources} if the source is bad.
+ */
+export declare function scanProject(sources: Methodology[], options: ScanFolderOptions): Promise<FileInfo[]>;
+export declare function scanProject(target: string, options: ScanFolderOptions): Promise<FileInfo[]>;

package/out/src/browser/lib.js

@@ -0,0 +1,126 @@
+import { Scanner, isPatternType } from "./scanner.js";
+import { glob } from "glob";
+import { FileInfo } from "./fileinfo.js";
+import { SourceInfo } from "./sourceinfo.js";
+import { targetGet } from "./binds/index.js";
+import path from "path";
+import { ErrorNoSources, ErrorTargetNotBound } from "./errors.js";
+import * as FS from "fs";
+export * from "./errors.js";
+export * from "./scanner.js";
+export * from "./fileinfo.js";
+export * from "./sourceinfo.js";
+export * as Styling from "./styling.js";
+export * as Sorting from "./sorting.js";
+export * as Plugins from "./binds/index.js";
+/**
+ * Contains all filter names.
+ */
+export const filterNameList = ["ignored", "included", "all"];
+/**
+ * Checks if the value is the {@link FilterName}.
+ */
+export function isFilterName(value) {
+    return typeof value === "string" && filterNameList.includes(value);
+}
+/**
+ * Checks if the value is the {@link Methodology}.
+ */
+export function isMethodology(value) {
+    if (value?.constructor !== Object) {
+        return false;
+    }
+    const v = value;
+    return isPatternType(v.matcher)
+        && (typeof v.pattern === "string")
+        && (v.matcherAdd === undefined || Array.isArray(v.matcherAdd) && v.matcherAdd.every(p => Scanner.patternIsValid(p, { patternType: v.matcher })));
+}
+/**
+ * Gets info about the file: it is ignored or not.
+ * @throws {ErrorNoSources} if the source is bad.
+ */
+export async function scanFile(filePath, sources, options) {
+    const { fsa = FS, cwd = process.cwd() } = options ?? {};
+    for (const methodology of sources) {
+        const sourceInfoList = await SourceInfo.fromMethodology(methodology, options);
+        for (const sourceInfo of sourceInfoList) {
+            sourceInfo.readSync(cwd, fsa.readFileSync ?? FS.readFileSync);
+            const isGoodSource = methodology.scan(sourceInfo);
+            if (isGoodSource) {
+                return FileInfo.from(filePath, sourceInfo);
+            }
+        }
+    }
+    throw new ErrorNoSources(sources);
+}
+export async function scanProject(arg1, options) {
+    if (typeof arg1 === "string") {
+        const bind = targetGet(arg1);
+        if (bind === undefined) {
+            throw new ErrorTargetNotBound(arg1);
+        }
+        return scanProject(bind.methodology, Object.assign(options, bind.scanOptions));
+    }
+    // Find good source.
+    const { filter = "included", fsa = FS, cwd = process.cwd() } = options;
+    for (const methodology of arg1) {
+        const resultList = [];
+        const sourceInfoList = await SourceInfo.fromMethodology(methodology, options);
+        if (sourceInfoList.length < 1) {
+            continue;
+        }
+        const allFilePaths = await glob("**", {
+            ...options,
+            nodir: true,
+            dot: true,
+            posix: true,
+        });
+        const cache = new Set();
+        let noSource = false;
+        for (const filePath of allFilePaths) {
+            if (cache.has(filePath)) {
+                continue;
+            }
+            const sourceInfo = SourceInfo.hierarcy(filePath, sourceInfoList, {
+                closest: false,
+                filter(sourceInfo) {
+                    if (!(sourceInfo instanceof SourceInfo)) {
+                        return true;
+                    }
+                    if (sourceInfo.content === undefined) {
+                        sourceInfo.readSync(cwd, fsa.readFileSync ?? FS.readFileSync);
+                    }
+                    return methodology.scan(sourceInfo);
+                }
+            });
+            if (sourceInfo === undefined) {
+                noSource = true;
+                break;
+            }
+            // also create cache for each file in the direcotry
+            const fileDir = path.dirname(filePath);
+            const fileDirAbsolute = path.join(cwd, fileDir);
+            const entryList = (fsa?.readdirSync ?? FS.readdirSync)(fileDirAbsolute);
+            for (const entry of entryList) {
+                const entryPath = path.join(fileDir, entry);
+                const entryPathNormal = fileDir !== '.' ? fileDir + '/' + entry : entry;
+                const entryPathAbsolute = path.join(cwd, entryPath);
+                const stat = (fsa?.statSync ?? FS.statSync)(entryPathAbsolute);
+                cache.add(entryPathNormal);
+                if (stat.isFile()) {
+                    // push new FileInfo
+                    const fileInfo = FileInfo.from(entryPathNormal, sourceInfo);
+                    if (fileInfo.isIncludedBy(filter)) {
+                        resultList.push(fileInfo);
+                    }
+                }
+            }
+        } // forend
+        if (noSource) {
+            continue;
+        }
+        return resultList;
+    } // forend
+    throw new ErrorNoSources(arg1);
+}
+//#endregion

package/out/src/browser/scanner.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Supported matchers/parsers by {@link Scanner}.
+ */
+export type PatternType = typeof patternTypeList[number];
+export declare const patternTypeList: readonly ["gitignore", "minimatch"];
+export declare function isPatternType(value: unknown): value is PatternType;
+/**
+ * @see {@link Scanner}
+ */
+export interface ScannerOptions {
+    /**
+     * Use the patterns for including instead of excluding/ignoring.
+     * @default false
+     */
+    negated?: boolean;
+    /**
+     * The parser for the patterns.
+     * @default "gitignore"
+     */
+    patternType?: PatternType;
+    /**
+     * Git configuration property.
+     * @see {@link https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreignoreCase|git-config ignorecase}.
+     * @default false
+     */
+    ignoreCase?: boolean;
+}
+export type IsValidPatternOptions = Pick<ScannerOptions, "patternType">;
+/**
+ * The Glob-like pattern of the specific matcher.
+ */
+export type ScannerPattern = string | string[];
+/**
+ * The pattern parser. Can check if the file path is ignored.
+ */
+export declare class Scanner {
+    /**
+     * If `true`, when calling {@link Scanner.matches}, method will return `true` for ignored path.
+     * @default false
+     */
+    readonly isNegated: boolean;
+    /**
+     * Defines way to check paths.
+     * @default "gitignore"
+     */
+    readonly patternType: PatternType;
+    /**
+     * Git configuration property.
+     * @see {@link https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreignoreCase|git-config ignorecase}.
+     * @default false
+     */
+    readonly ignoreCase: boolean;
+    private patternList;
+    private patternListExclude;
+    private patternListInclude;
+    private ignoreInstance;
+    private ignoreInstanceExclude;
+    private ignoreInstanceInclude;
+    constructor(options?: ScannerOptions);
+    /**
+     * Adds new ignore rule.
+     * @param pattern .gitignore file specification pattern.
+     */
+    add(pattern?: ScannerPattern): this;
+    /**
+     * Force ignore pattern.
+     * @param pattern .gitignore file specification pattern.
+     */
+    addExclude(pattern?: ScannerPattern): this;
+    /**
+     * Force ignore pattern.
+     * @param pattern .gitignore file specification pattern.
+     */
+    addInclude(pattern?: ScannerPattern): this;
+    /**
+     * Checks if the scanner should ignore path.
+     * @see {@link Scanner.isNegated} can change the return value.
+     * @param path Dir entry, path.
+     */
+    matches(path: string): boolean;
+    private matchesReal;
+    private static matchesGitignore;
+    private static matchesMinimatch;
+    /**
+     * Checks if given pattern is valid.
+     * @param pattern Parser pattern.
+     */
+    patternIsValid(pattern: unknown): pattern is ScannerPattern;
+    /**
+     * Checks if given pattern is valid.
+     * @param pattern Parser pattern.
+     */
+    static patternIsValid(pattern: unknown, options?: IsValidPatternOptions): pattern is ScannerPattern;
+    /**
+     * @returns New pattern array: `!pattern` for `pattern`, and `pattern` for `!pattern`.
+     */
+    static patternToNegated(pattern: string[]): string[];
+    /**
+     * @returns New pattern: `!pattern` for `pattern`, and `pattern` for `!pattern`.
+     */
+    static patternToNegated(pattern: string): string;
+    static patternIsNegated(pattern: string): boolean;
+}