view-ignored 0.5.2 → 0.6.0

package/out/patterns/resolveSources.js

@@ -0,0 +1,142 @@
+import { dirname, relative, resolve } from "node:path";
+import { normalizeCwd } from "../normalizeCwd.js";
+import { patternCompile } from "./pattern.js";
+/**
+ * Compiles the {@link SignedPattern} (forced).
+ * Can be compiled at any time.
+ * Extractors are compiling it.
+ *
+ * @see {@link patternCompile}
+ *
+ * @since 0.0.6
+ */
+export function signedPatternCompile(signedPattern) {
+    signedPattern.compiled = {
+        include: patternCompile(signedPattern.include),
+        exclude: patternCompile(signedPattern.exclude),
+    };
+    return signedPattern;
+}
+/**
+ * Populates the {@link MatcherContext.external} map with {@link Source} objects.
+ *
+ * @since 0.0.6
+ */
+export async function resolveSources(options) {
+    const { fs, ctx, cwd, target, root } = options;
+    let dir = options.dir;
+    if (ctx.external.has(dir)) {
+        return;
+    }
+    let source;
+    const noSourceDirList = [dir];
+    if (dir !== ".") {
+        dir = dirname(dir);
+        // find source from an ancestor [dir < ... < cwd]
+        while (true) {
+            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);
+                }
+                return;
+            }
+            noSourceDirList.push(dir);
+            const parent = dirname(dir);
+            if (dir === dir)
+                break;
+            dir = parent;
+            continue;
+        }
+    }
+    // else
+    // find non-cwd source [root > cwd) and populate [cwd > ... > dir]
+    // root, root/cwd[0], root/cwd[0]/cwd[2]
+    const preCwdSegments = [];
+    {
+        let c = dirname(cwd);
+        while (true) {
+            preCwdSegments.push(c);
+            if (c === "/" || c === root)
+                break;
+            const parent = dirname(c);
+            c = parent;
+        }
+        preCwdSegments.reverse();
+    }
+    source = await findSourceForAbsoluteDirs(preCwdSegments, ctx, fs, target);
+    if (typeof source === "object") {
+        for (const noSourceDir of noSourceDirList) {
+            ctx.external.set(noSourceDir, source);
+        }
+    }
+    const rels = noSourceDirList.map((rel) => normalizeCwd(resolve(process.cwd(), relative(normalizeCwd(rel), normalizeCwd(cwd)))));
+    source = await findSourceForAbsoluteDirs(rels, ctx, fs, target);
+    if (source !== undefined) {
+        for (const noSourceDir of noSourceDirList) {
+            ctx.external.set(noSourceDir, source);
+        }
+    }
+}
+async function findSourceForAbsoluteDirs(paths, ctx, fs, target) {
+    let source;
+    for (const parent of paths) {
+        for (const extractor of target.extractors) {
+            const s = await tryExtractor(parent, fs, ctx, extractor);
+            if (typeof s === "object" && s.error) {
+                ctx.failed.push(s);
+                continue;
+            }
+            source = s;
+            if (source === "none") {
+                continue;
+            }
+            break;
+        }
+        if (source !== undefined) {
+            break;
+        }
+    }
+    return source;
+}
+async function tryExtractor(cwd, fs, ctx, extractor) {
+    const abs = resolve(cwd, extractor.path);
+    const path = relative(cwd, abs);
+    const name = path.substring(path.lastIndexOf("/") + 1);
+    const newSource = {
+        inverted: false,
+        name,
+        path,
+        pattern: { exclude: [], include: [], compiled: null },
+    };
+    let buff;
+    try {
+        buff = await fs.promises.readFile(abs);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            return "none";
+        }
+        newSource.error = error;
+        return newSource;
+    }
+    try {
+        const act = extractor.extract(newSource, buff, ctx);
+        if (act === "none") {
+            return act;
+        }
+    }
+    catch (err) {
+        if (err === "none") {
+            return err;
+        }
+        newSource.error =
+            err instanceof Error
+                ? err
+                : new Error("Unknown error during source extraction", { cause: err });
+        return newSource;
+    }
+    return newSource;
+}

package/out/patterns/signedPattern.d.ts

