view-ignored 0.10.1 → 0.11.1

package/out/targets/yarnClassic.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJsonNocase, extractGitignoreNocase, } from "../patterns/index.js";
 import { unixify } from "../unixify.js";
 import { npmManifestParse } from "./npmManifest.js";
@@ -22,6 +21,7 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L26
@@ -53,9 +53,9 @@ const internal = [
             ".gitignore",
             ".DS_Store",
         ],
-        compiled: null,
     }, { nocase: true }),
     ruleCompile({
+        compiled: null,
         excludes: false,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L10
@@ -67,29 +67,31 @@ const internal = [
             "/changelog*",
             "/history*",
         ],
-        compiled: null,
     }, { nocase: true }),
 ];
 /**
  * @since 0.8.0
  */
 export const YarnClassic = {
-    internalRules: internal,
     extractors,
-    root: ".",
-    async init({ fs, cwd }) {
-        let content;
+    ignores: ruleTest,
+    init({ fs, cwd }, cb) {
         const normalCwd = unixify(cwd);
-        try {
-            content = await fs.promises.readFile(normalCwd + "/" + "package.json");
-        }
-        catch (error) {
-            throw new Error("Error while initializing Yarn classic", { cause: error });
-        }
-        const dist = npmManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid 'package.json': " + dist.summary, { cause: dist });
-        }
+        fs.readFile(normalCwd + "/package.json", (err, content) => {
+            if (err) {
+                cb(new Error("Error while initializing Yarn classic", { cause: err }));
+                return;
+            }
+            try {
+                npmManifestParse(content.toString());
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/types.d.ts

@@ -6,10 +6,11 @@ import type { Target } from "./targets/target.js";
  * @since 0.6.0
  */
 export interface FsAdapter {
-    promises: {
-        opendir: typeof fs.promises.opendir;
-        readFile: typeof fs.promises.readFile;
-    };
+    /**
+     * `readdir` is better than `opendir`.
+     */
+    readdir: typeof fs.readdir;
+    readFile: typeof fs.readFile;
 }
 /**
  * Used in multiple methods, primarily `scan`, `scanStream`, and their browser versions.
@@ -76,10 +77,10 @@ export type ScanOptions = {
      * {@link MatcherContext.totalDirs},
      * {@link MatcherContext.totalFiles},
      * {@link MatcherContext.totalMatchedFiles}
-     * and {@link MatcherContext.depthPaths}.
+     * and {@link MatcherContext.depthPaths} numbers.
      *
      * It's recommended to use this option unless you
-     * need precise statistics
+     * care about these stats.
      *
      * @default `false`
      *
@@ -97,7 +98,7 @@ export type ScanOptions = {
      * and {@link MatcherContext.depthPaths}.
      *
      * It's recommended to use this option unless the target
-     * allows overriding internal patterns.
+     * allows overriding internal patterns and you don't care about these stats.
      * This option should never affect {@link MatcherContext.totalMatchedFiles}.
      *
      * @default `false`

package/out/unixify.d.ts

@@ -1,4 +1,4 @@
 export declare function unixify(path: string): string;
 export declare function join(from: string, p2: string): string;
 export declare function relative(base: string, to: string): string;
-export declare function base(path: string): string;
+export declare function dirname(path: string): string;

package/out/unixify.js

@@ -1,38 +1,57 @@
 const strippedCwd = strip(process.cwd());
 export function unixify(path) {
-    let result = strip(path);
-    if (result.startsWith("./")) {
-        result = strippedCwd + result.substring(1);
+    const result = strip(path);
+    const c0 = result.charCodeAt(0);
+    if (c0 === 46 && result.charCodeAt(1) === 47) {
+        // "./"
+        return strippedCwd + result.substring(1);
     }
-    else if (!result.startsWith("/")) {
-        result = strippedCwd + "/" + result;
+    if (c0 !== 47 && c0 !== 92) {
+        // not starts with "/" or "\"
+        return strippedCwd + "/" + result;
     }
     return result;
 }
 export function join(from, p2) {
-    if (p2 === "." || p2 === "./") {
+    if (p2 === "." || p2 === "./")
         return from;
+    const p2startsDotSlash = p2.charCodeAt(0) === 46 && p2.charCodeAt(1) === 47;
+    const start = p2startsDotSlash ? 2 : 0;
+    let res = from;
+    if (from.charCodeAt(0) === 46 && from.charCodeAt(1) === 47) {
+        res = from.substring(2);
     }
-    let start = 0;
-    if (p2.startsWith("./")) {
-        start = 2;
+    const resLen = res.length;
+    if (resLen > 0 && res.charCodeAt(resLen - 1) !== 47) {
+        res += "/";
     }
-    if (!from.endsWith("/")) {
-        from += "/";
-    }
-    from += p2.substring(start);
-    return from;
+    return res + p2.substring(start);
 }
 export function relative(base, to) {
-    if (!base.endsWith("/")) {
+    const blen = base.length;
+    if (blen > 0 && base.charCodeAt(blen - 1) !== 47) {
         base += "/";
     }
-    const result = to.replace(base, "");
-    return result;
-}
-export function base(path) {
-    return path.substring(path.lastIndexOf("/") + 1);
+    return to.replace(base, "");
 }
 function strip(path) {
-    return path.replaceAll("\\", "/").replace(/^[a-zA-Z]:/, "");
+    let res = path.indexOf("\\") === -1 ? path : path.replaceAll("\\", "/");
+    if (res.length > 1 && res.charCodeAt(1) === 58) {
+        // X:
+        res = res.substring(2);
+    }
+    return res;
+}
+export function dirname(path) {
+    if (path === "/" || path === ".")
+        return path;
+    const len = path.length;
+    const lastIdx = len - 1;
+    const endsWithSlash = path.charCodeAt(lastIdx) === 47;
+    const lastSlash = path.lastIndexOf("/", endsWithSlash ? lastIdx - 1 : lastIdx);
+    if (lastSlash === -1)
+        return ".";
+    if (lastSlash === 0)
+        return "/";
+    return path.substring(0, lastSlash);
 }

package/out/walk.d.ts

@@ -1,13 +1,51 @@
 import type { Dirent } from "node:fs";
-import type { MatcherContext } from "./patterns/matcherContext.js";
+import type { MatcherContext, Total } from "./patterns/matcherContext.js";
 import type { MatcherStream } from "./patterns/matcherStream.js";
+import type { Resource } from "./patterns/resource.js";
 import type { ScanOptions } from "./types.js";
+import { type RuleMatch } from "./patterns/rule.js";
 export type WalkOptions = {
-    path: string;
+    relPath: string;
+    lowerRelPath?: string;
     parentPath: string;
     entry: Dirent;
-    ctx: MatcherContext;
+    resource: Resource;
     stream: MatcherStream | undefined;
     scanOptions: Required<ScanOptions>;
+    depth: number;
+};
+export type WalkResult = {
+    path: string;
+    parentPath: string;
+    match: RuleMatch;
+    includeParent: boolean;
+    tooDeep: boolean;
+    next: 0 | 1;
+    depth: number;
+    isDir: boolean;
+};
+export type WalkTotal = {
+    type?: "total";
+    dir: string;
+    files: number;
+    matched: number;
+    dirs: number;
+    depth: number;
+    ignored: boolean;
 };
-export declare function walkIncludes(options: WalkOptions): Promise<0 | 1 | 2>;
+/**
+ * @since 0.11.0
+ */
+export declare function walkIncludes(options: WalkOptions, cb: (err: Error | null, result: WalkResult) => void): void;
+/**
+ * Patches the {@link MatcherContext} with the given result.
+ */
+export declare function walkPatchResult(ctx: MatcherContext, r: WalkResult): void;
+/**
+ * Patches the {@link MatcherContext} with the given total.
+ */
+export declare function walkPatchTotal(ctx: MatcherContext, maxDepth: number, t: WalkTotal): void;
+/**
+ * Propagates totals from child directories to their parents.
+ */
+export declare function propagateTotals(total: Map<string, Total>): void;

package/out/walk.js

@@ -1,112 +1,166 @@
-import { getDepth } from "./getDepth.js";
-export async function walkIncludes(options) {
-    const { entry, ctx, stream, scanOptions, path, parentPath } = options;
-    const { fs, target, cwd, depth: maxDepth, invert, signal, fastDepth, fastInternal } = scanOptions;
-    signal?.throwIfAborted();
+import { isRuleMatchInvalid } from "./patterns/rule.js";
+/**
+ * @since 0.11.0
+ */
+export function walkIncludes(options, cb) {
+    const { entry, stream, scanOptions, relPath: path, lowerRelPath, parentPath, resource, depth, } = options;
+    const { target, depth: maxDepth, invert, fastDepth, fastInternal, fs, cwd, signal } = scanOptions;
     const isDir = entry.isDirectory();
-    let direntPath;
-    if (isDir) {
-        direntPath = path + "/";
-        ctx.totalDirs++;
-    }
-    else {
-        direntPath = path;
-        ctx.totalFiles++;
-    }
-    if (fastDepth) {
-        const { depth, depthSlash } = getDepth(path, maxDepth);
-        if (depth > maxDepth) {
-            const failedPrev = ctx.failed.length;
-            let match = await target.ignores({ fs, cwd, entry: path, ctx, signal, target, parentPath });
-            if (invert) {
+    const direntPath = isDir ? path + "/" : path;
+    const lowerEntry = lowerRelPath || path.toLowerCase();
+    const testOptions = {
+        cwd,
+        entry: path,
+        fs,
+        lowerEntry,
+        parentPath,
+        resource,
+        signal,
+        target,
+    };
+    if (fastDepth && depth > maxDepth) {
+        return target.ignores(testOptions, (err, match) => {
+            if (err)
+                return cb(err, null);
+            if (invert)
                 match.ignored = !match.ignored;
-            }
-            if (failedPrev < ctx.failed.length) {
+            const result = {
+                depth,
+                includeParent: false,
+                isDir,
+                match,
+                next: 0,
+                parentPath,
+                path: direntPath,
+                tooDeep: true,
+            };
+            if (isRuleMatchInvalid(match)) {
                 if (stream) {
-                    stream.emit("dirent", { dirent: entry, match, path: direntPath, ctx });
+                    stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
                 }
-                return 2;
+                return cb(null, result);
             }
             if (match.ignored) {
-                if (isDir && fastInternal && match.kind === "internal") {
-                    return 1;
-                }
-                return 0;
+                if (stream)
+                    stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
+                if (isDir && fastInternal)
+                    result.next = 1;
+                return cb(null, result);
+            }
+            result.next = isDir ? 0 : 1;
+            cb(null, result);
+        });
+    }
+    target.ignores(testOptions, (err, match) => {
+        if (err)
+            return cb(err, null);
+        if (invert)
+            match.ignored = !match.ignored;
+        const result = {
+            depth,
+            includeParent: false,
+            isDir,
+            match,
+            next: 0,
+            parentPath,
+            path: direntPath,
+            tooDeep: false,
+        };
+        if (isRuleMatchInvalid(match)) {
+            if (stream)
+                stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
+            return cb(null, result);
+        }
+        if (match.ignored) {
+            if (stream)
+                stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
+            if (isDir && fastInternal)
+                result.next = 1;
+            return cb(null, result);
+        }
+        if (isDir) {
+            if (depth <= maxDepth) {
+                if (stream)
+                    stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
             }
-            if (isDir) {
-                // ctx.totalMatchedDirs++;
-                // ctx.depthPaths.set(path, (ctx.depthPaths.get(path) ?? 0) + 1);
-                return 0;
+            else {
+                result.tooDeep = true;
             }
-            ctx.totalMatchedFiles++;
-            const dir = path.substring(0, depthSlash);
-            ctx.depthPaths.set(dir, (ctx.depthPaths.get(dir) ?? 0) + 1);
-            return 1;
+            return cb(null, result);
         }
-    }
-    const failedPrev = ctx.failed.length;
-    let match = await target.ignores({
-        fs,
-        cwd,
-        entry: path,
-        ctx,
-        signal,
-        target,
-        parentPath: parentPath,
-    });
-    if (invert) {
-        match.ignored = !match.ignored;
-    }
-    if (failedPrev < ctx.failed.length) {
-        if (stream) {
-            stream.emit("dirent", { dirent: entry, match, path: direntPath, ctx });
+        if (depth > maxDepth) {
+            result.tooDeep = true;
+            return cb(null, result);
         }
-        return 2;
-    }
-    if (match.ignored) {
+        const lastSlash = path.lastIndexOf("/");
+        if (lastSlash >= 0)
+            result.includeParent = true;
         if (stream) {
-            stream.emit("dirent", { dirent: entry, match, path: direntPath, ctx });
+            if (result.includeParent)
+                stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: parentPath + "/" } }));
+            stream.dispatchEvent(new CustomEvent("dirent", { detail: { dirent: entry, match, path: direntPath } }));
         }
-        if (isDir && fastInternal && match.kind === "internal") {
-            return 1;
-        }
-        return 0;
-    }
+        cb(null, result);
+    });
+}
+/**
+ * Patches the {@link MatcherContext} with the given result.
+ */
+export function walkPatchResult(ctx, r) {
+    const { path, parentPath, match, isDir, tooDeep, includeParent } = r;
     if (isDir) {
-        // ctx.totalMatchedDirs++;
-        // ctx.depthPaths.set(path, (ctx.depthPaths.get(path) ?? 0) + 1);
-        const { depth } = getDepth(path, maxDepth);
-        if (depth <= maxDepth) {
-            ctx.paths.set(direntPath, match);
-            if (stream) {
-                stream.emit("dirent", { dirent: entry, match, path: direntPath, ctx });
-            }
+        if (!match.ignored && !tooDeep)
+            ctx.paths.set(path, match);
+    }
+    else {
+        if (!match.ignored) {
+            if (!tooDeep)
+                ctx.paths.set(path, match);
         }
-        return 0;
     }
-    ctx.totalMatchedFiles++;
-    const { depth, depthSlash } = getDepth(path, maxDepth);
-    if (depth > maxDepth) {
-        const dir = path.substring(0, depthSlash);
-        ctx.depthPaths.set(dir, (ctx.depthPaths.get(dir) ?? 0) + 1);
-        return 0;
+    if (includeParent && !match.ignored)
+        if (!ctx.paths.has(parentPath + "/"))
+            ctx.paths.set(parentPath + "/", match);
+}
+/**
+ * Patches the {@link MatcherContext} with the given total.
+ */
+export function walkPatchTotal(ctx, maxDepth, t) {
+    const { dir, files, matched, dirs, ignored } = t;
+    const dirTotal = ctx.total.get(dir);
+    if (dirTotal) {
+        dirTotal.totalFiles += files;
+        dirTotal.totalDirs += dirs;
+        dirTotal.totalMatchedFiles += matched;
     }
-    if (depth <= maxDepth) {
-        const lastSlash = path.lastIndexOf("/");
-        if (lastSlash >= 0) {
-            const dir = path.substring(0, lastSlash) + "/";
-            const dirMatch = ctx.paths.get(dir);
-            if (dirMatch === undefined || dirMatch.ignored) {
-                ctx.paths.set(dir, match);
-                if (stream) {
-                    stream.emit("dirent", { dirent: entry, match, path: dir, ctx });
-                }
-            }
+    else if (t.depth <= maxDepth && !ignored) {
+        ctx.total.set(dir, { totalDirs: dirs, totalFiles: files, totalMatchedFiles: matched });
+    }
+}
+/**
+ * Propagates totals from child directories to their parents.
+ */
+export function propagateTotals(total) {
+    const dirs = Array.from(total.keys()).sort((a, b) => b.length - a.length);
+    for (let i = 0, len = dirs.length; i < len; i++) {
+        const dir = dirs[i];
+        if (dir === "." || dir === "/")
+            continue;
+        const dirTotal = total.get(dir);
+        const lastSlash = dir.lastIndexOf("/");
+        const parent = lastSlash === -1 ? "." : dir.slice(0, lastSlash) || "/";
+        const parentTotal = total.get(parent);
+        if (parentTotal) {
+            parentTotal.totalFiles += dirTotal.totalFiles;
+            parentTotal.totalDirs += dirTotal.totalDirs;
+            parentTotal.totalMatchedFiles += dirTotal.totalMatchedFiles;
         }
-        ctx.paths.set(path, match);
-        if (stream) {
-            stream.emit("dirent", { dirent: entry, match, path: direntPath, ctx });
+        else {
+            total.set(parent, {
+                totalDirs: dirTotal.totalDirs,
+                totalFiles: dirTotal.totalFiles,
+                totalMatchedFiles: dirTotal.totalMatchedFiles,
+            });
         }
     }
-    return 0;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "view-ignored",
-	"version": "0.10.1",
-	"description": "Retrieve list of files ignored/included by Git, NPM, Yarn, JSR, VSCE or other tools.",
+	"version": "0.11.1",
+	"description": "Retrieve list of files ignored/included by Git, NPM, Yarn, JSR, Deno, Bun, VSCode extension CLI and other tools.",
 	"keywords": [
 		".gitignore",
 		".npmignore",
@@ -76,10 +76,13 @@
 		"access": "public"
 	},
 	"scripts": {
-		"prerelease": "bun run test && bun run prod && bun run lint && bun run fmt --check && bun publint --pack bun --strict",
-		"cpu": "bun run cpu:igw; bun run cpu:me",
-		"cpu:igw": "bun run --expose-gc --cpu-prof --cpu-prof-md --cpu-prof-name CPU.igw scripts/ignoreWalk.js",
-		"cpu:me": "bun run --expose-gc --cpu-prof --cpu-prof-md --cpu-prof-name CPU.me scripts/scan.js --fastInternal",
+		"prerelease": "bun run test && bun run prod && bun run lint && bun run fmt --check && bun run ts-compat && bun publint --pack bun --strict",
+		"heap": "bun scripts/scanHeap.js --snapshot",
+		"heap:node": "node scripts/scanHeap.js --snapshot",
+		"cpu": "bun run --expose-gc --cpu-prof --cpu-prof-md --cpu-prof-name CPU.me scripts/scan.js --fastInternal",
+		"cpu:node": "node --expose-gc --cpu-prof --cpu-prof-name CPU.me.node.cpuprofile scripts/scan.js --fastInternal",
+		"bench": "bun run --expose-gc benchmarks/git.js && bun run --expose-gc benchmarks/npm.js",
+		"bench:node": "node --expose-gc benchmarks/git.js && node --expose-gc benchmarks/npm.js",
 		"test": "bun test src",
 		"test:patterns": "bun test src/patterns",
 		"test:targets": "bun test src/targets",
@@ -89,34 +92,46 @@
 		"test:self:npm": "bun test src/testSelfNPM.test.ts",
 		"lint": "bun run oxlint --type-aware",
 		"fmt": "bun run oxfmt",
-		"check": "bun tsgo -p . --noEmit",
-		"prod": "rm -rf out && tsgo -p tsconfig.prod.json",
-		"release:major": "bun run release-it --increment=major",
-		"release:minor": "bun run release-it --increment=minor",
-		"release:patch": "bun run release-it --increment=patch"
+		"check": "bun tsgo -p src --noEmit",
+		"dev": "bun tsgo -p src",
+		"prod": "rm -rf out && bun tsgo -p src/tsconfig.prod.json",
+		"node-compat": "bun node-compat-22 && bun node-compat-24",
+		"ts-compat": "bun run ts-compat-6 && bun run ts-compat-5",
+		"node-compat-24": "bun node_modules/typescript6/bin/tsc -p src/tsconfig.prod24.json --noEmit",
+		"node-compat-22": "bun node_modules/typescript6/bin/tsc -p src/tsconfig.prod22.json --noEmit",
+		"ts-compat-5": "bun node_modules/typescript5/bin/tsc -p src/tsconfig.prod.json --noEmit",
+		"ts-compat-6": "bun node_modules/typescript6/bin/tsc -p src/tsconfig.prod.json --noEmit",
+		"release:major": "bun run --bun release-it --increment=major",
+		"release:minor": "bun run --bun release-it --increment=minor",
+		"release:patch": "bun run --bun release-it --increment=patch"
 	},
 	"dependencies": {
-		"arktype": "^2.1.29",
 		"micromatch": "^4.0.8",
 		"strip-json-comments": "^5.0.3"
 	},
 	"devDependencies": {
-		"@release-it/keep-a-changelog": "^7.0.1",
-		"@types/bun": "^1.3.9",
-		"@types/ignore-walk": "^4.0.3",
-		"@types/micromatch": "^4.0.10",
-		"@types/node": "^18.19.130",
-		"@typescript/native-preview": "^7.0.0-dev.20260223.1",
-		"ignore-walk": "^8.0.0",
-		"memfs": "^4.56.10",
-		"mitata": "^1.0.34",
-		"oxfmt": "^0.35.0",
-		"oxlint": "^1.50.0",
-		"oxlint-tsgolint": "^0.14.2",
-		"publint": "^0.3.17",
-		"release-it": "^19.2.4"
+		"@release-it/keep-a-changelog": "latest",
+		"@types/braces": "*",
+		"@types/bun": "latest",
+		"@types/ignore-walk": "npm:@types/ignore-walk@^4.0.3",
+		"@types/micromatch": "npm:@types/micromatch@^4.0.10",
+		"@types/node": "npm:@types/node@latest",
+		"@types/node-22": "npm:@types/node@22.x",
+		"@types/node-24": "npm:@types/node@24.x",
+		"@typescript/native-preview": "latest",
+		"ignore-walk": "latest",
+		"memfs": "latest",
+		"mitata": "latest",
+		"oxfmt": "latest",
+		"oxlint": "latest",
+		"oxlint-tsgolint": "latest",
+		"publint": "latest",
+		"release-it": "latest",
+		"typescript5": "npm:typescript@5.7.x",
+		"typescript6": "npm:typescript@6.x",
+		"undici-types": "*"
 	},
 	"engines": {
-		"node": ">=18"
+		"node": ">=22"
 	}
 }

package/out/getDepth.d.ts

@@ -1,4 +0,0 @@
-export declare function getDepth(path: string, maxDepth: number): {
-    depth: number;
-    depthSlash: number;
-};

package/out/getDepth.js

@@ -1,21 +0,0 @@
-export function getDepth(path, maxDepth) {
-    if (path.endsWith("/")) {
-        path = path.substring(0, path.length - 1);
-    }
-    const result = {
-        depth: 0,
-        depthSlash: -1,
-    };
-    let i = -1;
-    for (const c of path) {
-        i++;
-        if (c !== "/") {
-            continue;
-        }
-        if (result.depth === maxDepth) {
-            result.depthSlash = i;
-        }
-        result.depth++;
-    }
-    return result;
-}

package/out/opendir.d.ts

@@ -1,3 +0,0 @@
-import type { Dirent } from "node:fs";
-import type { PatternFinderOptions } from "./patterns/extractor.js";
-export declare function opendir(options: PatternFinderOptions, place: string, cb: (dirent: Dirent, parentPath: string, path: string) => Promise<0 | 1 | 2>): Promise<boolean>;