view-ignored 0.10.0 → 0.10.1

package/README.md

@@ -18,7 +18,9 @@ Node.js 18 or later
   readers, not command-line wrappers.
 - **Plugins.** Built-in [targets](#targets) for popular tools. Use custom
   targets by implementing/extending the `Target` interface.
-- **TypeScript.** Written in TypeScript with type definitions included.
+- **Streaming.** Native `scanStream` support for processing massive file trees with minimal memory overhead.
+- **Execution Control.** Use `fastDepth` and `fastInternal` options to fine-tune traversal depth and skip unnecessary directory checks.
+- **Abortable.** Full support for `AbortSignal` to cancel long-running scans instantly.
 - **Lightweight.** Minimal dependencies for fast performance and small bundle size.
 - **Easy-to-modify.** Well-written and MIT-licensed.
 - **Browser.** Can be bundled for browser use. See `ScanOptions.fs` and `import ... "view-ignored/browser"`.

package/out/browser_scan.js

@@ -43,11 +43,11 @@ export function scan(options) {
     return (async () => {
         await target.init?.({ ctx, cwd, fs, signal, target });
         let from = join(normalCwd, within);
-        await opendir(fs, from, (entry, from) => {
-            const path = from.substring(normalCwd.length + 1);
+        await opendir({ ctx, cwd: normalCwd, fs, signal, target }, from, (entry, parentPath, path) => {
             return walkIncludes({
                 path,
                 entry,
+                parentPath,
                 ctx,
                 stream: undefined,
                 scanOptions,

package/out/opendir.d.ts

@@ -1,3 +1,3 @@
-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>;
+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>;

package/out/opendir.js

@@ -1,22 +1,28 @@
-export async function opendir(fs, path, cb) {
-    const dir = await fs.promises.opendir(path);
+import { resolveSources } from "./patterns/resolveSources.js";
+export async function opendir(options, place, cb) {
+    const { ctx, cwd, fs, signal, target } = options;
+    const dir = await fs.promises.opendir(place);
     const tasks = [];
+    const normalParentPath = place;
+    const substr = normalParentPath.substring(cwd.length + 1);
+    const isRootDir = normalParentPath.length === cwd.length;
+    const parentPath = isRootDir ? "." : substr;
+    await resolveSources({ ctx, cwd, fs, signal, target, dir: parentPath });
+    let stop = false;
     for await (const entry of dir) {
-        const from = path + "/" + entry.name;
+        const from = place + "/" + entry.name;
+        const path = isRootDir ? entry.name : substr + "/" + entry.name;
         const task = (async () => {
-            const r = await cb(entry, from);
-            if (r === 2)
-                return 2;
+            const r = await cb(entry, parentPath, path);
             if (r === 1)
                 return;
-            if (entry.isDirectory()) {
-                return await opendir(fs, from, cb);
+            if (r === 2 || (entry.isDirectory() && (await opendir(options, from, cb)))) {
+                stop = true;
+                return;
             }
         })();
         tasks.push(task);
     }
-    const results = await Promise.all(tasks);
-    if (results.includes(2)) {
-        return 2;
-    }
+    await Promise.all(tasks);
+    return stop;
 }

package/out/patterns/ignores.d.ts

@@ -12,6 +12,12 @@ export interface IgnoresOptions extends InitState {
      * @since 0.6.0
      */
     entry: string;
+    /**
+     * Result of the `dirname(entry)` call.
+     *
+     * @since 0.10.1
+     */
+    parentPath: string;
 }
 /**
  * Checks whether a given entry path should be ignored based on its patterns.

package/out/patterns/matcherContextPatch.js

@@ -3,6 +3,7 @@ import { getDepth } from "../getDepth.js";
 import { opendir } from "../opendir.js";
 import { unixify, join } from "../unixify.js";
 import { walkIncludes } from "../walk.js";
+import { resolveSources } from "./resolveSources.js";
 /**
  * Provides patching abilities for the given {@link MatcherContext}.
  * Directories should have the slash suffix.
@@ -21,28 +22,29 @@ export async function matcherContextAddPath(ctx, options, entry) {
         if (direntPath === ".") {
             return true;
         }
-        ctx.paths.set(entry, await target.ignores({ fs, cwd, entry: direntPath, ctx, signal, target }));
+        const parentPath = dirname(direntPath);
+        await resolveSources({ ctx, cwd, dir: direntPath, fs, signal, target });
+        ctx.paths.set(entry, await target.ignores({ fs, cwd, entry: direntPath, ctx, signal, target, parentPath }));
         if (ctx.totalFiles >= 0) {
             ctx.totalDirs++;
         }
-        const parent = dirname(direntPath);
-        if (parent !== ".") {
-            void (await matcherContextAddPath(ctx, options, parent + "/"));
+        if (parentPath !== ".") {
+            void (await matcherContextAddPath(ctx, options, parentPath + "/"));
         }
         return true;
     }
-    const parent = dirname(entry);
+    const parentPath = dirname(entry);
     const isSource = target.extractors.some((e) => e.path === entry);
     if (isSource) {
         // add pattern sources
-        await matcherContextRemovePath(ctx, options, parent + "/");
-        await rescan(ctx, { ...options, within: parent });
+        await matcherContextRemovePath(ctx, options, parentPath + "/");
+        await rescan(ctx, { ...options, within: parentPath });
     }
     // add paths
     // 1. recursively populate parents
-    await matcherContextAddPath(ctx, options, parent + "/");
+    await matcherContextAddPath(ctx, options, parentPath + "/");
     // 2. if ignored, remove, otherwise add
-    const match = await target.ignores({ fs, cwd, entry, ctx, signal, target });
+    const match = await target.ignores({ fs, cwd, entry, ctx, signal, target, parentPath });
     if (match.ignored) {
         // 2.1. remove
         await matcherContextRemovePath(ctx, options, entry);
@@ -140,12 +142,13 @@ export async function matcherContextRemovePath(ctx, options, entry) {
     return true;
 }
 async function rescan(ctx, options) {
-    const normalCwd = unixify(options.cwd);
-    let from = join(normalCwd, options.within);
-    await opendir(options.fs, from, (entry, from) => {
-        const path = from.substring(normalCwd.length + 1);
+    const { cwd, within, fs, signal, target } = options;
+    const normalCwd = unixify(cwd);
+    let from = join(normalCwd, within);
+    await opendir({ ctx, cwd: normalCwd, fs, signal, target }, from, (entry, parentPath, path) => {
         return walkIncludes({
             path,
+            parentPath,
             entry,
             ctx,
             stream: undefined,

package/out/patterns/matcherStream.js

@@ -51,10 +51,10 @@ export class MatcherStream extends EventEmitter {
         };
         await target.init?.({ ctx, cwd, fs, signal, target });
         let from = join(normalCwd, within);
-        await opendir(fs, from, (entry, from) => {
-            const path = from.substring(normalCwd.length + 1);
+        await opendir({ ctx, cwd: normalCwd, fs, signal, target }, from, (entry, parentPath, path) => {
             return walkIncludes({
                 path,
+                parentPath,
                 entry,
                 ctx,
                 stream: this,

package/out/patterns/patternCompile.js

@@ -1,4 +1,4 @@
-import { makeRe } from "minimatch";
+import glob from "micromatch";
 /**
  * Compiles a string of the {@link PatternList}.
  *
@@ -8,24 +8,55 @@ import { makeRe } from "minimatch";
  */
 export function patternCompile(pattern, context = [], options) {
     const original = pattern;
-    if (pattern.endsWith("/")) {
-        pattern = pattern.substring(0, pattern.length - 1);
-    }
-    if (pattern.startsWith("/")) {
-        pattern = pattern.substring(1);
-    }
-    else if (!pattern.startsWith("**/")) {
-        pattern = "**/" + pattern;
-    }
-    if (!pattern.endsWith("/**")) {
-        pattern += "/**";
-    }
-    const re = makeRe(pattern, {
+    const isRoot = pattern.startsWith("/");
+    const nocase = !!options?.nocase;
+    let cleaned = pattern;
+    if (cleaned.endsWith("/"))
+        cleaned = cleaned.slice(0, -1);
+    if (isRoot)
+        cleaned = cleaned.slice(1);
+    const lowerCleaned = nocase ? cleaned.toLowerCase() : cleaned;
+    const prefix = lowerCleaned + "/";
+    const hasGlob = cleaned.includes("*");
+    const matchBase = !isRoot && !cleaned.includes("/");
+    const matcherOpts = {
         dot: true,
         nonegate: true,
         nocomment: true,
         nobrace: true,
-        nocase: options?.nocase ?? false,
-    });
+        nocase,
+        matchBase,
+        optimizationLevel: 2,
+    };
+    const re = {
+        test(str) {
+            const lowerStr = nocase ? str.toLowerCase() : str;
+            if (lowerStr === lowerCleaned || lowerStr.startsWith(prefix)) {
+                return true;
+            }
+            if (matchBase) {
+                if (str.includes(cleaned)) {
+                    const segments = str.split("/");
+                    for (const seg of segments) {
+                        if (seg === lowerCleaned)
+                            return true;
+                    }
+                }
+            }
+            if (hasGlob) {
+                if (glob.isMatch(str, cleaned, matcherOpts))
+                    return true;
+                // Check parents only if there's a glob
+                let lastSlash = str.lastIndexOf("/");
+                while (lastSlash !== -1) {
+                    const parent = str.substring(0, lastSlash);
+                    if (glob.isMatch(parent, cleaned, matcherOpts))
+                        return true;
+                    lastSlash = str.lastIndexOf("/", lastSlash - 1);
+                }
+            }
+            return false;
+        },
+    };
     return { re, pattern: original, patternContext: context };
 }

package/out/patterns/patternList.d.ts

@@ -9,19 +9,21 @@ import { type PatternCompileOptions } from "./patternCompile.js";
  */
 export type PatternCache = {
     /**
-     * The regular expression instance.
+     * The regular expression interface.
      *
      * @since 0.6.0
      */
-    re: RegExp;
+    re: {
+        test(string: string): boolean;
+    };
     /**
-     * The original pattern string this minimatch was compiled from.
+     * The original pattern string this cache was compiled from.
      *
      * @since 0.6.0
      */
     pattern: string;
     /**
-     * The original pattern list this pattern was compiled from.
+     * The original pattern list this cache was compiled from.
      *
      * @since 0.6.0
      */
@@ -34,7 +36,7 @@ export type PatternCache = {
  */
 export declare function patternCacheTest(cache: PatternCache, path: string): boolean;
 /**
- * Represents a list of positive minimatch patterns.
+ * Represents a list of positive glob patterns.
  *
  * @since 0.6.0
  */

package/out/patterns/patternList.js

@@ -5,7 +5,6 @@ import { patternCompile } from "./patternCompile.js";
  * @since 0.6.0
  */
 export function patternCacheTest(cache, path) {
-    cache.re.lastIndex = 0;
     return cache.re.test(path);
 }
 /**

package/out/patterns/rule.d.ts

@@ -3,7 +3,7 @@ import type { Source } from "./source.js";
 import { type PatternList, type PatternCache } from "./patternList.js";
 /**
  * Represents a set of include and exclude patterns.
- * These patterns are positive minimatch patterns.
+ * These patterns are positive glob patterns.
  *
  * @see {@link ruleTest} provides the ignoring algorithm.
  * @see {@link ruleCompile} compiles the signed pattern.
@@ -105,6 +105,12 @@ export interface RuleTestOptions extends PatternFinderOptions {
      * @since 0.6.0
      */
     entry: string;
+    /**
+     * Result of the `dirname(entry)` call.
+     *
+     * @since 0.10.1
+     */
+    parentPath: string;
 }
 /**
  * Checks whether a given entry should be ignored based on internal and external patterns.

package/out/patterns/rule.js

@@ -1,6 +1,4 @@
-import { dirname } from "node:path/posix";
 import { patternCacheTest } from "./patternList.js";
-import { resolveSources } from "./resolveSources.js";
 function cacheTest(rs, path) {
     for (const r of rs) {
         try {
@@ -73,12 +71,12 @@ function testExternal(options, path, source) {
  * @since 0.6.0
  */
 export async function ruleTest(options) {
-    const parent = dirname(options.entry);
+    const parent = options.parentPath;
     let source = options.ctx?.external.get(parent);
-    if (source === undefined) {
-        await resolveSources({ ...options, dir: parent });
-        source = options.ctx.external.get(parent);
-    }
+    // if (source === undefined) {
+    // 	await resolveSources({ ...options, dir: parent })
+    // 	source = options.ctx.external.get(parent)
+    // }
     if (source === undefined) {
         throw new Error("view-ignored has crashed: no source cached.");
     }

package/out/walk.d.ts

@@ -4,6 +4,7 @@ import type { MatcherStream } from "./patterns/matcherStream.js";
 import type { ScanOptions } from "./types.js";
 export type WalkOptions = {
     path: string;
+    parentPath: string;
     entry: Dirent;
     ctx: MatcherContext;
     stream: MatcherStream | undefined;

package/out/walk.js

@@ -1,6 +1,6 @@
 import { getDepth } from "./getDepth.js";
 export async function walkIncludes(options) {
-    const { entry, ctx, stream, scanOptions, path } = options;
+    const { entry, ctx, stream, scanOptions, path, parentPath } = options;
     const { fs, target, cwd, depth: maxDepth, invert, signal, fastDepth, fastInternal } = scanOptions;
     signal?.throwIfAborted();
     const isDir = entry.isDirectory();
@@ -17,7 +17,7 @@ export async function walkIncludes(options) {
         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 });
+            let match = await target.ignores({ fs, cwd, entry: path, ctx, signal, target, parentPath });
             if (invert) {
                 match.ignored = !match.ignored;
             }
@@ -45,7 +45,15 @@ export async function walkIncludes(options) {
         }
     }
     const failedPrev = ctx.failed.length;
-    let match = await target.ignores({ fs, cwd, entry: path, ctx, signal, target });
+    let match = await target.ignores({
+        fs,
+        cwd,
+        entry: path,
+        ctx,
+        signal,
+        target,
+        parentPath: parentPath,
+    });
     if (invert) {
         match.ignored = !match.ignored;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "view-ignored",
-	"version": "0.10.0",
+	"version": "0.10.1",
 	"description": "Retrieve list of files ignored/included by Git, NPM, Yarn, JSR, VSCE or other tools.",
 	"keywords": [
 		".gitignore",
@@ -97,13 +97,14 @@
 	},
 	"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",
 		"@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",