@@ -0,0 +1,117 @@
+import type { PatternFinderOptions } from "./extractor.js";
+import { type Pattern, type PatternMinimatch } from "./pattern.js";
+import type { Source } from "./source.js";
+/**
+ * Represents a set of include and exclude patterns.
+ * These patterns are positive minimatch patterns.
+ *
+ * @see {@link PatternMatcher} uses it.
+ * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+ * @see {@link signedPatternCompile} compiles the signed pattern.
+ * Use this or an extractor's method to compile.
+ *
+ * @since 0.0.6
+ */
+export type SignedPattern = {
+    /**
+     * Provides ignored or included file and directory patterns.
+     *
+     * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+     *
+     * @since 0.0.6
+     */
+    include: Pattern;
+    /**
+     * Provides ignored or included file and directory patterns.
+     *
+     * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+     *
+     * @since 0.0.6
+     */
+    exclude: Pattern;
+    /**
+     * Provides compiled ignored or included file and directory patterns.
+     *
+     * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+     *
+     * @since 0.0.6
+     */
+    compiled: null | {
+        /**
+         * Provides compiled ignored or included file and directory patterns.
+         *
+         * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+         *
+         * @since 0.0.6
+         */
+        include: PatternMinimatch[];
+        /**
+         * Provides compiled ignored or included file and directory patterns.
+         *
+         * @see {@link signedPatternIgnores} provides the ignoring algorithm.
+         *
+         * @since 0.0.6
+         */
+        exclude: PatternMinimatch[];
+    };
+};
+/**
+ * @see {@link signedPatternIgnores}
+ *
+ * @since 0.0.6
+ */
+export type SignedPatternMatch = {
+    kind: "none" | "no-match" | "invalid-internal-pattern" | "missing-source" | "broken-source" | "invalid-pattern";
+    ignored: boolean;
+} | {
+    kind: "internal";
+    pattern: string;
+    ignored: boolean;
+} | {
+    kind: "external";
+    pattern: string;
+    source: Source;
+    ignored: boolean;
+};
+/**
+ * @see {@link signedPatternIgnores}
+ *
+ * @since 0.0.6
+ */
+export interface SignedPatternIgnoresOptions extends PatternFinderOptions {
+    /**
+     * Relative entry path.
+     *
+     * @example
+     * "dir/subdir"
+     * "dir/subdir/index.js"
+     *
+     * @since 0.0.6
+     */
+    entry: string;
+    /**
+     * The internal pattern. Should be compiled.
+     *
+     * @since 0.0.6
+     */
+    internal: SignedPattern;
+}
+/**
+ * Checks whether a given entry should be ignored based on internal and external patterns.
+ * Populates unknown sources using {@link resolveSources}.
+ *
+ * Algorithm:
+ * 1. Check internal exclude patterns. If matched, return true.
+ * 2. Check internal include patterns. If matched, return false.
+ * 3. Check external patterns:
+ *    - If not inverted:
+ *      a. Check external include patterns. If matched, return false.
+ *      b. Check external exclude patterns. If matched, return true.
+ *    - If inverted:
+ *      a. Check external exclude patterns. If matched, return true.
+ *      b. Check external include patterns. If matched, return false.
+ * 4. If no patterns matched, return the inverted state.
+ *
+ * @since 0.0.6
+ */
+export declare function signedPatternIgnores(options: SignedPatternIgnoresOptions): Promise<SignedPatternMatch>;

package/out/patterns/signedPattern.js

