view-ignored 0.10.1 → 0.11.1

package/out/patterns/resolveSources.js

@@ -1,5 +1,5 @@
-import { dirname } from "node:path";
-import { join, base } from "../unixify.js";
+import { join } from "../unixify.js";
+import {} from "./extractor.js";
 import { patternListCompile } from "./patternList.js";
 /**
  * Compiles the {@link Rule} (forced).
@@ -10,128 +10,184 @@ import { patternListCompile } from "./patternList.js";
  *
  * @since 0.6.0
  */
-export function ruleCompile(signedPattern, options) {
-    signedPattern.compiled = patternListCompile(signedPattern.pattern, options);
-    return signedPattern;
+export function ruleCompile(rule, options) {
+    rule.compiled = patternListCompile(rule.pattern, options);
+    return rule;
 }
 /**
- * Populates the {@link MatcherContext.external} map with {@link Source} objects.
- *
  * @since 0.6.0
  */
-export async function resolveSources(options) {
-    const { fs, ctx, cwd, signal, target } = options;
+export function resolveSources(options, cb) {
+    const { fs, external, cwd, signal, target, resource: parentResource } = options;
     let dir = options.dir;
-    if (ctx.external.has(dir)) {
+    if (target.root === "." && dir !== ".") {
+        resolveSources({ ...options, dir: "." }, (err, res) => {
+            if (err)
+                return cb(err, null);
+            external.set(dir, res);
+            cb(null, res);
+        });
+        return;
+    }
+    let source = external.get(dir);
+    if (source !== undefined) {
+        cb(null, source);
         return;
     }
-    let source;
     const noSourceDirList = [dir];
     if (dir !== ".") {
-        dir = dirname(dir);
-        // find source from an ancestor [dir < ... < cwd]
-        while (true) {
-            signal?.throwIfAborted();
-            source = ctx.external.get(dir);
-            if (source !== undefined) {
-                // if cache is found populate descendants [cwd > ... > dir]
-                for (const noSourceDir of noSourceDirList) {
-                    ctx.external.set(noSourceDir, source);
-                }
+        const segments = dir.split("/");
+        for (let i = segments.length - 1; i >= 0; i--) {
+            if (signal?.aborted) {
+                cb(signal.reason, null);
                 return;
             }
-            noSourceDirList.push(dir);
-            const parent = dirname(dir);
-            if (dir === parent)
+            const d = segments.slice(0, i).join("/") || ".";
+            source = external.get(d);
+            if (source !== undefined) {
+                dir = d;
                 break;
-            dir = parent;
-            continue;
+            }
+            noSourceDirList.push(d);
+            if (d === ".") {
+                dir = ".";
+                break;
+            }
         }
     }
-    // else
     // find non-cwd source [root > cwd) and populate [cwd > ... > dir]
-    const preCwdSegments = [];
-    if (target.root.startsWith("/")) {
-        let c = dirname(cwd);
-        while (true) {
-            signal?.throwIfAborted();
-            preCwdSegments.push(c);
-            if (c === target.root)
-                break;
-            const parent = dirname(c);
-            c = parent;
+    if (target.root.charCodeAt(0) === 47) {
+        // "/"
+        const segments = cwd.split("/");
+        const preCwdSegments = [];
+        let current = "";
+        for (let i = 0, len = segments.length - 1; i < len; i++) {
+            current += segments[i] + "/";
+            const path = current.length > 1 ? current.slice(0, -1) : "/";
+            if (path.length >= target.root.length) {
+                preCwdSegments.push(path);
+            }
         }
-        preCwdSegments.reverse();
-        source = await findSourceForAbsoluteDirs(preCwdSegments, ctx, fs, target, signal);
-        if (typeof source === "object") {
-            for (const noSourceDir of noSourceDirList) {
-                signal?.throwIfAborted();
-                ctx.external.set(noSourceDir, source);
+        findSourceForAbsoluteDirsCb(preCwdSegments, fs, target, signal, (err, source) => {
+            if (err) {
+                cb(err, null);
+                return;
             }
+            const absPaths = Array.from({ length: noSourceDirList.length });
+            for (let i = 0, len = noSourceDirList.length; i < len; i++) {
+                absPaths[i] = join(cwd, noSourceDirList[i]);
+            }
+            findSourceForAbsoluteDirsCb(absPaths, fs, target, signal, (err, s) => {
+                if (err) {
+                    cb(err, null);
+                    return;
+                }
+                const finalSource = s || source || parentResource || null;
+                external.set(options.dir, finalSource);
+                cb(null, finalSource);
+            }, options.entries);
+        });
+        return;
+    }
+    const absPaths = Array.from({ length: noSourceDirList.length });
+    for (let i = 0, len = noSourceDirList.length; i < len; i++) {
+        absPaths[i] = join(cwd, noSourceDirList[i]);
+    }
+    findSourceForAbsoluteDirsCb(absPaths, fs, target, signal, (err, source) => {
+        if (err) {
+            cb(err, null);
             return;
         }
+        const finalSource = source || parentResource || null;
+        external.set(options.dir, finalSource);
+        cb(null, finalSource);
+    }, options.entries);
+}
+function findSourceForAbsoluteDirsCb(paths, fs, target, signal, cb, entries) {
+    if (signal?.aborted) {
+        cb(signal.reason, null);
+        return;
     }
-    const absPaths = noSourceDirList.map((rel) => join(cwd, rel));
-    source = await findSourceForAbsoluteDirs(absPaths, ctx, fs, target, signal);
-    if (source !== undefined) {
-        for (const noSourceDir of noSourceDirList) {
-            signal?.throwIfAborted();
-            ctx.external.set(noSourceDir, source);
+    const extractors = target.extractors;
+    const plen = paths.length;
+    const elen = extractors.length;
+    let i = 0;
+    let j = 0;
+    function next() {
+        if (i >= plen) {
+            cb(null, null);
+            return;
         }
-    }
-}
-async function findSourceForAbsoluteDirs(paths, ctx, fs, target, signal) {
-    for (const parent of paths) {
-        for (const extractor of target.extractors) {
-            signal?.throwIfAborted();
-            const s = await tryExtractor(parent, fs, ctx, extractor);
-            if (typeof s === "object" && s.error) {
-                ctx.failed.push(s);
-                return s;
+        const parent = paths[i];
+        const extractor = extractors[j];
+        j++;
+        if (j >= elen) {
+            i++;
+            j = 0;
+        }
+        if (entries && plen > 0 && parent === paths[0]) {
+            const epath = extractor.path;
+            const slashIdx = epath.indexOf("/");
+            const firstSegment = slashIdx === -1 ? epath : epath.substring(0, slashIdx);
+            let found = false;
+            for (let k = 0, len = entries.length; k < len; k++) {
+                if (entries[k].name === firstSegment) {
+                    found = true;
+                    break;
+                }
             }
-            if (typeof s === "object") {
-                return s;
+            if (!found) {
+                next();
+                return;
             }
         }
+        tryExtractorCb(parent, fs, extractor, (err, source) => {
+            if (err) {
+                cb(err, null);
+                return;
+            }
+            if (source !== null) {
+                cb(null, source);
+                return;
+            }
+            next();
+        });
     }
-    return "none";
+    next();
 }
-async function tryExtractor(cwd, fs, ctx, extractor) {
-    let abs = join(cwd, extractor.path);
-    const name = base(extractor.path);
-    const newSource = {
-        name,
-        path: extractor.path,
-        inverted: false,
-        pattern: [],
-    };
-    let buff;
-    try {
-        buff = await fs.promises.readFile(abs);
-    }
-    catch (err) {
-        const error = err;
-        if (error.code === "ENOENT") {
-            return "none";
+function tryExtractorCb(cwd, fs, extractor, cb) {
+    const abs = join(cwd, extractor.path);
+    fs.readFile(abs, (err, buff) => {
+        if (err) {
+            const error = err;
+            if (error.code === "ENOENT") {
+                cb(null, null);
+                return;
+            }
+            cb(null, {
+                error,
+                source: {
+                    inverted: false,
+                    path: extractor.path,
+                    rules: [],
+                },
+            });
+            return;
         }
-        newSource.error = error;
-        return newSource;
-    }
-    try {
-        const act = extractor.extract(newSource, buff, ctx);
-        if (act === "none") {
-            return act;
+        const newSource = {
+            inverted: false,
+            path: extractor.path,
+            rules: [],
+        };
+        const act = extractor.extract(newSource, buff);
+        if (act === null) {
+            cb(null, null);
+            return;
         }
-    }
-    catch (err) {
-        if (err === "none") {
-            return err;
+        if (act instanceof Error) {
+            cb(null, { error: act, source: newSource });
+            return;
         }
-        newSource.error =
-            err instanceof Error
-                ? err
-                : new Error("Unknown error during source extraction", { cause: err });
-        return newSource;
-    }
-    return newSource;
+        cb(null, newSource);
+    });
 }

package/out/patterns/resource.d.ts

@@ -0,0 +1,16 @@
+import type { Source } from "./source.js";
+/**
+ * Represents missing source, existing source or invalid source.
+ *
+ * @since 0.11.0
+ */
+export type Resource = Source | InvalidSource | null;
+/**
+ * Represents a source with an associated error.
+ *
+ * @since 0.11.0
+ */
+export type InvalidSource = {
+    source: Source;
+    error: Error;
+};

package/out/patterns/resource.js

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

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.