view-ignored 0.1.0 → 0.2.0

package/out/src/browser/scanner.js

@@ -0,0 +1,161 @@
+import ignore from "ignore";
+import { minimatch } from "minimatch";
+export const patternTypeList = ["gitignore", "minimatch"];
+export function isPatternType(value) {
+    return typeof value === "string" && patternTypeList.includes(value);
+}
+/**
+ * The pattern parser. Can check if the file path is ignored.
+ */
+export class Scanner {
+    /**
+     * If `true`, when calling {@link Scanner.matches}, method will return `true` for ignored path.
+     * @default false
+     */
+    isNegated = false;
+    /**
+     * Defines way to check paths.
+     * @default "gitignore"
+     */
+    patternType;
+    /**
+     * Git configuration property.
+     * @see {@link https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreignoreCase|git-config ignorecase}.
+     * @default false
+     */
+    ignoreCase;
+    patternList = new Set();
+    patternListExclude = new Set();
+    patternListInclude = new Set();
+    ignoreInstance;
+    ignoreInstanceExclude;
+    ignoreInstanceInclude;
+    constructor(options) {
+        this.patternType = options?.patternType ?? "gitignore";
+        this.ignoreCase = options?.ignoreCase ?? false;
+        this.isNegated = options?.negated ?? false;
+        this.ignoreInstance = ignore.default(options);
+        this.ignoreInstanceExclude = ignore.default(options);
+        this.ignoreInstanceInclude = ignore.default(options);
+    }
+    /**
+     * Adds new ignore rule.
+     * @param pattern .gitignore file specification pattern.
+     */
+    add(pattern) {
+        if (typeof pattern === "string") {
+            pattern = pattern.split('\n');
+        }
+        if (Array.isArray(pattern)) {
+            for (const pat of pattern) {
+                this.patternList.add(pat);
+                this.ignoreInstance.add(pat);
+            }
+        }
+        return this;
+    }
+    /**
+     * Force ignore pattern.
+     * @param pattern .gitignore file specification pattern.
+     */
+    addExclude(pattern) {
+        if (typeof pattern === "string") {
+            pattern = pattern.split('\n');
+        }
+        if (Array.isArray(pattern)) {
+            for (const pat of pattern) {
+                this.patternListExclude.add(pat);
+                this.ignoreInstanceExclude.add(pat);
+            }
+        }
+        return this;
+    }
+    /**
+     * Force ignore pattern.
+     * @param pattern .gitignore file specification pattern.
+     */
+    addInclude(pattern) {
+        if (typeof pattern === "string") {
+            pattern = pattern.split('\n');
+        }
+        if (Array.isArray(pattern)) {
+            for (const pat of pattern) {
+                this.patternListInclude.add(pat);
+                this.ignoreInstanceInclude.add(pat);
+            }
+        }
+        return this;
+    }
+    /**
+     * Checks if the scanner should ignore path.
+     * @see {@link Scanner.isNegated} can change the return value.
+     * @param path Dir entry, path.
+     */
+    matches(path) {
+        if (this.patternType === "gitignore") {
+            return this.matchesReal(() => Scanner.matchesGitignore(path, this.ignoreInstanceInclude), () => Scanner.matchesGitignore(path, this.ignoreInstanceExclude), () => Scanner.matchesGitignore(path, this.ignoreInstance));
+        }
+        // minimatch
+        return this.matchesReal(() => Scanner.matchesMinimatch(path, Array.from(this.patternListInclude)), () => Scanner.matchesMinimatch(path, Array.from(this.patternListExclude)), () => Scanner.matchesMinimatch(path, Array.from(this.patternList)));
+    }
+    matchesReal(include, exclude, ignores) {
+        if (include()) {
+            return false;
+        }
+        if (exclude()) {
+            return true;
+        }
+        const ign = ignores();
+        return this.isNegated ? !ign : ign;
+    }
+    static matchesGitignore(path, ignoreInstance) {
+        return ignoreInstance.ignores(path);
+    }
+    static matchesMinimatch(path, patternList) {
+        return Array.from(patternList).some((pattern) => {
+            return minimatch(path, pattern, { dot: true });
+        });
+    }
+    /**
+     * Checks if given pattern is valid.
+     * @param pattern Parser pattern.
+     */
+    patternIsValid(pattern) {
+        return Scanner.patternIsValid(pattern, { patternType: this.patternType });
+    }
+    /**
+     * Checks if given pattern is valid.
+     * @param pattern Parser pattern.
+     */
+    static patternIsValid(pattern, options) {
+        const { patternType = "gitignore" } = options ?? {};
+        if (Array.isArray(pattern)) {
+            return pattern.every(p => this.patternIsValid(p, options));
+        }
+        if (typeof pattern !== "string") {
+            return false;
+        }
+        if (patternType === "gitignore") {
+            return ignore.default.isPathValid(pattern);
+        }
+        if (patternType === "minimatch") {
+            try {
+                minimatch.makeRe(pattern);
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        }
+        throw new TypeError(`Unknown pattern type '${patternType}'.`);
+    }
+    static patternToNegated(pattern) {
+        if (Array.isArray(pattern)) {
+            return pattern.map(Scanner.patternToNegated);
+        }
+        return Scanner.patternIsNegated(pattern) ? pattern.replace(/^!/, '') : `!${pattern}`;
+    }
+    static patternIsNegated(pattern) {
+        return pattern.startsWith('!');
+    }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Contains all file sort names.
+ */
+export declare const sortNameList: readonly ["firstFolders", "firstFiles", "type", "mixed", "modified"];
+/**
+ * Contains all file sort names as a type.
+ */
+export type SortName = typeof sortNameList[number];
+/**
+ * {@link Array.prototype.sort}'s file path comparator.
+ */
+export type SortFunc = (a: string, b: string) => number;
+/**
+ * Checks if the value is the {@link SortName}.
+ */
+export declare function isSortName(value: unknown): value is SortName;
+/**
+ * Files and folders are sorted by their names.
+ * Folders are displayed before files.
+ */
+export declare function firstFolders(a: string, b: string): number;
+/**
+ * Files and folders are sorted by their names.
+ * Files are displayed before folders.
+ */
+export declare function firstFiles(a: string, b: string): number;
+/**
+ * Files and folders are sorted by last modified date in descending order.
+ * Folders are displayed before files.
+ */
+export declare function modified(a: string, b: string, map: Map<string, number>): number;
+/**
+ * Files and folders are grouped by extension type then sorted by thir names.
+ * Folders are displayed before files.
+ */
+export declare function type(a: string, b: string): number;
+/**
+ * Files and folders are sorted by their names.
+ * Files are interwoven with folders.
+ */
+export declare function mixed(a: string, b: string): number;

package/out/src/browser/sorting.js

@@ -0,0 +1,133 @@
+import path from "path";
+/**
+ * Contains all file sort names.
+ */
+export const sortNameList = ["firstFolders", "firstFiles", "type", "mixed", "modified"];
+/**
+ * Checks if the value is the {@link SortName}.
+ */
+export function isSortName(value) {
+    return typeof value === "string" && sortNameList.includes(value);
+}
+/**
+ * @example
+ * "path/to/the/file" -> ["path", "to/the/file", false]
+ * "file" -> ["file", "file", true]
+ * "file/" -> ["file", "", false]
+ */
+function slicePath(p) {
+    const slashIndex = p.indexOf('/');
+    const next = p.substring(0, slashIndex);
+    const other = p.substring(slashIndex + 1);
+    const isLast = next === '' && (p.lastIndexOf('/') === slashIndex);
+    return [slashIndex < 0 ? other : next, other, isLast];
+}
+/**
+ * Files and folders are sorted by their names.
+ * Folders are displayed before files.
+ */
+export function firstFolders(a, b) {
+    let comp = 0;
+    let next1, others1, next2, others2, last1, last2;
+    for (; comp === 0;) {
+        [next1, others1, last1] = slicePath(a);
+        a = others1;
+        [next2, others2, last2] = slicePath(b);
+        b = others2;
+        comp = mixed(next1, next2);
+        if (last1 || last2) {
+            if (last1 === last2) {
+                break;
+            }
+            if (last1 === false) {
+                return -1;
+            }
+            return +1;
+        }
+    }
+    return comp;
+}
+/**
+ * Files and folders are sorted by their names.
+ * Files are displayed before folders.
+ */
+export function firstFiles(a, b) {
+    let comp = 0;
+    let next1, others1, next2, others2, last1, last2;
+    for (; comp === 0;) {
+        [next1, others1, last1] = slicePath(a);
+        a = others1;
+        [next2, others2, last2] = slicePath(b);
+        b = others2;
+        comp = mixed(next1, next2);
+        if (last1 || last2) {
+            if (last1 === last2) {
+                break;
+            }
+            if (last1 === true) {
+                return -1;
+            }
+            return +1;
+        }
+    }
+    return comp;
+}
+/**
+ * Files and folders are sorted by last modified date in descending order.
+ * Folders are displayed before files.
+ */
+export function modified(a, b, map) {
+    let comp = 0;
+    let others1, others2, last1, last2;
+    for (; comp === 0;) {
+        [, others1, last1] = slicePath(a);
+        a = others1;
+        [, others2, last2] = slicePath(b);
+        b = others2;
+        comp = (map.get(a) ?? 0) - (map.get(b) ?? 0);
+        if (last1 || last2) {
+            if (last1 === last2) {
+                break;
+            }
+            if (last1 === false) {
+                return -1;
+            }
+            return +1;
+        }
+    }
+    return comp;
+}
+/**
+ * Files and folders are grouped by extension type then sorted by thir names.
+ * Folders are displayed before files.
+ */
+export function type(a, b) {
+    let comp = 0;
+    let next1, others1, next2, others2, last1, last2;
+    for (; comp === 0;) {
+        [next1, others1, last1] = slicePath(a);
+        a = others1;
+        [next2, others2, last2] = slicePath(b);
+        b = others2;
+        const ppa = path.parse(next1);
+        const ppb = path.parse(next2);
+        comp = mixed(ppa.ext, ppb.ext) || mixed(ppa.name, ppb.name);
+        if (last1 || last2) {
+            if (last1 === last2) {
+                break;
+            }
+            if (last1 === false) {
+                return -1;
+            }
+            return +1;
+        }
+    }
+    return comp;
+}
+/**
+ * Files and folders are sorted by their names.
+ * Files are interwoven with folders.
+ */
+export function mixed(a, b) {
+    return a.localeCompare(b, undefined, { ignorePunctuation: false });
+}

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

@@ -0,0 +1,62 @@
+/// <reference types="node" resolution-mode="require"/>
+import { FileSystemAdapter, Methodology, ScanFileOptions, Scanner } from "./lib.js";
+export interface SourceInfoHierarcyOptions<T extends {
+    toString(): string;
+}> {
+    /**
+     * @default true
+     */
+    closest?: boolean;
+    /**
+     * @default undefined
+     */
+    filter?: (path: T) => boolean;
+}
+/**
+ * The source of patterns.
+ */
+export declare class SourceInfo {
+    /**
+     * The relative path to the file.
+     */
+    readonly sourcePath: string;
+    /**
+     * The pattern parser.
+     */
+    readonly scanner: Scanner;
+    /**
+     * The last source file content.
+     */
+    content?: Buffer;
+    constructor(
+    /**
+     * The relative path to the file.
+     */
+    sourcePath: string, 
+    /**
+     * The pattern parser.
+     */
+    scanner: Scanner);
+    /**
+     * Creates new {@link SourceInfo} instance.
+     */
+    static from(path: string, methodology: Methodology): SourceInfo;
+    /**
+     * Gets sources from the methodology.
+     */
+    static fromMethodology(methodology: Methodology, options: ScanFileOptions): Promise<SourceInfo[]>;
+    /**
+     * Selects the closest or farthest siblings relative to the path.
+     */
+    static hierarcy<T extends {
+        toString(): string;
+    }>(target: string, pathList: T[], options?: SourceInfoHierarcyOptions<T>): T | undefined;
+    /**
+     * @returns File path of the source.
+     */
+    toString(): string;
+    /**
+     * @returns The contents of the source file.
+     */
+    readSync(cwd: string | undefined, readFileSync: Exclude<FileSystemAdapter["readFileSync"], undefined>): Buffer;
+}

package/out/src/browser/sourceinfo.js

@@ -0,0 +1,105 @@
+import { dirname, join } from "path";
+import { Scanner } from "./lib.js";
+import { glob } from "glob";
+import arrify from "arrify";
+/**
+ * The source of patterns.
+ */
+export class SourceInfo {
+    sourcePath;
+    scanner;
+    /**
+     * The last source file content.
+     */
+    content;
+    constructor(
+    /**
+     * The relative path to the file.
+     */
+    sourcePath, 
+    /**
+     * The pattern parser.
+     */
+    scanner) {
+        this.sourcePath = sourcePath;
+        this.scanner = scanner;
+    }
+    /**
+     * Creates new {@link SourceInfo} instance.
+     */
+    static from(path, methodology) {
+        const scanner = new Scanner({
+            negated: methodology.matcherNegated,
+            ignoreCase: methodology.ignoreCase,
+            patternType: methodology.matcher
+        });
+        scanner.add(methodology.matcherAdd);
+        scanner.addExclude(methodology.matcherExclude);
+        scanner.addInclude(methodology.matcherInclude);
+        return new SourceInfo(path, scanner);
+    }
+    /**
+     * Gets sources from the methodology.
+     */
+    static async fromMethodology(methodology, options) {
+        const patterns = arrify(methodology.pattern);
+        if (patterns.some(p => typeof p !== "string")) {
+            return patterns;
+        }
+        const paths = await glob(patterns, {
+            ...options,
+            nodir: true,
+            dot: true,
+            posix: true
+        });
+        const sourceInfoList = paths.map(p => SourceInfo.from(p, methodology));
+        return sourceInfoList;
+    }
+    /**
+     * Selects the closest or farthest siblings relative to the path.
+     */
+    static hierarcy(target, pathList, options) {
+        const { closest = true, filter: scan } = options ?? {};
+        pathList = pathList.sort((a, b) => a.toString().localeCompare(b.toString()));
+        const checkStack = [];
+        // fill checkStack
+        let dir = target.toString();
+        for (;;) {
+            const parent = dirname(dir);
+            if (dir === parent) {
+                break;
+            }
+            checkStack.push(dir = parent);
+        }
+        if (!closest) {
+            checkStack.reverse();
+        }
+        const cacheDirNames = new Map();
+        for (const dir of checkStack) {
+            const closestPath = pathList.find(path => {
+                let pathDir = cacheDirNames.get(path);
+                if (!pathDir) {
+                    cacheDirNames.set(path, pathDir = dirname(path.toString()));
+                }
+                if (dir !== pathDir) {
+                    return false;
+                }
+                return scan ? scan?.(path) : true;
+            });
+            return closestPath;
+        }
+    }
+    /**
+     * @returns File path of the source.
+     */
+    toString() {
+        return this.sourcePath;
+    }
+    /**
+     * @returns The contents of the source file.
+     */
+    readSync(cwd, readFileSync) {
+        cwd ??= process.cwd();
+        return this.content = readFileSync(join(cwd, this.sourcePath));
+    }
+}

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

@@ -0,0 +1,90 @@
+import { FileInfo } from "../index.js";
+import { ChalkInstance } from "chalk";
+import { Options } from "boxen";
+export interface FormatFilesOptions {
+    /**
+     * @default false
+     */
+    showSources?: boolean;
+    /**
+     * @default "paths"
+     */
+    style: StyleName;
+    /**
+     * @default "paths"
+     */
+    decor?: DecorName;
+    chalk: ChalkInstance;
+}
+/**
+ * @returns Prints a readable file list. Here is '\n' ending.
+ */
+export declare function formatFiles(files: FileInfo[], options: FormatFilesOptions): string;
+/**
+ * Contains all style names.
+ */
+export declare const styleNameList: readonly ["tree", "paths"];
+/**
+ * Contains all style names as a type.
+ */
+export type StyleName = typeof styleNameList[number];
+/**
+ * Checks if the value is the {@link StyleName}.
+ */
+export declare function isStyleName(value: unknown): value is StyleName;
+/**
+ * Contains all decor names.
+ */
+export declare const decorNameList: readonly ["normal", "emoji", "nerdfonts"];
+/**
+ * Contains all decor names as a type.
+ */
+export type DecorName = typeof decorNameList[number];
+/**
+ * Checks if the value is the {@link DecorName}.
+ */
+export declare function isDecorName(value: unknown): value is DecorName;
+/**
+ * Formatting options for the {@link decorCondition}.
+ */
+export interface DecorConditionOptions {
+    /**
+     * @default ""
+     */
+    prefix?: string;
+    /**
+     * @default ""
+     */
+    postfix?: string;
+    /**
+     * If the decor is not an emoji or nerd use this string.
+     * @default ""
+     */
+    ifNormal?: string;
+    /**
+     * If style name (lowercase) contains `emoji` use this string.
+     * @default ""
+     */
+    ifEmoji?: string;
+    /**
+     * If style name (lowercase) contains `nerd` use this string.
+     * @default ""
+     */
+    ifNerd?: string;
+}
+/**
+ * Formats the string for specific style types.
+ * @param decor The decor name.
+ * @param condition Formatting options.
+ */
+export declare function decorCondition(decor: DecorName, condition: DecorConditionOptions): string;
+export interface BoxOptions extends Options {
+    noColor?: boolean;
+}
+export declare function boxError(message: string, options?: BoxOptions): string;
+/**
+ * Returns file icon for the file name & extension.
+ * @param decor The decor name.
+ * @param filePath The full file path.
+ */
+export declare function decorFile(decor: DecorName | undefined, filePath: string): string;