view-ignored 0.10.1 → 0.11.0

package/out/patterns/rule.d.ts

@@ -48,7 +48,7 @@ export type MatchKind = RuleMatch["kind"];
  *
  * @since 0.9.1
  */
-export interface RuleMatchBase<K extends string> {
+export interface RuleMatchBase<K extends string | number | symbol> {
     kind: K;
     ignored: boolean;
 }
@@ -57,7 +57,7 @@ export interface RuleMatchBase<K extends string> {
  *
  * @since 0.9.1
  */
-export interface RuleMatchBaseSource<K extends string> extends RuleMatchBase<K> {
+export interface RuleMatchBaseSource<K extends string | number | symbol> extends RuleMatchBase<K> {
     source: Source;
 }
 /**
@@ -65,30 +65,72 @@ export interface RuleMatchBaseSource<K extends string> extends RuleMatchBase<K>
  *
  * @since 0.9.1
  */
-export interface RuleMatchBasePattern<K extends string> extends RuleMatchBase<K> {
+export interface RuleMatchBasePattern<K extends string | number | symbol> extends RuleMatchBase<K> {
     pattern: string;
 }
 /**
  * @see {@link RuleMatch}
  *
- * @since 0.9.1
+ * @since 0.11.0
  */
-export interface RuleMatchBaseErrorPattern<K extends string> extends RuleMatchBasePattern<K> {
+export interface RuleMatchBaseError<K extends string | number | symbol> extends RuleMatchBase<K> {
     error: Error;
 }
+/**
+ * @see {@link RuleMatch}
+ *
+ * @since 0.11.0
+ */
+export interface RuleMatchBaseInvalidSource<K extends string | number | symbol> extends RuleMatchBaseError<K>, RuleMatchBaseSource<K> {
+}
+/**
+ * @see {@link RuleMatch}
+ *
+ * @since 0.11.0
+ */
+export interface RuleMatchBaseInvalidPattern<K extends string | number | symbol> extends RuleMatchBasePattern<K>, RuleMatchBaseError<K> {
+}
+/**
+ * @see {@link RuleMatch}
+ *
+ * @since 0.11.0
+ */
+export interface RuleMatchBaseInvalidExternal<K extends string | number | symbol> extends RuleMatchBaseInvalidPattern<K>, RuleMatchBaseSource<K> {
+}
 /**
  * @see {@link RuleMatch}
  *
  * @since 0.9.1
  */
-export interface RuleMatchBaseSourcePattern<K extends string> extends RuleMatchBasePattern<K>, RuleMatchBaseSource<K> {
+export interface RuleMatchBaseExternal<K extends string | number | symbol> extends RuleMatchBasePattern<K>, RuleMatchBaseSource<K> {
+}
+/**
+ * The kind of a pattern match.
+ *
+ * @since 0.11.0
+ */
+export declare const enum RuleMatchKind {
+    "none" = 0,
+    "missingSource" = 1,
+    "noMatch" = 2,
+    "invalidSource" = 3,
+    "invalidExternal" = 4,
+    "invalidInternal" = 5,
+    "external" = 6,
+    "internal" = 7
 }
 /**
  * @see {@link ruleTest}
  *
  * @since 0.6.0
  */
-export type RuleMatch = RuleMatchBase<"none" | "missing-source"> | RuleMatchBaseSource<"no-match" | "broken-source" | "invalid-pattern"> | RuleMatchBaseErrorPattern<"invalid-internal-pattern"> | RuleMatchBasePattern<"internal"> | RuleMatchBaseSourcePattern<"external">;
+export type RuleMatch = RuleMatchBase<RuleMatchKind.none> | RuleMatchBase<RuleMatchKind.missingSource> | RuleMatchBaseSource<RuleMatchKind.noMatch> | RuleMatchBaseInvalidSource<RuleMatchKind.invalidSource> | RuleMatchBaseInvalidExternal<RuleMatchKind.invalidExternal> | RuleMatchBaseInvalidPattern<RuleMatchKind.invalidInternal> | RuleMatchBaseExternal<RuleMatchKind.external> | RuleMatchBasePattern<RuleMatchKind.internal>;
+/**
+ * Check if a rule match is invalid.
+ *
+ * @since 0.11.0
+ */
+export declare function isRuleMatchInvalid(match: RuleMatch): match is RuleMatchBaseInvalidSource<RuleMatchKind.invalidSource> | RuleMatchBaseInvalidExternal<RuleMatchKind.invalidExternal> | RuleMatchBaseInvalidPattern<RuleMatchKind.invalidInternal>;
 /**
  * @see {@link ruleTest}
  *
@@ -106,16 +148,22 @@ export interface RuleTestOptions extends PatternFinderOptions {
      */
     entry: string;
     /**
-     * Result of the `dirname(entry)` call.
+     * Pre-lowercased entry path.
      *
-     * @since 0.10.1
+     * @since 0.11.0
      */
-    parentPath: string;
+    lowerEntry?: string;
 }
+/**
+ * Synchronous version of {@link ruleTest}.
+ *
+ * @since 0.11.0
+ */
+export declare function ruleTestSync(options: RuleTestOptions): RuleMatch;
 /**
  * Checks whether a given entry should be ignored based on internal and external patterns.
  * Populates unknown sources using {@link resolveSources}.
  *
  * @since 0.6.0
  */
-export declare function ruleTest(options: RuleTestOptions): Promise<RuleMatch>;
+export declare function ruleTest(options: RuleTestOptions, cb: (err: Error | null, match: RuleMatch) => void): void;

package/out/patterns/rule.js

@@ -1,67 +1,119 @@
 import { patternCacheTest } from "./patternList.js";
-function cacheTest(rs, path) {
-    for (const r of rs) {
+/**
+ * The kind of a pattern match.
+ *
+ * @since 0.11.0
+ */
+export var RuleMatchKind;
+(function (RuleMatchKind) {
+    RuleMatchKind[RuleMatchKind["none"] = 0] = "none";
+    RuleMatchKind[RuleMatchKind["missingSource"] = 1] = "missingSource";
+    RuleMatchKind[RuleMatchKind["noMatch"] = 2] = "noMatch";
+    RuleMatchKind[RuleMatchKind["invalidSource"] = 3] = "invalidSource";
+    RuleMatchKind[RuleMatchKind["invalidExternal"] = 4] = "invalidExternal";
+    RuleMatchKind[RuleMatchKind["invalidInternal"] = 5] = "invalidInternal";
+    RuleMatchKind[RuleMatchKind["external"] = 6] = "external";
+    RuleMatchKind[RuleMatchKind["internal"] = 7] = "internal";
+})(RuleMatchKind || (RuleMatchKind = {}));
+/**
+ * Check if a rule match is invalid.
+ *
+ * @since 0.11.0
+ */
+export function isRuleMatchInvalid(match) {
+    const k = match.kind;
+    return (k === RuleMatchKind.invalidSource ||
+        k === RuleMatchKind.invalidExternal ||
+        k === RuleMatchKind.invalidInternal);
+}
+function cacheTest(rs, path, matchCtx) {
+    const len = rs.length;
+    for (let i = 0; i < len; i++) {
+        const r = rs[i];
         try {
-            if (patternCacheTest(r, path)) {
-                return [r.pattern, undefined];
+            if (patternCacheTest(r, path, matchCtx)) {
+                return r;
             }
         }
         catch (err) {
-            return [r.pattern, err];
+            return err;
         }
     }
-    return ["", undefined];
+    return null;
 }
-function testInternal(options, path) {
-    for (const si of options.target.internalRules) {
-        const compiled = si.compiled;
-        if (compiled === null)
+/**
+ * Synchronous version of {@link ruleTest}.
+ *
+ * @since 0.11.0
+ */
+export function ruleTestSync(options) {
+    const src = options.resource;
+    if (src === undefined) {
+        throw new Error("view-ignored has crashed: no source cached.");
+    }
+    if (src === null) {
+        return { ignored: false, kind: RuleMatchKind.missingSource };
+    }
+    if ("error" in src) {
+        return { ...src, ignored: true, kind: RuleMatchKind.invalidSource };
+    }
+    const entry = options.entry;
+    const matchCtx = { lower: options.lowerEntry };
+    const internalRules = options.target.internalRules;
+    for (let i = 0, len = internalRules.length; i < len; i++) {
+        const rule = internalRules[i];
+        const res = cacheTest(rule.compiled, entry, matchCtx);
+        if (res === null)
             continue;
-        let [patternMatch, error] = cacheTest(compiled, path);
-        if (error)
+        if (res instanceof Error) {
             return {
-                kind: "invalid-internal-pattern",
-                pattern: patternMatch,
-                error,
+                error: res,
                 ignored: false,
+                kind: RuleMatchKind.invalidInternal,
+                pattern: "",
             };
-        if (patternMatch)
-            return {
-                kind: "internal",
-                pattern: patternMatch,
-                ignored: si.excludes,
-            };
+        }
+        return {
+            ignored: rule.excludes,
+            kind: RuleMatchKind.internal,
+            pattern: res.pattern,
+        };
     }
-    return null;
-}
-function testExternal(options, path, source) {
-    for (const si of source.pattern) {
-        const compiled = si.compiled;
-        if (compiled === null) {
+    const rules = src.rules;
+    const elen = rules.length;
+    if (elen === 0) {
+        return (src._noMatchCache ??
+            (src._noMatchCache = {
+                ignored: src.inverted,
+                kind: RuleMatchKind.noMatch,
+                source: src,
+            }));
+    }
+    for (let i = 0; i < elen; i++) {
+        const rule = rules[i];
+        const res = cacheTest(rule.compiled, entry, matchCtx);
+        if (res === null)
             continue;
-        }
-        let [patternMatch, err] = cacheTest(compiled, path);
-        if (err) {
-            source.error = err;
-            options.ctx?.failed.push(source);
+        if (res instanceof Error) {
             return {
-                kind: "invalid-pattern",
+                error: res,
                 ignored: false,
-                source,
+                kind: RuleMatchKind.invalidExternal,
+                pattern: "",
+                source: src,
             };
         }
-        if (patternMatch)
-            return {
-                kind: "external",
-                pattern: patternMatch,
-                ignored: si.excludes,
-                source,
-            };
+        return {
+            ignored: rule.excludes,
+            kind: RuleMatchKind.external,
+            pattern: res.pattern,
+            source: src,
+        };
     }
     return {
-        kind: "no-match",
-        ignored: source.inverted,
-        source,
+        ignored: src.inverted,
+        kind: RuleMatchKind.noMatch,
+        source: src,
     };
 }
 /**
@@ -70,26 +122,11 @@ function testExternal(options, path, source) {
  *
  * @since 0.6.0
  */
-export async function ruleTest(options) {
-    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) {
-        throw new Error("view-ignored has crashed: no source cached.");
-    }
-    if (source === "none") {
-        return { kind: "missing-source", ignored: false };
-    }
-    if (typeof source === "object" && source.error) {
-        return { kind: "broken-source", ignored: true, source };
+export function ruleTest(options, cb) {
+    try {
+        cb(null, ruleTestSync(options));
     }
-    let internalMatch = testInternal(options, options.entry);
-    if (internalMatch !== null) {
-        return internalMatch;
+    catch (err) {
+        cb(err, null);
     }
-    const externalMatch = testExternal(options, options.entry, source);
-    return externalMatch;
 }

package/out/patterns/source.d.ts

@@ -1,25 +1,25 @@
-import type { Rule } from "./rule.js";
+import type { Rule, RuleMatch } from "./rule.js";
 /**
  * Represents a source of external patterns.
  *
  * @since 0.6.0
  */
 export type Source = {
+    /**
+     * @internal
+     *
+     * @since 0.11.0
+     */
+    _noMatchCache?: RuleMatch;
     /**
      * Patterns defined within the source file.
      * Those patterns are for ignoring files.
      *
      * @see {@link ruleTest}
      *
-     * @since 0.6.0
+     * @since 0.11.0
      */
-    pattern: Rule[];
-    /**
-     * Name of the source file.
-     *
-     * @since 0.6.0
-     */
-    name: string;
+    rules: Rule[];
     /**
      * Relative path to the source file.
      *
@@ -36,14 +36,6 @@ export type Source = {
      * @since 0.6.0
      */
     inverted: boolean;
-    /**
-     * Error encountered during extraction, if any.
-     *
-     * @see {@link ExtractorFn}
-     *
-     * @since 0.6.0
-     */
-    error?: Error;
 };
 /**
  * Adds a negatable pattern to the source's rules.

package/out/scan.d.ts

@@ -4,10 +4,7 @@ export type * from "./types.js";
 /**
  * Scan the directory for included files based on the provided targets.
  *
- * Note that this function uses `fs.promises.readFile` and `fs.promises.opendir` without options within
- * custom recursion, instead of `fs.promises.readdir` with `{ withFileTypes: true }.
  * It also normalizes paths to use forward slashes.
- * Please report any issues if you encounter problems related to this behavior.
  *
  * @param options Scan options.
  * @returns A promise that resolves to a {@link MatcherContext} containing the scan results.
@@ -15,3 +12,14 @@ export type * from "./types.js";
  * @since 0.6.0
  */
 export declare function scan(options: ScanOptions): Promise<MatcherContext>;
+/**
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @param cb Callback function.
+ *
+ * @since 0.11.0
+ */
+export declare function scanCb(options: ScanOptions, cb: (err: Error | null, ctx: MatcherContext) => void): void;

package/out/scan.js

@@ -1,13 +1,11 @@
 import * as nodefs from "node:fs";
 import * as process from "node:process";
 import { scan as browserScan } from "./browser_scan.js";
+import { scanCb as browserScanCb } from "./scanCb.js";
 /**
  * Scan the directory for included files based on the provided targets.
  *
- * Note that this function uses `fs.promises.readFile` and `fs.promises.opendir` without options within
- * custom recursion, instead of `fs.promises.readdir` with `{ withFileTypes: true }.
  * It also normalizes paths to use forward slashes.
- * Please report any issues if you encounter problems related to this behavior.
  *
  * @param options Scan options.
  * @returns A promise that resolves to a {@link MatcherContext} containing the scan results.
@@ -16,5 +14,19 @@ import { scan as browserScan } from "./browser_scan.js";
  */
 export function scan(options) {
     const { cwd = process.cwd(), fs = nodefs } = options;
-    return browserScan({ fs, cwd, ...options });
+    return browserScan({ cwd, fs, ...options });
+}
+/**
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @param cb Callback function.
+ *
+ * @since 0.11.0
+ */
+export function scanCb(options, cb) {
+    const { cwd = process.cwd(), fs = nodefs } = options;
+    browserScanCb({ cwd, fs, ...options }, cb);
 }

package/out/scanCb.d.ts

@@ -0,0 +1,16 @@
+import type { MatcherContext } from "./patterns/matcherContext.js";
+import type { ScanOptions, FsAdapter } from "./types.js";
+/**
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @param cb Callback function.
+ *
+ * @since 0.11.0
+ */
+export declare function scanCb(options: ScanOptions & {
+    fs: FsAdapter;
+    cwd: string;
+}, cb: (err: Error | null, ctx: MatcherContext) => void): void;

package/out/scanCb.js

@@ -0,0 +1,73 @@
+import { scanParallel } from "./scanParallel.js";
+import { unixify } from "./unixify.js";
+import { walkPatchResult, walkPatchTotal, propagateTotals } from "./walk.js";
+/**
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @param cb Callback function.
+ *
+ * @since 0.11.0
+ */
+export function scanCb(options, cb) {
+    const { target, cwd, within = ".", invert = false, depth: maxDepth = Infinity, signal = null, fastDepth = false, fastInternal = false, fs, } = options;
+    if (maxDepth < 0) {
+        cb(new TypeError("Depth must be a non-negative integer"), null);
+        return;
+    }
+    const ctx = {
+        external: new Map(),
+        failed: [],
+        paths: new Map(),
+        total: new Map([[".", { totalDirs: 0, totalFiles: 0, totalMatchedFiles: 0 }]]),
+    };
+    const normalCwd = unixify(cwd);
+    const scanOptions = {
+        cwd: normalCwd,
+        depth: maxDepth,
+        fastDepth,
+        fastInternal,
+        fs,
+        invert,
+        signal,
+        target,
+        within,
+    };
+    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,
+            within,
+        }, (err) => {
+            if (err) {
+                cb(err, null);
+                return;
+            }
+            propagateTotals(ctx.total);
+            cb(null, ctx);
+        });
+    };
+    if (target.init) {
+        target.init({ cwd: normalCwd, fs, signal, target }, (err) => {
+            if (err) {
+                cb(err, null);
+                return;
+            }
+            startScan();
+        });
+    }
+    else {
+        startScan();
+    }
+}

package/out/scanParallel.d.ts

@@ -0,0 +1,18 @@
+import type { MatcherStream } from "./patterns/matcherStream.js";
+import type { Resource, InvalidSource } from "./patterns/resource.js";
+import type { ScanOptions } from "./types.js";
+import { type WalkResult, type WalkTotal } from "./walk.js";
+export interface ScanParallelOptions {
+    scanOptions: Required<ScanOptions>;
+    within: string;
+    stream?: MatcherStream;
+    external: Map<string, Resource>;
+    failed?: InvalidSource[];
+    onResult?: (result: WalkResult | WalkTotal) => void;
+}
+/**
+ * Executes a parallel directory scan.
+ *
+ * @since 0.11.0
+ */
+export declare function scanParallel(options: ScanParallelOptions, cb: (err: Error | null, results: WalkResult[] | null) => void): void;

package/out/scanParallel.js

@@ -0,0 +1,146 @@
+import { resolveSources } from "./patterns/resolveSources.js";
+import { join, unixify } from "./unixify.js";
+import { walkIncludes } from "./walk.js";
+/**
+ * Executes a parallel directory scan.
+ *
+ * @since 0.11.0
+ */
+export function scanParallel(options, cb) {
+    const { scanOptions, stream, external, failed, onResult } = options;
+    scanOptions.cwd = unixify(scanOptions.cwd);
+    let { within } = options;
+    if (within.startsWith("./"))
+        within = within.slice(2);
+    const results = onResult ? null : [];
+    let activeTasks = 0;
+    let errorOccurred = null;
+    function walk(relPath, depth, resource, lowerRelPath) {
+        if (errorOccurred)
+            return;
+        activeTasks++;
+        scanOptions.fs.readdir(join(scanOptions.cwd, relPath), { withFileTypes: true }, (err, entries) => {
+            if (err) {
+                handleError(err);
+                return;
+            }
+            resolveSources({ ...scanOptions, dir: relPath, entries, external, resource }, (err, res) => {
+                if (err) {
+                    handleError(err);
+                    return;
+                }
+                if (res && "error" in res && res.error) {
+                    if (failed) {
+                        failed.push(res);
+                    }
+                    else {
+                        handleError(res.error);
+                        return;
+                    }
+                }
+                const len = entries.length;
+                const prefix = relPath === "." || relPath === "" ? "" : relPath + "/";
+                const lowerPrefix = lowerRelPath
+                    ? lowerRelPath + "/"
+                    : prefix
+                        ? prefix.toLowerCase()
+                        : "";
+                let pendingResults = len;
+                let dirFiles = 0;
+                let dirMatched = 0;
+                let dirDirs = 0;
+                if (len === 0) {
+                    if (onResult) {
+                        onResult({
+                            depth,
+                            dir: relPath,
+                            dirs: 0,
+                            files: 0,
+                            ignored: false,
+                            matched: 0,
+                            type: "total",
+                        });
+                    }
+                }
+                for (let i = 0; i < len; i++) {
+                    const entry = entries[i];
+                    activeTasks++;
+                    const name = entry.name;
+                    const currentRelPath = prefix + name;
+                    const currentLowerRelPath = lowerPrefix + name.toLowerCase();
+                    walkIncludes({
+                        depth,
+                        entry,
+                        lowerRelPath: currentLowerRelPath,
+                        parentPath: relPath,
+                        relPath: currentRelPath,
+                        resource: res,
+                        scanOptions,
+                        stream,
+                    }, (err, self) => {
+                        if (err) {
+                            handleError(err);
+                            return;
+                        }
+                        if (self && self.match) {
+                            if (self.isDir) {
+                                dirDirs++;
+                            }
+                            else {
+                                dirFiles++;
+                                if (!self.match.ignored)
+                                    dirMatched++;
+                            }
+                            if (onResult) {
+                                onResult(self);
+                            }
+                            else {
+                                results.push(self);
+                            }
+                            if (entry.isDirectory() && self.next === 0) {
+                                walk(currentRelPath, depth + 1, res, currentLowerRelPath);
+                            }
+                        }
+                        pendingResults--;
+                        if (pendingResults === 0) {
+                            if (onResult) {
+                                onResult({
+                                    depth,
+                                    dir: relPath,
+                                    dirs: dirDirs,
+                                    files: dirFiles,
+                                    ignored: false,
+                                    matched: dirMatched,
+                                    type: "total",
+                                });
+                            }
+                        }
+                        taskDone();
+                    });
+                }
+                taskDone();
+            });
+        });
+    }
+    function handleError(err) {
+        if (!errorOccurred) {
+            errorOccurred = err;
+            cb(err, null);
+        }
+    }
+    function taskDone() {
+        activeTasks--;
+        if (activeTasks === 0 && !errorOccurred) {
+            cb(null, results);
+        }
+    }
+    let initialDepth = 0;
+    if (within !== "." && within !== "") {
+        const len = within.length;
+        for (let i = 0; i < len; i++) {
+            if (within.charCodeAt(i) === 47)
+                initialDepth++;
+        }
+    }
+    walk(within, initialDepth, undefined, within === "." || within === "" ? "" : within.toLowerCase());
+}