@@ -0,0 +1,110 @@
+import { dirname } from "node:path/posix";
+import { patternMinimatchTest } from "./pattern.js";
+import { resolveSources } from "./resolveSources.js";
+function patternRegExpTest(path, rs) {
+    for (const r of rs) {
+        if (patternMinimatchTest(r, path)) {
+            return r.pattern;
+        }
+    }
+    return "";
+}
+function signedPatternCompiledMatchInternal(options, path) {
+    let patternMatch = "";
+    const kind = "internal";
+    const signedPattern = options.internal;
+    const compiled = signedPattern.compiled; // no null
+    try {
+        patternMatch = patternRegExpTest(path, compiled.exclude);
+        if (patternMatch) {
+            // return true
+            return { kind, pattern: patternMatch, ignored: true };
+        }
+        patternMatch = patternRegExpTest(path, compiled.include);
+        if (patternMatch) {
+            // return false
+            return { kind, pattern: patternMatch, ignored: false };
+        }
+    }
+    catch {
+        return { kind: "invalid-internal-pattern", ignored: false };
+    }
+    return { kind: "no-match", ignored: true };
+}
+function signedPatternCompiledMatchExternal(options, path, source) {
+    let patternMatch = "";
+    const kind = "external";
+    const signedPattern = source.pattern;
+    const compiled = signedPattern.compiled; // no null
+    try {
+        if (source.inverted) {
+            patternMatch = patternRegExpTest(path, compiled.exclude);
+            if (patternMatch) {
+                // return true
+                return { kind, source, pattern: patternMatch, ignored: true };
+            }
+            patternMatch = patternRegExpTest(path, compiled.include);
+            if (patternMatch) {
+                // return false
+                return { kind, source, pattern: patternMatch, ignored: false };
+            }
+        }
+        else {
+            patternMatch = patternRegExpTest(path, compiled.include);
+            if (patternMatch) {
+                // return false
+                return { kind, source, pattern: patternMatch, ignored: false };
+            }
+            patternMatch = patternRegExpTest(path, compiled.exclude);
+            if (patternMatch) {
+                // return true
+                return { kind, source, pattern: patternMatch, ignored: true };
+            }
+        }
+    }
+    catch (err) {
+        source.error = err;
+        options.ctx.failed.push(source);
+        return { kind: "invalid-pattern", ignored: false };
+    }
+    return { kind: "no-match", ignored: source.inverted };
+}
+/**
+ * Checks whether a given entry should be ignored based on internal and external patterns.
+ * Populates unknown sources using {@link resolveSources}.
+ *
+ * Algorithm:
+ * 1. Check internal exclude patterns. If matched, return true.
+ * 2. Check internal include patterns. If matched, return false.
+ * 3. Check external patterns:
+ *    - If not inverted:
+ *      a. Check external include patterns. If matched, return false.
+ *      b. Check external exclude patterns. If matched, return true.
+ *    - If inverted:
+ *      a. Check external exclude patterns. If matched, return true.
+ *      b. Check external include patterns. If matched, return false.
+ * 4. If no patterns matched, return the inverted state.
+ *
+ * @since 0.0.6
+ */
+export async function signedPatternIgnores(options) {
+    const parent = dirname(options.entry);
+    let source = options.ctx.external.get(parent);
+    if (source === undefined) {
+        const failedPrev = options.ctx.failed.length;
+        await resolveSources({ ...options, dir: parent, root: options.root });
+        if (failedPrev < options.ctx.failed.length) {
+            return { kind: "broken-source", ignored: false };
+        }
+        source = options.ctx.external.get(parent);
+    }
+    let internalMatch = signedPatternCompiledMatchInternal(options, options.entry);
+    if (internalMatch.kind !== "no-match") {
+        return internalMatch;
+    }
+    if (source === undefined || source === "none") {
+        return { kind: "no-match", ignored: false };
+    }
+    const externalMatch = signedPatternCompiledMatchExternal(options, options.entry, source);
+    return externalMatch;
+}

package/out/patterns/source.d.ts

@@ -0,0 +1,57 @@
+import type { SignedPattern } from "./signedPattern.js";
+/**
+ * Represents a source of external patterns.
+ *
+ * @since 0.0.6
+ */
+export type Source = {
+    /**
+     * Patterns defined within the source file.
+     * Those patterns are for ignoring files.
+     *
+     * @see {@link PatternMatcher}
+     * @see {@link signedPatternIgnores}
+     *
+     * @since 0.0.6
+     */
+    pattern: SignedPattern;
+    /**
+     * Name of the source file.
+     *
+     * @since 0.0.6
+     */
+    name: string;
+    /**
+     * Relative path to the source file.
+     *
+     * @since 0.0.6
+     */
+    path: string;
+    /**
+     * Indicates if the matching logic is inverted.
+     * For example, `package.json` `files` field inverts the matching logic,
+     * because it specifies files to include rather than exclude.
+     *
+     * @see {@link PatternMatcher}
+     * @see {@link signedPatternIgnores}
+     *
+     * @since 0.0.6
+     */
+    inverted: boolean;
+    /**
+     * Error encountered during extraction, if any.
+     *
+     * @see {@link ExtractorFn}
+     *
+     * @since 0.0.6
+     */
+    error?: Error;
+};
+/**
+ * Adds a negatable pattern to the source's pattern lists.
+ * Strips the leading '!' for include patterns,
+ * and adds to exclude patterns otherwise.
+ *
+ * @since 0.0.6
+ */
+export declare function sourcePushNegatable(source: Source, pattern: string): void;

