view-ignored 0.10.1 → 0.11.1

package/out/patterns/matcherStream.js

@@ -1,18 +1,17 @@
-import { EventEmitter } from "node:events";
-import { opendir } from "../opendir.js";
-import { join, unixify } from "../unixify.js";
-import { walkIncludes } from "../walk.js";
+import { scanParallel } from "../scanParallel.js";
+import { unixify } from "../unixify.js";
+import { walkPatchResult, walkPatchTotal, propagateTotals } from "../walk.js";
 /**
  * Event emitter.
- * @extends EventEmitter
+ * @augments EventTarget
  *
  * @since 0.6.0
  */
-export class MatcherStream extends EventEmitter {
+export class MatcherStream extends EventTarget {
     #timeout;
     #options;
     constructor(options) {
-        super({ captureRejections: options.captureRejections });
+        super();
         this.#options = options;
         if (!options.noTimeout) {
             this.#timeout = setTimeout(() => {
@@ -20,27 +19,53 @@ export class MatcherStream extends EventEmitter {
             }, 5e3);
         }
     }
+    addEventListener(type, callback, options) {
+        super.addEventListener(type, callback, options);
+    }
+    removeEventListener(type, callback, options) {
+        super.removeEventListener(type, callback, options);
+    }
+    dispatchEvent(event) {
+        return super.dispatchEvent(event);
+    }
     /**
      * Resolves when everything is scanned.
      *
      * @since 0.8.0
      */
-    async start() {
+    start() {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.startCb((err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+        return promise;
+    }
+    /**
+     * Resolves when everything is scanned. (Callback version)
+     *
+     * @since 0.11.0
+     */
+    startCb(cb) {
         clearTimeout(this.#timeout);
         const { target, cwd, within = ".", invert = false, depth: maxDepth = Infinity, signal = null, fastDepth = false, fastInternal = false, fs, } = this.#options;
         const ctx = {
-            paths: new Map(),
             external: new Map(),
             failed: [],
-            depthPaths: new Map(),
-            totalFiles: 0,
-            totalMatchedFiles: 0,
-            totalDirs: 0,
+            paths: new Map(),
+            total: new Map([[".", { totalDirs: 0, totalFiles: 0, totalMatchedFiles: 0 }]]),
         };
         const normalCwd = unixify(cwd);
         const scanOptions = {
             cwd: normalCwd,
-            within,
             depth: maxDepth,
             fastDepth,
             fastInternal,
@@ -48,19 +73,44 @@ export class MatcherStream extends EventEmitter {
             invert,
             signal,
             target,
+            within,
         };
-        await target.init?.({ ctx, cwd, fs, signal, target });
-        let from = join(normalCwd, within);
-        await opendir({ ctx, cwd: normalCwd, fs, signal, target }, from, (entry, parentPath, path) => {
-            return walkIncludes({
-                path,
-                parentPath,
-                entry,
-                ctx,
-                stream: this,
+        const startScan = () => {
+            scanParallel({
+                external: ctx.external,
+                failed: ctx.failed,
+                onResult: (result) => {
+                    if ("dir" in result) {
+                        walkPatchTotal(ctx, scanOptions.depth, result);
+                    }
+                    else {
+                        walkPatchResult(ctx, result);
+                    }
+                },
                 scanOptions,
+                stream: this,
+                within,
+            }, (err) => {
+                if (err) {
+                    cb(err, null);
+                    return;
+                }
+                propagateTotals(ctx.total);
+                cb(null, ctx);
+                this.dispatchEvent(new CustomEvent("end", { detail: ctx }));
             });
-        });
-        this.emit("end", ctx);
+        };
+        if (target.init) {
+            target.init({ cwd: normalCwd, fs, signal, target }, (err) => {
+                if (err) {
+                    cb(err, null);
+                    return;
+                }
+                startScan();
+            });
+        }
+        else {
+            startScan();
+        }
     }
 }

package/out/patterns/matcherStreamTypes.d.ts

@@ -0,0 +1,65 @@
+import type { Dirent } from "node:fs";
+import type { MatcherContext } from "./matcherContext.js";
+import type { RuleMatch } from "./rule.js";
+/**
+ * Post-scan entry information.
+ *
+ * @since 0.6.0
+ */
+export type EntryInfo = {
+    /**
+     * The relative path of the entry.
+     *
+     * @since 0.6.0
+     */
+    path: string;
+    /**
+     * The directory entry.
+     *
+     * @since 0.6.0
+     */
+    dirent: Dirent;
+    /**
+     * Whether the entry was ignored.
+     *
+     * @since 0.6.0
+     */
+    match: RuleMatch;
+};
+/**
+ * @see {@link MatcherStream} uses it for the "dirent" event.
+ *
+ * @since 0.6.0
+ */
+export type EntryListener = (info: EntryInfo) => void;
+/**
+ * @see {@link MatcherStream} uses it for the "end" event.
+ *
+ * @since 0.6.0
+ */
+export type EndListener = (ctx: MatcherContext) => void;
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.6.0
+ */
+export type EventMap = {
+    dirent: CustomEvent<EntryInfo>;
+    end: CustomEvent<MatcherContext>;
+};
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.11.0
+ */
+export interface EventListener<K extends keyof EventMap> {
+    (evt: EventMap[K]): void;
+}
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.11.0
+ */
+export interface EventListenerObject<K extends keyof EventMap> {
+    handleEvent(object: EventMap[K]): void;
+}

package/out/patterns/matcherStreamTypes.js

@@ -0,0 +1 @@
+export {};

package/out/patterns/packagejson.d.ts

@@ -6,7 +6,7 @@ import { type Source } from "./source.js";
  *
  * @since 0.6.0
  */
-export declare function extractPackageJson(source: Source, content: Buffer): void | "none";
+export declare function extractPackageJson(source: Source, content: Buffer): void | null | Error;
 /**
  * Extracts and compiles patterns from the file.
  *
@@ -14,4 +14,4 @@ export declare function extractPackageJson(source: Source, content: Buffer): voi
  *
  * @since 0.8.0
  */
-export declare function extractPackageJsonNocase(source: Source, content: Buffer): void | "none";
+export declare function extractPackageJsonNocase(source: Source, content: Buffer): void | null | Error;

package/out/patterns/packagejson.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { npmManifestParse } from "../targets/npmManifest.js";
 import { ruleCompile } from "./resolveSources.js";
 import { resolveNegatable } from "./source.js";
@@ -12,12 +11,10 @@ import { resolveNegatable } from "./source.js";
 export function extractPackageJson(source, content) {
     const result = extract(source, content);
     if (result === undefined) {
-        for (const element of source.pattern) {
+        for (const element of source.rules) {
             ruleCompile(element);
         }
     }
-    if (result === "error")
-        return;
     return result;
 }
 /**
@@ -30,29 +27,29 @@ export function extractPackageJson(source, content) {
 export function extractPackageJsonNocase(source, content) {
     const result = extract(source, content);
     if (result === undefined) {
-        for (const element of source.pattern) {
+        for (const element of source.rules) {
             ruleCompile(element, { nocase: true });
         }
     }
-    if (result === "error")
-        return;
     return result;
 }
 function extract(source, content) {
     source.inverted = true;
     const include = { compiled: null, excludes: false, pattern: [] };
     const exclude = { compiled: null, excludes: true, pattern: [] };
-    const dist = npmManifestParse(content.toString());
-    if (dist instanceof type.errors) {
-        source.error = new Error("Invalid '" + source.path + "': " + dist.summary, { cause: dist });
-        return "error";
+    let dist;
+    try {
+        dist = npmManifestParse(content.toString());
     }
-    if (!dist.files) {
-        return "none";
+    catch (err) {
+        return new Error("Invalid '" + source.path + "': Expected '}'", { cause: err });
+    }
+    if (!dist?.files || !Array.isArray(dist.files)) {
+        return null;
     }
     for (const pattern of dist.files) {
         resolveNegatable(pattern, true, include, exclude);
     }
-    source.pattern.push(include, exclude);
+    source.rules.push(include, exclude);
 }
 extractPackageJson;

package/out/patterns/patternCompile.js

@@ -7,56 +7,54 @@ import glob from "micromatch";
  * @since 0.8.0
  */
 export function patternCompile(pattern, context = [], options) {
-    const original = pattern;
-    const isRoot = pattern.startsWith("/");
+    const isRoot = pattern.charCodeAt(0) === 47; // '/'
     const nocase = !!options?.nocase;
     let cleaned = pattern;
-    if (cleaned.endsWith("/"))
+    if (cleaned.charCodeAt(cleaned.length - 1) === 47)
         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,
+        matchBase,
         nobrace: true,
         nocase,
-        matchBase,
-        optimizationLevel: 2,
+        nonegate: true,
     };
+    const isMatch = glob.matcher(lowerCleaned, { ...matcherOpts, nocase: false });
     const re = {
-        test(str) {
-            const lowerStr = nocase ? str.toLowerCase() : str;
-            if (lowerStr === lowerCleaned || lowerStr.startsWith(prefix)) {
+        test: (str, matchCtx) => test(str, matchCtx, isMatch, lowerCleaned, isRoot, nocase, matchBase),
+    };
+    const cache = { pattern, patternContext: context, re };
+    return cache;
+}
+function test(str, matchCtx, isMatch, cleaned, isRoot, nocase, matchBase) {
+    const normStr = nocase ? (matchCtx.lower ?? (matchCtx.lower = str.toLowerCase())) : str;
+    if (normStr === cleaned || normStr.startsWith(cleaned + "/")) {
+        return true;
+    }
+    if (matchBase) {
+        const len = cleaned.length;
+        let pos = normStr.indexOf(cleaned);
+        while (pos !== -1) {
+            if ((pos === 0 || normStr.charCodeAt(pos - 1) === 47) &&
+                (pos + len === normStr.length || normStr.charCodeAt(pos + len) === 47)) {
                 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 };
+            pos = normStr.indexOf(cleaned, pos + 1);
+        }
+    }
+    if (isMatch(normStr))
+        return true;
+    if (!isRoot) {
+        let lastSlash = normStr.lastIndexOf("/");
+        while (lastSlash !== -1) {
+            if (isMatch(normStr.slice(0, lastSlash)))
+                return true;
+            lastSlash = normStr.lastIndexOf("/", lastSlash - 1);
+        }
+    }
+    return false;
 }

package/out/patterns/patternList.d.ts

@@ -14,7 +14,9 @@ export type PatternCache = {
      * @since 0.6.0
      */
     re: {
-        test(string: string): boolean;
+        test(string: string, matchCtx: {
+            lower?: string;
+        }): boolean;
     };
     /**
      * The original pattern string this cache was compiled from.
@@ -34,7 +36,9 @@ export type PatternCache = {
  *
  * @since 0.6.0
  */
-export declare function patternCacheTest(cache: PatternCache, path: string): boolean;
+export declare function patternCacheTest(cache: PatternCache, path: string, matchCtx?: {
+    lower?: string;
+}): boolean;
 /**
  * Represents a list of positive glob patterns.
  *

package/out/patterns/patternList.js

@@ -4,8 +4,8 @@ import { patternCompile } from "./patternCompile.js";
  *
  * @since 0.6.0
  */
-export function patternCacheTest(cache, path) {
-    return cache.re.test(path);
+export function patternCacheTest(cache, path, matchCtx = {}) {
+    return cache.re.test(path, matchCtx);
 }
 /**
  * Compiles the {@link PatternList}.
@@ -16,5 +16,10 @@ export function patternCacheTest(cache, path) {
  * @since 0.6.0
  */
 export function patternListCompile(list, options) {
-    return list.map((p, _, pattern) => patternCompile(p, pattern, options));
+    const len = list.length;
+    const res = Array.from({ length: len });
+    for (let i = 0; i < len; i++) {
+        res[i] = patternCompile(list[i], list, options);
+    }
+    return res;
 }

package/out/patterns/resolveSources.d.ts

@@ -1,6 +1,8 @@
-import type { PatternFinderOptions } from "./extractor.js";
+import type { Dirent } from "node:fs";
 import type { PatternCompileOptions } from "./patternCompile.js";
+import type { Resource } from "./resource.js";
 import type { Rule } from "./rule.js";
+import { type PatternFinderOptions } from "./extractor.js";
 /**
  * Compiles the {@link Rule} (forced).
  * Can be compiled at any time.
@@ -10,7 +12,7 @@ import type { Rule } from "./rule.js";
  *
  * @since 0.6.0
  */
-export declare function ruleCompile(signedPattern: Rule, options?: PatternCompileOptions): Rule;
+export declare function ruleCompile(rule: Rule, options?: PatternCompileOptions): Rule;
 /**
  * @see {@link resolveSources}
  *
@@ -26,10 +28,25 @@ export interface ResolveSourcesOptions extends PatternFinderOptions {
      * @since 0.6.0
      */
     dir: string;
+    /**
+     * Maps directory paths to their corresponding sources.
+     *
+     * @example
+     * "dir" => Resource
+     * "dir/subdir" => Resource
+     *
+     * @since 0.11.0
+     */
+    external: Map<string, Resource>;
+    /**
+     * Directory entries of the current directory.
+     * Used for optimization to avoid redundant `fs.readFile` calls.
+     *
+     * @since 0.11.0
+     */
+    entries?: Dirent[];
 }
 /**
- * Populates the {@link MatcherContext.external} map with {@link Source} objects.
- *
  * @since 0.6.0
  */
-export declare function resolveSources(options: ResolveSourcesOptions): Promise<void>;
+export declare function resolveSources(options: ResolveSourcesOptions, cb: (err: Error | null, resource: Resource) => void): void;