view-ignored 0.10.0 → 0.11.0

package/out/walk.d.ts

@@ -1,12 +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,104 +1,166 @@
-import { getDepth } from "./getDepth.js";
-export async function walkIncludes(options) {
-    const { entry, ctx, stream, scanOptions, path } = 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 });
-            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 });
-    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 (isDir && fastInternal && match.kind === "internal") {
-            return 1;
+            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 } }));
         }
-        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.0",
-	"description": "Retrieve list of files ignored/included by Git, NPM, Yarn, JSR, VSCE or other tools.",
+	"version": "0.11.0",
+	"description": "Retrieve list of files ignored/included by Git, NPM, Yarn, JSR, Deno, Bun, VSCode extension CLI and other tools.",
 	"keywords": [
 		".gitignore",
 		".npmignore",
@@ -77,9 +77,12 @@
 	},
 	"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",
+		"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,31 +92,32 @@
 		"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",
+		"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",
-		"minimatch": "^10.2.2",
+		"micromatch": "^4.0.8",
 		"strip-json-comments": "^5.0.3"
 	},
 	"devDependencies": {
-		"@release-it/keep-a-changelog": "^7.0.1",
-		"@types/bun": "^1.3.9",
+		"@release-it/keep-a-changelog": "latest",
+		"@types/bun": "latest",
 		"@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"
+		"@typescript/native-preview": "latest",
+		"ignore-walk": "latest",
+		"memfs": "latest",
+		"mitata": "latest",
+		"oxfmt": "latest",
+		"oxlint": "latest",
+		"oxlint-tsgolint": "latest",
+		"publint": "latest",
+		"release-it": "latest"
 	},
 	"engines": {
 		"node": ">=18"

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, PathLike } from "node:fs";
-import type { FsAdapter } from "./types.js";
-export declare function opendir(fs: FsAdapter, path: PathLike, cb: (entry: Dirent, from: string) => Promise<0 | 1 | 2>): Promise<void | 2>;

package/out/opendir.js

@@ -1,22 +0,0 @@
-export async function opendir(fs, path, cb) {
-    const dir = await fs.promises.opendir(path);
-    const tasks = [];
-    for await (const entry of dir) {
-        const from = path + "/" + entry.name;
-        const task = (async () => {
-            const r = await cb(entry, from);
-            if (r === 2)
-                return 2;
-            if (r === 1)
-                return;
-            if (entry.isDirectory()) {
-                return await opendir(fs, from, cb);
-            }
-        })();
-        tasks.push(task);
-    }
-    const results = await Promise.all(tasks);
-    if (results.includes(2)) {
-        return 2;
-    }
-}