package/out/patterns/source.js

@@ -0,0 +1,20 @@
+/**
+ * Adds a negatable pattern to the source's pattern lists.
+ * Strips the leading '!' for include patterns,
+ * and adds to exclude patterns otherwise.
+ *
+ * @since 0.0.6
+ */
+export function sourcePushNegatable(source, pattern) {
+    let exclude = source.pattern.exclude, include = source.pattern.include;
+    if (source.inverted) {
+        ;
+        [exclude, include] = [include, exclude];
+    }
+    let dist = exclude;
+    if (pattern.startsWith("!")) {
+        dist = include;
+        pattern = pattern.substring(1);
+    }
+    dist.push(pattern);
+}

package/out/patterns/stringCompile.d.ts

@@ -0,0 +1,9 @@
+import type { PatternMinimatch, Pattern } from "./pattern.js";
+/**
+ * Compiles a string of the {@link Pattern}.
+ *
+ * @see {@link patternCompile}
+ *
+ * @since 0.0.6
+ */
+export declare function stringCompile(pattern: string, _?: number, array?: Pattern): PatternMinimatch;

package/out/patterns/stringCompile.js

@@ -0,0 +1,28 @@
+import { makeRe } from "minimatch";
+/**
+ * Compiles a string of the {@link Pattern}.
+ *
+ * @see {@link patternCompile}
+ *
+ * @since 0.0.6
+ */
+export function stringCompile(pattern, _ = -1, array = []) {
+    const original = pattern;
+    if (pattern.endsWith("/")) {
+        pattern = pattern.substring(0, pattern.length - 1);
+    }
+    if (pattern.startsWith("/")) {
+        pattern = pattern.substring(1);
+    }
+    else if (!pattern.startsWith("**/")) {
+        pattern = "**/" + pattern;
+    }
+    pattern += "/**";
+    const re = makeRe(pattern, {
+        dot: true,
+        nonegate: true,
+        nocomment: true,
+        nobrace: true,
+    });
+    return { re, pattern: original, patternContext: array };
+}

package/out/scan.d.ts

@@ -1,40 +1,6 @@
-import type { MatcherContext } from './patterns/matcher.js';
-import type { Target } from './targets/target.js';
-export type DepthMode = 'files' | undefined;
-export type ScanOptions = {
-    /**
-     * Provides the matcher to use for scanning.
-     */
-    target: Target;
-    /**
-     * Current working directory to start the scan from.
-     */
-    cwd?: string;
-    /**
-     * If enabled, the scan will return files that are ignored by the target matcher.
-     */
-    invert?: boolean;
-    /**
-     * Starting from depth `0` means you will see
-     * children of the current working directory.
-     */
-    depth?: number;
-    /**
-     * Return as soon as possible.
-     */
-    signal?: AbortSignal;
-    /**
-     * Requires depth >= 0.
-     * If enabled, directories will be processed faster
-     * by skipping files after first match.
-     * This makes the scan faster but affects
-     * {@link MatcherContext.totalDirs},
-     * {@link MatcherContext.totalFiles},
-     * {@link MatcherContext.totalMatchedFiles}
-     * and {@link MatcherContext.depthPaths}.
-     */
-    fastDepth?: boolean;
-};
+import type { MatcherContext } from "./patterns/matcherContext.js";
+import type { ScanOptions } from "./types.js";
+export type * from "./types.js";
 /**
  * Scan the directory for included files based on the provided targets.
  *
@@ -45,5 +11,7 @@ export type ScanOptions = {
  *
  * @param options Scan options.
  * @returns A promise that resolves to a {@link MatcherContext} containing the scan results.
+ *
+ * @since 0.0.6
  */
 export declare function scan(options: ScanOptions): Promise<MatcherContext>;

package/out/scan.js

@@ -1,5 +1,6 @@
-import { posix } from 'node:path';
-import { opendir } from './walk.js';
+import * as nodefs from "node:fs";
+import * as process from "node:process";
+import { scan as browserScan } from "./browser_scan.js";
 /**
  * Scan the directory for included files based on the provided targets.
  *
@@ -10,104 +11,10 @@ import { opendir } from './walk.js';
  *
  * @param options Scan options.
  * @returns A promise that resolves to a {@link MatcherContext} containing the scan results.
+ *
+ * @since 0.0.6
  */
