view-ignored 0.2.2 → 0.3.0

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

@@ -1,99 +1,81 @@
-/// <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";
+import * as PATH from 'node:path';
+import * as FS from 'node:fs';
+import { Directory, File, FileInfo, type DeepStreamEventEmitter, type SourceInfo } from './fs/index.js';
+import { type FilterName } from './filtering.js';
+export * from './errors.js';
+export * from './fs/index.js';
+export * as Filtering from './filtering.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"];
+ * ViewIgnored's package.json.
+ * @public
+*/
+export declare const package_: typeof import("../../package.json");
 /**
- * Contains all filter names as a type.
+ * Uses `node:fs` and `node:fs/promises` by default.
+ * @public
  */
-export type FilterName = typeof filterNameList[number];
+export type FileSystemAdapter = {
+    readFileSync?: typeof FS.readFileSync;
+    readdirSync?: typeof FS.readdirSync;
+    promises?: {
+        readdir(path: string, options: {
+            withFileTypes: true;
+        }): Promise<FS.Dirent[]>;
+        stat(path: string): Promise<FS.Stats>;
+    };
+};
 /**
- * Checks if the value is the {@link FilterName}.
+ * The custom scanner.
+ * @public
  */
-export declare function isFilterName(value: unknown): value is FilterName;
+export type Scanner = {
+    /**
+     * @returns `true`, if the given path is ignored.
+     */
+    ignores(path: string): boolean;
+};
 /**
- * Uses `readFileSync` and `readFile`.
- * @extends glob.FileSystemAdapter
+ * Recursively creates a cache scanner for each file.
+ * @throws If the target does not allow the current ignore configurations: {@link ViewIgnoredError}.
+ * For example, {@link https://www.npmjs.com/package/@vscode/vsce vsce} considers it invalid if your manifest is missing the 'engines' field.
+ * Similarly, npm will raise an error if you attempt to publish a package without a basic 'package.json'.
+ * @public
  */
-export interface FileSystemAdapter extends FSOption {
-    readFileSync?: typeof FS.readFileSync;
-    readdirSync?: typeof FS.readdirSync;
-    statSync?: typeof FS.statSync;
-}
+export type Methodology = (tree: Directory, realOptions: RealScanOptions) => Map<File, SourceInfo>;
 /**
- * Also can write rules to the {@link Scanner}.
- * @returns `true`, if the given source is valid.
+ * Options with defaults and additional properties.
+ * @public
  */
-export type ScanMethod = (sourceInfo: SourceInfo) => boolean;
+export type RealScanOptions = Required<Omit<ScanOptions, 'fsa'>> & {
+    modules: {
+        /**
+         * File system adapter.
+         */
+        fs: Required<FileSystemAdapter>;
+        /**
+         * Path module adapter.
+         */
+        path: PATH.PlatformPath;
+    };
+};
 /**
- * Represents the methodology for reading the target's source.
+ * Folder deep scanning options.
+ * @public
  */
-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[];
+export type ScanOptions = {
     /**
-     * First valid source will be used as {@link Scanner}.
+     * The target or the scan methodology.
+     * @default "git"
      */
-    pattern: SourceInfo[] | string[] | SourceInfo | string;
+    target?: string | Methodology;
     /**
-     * Scanner function. Should return `true`, if the given source is valid and also add patterns to the {@link FileInfo.scanner}.
+     * The max concurrency for file-system operations.
+     * @default 8
      */
-    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 {
+    concurrency?: number;
     /**
      * Custom implementation of methods for working with the file system.
      * @default import * as FS from "fs"
@@ -104,38 +86,57 @@ export interface ScanFileOptions {
      * @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 {
+    /**
+     * 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;
     /**
      * Filter output.
      * @default "included"
      */
     filter?: FilterName | ((fileInfo: FileInfo) => boolean);
-}
+};
+/**
+ * Gets info about the each file: it is ignored or not.
+ * @param directoryPath The relative path to the directory.
+ * @throws If no valid sources: {@link ErrorNoSources}.
+ * @public
+ */
+export declare function scan(directoryPath: string, options?: ScanOptions): Promise<FileInfo[]>;
+/**
+ * Gets info about the each file: it is ignored or not.
+ * @param directory The current working directory.
+ * @throws If no valid sources: {@link ErrorNoSources}.
+ * @public
+ */
+export declare function scan(directory: Directory, options?: ScanOptions): Promise<FileInfo[]>;
+/**
+ * Gets info about the each file: it is ignored or not.
+ * @param stream The stream of the current working directory reading.
+ * @throws If no valid sources: {@link ErrorNoSources}.
+ * @public
+ */
+export declare function scan(stream: DeepStreamEventEmitter, options?: ScanOptions): Promise<FileInfo[]>;
 /**
- * Gets info about the file: it is ignored or not.
- * @throws {ErrorNoSources} if the source is bad.
+ * Gets info about the each file: it is ignored or not.
+ * @param pathList The list of relative paths. The should be relative to the current working directory.
+ * @throws If no valid sources: {@link ErrorNoSources}.
+ * @public
  */
-export declare function scanFile(filePath: string, sources: Methodology[], options: ScanFileOptions): Promise<FileInfo>;
+export declare function scan(pathList: string[], options?: ScanOptions): Promise<FileInfo[]>;
 /**
- * Scans project's directory paths to determine whether they are being ignored.
- * @throws {ErrorNoSources} if the source is bad.
+ * @returns Options with defaults and additional properties.
+ * @public
  */
-export declare function scanProject(sources: Methodology[], options: ScanFolderOptions): Promise<FileInfo[]>;
-export declare function scanProject(target: string, options: ScanFolderOptions): Promise<FileInfo[]>;
+export declare function makeOptionsReal(options?: ScanOptions): RealScanOptions;

