view-ignored 0.2.2 → 0.3.0

package/out/src/browser/fs/directory.js

@@ -0,0 +1,235 @@
+/* eslint-disable unicorn/prefer-event-target */
+import { join, parse, relative, } from 'node:path';
+import EventEmitter from 'node:events';
+import * as FSP from 'node:fs/promises';
+import process from 'node:process';
+import pLimit from 'p-limit';
+import { configDefault } from '../../config.js';
+import { File } from './file.js';
+/**
+ * File system directory representation.
+ * @public
+ */
+export class Directory {
+    parent;
+    relativePath;
+    absolutePath;
+    children;
+    /**
+     * Get the number of directories and files.
+     * @param directoryPath Relative path to the directory.
+     * @param options The counter and reader options.
+     */
+    static async deepCount(directoryPath, options) {
+        const { modules, cwd, concurrency, progress = {
+            current: 0, total: 0, files: 0, directories: 0,
+        }, } = options;
+        const limit = pLimit(concurrency);
+        const readdir = modules.fs.promises.readdir ?? FSP.readdir;
+        const absolutePath = modules.path.join(cwd, String(directoryPath));
+        const entryList = await readdir(absolutePath, { withFileTypes: true });
+        const promises = entryList.map(entry => limit(async () => {
+            ++progress.total;
+            if (entry.isDirectory() && !entry.isSymbolicLink()) {
+                const absolutePath = modules.path.join(entry.parentPath, entry.name);
+                const relativePath = modules.path.relative(cwd, absolutePath);
+                await Directory.deepCount(relativePath, { ...options, progress });
+                ++progress.directories;
+                return;
+            }
+            ++progress.files;
+        }));
+        await Promise.all(promises);
+        return progress;
+    }
+    /**
+     * Read directories and files progressively.
+     * @param directoryPath Relative path to the directory.
+     * @param options The reader options.
+     */
+    static deepStream(directoryPath, optionsReal) {
+        const controller = new EventEmitter();
+        controller.endPromise = new Promise(resolve => {
+            controller.once('end', data => {
+                resolve(data);
+            });
+        });
+        controller.run = async function () {
+            const data = await Directory.deepStreamNested(directoryPath, { ...optionsReal, controller });
+            const { progress, target } = data;
+            const dataRoot = { progress, tree: target };
+            controller.emit('end', dataRoot);
+            return dataRoot;
+        };
+        return controller;
+    }
+    /**
+     * Get the {@link Directory} instance from a file path list. Paths should be relative.
+     */
+    static from(pathList, cwd = process.cwd()) {
+        const tree = new Directory(undefined, '.', cwd, new Map());
+        for (const path of pathList) {
+            const entryNameList = path.toString().split(/[\\/]/);
+            // eslint-disable-next-line unicorn/no-array-reduce
+            entryNameList.reduce((tree, entryName, index) => {
+                const absolutePath = join(tree.absolutePath, entryName);
+                const relativePath = relative(cwd, absolutePath);
+                if (index === entryNameList.length - 1) {
+                    const file = new File(tree, relativePath, absolutePath);
+                    tree.set(file.base, file);
+                    return tree;
+                }
+                let directory = Array.from(tree.children.values()).find(c => c instanceof Directory && c.absolutePath === absolutePath);
+                if (directory === undefined) {
+                    directory = new Directory(tree, relativePath, absolutePath, new Map());
+                    tree.set(`${directory.base}/`, directory);
+                }
+                return directory;
+            }, tree);
+        }
+        return tree;
+    }
+    /**
+     * Get deep iterator for the directory.
+     */
+    static deepIterator = function* (directory, instanceOf) {
+        const subDirectories = [];
+        for (const element of directory.children.values()) {
+            if (instanceOf === undefined || element instanceof instanceOf) {
+                yield element;
+            }
+            if (element instanceof Directory) {
+                subDirectories.push(element);
+            }
+        }
+        for (const subDirectory of subDirectories) {
+            yield* Directory.deepIterator(subDirectory);
+        }
+    };
+    /**
+     * Read directories and files progressively.
+     * @private This function should be wrapped by {@link deepStream}.
+     * @param directoryPath Relative path to the directory.
+     * @param options The reader options.
+     */
+    static async deepStreamNested(directoryPath, options) {
+        const { modules, cwd, concurrency, parent } = options;
+        const controller = options.controller ?? new EventEmitter();
+        const progress = options.progress ?? await Directory.deepCount(directoryPath, options);
+        controller.emit('progress', progress);
+        const limit = pLimit(concurrency);
+        const readdir = modules.fs.promises.readdir ?? FSP.readdir;
+        const absolutePath = modules.path.join(cwd, String(directoryPath));
+        const relativePath = modules.path.relative(cwd, absolutePath);
+        const directory = new Directory(parent, relativePath, absolutePath, new Map());
+        const entryList = await readdir(absolutePath, { withFileTypes: true });
+        const promises = entryList.map(entry => limit(async () => {
+            const parent = directory;
+            const absolutePath = modules.path.join(entry.parentPath, entry.name);
+            const relativePath = modules.path.relative(cwd, absolutePath);
+            if (entry.isDirectory() && !entry.isSymbolicLink()) {
+                const data = await Directory.deepStreamNested(relativePath, {
+                    ...options, controller, progress, parent,
+                });
+                ++progress.current;
+                controller.emit('progress', progress);
+                return data;
+            }
+            const file = new File(parent, relativePath, absolutePath);
+            const data = { target: file, progress };
+            ++progress.current;
+            controller.emit('progress', progress);
+            controller.emit('data', data);
+            return data;
+        }));
+        const dataList = await Promise.all(promises);
+        for (const { target: entry } of dataList) {
+            directory.children.set(`${entry.base}${entry instanceof Directory ? '/' : ''}`, entry);
+        }
+        const data = { target: directory, progress };
+        controller.emit('progress', progress);
+        controller.emit('data', data);
+        return data;
+    }
+    base;
+    dir;
+    ext;
+    name;
+    root;
+    constructor(
+    /**
+     * The parent of the directory.
+     */
+    parent, 
+    /**
+     * The relative path to the directory.
+     */
+    relativePath, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath, 
+    /**
+     * The content of the directory. It is a Map for performance reasons: you can find any file or folder without a loop if you know the name.
+     *
+     * Keys: {@link File.base} or {@link Directory.base}. Directory base ends with '/'.
+     *
+     * Values: {@link File} or {@link Directory} itself.
+     */
+    children) {
+        this.parent = parent;
+        this.relativePath = relativePath;
+        this.absolutePath = absolutePath;
+        this.children = children;
+        const parsed = parse(absolutePath);
+        this.base = parsed.base;
+        this.dir = parsed.dir;
+        this.ext = parsed.ext;
+        this.name = parsed.name;
+        this.root = parsed.root;
+    }
+    /**
+     * @param instanceOf Optionally filter children by type.
+     */
+    deepIterator(instanceOf) {
+        return Directory.deepIterator(this, instanceOf);
+    }
+    /**
+     * @param instanceOf Optionally filter children by type.
+     */
+    deep(instanceOf) {
+        return Array.from(Directory.deepIterator(this, instanceOf));
+    }
+    /**
+     * @returns The relative path to the directory.
+     */
+    toString() {
+        return this.relativePath;
+    }
+    get(key) {
+        return this.children.get(key);
+    }
+    set(key, value) {
+        return this.children.set(key, value);
+    }
+    /**
+     * @returns The cache for each file of the directory with last time edited number.
+     * @see {@link modified}.
+     */
+    async deepModifiedTime(out, realOptions) {
+        const { concurrency = configDefault.concurrency, modules } = realOptions;
+        const limit = pLimit(concurrency);
+        const promiseList = [];
+        for (const entry of this.deepIterator()) {
+            if (entry instanceof Directory) {
+                continue;
+            }
+            promiseList.push(limit(async () => {
+                const fileStat = await modules.fs.promises.stat(entry.absolutePath);
+                out.set(entry, fileStat.mtime.getTime());
+            }));
+        }
+        void await Promise.all(promiseList);
+        return out;
+    }
+}