-export async function scan(options) {
-    const { target, cwd: cwdo = (await import('node:process')).cwd(), depth: maxDepth = Infinity, invert = false, signal = undefined, fastDepth = false, } = options;
-    if (maxDepth < 0) {
-        throw new TypeError('Depth must be a non-negative integer');
-    }
-    const cwd = cwdo.replaceAll('\\', '/');
-    const ctx = {
-        paths: new Set(),
-        external: new Map(),
-        depthPaths: new Map(),
-        sourceErrors: [],
-        totalFiles: 0,
-        totalMatchedFiles: 0,
-        totalDirs: 0,
-    };
-    await opendir(cwd, async (entry) => {
-        signal?.throwIfAborted();
-        const path = posix.join(posix.relative(cwd, entry.parentPath.replaceAll('\\', '/')), entry.name);
-        if (entry.isDirectory()) {
-            ctx.totalDirs++;
-            if (!fastDepth) {
-                return 0;
-            }
-            const { depth } = getDepth(path, maxDepth);
-            if (depth <= maxDepth) {
-                return 0;
-            }
-            return 1;
-        }
-        ctx.totalFiles++;
-        if (fastDepth) {
-            const { depth, depthSlash } = getDepth(path, maxDepth);
-            if (depth > maxDepth) {
-                let ignored = await target.matcher(path, false, ctx);
-                if (ctx.sourceErrors.length > 0) {
-                    return 2;
-                }
-                if (invert) {
-                    ignored = !ignored;
-                }
-                if (ignored) {
-                    return 0;
-                }
-                const dir = path.substring(0, depthSlash);
-                ctx.depthPaths.set(dir, (ctx.depthPaths.get(dir) ?? 0) + 1);
-                return 1;
-            }
-        }
-        let ignored = await target.matcher(path, false, ctx);
-        if (ctx.sourceErrors.length > 0) {
-            return 2;
-        }
-        if (invert) {
-            ignored = !ignored;
-        }
-        if (ignored) {
-            return 0;
-        }
-        ctx.totalMatchedFiles++;
-        const { depth, depthSlash } = getDepth(path, maxDepth);
-        if (depth > maxDepth) {
-            const dir = path.substring(0, depthSlash);
-            ctx.depthPaths.set(dir, (ctx.depthPaths.get(dir) ?? 0) + 1);
-        }
-        else {
-            ctx.paths.add(path);
-        }
-        return 0;
-    });
-    signal?.throwIfAborted();
-    for (const [dir, count] of ctx.depthPaths) {
-        if (count === 0) {
-            continue;
-        }
-        ctx.paths.add(dir + '/');
-    }
-    return ctx;
-}
-function getDepth(path, maxDepth) {
-    const result = {
-        depth: 0,
-        depthSlash: 0,
-    };
-    result.depthSlash = -1;
-    if (maxDepth < 0) {
-        return result;
-    }
-    for (const [i, c] of Array.from(path).entries()) {
-        if (c !== '/') {
-            continue;
-        }
-        result.depth++;
-        if (result.depth < maxDepth) {
-            continue;
-        }
-        result.depthSlash = i;
-        return result;
-    }
-    return result;
+export function scan(options) {
+    const { cwd = process.cwd(), fs = nodefs } = options;
+    return browserScan({ fs, cwd, ...options });
 }

package/out/stream.d.ts

@@ -0,0 +1,9 @@
+import type { MatcherStream } from "./patterns/matcherStream.js";
+import type { ScanOptions } from "./types.js";
+export type * from "./types.js";
+/**
+ * @see {@link scan}
+ *
+ * @since 0.0.6
+ */
+export declare function scanStream(options: ScanOptions): MatcherStream;

package/out/stream.js

@@ -0,0 +1,12 @@
+import * as nodefs from "node:fs";
+import * as process from "node:process";
+import { scanStream as browserStream } from "./browser_stream.js";
+/**
+ * @see {@link scan}
+ *
+ * @since 0.0.6
+ */
+export function scanStream(options) {
+    const { cwd = process.cwd(), fs = nodefs } = options;
+    return browserStream({ fs, cwd, ...options });
+}

package/out/targets/git.d.ts

@@ -1,2 +1,5 @@
-import type { Target } from './target.js';
+import type { Target } from "./target.js";
+/**
+ * @since 0.0.6
+ */
 export declare const Git: Target;