package/out/src/browser/lib.js

@@ -1,126 +1,92 @@
-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";
+import * as PATH from 'node:path';
+import process from 'node:process';
+import * as FS from 'node:fs';
+import { createRequire } from 'node:module';
+import EventEmitter from 'node:events';
+import pLimit from 'p-limit';
+import { configDefault } from '../config.js';
+import { Directory, File, FileInfo, } from './fs/index.js';
+import { targetGet } from './binds/index.js';
+import { TargetNotBoundError } from './errors.js';
+export * from './errors.js';
+export * from './fs/index.js';
+export * as Filtering from './filtering.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);
+ * ViewIgnored's package.json.
+ * @public
+*/
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+export const package_ = createRequire(import.meta.url)('../../package.json');
+export async function scan(argument0, options) {
+    options ??= {};
+    const optionsReal = makeOptionsReal(options);
+    if (typeof optionsReal.target === 'string') {
+        const bind = targetGet(optionsReal.target);
         if (bind === undefined) {
-            throw new ErrorTargetNotBound(arg1);
+            throw new TargetNotBoundError(optionsReal.target);
         }
-        return scanProject(bind.methodology, Object.assign(options, bind.scanOptions));
+        return scan(argument0, Object.assign(options, bind.scanOptions));
     }
-    const allFilePaths = await glob("**", {
-        ...options,
-        nodir: true,
-        dot: true,
-        posix: true,
-    });
-    // 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 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);
-                    }
-                }
+    if (typeof argument0 === 'string') {
+        const stream = Directory.deepStream(argument0, optionsReal);
+        const result = scan(stream, options);
+        stream.run();
+        return result;
+    }
+    if (Array.isArray(argument0)) {
+        const tree = Directory.from(argument0, optionsReal.cwd);
+        return scan(tree, options);
+    }
+    if (argument0 instanceof EventEmitter) {
+        const { tree } = await argument0.endPromise;
+        return scan(tree, options);
+    }
+    const tree = argument0;
+    const cache = optionsReal.target(tree, optionsReal);
+    const fileInfoList = [];
+    const promiseList = [];
+    const cacheDirectories = new Map();
+    for (const directory of [tree].concat(tree.deep(Directory))) {
+        cacheDirectories.set(directory, pLimit(optionsReal.concurrency));
+    }
+    for (const entry of tree.deepIterator(File)) {
+        const limit = cacheDirectories.get(entry.parent);
+        promiseList.push(limit(async () => {
+            const sourceInfo = cache.get(entry);
+            const fileInfo = FileInfo.from(entry, sourceInfo);
+            const ignored = !fileInfo.isIncludedBy(optionsReal.filter);
+            if (ignored) {
+                return;
             }
-        } // forend
-        if (noSource) {
-            continue;
-        }
-        return resultList;
-    } // forend
-    throw new ErrorNoSources(arg1);
+            fileInfoList.push(fileInfo);
+        }));
+    }
+    await Promise.all(promiseList);
+    return fileInfoList;
+}
+/**
+ * @returns Options with defaults and additional properties.
+ * @public
+ */
+export function makeOptionsReal(options) {
+    options ??= {};
+    const posix = options.posix ?? false;
+    const concurrency = options.concurrency ?? configDefault.concurrency;
+    const optionsReal = {
+        concurrency,
+        target: options.target ?? 'git',
+        cwd: options.cwd ?? process.cwd(),
+        filter: options.filter ?? configDefault.filter,
+        modules: {
+            fs: (options.fsa ?? FS),
+            path: posix ? PATH.posix : PATH,
+        },
+        maxDepth: options.maxDepth ?? configDefault.depth,
+        posix,
+    };
+    return optionsReal;
 }
-//#endregion
+// #endregion

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

@@ -1,41 +1,61 @@
 /**
  * Contains all file sort names.
+ * @public
  */
 export declare const sortNameList: readonly ["firstFolders", "firstFiles", "type", "mixed", "modified"];
 /**
  * Contains all file sort names as a type.
+ * @public
  */
 export type SortName = typeof sortNameList[number];
 /**
  * {@link Array.prototype.sort}'s file path comparator.
+ * @public
  */
-export type SortFunc = (a: string, b: string) => number;
+export type SortFunction = (a: string, b: string) => number;
 /**
  * Checks if the value is the {@link SortName}.
+ * @public
  */
 export declare function isSortName(value: unknown): value is SortName;
+/**
+ * @public
+ * @example
+ * "path/to/the/file" -> ["path", "to/the/file", false]
+ * "file" -> ["file", "file", true]
+ * "file/" -> ["file", "", false]
+ */
+export declare function shiftPath(p: string): [next: string, other: string, isLast: boolean];
 /**
  * Files and folders are sorted by their names.
  * Folders are displayed before files.
+ * @public
  */
 export declare function firstFolders(a: string, b: string): number;
 /**
  * Files and folders are sorted by their names.
  * Files are displayed before folders.
+ * @public
  */
 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.
+ * @see {@link makeMtimeCache}
+ * @public
  */
-export declare function modified(a: string, b: string, map: Map<string, number>): number;
+export declare function modified(a: string, b: string, map: Map<{
+    toString(): string;
+}, number>): number;
 /**
  * Files and folders are grouped by extension type then sorted by thir names.
  * Folders are displayed before files.
+ * @public
  */
 export declare function type(a: string, b: string): number;
 /**
  * Files and folders are sorted by their names.
  * Files are interwoven with folders.
+ * @public
  */
 export declare function mixed(a: string, b: string): number;