view-ignored 0.10.1 → 0.11.0

package/out/patterns/jsrjson.js

@@ -1,26 +1,16 @@
-import { type } from "arktype";
 import stripJsonComments from "strip-json-comments";
 import { ruleCompile } from "./resolveSources.js";
 import { resolveNegatable } from "./source.js";
-const jsrManifest = type({
-    exclude: "string[]?",
-    include: "string[]?",
-    "publish?": {
-        exclude: "string[]?",
-        include: "string[]?",
-    },
-});
-const parse = type("string")
-    .pipe((s) => JSON.parse(s))
-    .pipe(jsrManifest);
 /**
  * Extracts and compiles patterns from the file.
  *
  * @since 0.6.0
  */
-export function extractJsrJson(source, content, ctx) {
-    extract(source, content, ctx);
-    for (const element of source.pattern) {
+export function extractJsrJson(source, content) {
+    const result = extract(source, content);
+    if (result instanceof Error)
+        return result;
+    for (const element of source.rules) {
         ruleCompile(element);
     }
 }
@@ -32,39 +22,36 @@ extractJsrJson;
  *
  * @since 0.6.0
  */
-export function extractJsrJsonc(source, content, ctx) {
-    extractJsrJson(source, Buffer.from(stripJsonComments(content.toString())), ctx);
+export function extractJsrJsonc(source, content) {
+    return extractJsrJson(source, Buffer.from(stripJsonComments(content.toString())));
 }
 extractJsrJsonc;
-function extract(source, content, ctx) {
-    const dist = parse(content.toString());
-    const include = { compiled: null, excludes: false, pattern: [] };
-    const exclude = { compiled: null, excludes: true, pattern: [] };
-    if (dist instanceof type.errors) {
-        source.error = new Error("Invalid '" + source.path + "': " + dist.summary, { cause: dist });
-        ctx.failed.push(source);
-        return;
+function extract(source, content) {
+    let dist;
+    try {
+        dist = JSON.parse(content.toString());
     }
-    if (!dist.publish) {
-        if (dist.exclude) {
-            exclude.pattern.push(...dist.exclude);
-        }
+    catch (e) {
+        return new Error("Invalid JSON in " + source.path, { cause: e });
     }
-    else if (dist.publish.exclude) {
-        exclude.pattern.push(...dist.publish.exclude);
+    // Basic runtime check to ensure dist is an object
+    if (!dist || typeof dist !== "object" || Array.isArray(dist)) {
+        return new Error("Invalid " + source.path + ": Root must be an object");
     }
-    if (!dist.publish) {
-        if (dist.include) {
-            include.pattern.push(...dist.include);
-        }
+    const include = { compiled: null, excludes: false, pattern: [] };
+    const exclude = { compiled: null, excludes: true, pattern: [] };
+    // Resolve patterns based on the manifest hierarchy
+    const target = dist.publish ?? dist;
+    if (target.exclude && Array.isArray(target.exclude)) {
+        exclude.pattern.push(...target.exclude);
     }
-    else if (dist.publish.include) {
-        include.pattern.push(...dist.publish.include);
+    if (target.include && Array.isArray(target.include)) {
+        include.pattern.push(...target.include);
     }
     for (const si of [include, exclude]) {
         for (const pattern of si.pattern) {
             resolveNegatable(pattern, true, include, exclude);
         }
     }
-    source.pattern.push(include, exclude);
+    source.rules.push(include, exclude);
 }

package/out/patterns/matcherContext.d.ts

@@ -1,5 +1,5 @@
+import type { Resource, InvalidSource } from "./resource.js";
 import type { RuleMatch } from "./rule.js";
-import type { Source } from "./source.js";
 /**
  * Post-scan results.
  *
@@ -22,16 +22,16 @@ export interface MatcherContext {
      *
      * @since 0.6.0
      */
-    external: Map<string, Source | "none">;
+    external: Map<string, Resource>;
     /**
      * If any fatal errors were encountered during source extractions,
      * this property will contain an array of failed sources.
      *
      * @since 0.6.0
      */
-    failed: Source[];
+    failed: InvalidSource[];
     /**
-     * Maps directory paths to the quantity of files they contain.
+     * Total number of files and directories scanned.
      *
      * @example
      * // for
@@ -41,15 +41,18 @@ export interface MatcherContext {
      * "src/views/index.html"
      *
      * // depth: 0
-     * "src" => 1
+     * "." => { totalFiles: 1, totalMatchedFiles: 1, totalDirs: 3 }
+     * "src" => { totalFiles: 1, totalMatchedFiles: 1, totalDirs: 2 }
      *
      * // depth: 1
-     * "src/components" => 0
-     * "src/views" => 1
+     * "src/components" => { totalFiles: 0, totalMatchedFiles: 0, totalDirs: 0 }
+     * "src/views" => { totalFiles: 1, totalMatchedFiles: 1, totalDirs: 0 }
      *
-     * @since 0.6.0
+     * @since 0.11.0
      */
-    depthPaths: Map<string, number>;
+    total: Map<string, Total>;
+}
+export interface Total {
     /**
      * Total number of files scanned.
      *

package/out/patterns/matcherContextPatch.js

@@ -1,9 +1,16 @@
-import { dirname } from "node:path";
-import { getDepth } from "../getDepth.js";
-import { opendir } from "../opendir.js";
-import { unixify, join } from "../unixify.js";
-import { walkIncludes } from "../walk.js";
+import { scanParallel } from "../scanParallel.js";
+import { dirname } from "../unixify.js";
+import { walkPatchResult, walkPatchTotal, propagateTotals, } from "../walk.js";
 import { resolveSources } from "./resolveSources.js";
+function promiseCb(resolve, reject) {
+    return (err, res) => {
+        if (err) {
+            reject(err);
+            return;
+        }
+        resolve(res);
+    };
+}
 /**
  * Provides patching abilities for the given {@link MatcherContext}.
  * Directories should have the slash suffix.
@@ -14,46 +21,110 @@ export async function matcherContextAddPath(ctx, options, entry) {
     if (ctx.paths.has(entry)) {
         return false;
     }
-    const { target, fs, cwd, signal } = options;
     const isDir = entry.endsWith("/");
+    const direntPath = isDir ? entry.slice(0, -1) : entry;
+    if (isDir && direntPath === ".") {
+        return true;
+    }
+    const parentPath = dirname(direntPath);
+    const { target, fs, cwd, signal, depth: maxDepth } = options;
     if (isDir) {
         // recursive parent population
-        const direntPath = entry.replace(/\/$/, "");
-        if (direntPath === ".") {
-            return true;
+        const resource = await new Promise((resolve, reject) => {
+            resolveSources({
+                cwd,
+                dir: direntPath,
+                external: ctx.external,
+                fs,
+                signal,
+                target,
+            }, promiseCb(resolve, reject));
+        });
+        ctx.paths.set(entry, await new Promise((resolve, reject) => {
+            target.ignores({
+                cwd,
+                entry: direntPath,
+                fs,
+                parentPath,
+                resource,
+                signal,
+                target,
+            }, promiseCb(resolve, reject));
+        }));
+        const total = ctx.total.get(parentPath);
+        if (!total) {
+            ctx.total.set(parentPath, { totalDirs: 1, totalFiles: 0, totalMatchedFiles: 0 });
         }
-        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++;
+        else if (total.totalFiles >= 0) {
+            total.totalDirs++;
         }
         if (parentPath !== ".") {
             void (await matcherContextAddPath(ctx, options, parentPath + "/"));
         }
         return true;
     }
-    const parentPath = dirname(entry);
     const isSource = target.extractors.some((e) => e.path === entry);
     if (isSource) {
         // add pattern sources
+        const resultPromise = new Promise((resolve, reject) => {
+            scanParallel({
+                external: ctx.external,
+                failed: ctx.failed,
+                onResult: (result) => {
+                    if ("dir" in result) {
+                        walkPatchTotal(ctx, maxDepth, result);
+                    }
+                    else {
+                        walkPatchResult(ctx, result);
+                    }
+                },
+                scanOptions: options,
+                stream: undefined,
+                within: parentPath,
+            }, promiseCb(resolve, reject));
+        });
         await matcherContextRemovePath(ctx, options, parentPath + "/");
-        await rescan(ctx, { ...options, within: parentPath });
+        await resultPromise;
+        propagateTotals(ctx.total);
     }
     // add paths
     // 1. recursively populate parents
     await matcherContextAddPath(ctx, options, parentPath + "/");
     // 2. if ignored, remove, otherwise add
-    const match = await target.ignores({ fs, cwd, entry, ctx, signal, target, parentPath });
+    const resource = (await new Promise((resolve, reject) => {
+        resolveSources({
+            cwd,
+            dir: parentPath,
+            external: ctx.external,
+            fs,
+            signal,
+            target,
+        }, promiseCb(resolve, reject));
+    }));
+    const match = await new Promise((resolve, reject) => {
+        target.ignores({
+            cwd,
+            entry,
+            fs,
+            parentPath,
+            resource,
+            signal,
+            target,
+        }, promiseCb(resolve, reject));
+    });
     if (match.ignored) {
         // 2.1. remove
         await matcherContextRemovePath(ctx, options, entry);
         return false;
     }
     // 2.2. add
-    if (ctx.totalFiles >= 0) {
-        ctx.totalFiles++;
-        ctx.totalMatchedFiles++;
+    const total = ctx.total.get(parentPath);
+    if (!total) {
+        ctx.total.set(parentPath, { totalDirs: 0, totalFiles: 1, totalMatchedFiles: 1 });
+    }
+    else {
+        total.totalFiles++;
+        total.totalMatchedFiles++;
     }
     ctx.paths.set(entry, match);
     return true;
@@ -66,94 +137,103 @@ export async function matcherContextAddPath(ctx, options, entry) {
  */
 export async function matcherContextRemovePath(ctx, options, entry) {
     const isDir = entry.endsWith("/");
+    const direntPath = isDir ? entry.slice(0, -1) : entry;
+    if (isDir && direntPath === ".") {
+        ctx.paths.clear();
+        ctx.external.clear();
+        ctx.failed.length = 0;
+        ctx.total.set(direntPath, { totalDirs: 0, totalFiles: 0, totalMatchedFiles: 0 });
+        return true;
+    }
+    const parentPath = dirname(direntPath);
+    const parentPathDir = parentPath + "/";
     if (isDir) {
         // remove directories
-        const direntPath = entry.replace(/\/$/, "");
+        let deletedDirs = 0, deletedFiles = 0;
+        const total = ctx.total.get(direntPath);
         for (const [element] of ctx.paths) {
-            if (entry !== "./" && !element.startsWith(entry)) {
+            if (!element.startsWith(entry)) {
                 continue;
             }
-            if (ctx.totalFiles >= 0) {
+            if (total && total.totalFiles >= 0) {
                 const isDir = element.endsWith("/");
                 if (isDir) {
-                    ctx.totalDirs--;
+                    deletedDirs++;
                 }
                 else {
-                    ctx.totalFiles--;
-                    ctx.totalMatchedFiles--;
+                    deletedFiles++;
                 }
             }
             ctx.paths.delete(element);
         }
-        for (const [element] of ctx.depthPaths) {
-            if (entry !== "./" && !element.startsWith(direntPath)) {
+        deleteTotals(ctx, entry, deletedDirs, deletedFiles);
+        for (const [element] of ctx.external) {
+            if (!element.startsWith(direntPath)) {
                 continue;
             }
-            ctx.depthPaths.delete(element);
-        }
-        for (const [element] of ctx.external) {
-            if (entry !== "./" && !element.startsWith(direntPath)) {
+            if (!ctx.external.delete(element) || !ctx.failed.length) {
                 continue;
             }
-            if (ctx.external.delete(element) && ctx.failed.length) {
-                // 3.1. remove failed sources
-                const failedEntryIndex = ctx.failed.findIndex((fail) => dirname(fail.path) === element);
-                if (failedEntryIndex >= 0) {
-                    ctx.failed.splice(failedEntryIndex, 1);
-                }
+            // 3.1. remove failed sources
+            const failedEntryIndex = ctx.failed.findIndex((fail) => dirname(fail.source.path) === element);
+            if (failedEntryIndex >= 0) {
+                ctx.failed.splice(failedEntryIndex, 1);
             }
         }
         return true;
     }
-    const parent = dirname(entry);
     const isSource = options.target.extractors.some((e) => e.path === entry);
     if (isSource) {
+        const maxDepth = options.depth;
         // remove pattern sources
         // rescan directory and repopulate stats
-        await matcherContextRemovePath(ctx, options, parent + "/");
-        await rescan(ctx, { ...options, within: parent });
+        const resultPromise = new Promise((resolve, reject) => {
+            scanParallel({
+                external: ctx.external,
+                failed: ctx.failed,
+                onResult: (result) => {
+                    if ("dir" in result) {
+                        walkPatchTotal(ctx, maxDepth, result);
+                    }
+                    else {
+                        walkPatchResult(ctx, result);
+                    }
+                },
+                scanOptions: options,
+                stream: undefined,
+                within: parentPath,
+            }, promiseCb(resolve, reject));
+        });
+        await matcherContextRemovePath(ctx, options, parentPathDir);
+        await resultPromise;
+        propagateTotals(ctx.total);
         return true;
     }
     // remove path
     // 1. change stats
     {
-        if (ctx.totalFiles >= 0) {
-            ctx.totalFiles--;
-            ctx.totalMatchedFiles--;
+        const total = ctx.total.get(parentPath);
+        if (!total) {
+            ctx.total.set(parentPath, { totalDirs: 0, totalFiles: 0, totalMatchedFiles: 0 });
         }
-        // 1.1 remove depthPaths
-        const { depthSlash } = getDepth(entry, options.depth);
-        if (depthSlash >= 0) {
-            const dir = entry.substring(0, depthSlash);
-            let num = ctx.depthPaths.get(dir);
-            if (num) {
-                num--;
-                if (num <= 0) {
-                    ctx.depthPaths.delete(dir);
-                }
-                else {
-                    ctx.depthPaths.set(dir, num);
-                }
-            }
+        else if (total.totalFiles >= 0) {
+            total.totalFiles--;
+            total.totalMatchedFiles--;
         }
     }
     // 2. remove from paths
     ctx.paths.delete(entry);
     return true;
 }
-async function rescan(ctx, options) {
-    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,
-            scanOptions: { ...options, cwd: normalCwd },
-        });
-    });
-    ctx.totalDirs = ctx.totalFiles = ctx.totalMatchedFiles = -1;
+function deleteTotals(ctx, entry, deletedDirs = 0, deletedFiles = 0) {
+    if (entry.endsWith("/"))
+        ctx.total.delete(entry);
+    for (let parent = dirname(entry); parent !== "./"; parent = dirname(parent) + "/") {
+        const total = ctx.total.get(parent);
+        if (!total)
+            continue;
+        total.totalDirs -= deletedDirs;
+        total.totalFiles -= deletedFiles;
+        total.totalMatchedFiles -= deletedFiles;
+    }
 }

package/out/patterns/matcherStream.d.ts

@@ -1,5 +1,4 @@
 import type { Dirent } from "node:fs";
-import { EventEmitter } from "node:events";
 import type { MatcherContext } from "../patterns/matcherContext.js";
 import type { ScanOptions, FsAdapter } from "../types.js";
 import type { RuleMatch } from "./rule.js";
@@ -27,12 +26,6 @@ export type EntryInfo = {
      * @since 0.6.0
      */
     match: RuleMatch;
-    /**
-     * The matcher context.
-     *
-     * @since 0.6.0
-     */
-    ctx: MatcherContext;
 };
 /**
  * @see {@link MatcherStream} uses it for the "dirent" event.
@@ -52,16 +45,32 @@ export type EndListener = (ctx: MatcherContext) => void;
  * @since 0.6.0
  */
 export type EventMap = {
-    dirent: [EntryInfo];
-    end: [MatcherContext];
+    dirent: CustomEvent<EntryInfo>;
+    end: CustomEvent<MatcherContext>;
 };
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.11.0
+ */
+interface EventListener<K extends keyof EventMap> {
+    (evt: EventMap[K]): void;
+}
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.11.0
+ */
+interface EventListenerObject<K extends keyof EventMap> {
+    handleEvent(object: EventMap[K]): void;
+}
 /**
  * Event emitter.
- * @extends EventEmitter
+ * @augments EventTarget
  *
  * @since 0.6.0
  */
-export declare class MatcherStream extends EventEmitter<EventMap> {
+export declare class MatcherStream extends EventTarget {
     #private;
     constructor(options: ScanOptions & {
         fs: FsAdapter;
@@ -70,10 +79,20 @@ export declare class MatcherStream extends EventEmitter<EventMap> {
     } & {
         captureRejections?: boolean;
     });
+    addEventListener<K extends keyof EventMap>(type: K, callback: EventListenerObject<K> | EventListener<K>, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof EventMap>(type: K, callback: EventListenerObject<K> | EventListener<K>, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: EventMap[keyof EventMap]): boolean;
     /**
      * Resolves when everything is scanned.
      *
      * @since 0.8.0
      */
     start(): Promise<void>;
+    /**
+     * Resolves when everything is scanned. (Callback version)
+     *
+     * @since 0.11.0
+     */
+    startCb(cb: (err: Error | null, ctx: MatcherContext) => void): void;
 }
+export {};

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,48 @@ 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() {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        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 +68,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/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;