view-ignored 0.10.1 → 0.11.1

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,79 +1,39 @@
-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";
-/**
- * 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;
-    /**
-     * The matcher context.
-     *
-     * @since 0.6.0
-     */
-    ctx: MatcherContext;
-};
-/**
- * @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: [EntryInfo];
-    end: [MatcherContext];
-};
+import type { EventMap, EventListener, EventListenerObject } from "./matcherStreamTypes.js";
+export type { EntryInfo, EntryListener, EndListener, EventMap } from "./matcherStreamTypes.js";
+export interface AddEventListenerOptions {
+    capture?: boolean;
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
 /**
  * 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;
         cwd: string;
         noTimeout?: boolean;
-    } & {
-        captureRejections?: boolean;
     });
+    addEventListener<K extends keyof EventMap>(type: K, callback: EventListenerObject<K> | EventListener<K> | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof EventMap>(type: K, callback: EventListenerObject<K> | EventListener<K> | null, 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;
 }