package/out/src/browser/{fileinfo.d.ts → fs/file-info.d.ts}

@@ -1,10 +1,23 @@
-import { ChalkInstance } from "chalk";
-import { DecorName } from "./styling.js";
-import { FilterName, Scanner, SourceInfo } from "./lib.js";
+import { type ChalkInstance } from 'chalk';
+import { type DecorName } from '../styling.js';
+import { type FilterName } from '../filtering.js';
+import { File } from './file.js';
+import { type SourceInfo } from './source-info.js';
+import { type Directory } from './directory.js';
 /**
  * @see {@link FileInfo.prototype.toString}
+ * @public
  */
-export interface FileInfoToStringOptions {
+export type FileInfoToStringOptions = {
+    /**
+     * On posix systems, this has no effect.  But, on Windows, it means that
+     * paths will be `/` delimited, and absolute paths will be their full
+     * resolved UNC forms, eg instead of `'C:\\foo\\bar'`, it would return
+     * `'//?/C:/foo/bar'`
+     * @default false
+     * @returns `/` delimited paths, even on Windows.
+     */
+    posix?: boolean;
     /**
      * The appearance behavior of the file icon.
      * @default undefined
@@ -31,44 +44,42 @@ export interface FileInfoToStringOptions {
      * @default true
      */
     entire?: boolean;
-}
+};
+/**
+ * @public
+ */
+export type FileInfoStatus = 'ignored' | 'included' | 'non-target';
 /**
  * The result of the file path scan.
+ * @public
  */
