view-ignored 0.10.0 → 0.11.0

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

@@ -1,4 +1,4 @@
-import { makeRe } from "minimatch";
+import glob from "micromatch";
 /**
  * Compiles a string of the {@link PatternList}.
  *
@@ -7,25 +7,54 @@ import { makeRe } from "minimatch";
  * @since 0.8.0
  */
 export function patternCompile(pattern, context = [], options) {
-    const original = pattern;
-    if (pattern.endsWith("/")) {
-        pattern = pattern.substring(0, pattern.length - 1);
-    }
-    if (pattern.startsWith("/")) {
-        pattern = pattern.substring(1);
+    const isRoot = pattern.charCodeAt(0) === 47; // '/'
+    const nocase = !!options?.nocase;
+    let cleaned = pattern;
+    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 matchBase = !isRoot && !cleaned.includes("/");
+    const matcherOpts = {
+        dot: true,
+        matchBase,
+        nobrace: true,
+        nocase,
+        nonegate: true,
+    };
+    const isMatch = glob.matcher(lowerCleaned, { ...matcherOpts, nocase: false });
+    const re = {
+        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;
     }
-    else if (!pattern.startsWith("**/")) {
-        pattern = "**/" + pattern;
+    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;
+            }
+            pos = normStr.indexOf(cleaned, pos + 1);
+        }
     }
-    if (!pattern.endsWith("/**")) {
-        pattern += "/**";
+    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);
+        }
     }
-    const re = makeRe(pattern, {
-        dot: true,
-        nonegate: true,
-        nocomment: true,
-        nobrace: true,
-        nocase: options?.nocase ?? false,
-    });
-    return { re, pattern: original, patternContext: context };
+    return false;
 }

package/out/patterns/patternList.d.ts

@@ -9,19 +9,23 @@ import { type PatternCompileOptions } from "./patternCompile.js";
  */
 export type PatternCache = {
     /**
-     * The regular expression instance.
+     * The regular expression interface.
      *
      * @since 0.6.0
      */
-    re: RegExp;
+    re: {
+        test(string: string, matchCtx: {
+            lower?: string;
+        }): boolean;
+    };
     /**
-     * The original pattern string this minimatch was compiled from.
+     * The original pattern string this cache was compiled from.
      *
      * @since 0.6.0
      */
     pattern: string;
     /**
-     * The original pattern list this pattern was compiled from.
+     * The original pattern list this cache was compiled from.
      *
      * @since 0.6.0
      */
@@ -32,9 +36,11 @@ 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 minimatch patterns.
+ * Represents a list of positive glob patterns.
  *
  * @since 0.6.0
  */

package/out/patterns/patternList.js

@@ -4,9 +4,8 @@ import { patternCompile } from "./patternCompile.js";
  *
  * @since 0.6.0
  */
-export function patternCacheTest(cache, path) {
-    cache.re.lastIndex = 0;
-    return cache.re.test(path);
+export function patternCacheTest(cache, path, matchCtx = {}) {
+    return cache.re.test(path, matchCtx);
 }
 /**
  * Compiles the {@link PatternList}.
@@ -17,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;

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 {};