-export declare class FileInfo {
-    /**
-     * Relative path to the file.
-    */
-    readonly filePath: string;
-    /**
-     * Source of patterns, used by {@link scanner}.
-     */
-    readonly source: SourceInfo;
+export declare class FileInfo extends File {
     /**
-     * The pattern parser.
+     * The source of patterns.
      */
-    readonly scanner: Scanner;
-    constructor(
+    readonly source?: SourceInfo | undefined;
+    static from(file: File, source?: SourceInfo): FileInfo;
     /**
-     * Relative path to the file.
+     * Determines if ignored file is ignored or not.
     */
-    filePath: string, 
+    readonly status: FileInfoStatus;
+    constructor(
     /**
-     * Source of patterns, used by {@link scanner}.
+     * The parent of the file.
      */
-    source: SourceInfo);
+    parent: Directory, 
     /**
-     * Determines if ignored file is ignored or not.
+     * The relative path to the file.
      */
-    isIgnored(): boolean;
+    relativePath: string, 
     /**
-     * Creates new {@link FileInfo} from each file path.
+     * The absolute path to the file.
      */
-    static from(filePathList: string[], sourceInfo: SourceInfo): FileInfo[];
+    absolutePath: string, 
     /**
-     * Creates new {@link FileInfo} from the file path.
+     * The source of patterns.
      */
-    static from(filePath: string, sourceInfo: SourceInfo): FileInfo;
+    source?: SourceInfo | undefined);
     /**
      * @param options Styling options.
      * @returns Relative file path. Optionally formatted.

package/out/src/browser/fs/file-info.js

@@ -0,0 +1,86 @@
+import PATH from 'node:path';
+import nf from '@m234/nerd-fonts';
+import { decorCondition } from '../styling.js';
+import { File } from './file.js';
+/**
+ * The result of the file path scan.
+ * @public
+ */
+export class FileInfo extends File {
+    source;
+    static from(file, source) {
+        return new FileInfo(file.parent, file.relativePath, file.absolutePath, source);
+    }
+    /**
+     * Determines if ignored file is ignored or not.
+    */
+    status;
+    constructor(
+    /**
+     * The parent of the file.
+     */
+    parent, 
+    /**
+     * The relative path to the file.
+     */
+    relativePath, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath, 
+    /**
+     * The source of patterns.
+     */
+    source) {
+        super(parent, relativePath, absolutePath);
+        this.source = source;
+        this.status = source === undefined ? 'non-target'
+            : (source.scanner.ignores(relativePath) ? 'ignored' : 'included');
+    }
+    /**
+     * @param options Styling options.
+     * @returns Relative file path. Optionally formatted.
+     */
+    toString(options) {
+        const { fileIcon, chalk, usePrefix = false, source: useSource = false, entire = true, posix = false } = options ?? {};
+        const patha = posix ? PATH.posix : PATH;
+        const parsed = PATH.parse(this.relativePath);
+        const glyph = nf.FSC.fromPath(parsed, nf.FSC.mappings.seti);
+        const fIcon = fileIcon ? decorCondition(fileIcon, {
+            ifEmoji: '📄',
+            ifNerd: chalk && glyph.color !== undefined ? chalk.hex(glyph.color.toString(16))(glyph.char) : glyph.char,
+            postfix: ' ',
+        }) : '';
+        let prefix = usePrefix && this.status !== 'non-target' ? (this.status === 'ignored' ? '!' : '+') : '';
+        let postfix = useSource && this.source !== undefined ? ' < ' + this.source.toString() : '';
+        if (chalk) {
+            prefix = chalk.dim(prefix);
+            postfix = chalk.dim(postfix);
+            const clr = this.status === 'non-target' ? chalk.white
+                : (this.status === 'included' ? chalk.green : chalk.white);
+            if (entire) {
+                return fIcon + clr(prefix + this.relativePath + postfix);
+            }
+            return parsed.dir + patha.sep + fIcon + clr(prefix + parsed.base + postfix);
+        }
+        if (entire) {
+            return prefix + this.relativePath + postfix;
+        }
+        return parsed.dir + patha.sep + 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.status === 'ignored';
+        const filterInclude = (filter === 'included') && this.status === 'included';
+        const filterAll = filter === 'all';
+        const result = filterIgnore || filterInclude || filterAll;
+        return result;
+    }
+}

package/out/src/browser/fs/file.d.ts

@@ -0,0 +1,41 @@
+import { type ParsedPath } from 'node:path';
+import { type Directory } from './directory.js';
+/**
+ * @public
+ */
+export declare class File implements ParsedPath {
+    /**
+     * The parent of the file.
+     */
+    readonly parent: Directory;
+    /**
+     * The relative path to the file.
+     */
+    readonly relativePath: string;
+    /**
+     * The absolute path to the file.
+     */
+    readonly absolutePath: string;
+    readonly base: string;
+    readonly dir: string;
+    readonly ext: string;
+    readonly name: string;
+    readonly root: string;
+    constructor(
+    /**
+     * The parent of the file.
+     */
+    parent: Directory, 
+    /**
+     * The relative path to the file.
+     */
+    relativePath: string, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath: string);
+    /**
+     * @returns The relative path to the file.
+     */
+    toString(): string;
+}

package/out/src/browser/fs/file.js

@@ -0,0 +1,43 @@
+import { parse } from 'node:path';
+/**
+ * @public
+ */
+export class File {
+    parent;
+    relativePath;
+    absolutePath;
+    base;
+    dir;
+    ext;
+    name;
+    root;
+    constructor(
+    /**
+     * The parent of the file.
+     */
+    parent, 
+    /**
+     * The relative path to the file.
+     */
+    relativePath, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath) {
+        this.parent = parent;
+        this.relativePath = relativePath;
+        this.absolutePath = absolutePath;
+        const parsed = parse(absolutePath);
+        this.base = parsed.base;
+        this.dir = parsed.dir;
+        this.ext = parsed.ext;
+        this.name = parsed.name;
+        this.root = parsed.root;
+    }
+    /**
+     * @returns The relative path to the file.
+     */
+    toString() {
+        return this.relativePath;
+    }
+}

package/out/src/browser/fs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './directory.js';
+export * from './file.js';
+export * from './file-info.js';
+export * from './source-info.js';

package/out/src/browser/fs/index.js

@@ -0,0 +1,4 @@
+export * from './directory.js';
+export * from './file.js';
+export * from './file-info.js';
+export * from './source-info.js';

package/out/src/browser/fs/source-info.d.ts

@@ -0,0 +1,29 @@
+import { type Directory, File, type Scanner } from '../lib.js';
+/**
+ * The source of patterns.
+ * @public
+ */
+export declare class SourceInfo extends File {
+    /**
+     * The scanner of patterns.
+     */
+    readonly scanner: Scanner;
+    static from(file: File, scanner: Scanner): SourceInfo;
+    constructor(
+    /**
+     * The parent of the file.
+     */
+    parent: Directory, 
+    /**
+     * The relative path to the file.
+     */
+    relativePath: string, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath: string, 
+    /**
+     * The scanner of patterns.
+     */
+    scanner: Scanner);
+}

package/out/src/browser/fs/source-info.js

@@ -0,0 +1,31 @@
+import { File, } from '../lib.js';
+/**
+ * The source of patterns.
+ * @public
+ */
+export class SourceInfo extends File {
+    scanner;
+    static from(file, scanner) {
+        return new SourceInfo(file.parent, file.relativePath, file.absolutePath, scanner);
+    }
+    constructor(
+    /**
+     * The parent of the file.
+     */
+    parent, 
+    /**
+     * The relative path to the file.
+     */
+    relativePath, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath, 
+    /**
+     * The scanner of patterns.
+     */
+    scanner) {
+        super(parent, relativePath, absolutePath);
+        this.scanner = scanner;
+    }
+}

package/out/src/browser/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/browser/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';