view-ignored 0.5.1 → 0.6.0

package/out/patterns/jsrjson.js

@@ -1,18 +1,28 @@
-import { type } from 'arktype';
-import stripJsonComments from 'strip-json-comments';
+import { type } from "arktype";
+import stripJsonComments from "strip-json-comments";
+import { signedPatternCompile } from "./resolveSources.js";
 const jsrManifest = type({
-    exclude: 'string[]?',
-    include: 'string[]?',
-    publish: {
-        exclude: 'string[]?',
-        include: 'string[]?',
+    exclude: "string[]?",
+    include: "string[]?",
+    "publish?": {
+        exclude: "string[]?",
+        include: "string[]?",
     },
 });
-const parse = jsrManifest.pipe((s) => JSON.parse(s));
-export function extractJsrJson(source, content) {
+const parse = type("string")
+    .pipe((s) => JSON.parse(s))
+    .pipe(jsrManifest);
+/**
+ * Extracts and compiles patterns from the file.
+ *
+ * @since 0.0.6
+ */
+export function extractJsrJson(source, content, ctx) {
     const dist = parse(content.toString());
     if (dist instanceof type.errors) {
-        return dist;
+        source.error = new Error("Invalid '" + source.path + "': " + dist.summary, { cause: dist });
+        ctx.failed.push(source);
+        return;
     }
     if (!dist.publish) {
         if (dist.exclude) {
@@ -30,10 +40,17 @@ export function extractJsrJson(source, content) {
     else if (dist.publish.include) {
         source.pattern.include.push(...dist.publish.include);
     }
-    return;
+    signedPatternCompile(source.pattern);
 }
 extractJsrJson;
-export function extractJsrJsonc(source, content) {
-    return extractJsrJson(source, Buffer.from(stripJsonComments(content.toString())));
+/**
+ * Extracts and compiles patterns from the file.
+ *
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
+export function extractJsrJsonc(source, content, ctx) {
+    extractJsrJson(source, Buffer.from(stripJsonComments(content.toString())), ctx);
 }
 extractJsrJsonc;

package/out/patterns/matcherContext.d.ts

@@ -0,0 +1,71 @@
+import type { SignedPatternMatch } from "./signedPattern.js";
+import type { Source } from "./source.js";
+/**
+ * Post-scan results.
+ *
+ * @since 0.0.6
+ */
+export interface MatcherContext {
+    /**
+     * Paths and their corresponding sources.
+     * Directory paths are having the slash suffix.
+     *
+     * @since 0.0.6
+     */
+    paths: Map<string, SignedPatternMatch>;
+    /**
+     * Maps directory paths to their corresponding sources.
+     *
+     * @example
+     * "dir" => Source
+     * "dir/subdir" => Source
+     *
+     * @since 0.0.6
+     */
+    external: Map<string, Source | "none">;
+    /**
+     * If any fatal errors were encountered during source extractions,
+     * this property will contain an array of failed sources.
+     *
+     * @since 0.0.6
+     */
+    failed: Source[];
+    /**
+     * Maps directory paths to the quantity of files they contain.
+     *
+     * @example
+     * // for
+     * "src/"
+     * "src/components/"
+     * "src/views/"
+     * "src/views/index.html"
+     *
+     * // depth: 0
+     * "src" => 1
+     *
+     * // depth: 1
+     * "src/components" => 0
+     * "src/views" => 1
+     *
+     * @since 0.0.6
+     */
+    depthPaths: Map<string, number>;
+    /**
+     * Total number of files scanned.
+     *
+     * @since 0.0.6
+     */
+    totalFiles: number;
+    /**
+     * Total number of files matched by the target.
+     *
+     * @since 0.0.6
+     */
+    totalMatchedFiles: number;
+    /**
+     * Total number of directories scanned.
+     *
+     * @since 0.0.6
+     */
+    totalDirs: number;
+}

package/out/patterns/matcherContext.js

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

package/out/patterns/matcherContextPatch.d.ts

@@ -0,0 +1,16 @@
+import type { ScanOptions } from "../types.js";
+import type { MatcherContext } from "./matcherContext.js";
+/**
+ * Provides patching abilities for the given {@link MatcherContext}.
+ * Directories should have the slash suffix.
+ *
+ * @since 0.0.6
+ */
+export declare function matcherContextAddPath(ctx: MatcherContext, options: Required<ScanOptions>, entry: string): Promise<boolean>;
+/**
+ * Provides patching abilities for the given {@link MatcherContext}.
+ * Directories should have the slash suffix.
+ *
+ * @since 0.0.6
+ */
+export declare function matcherContextRemovePath(ctx: MatcherContext, options: Required<ScanOptions>, entry: string): Promise<boolean>;

package/out/patterns/matcherContextPatch.js

@@ -0,0 +1,151 @@
+import { resolve, dirname } from "node:path";
+import { getDepth } from "../getDepth.js";
+import { normalizeCwd } from "../normalizeCwd.js";
+import { opendir } from "../opendir.js";
+import { walkIncludes } from "../walk.js";
+/**
+ * Provides patching abilities for the given {@link MatcherContext}.
+ * Directories should have the slash suffix.
+ *
+ * @since 0.0.6
+ */
+export async function matcherContextAddPath(ctx, options, entry) {
+    if (ctx.paths.has(entry)) {
+        return false;
+    }
+    const { target, fs, cwd } = options;
+    const isDir = entry.endsWith("/");
+    if (isDir) {
+        // recursive parent population
+        const direntPath = entry.replace(/\/$/, "");
+        if (direntPath === ".") {
+            return true;
+        }
+        ctx.paths.set(entry, await target.ignores({ fs, cwd, entry: direntPath, ctx }));
+        if (ctx.totalFiles >= 0) {
+            ctx.totalDirs++;
+        }
+        const parent = dirname(direntPath);
+        if (parent !== ".") {
+            void (await matcherContextAddPath(ctx, options, parent + "/"));
+        }
+        return true;
+    }
+    const parent = dirname(entry);
+    const isSource = target.extractors.some((e) => e.path === entry);
+    if (isSource) {
+        // add pattern sources
+        await matcherContextRemovePath(ctx, options, parent + "/");
+        await rescan(ctx, { ...options, within: parent });
+    }
+    // add paths
+    // 1. recursively populate parents
+    await matcherContextAddPath(ctx, options, parent + "/");
+    // 2. if ignored, remove, otherwise add
+    const match = await target.ignores({ fs, cwd, entry, ctx });
+    if (match.ignored) {
+        // 2.1. remove
+        await matcherContextRemovePath(ctx, options, entry);
+        return false;
+    }
+    // 2.2. add
+    if (ctx.totalFiles >= 0) {
+        ctx.totalFiles++;
+        ctx.totalMatchedFiles++;
+    }
+    ctx.paths.set(entry, match);
+    return true;
+}
+/**
+ * Provides patching abilities for the given {@link MatcherContext}.
+ * Directories should have the slash suffix.
+ *
+ * @since 0.0.6
+ */
+export async function matcherContextRemovePath(ctx, options, entry) {
+    const isDir = entry.endsWith("/");
+    if (isDir) {
+        // remove directories
+        const direntPath = entry.replace(/\/$/, "");
+        for (const [element] of ctx.paths) {
+            if (entry !== "./" && !element.startsWith(entry)) {
+                continue;
+            }
+            if (ctx.totalFiles >= 0) {
+                const isDir = element.endsWith("/");
+                if (isDir) {
+                    ctx.totalDirs--;
+                }
+                else {
+                    ctx.totalFiles--;
+                    ctx.totalMatchedFiles--;
+                }
+            }
+            ctx.paths.delete(element);
+        }
+        for (const [element] of ctx.depthPaths) {
+            if (entry !== "./" && !element.startsWith(direntPath)) {
+                continue;
+            }
+            ctx.depthPaths.delete(element);
+        }
+        for (const [element] of ctx.external) {
+            if (entry !== "./" && !element.startsWith(direntPath)) {
+                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);
+                }
+            }
+        }
+        return true;
+    }
+    const parent = dirname(entry);
+    const isSource = options.target.extractors.some((e) => e.path === entry);
+    if (isSource) {
+        // remove pattern sources
+        // rescan directory and repopulate stats
+        await matcherContextRemovePath(ctx, options, parent + "/");
+        await rescan(ctx, { ...options, within: parent });
+        return true;
+    }
+    // remove path
+    // 1. change stats
+    {
+        if (ctx.totalFiles >= 0) {
+            ctx.totalFiles--;
+            ctx.totalMatchedFiles--;
+        }
+        // 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);
+                }
+            }
+        }
+    }
+    // 2. remove from paths
+    ctx.paths.delete(entry);
+    return true;
+}
+async function rescan(ctx, options) {
+    const normalCwd = normalizeCwd(options.cwd);
+    await opendir(options.fs, resolve(normalCwd, options.within), (entry) => walkIncludes({
+        entry,
+        ctx,
+        stream: undefined,
+        scanOptions: { ...options, cwd: normalCwd },
+    }));
+    ctx.totalDirs = ctx.totalFiles = ctx.totalMatchedFiles = -1;
+}

package/out/patterns/matcherStream.d.ts

@@ -0,0 +1,64 @@
+import { EventEmitter } from "node:events";
+import type { Dirent } from "node:fs";
+import type { MatcherContext } from "../patterns/matcherContext.js";
+import type { SignedPatternMatch } from "./signedPattern.js";
+/**
+ * Post-scan entry information.
+ *
+ * @since 0.0.6
+ */
+export type EntryInfo = {
+    /**
+     * The relative path of the entry.
+     *
+     * @since 0.0.6
+     */
+    path: string;
+    /**
+     * The directory entry.
+     *
+     * @since 0.0.6
+     */
+    dirent: Dirent;
+    /**
+     * Whether the entry was ignored.
+     *
+     * @since 0.0.6
+     */
+    match: SignedPatternMatch;
+    /**
+     * The matcher context.
+     *
+     * @since 0.0.6
+     */
+    ctx: MatcherContext;
+};
+/**
+ * @see {@link MatcherStream} uses it for the "dirent" event.
+ *
+ * @since 0.0.6
+ */
+export type EntryListener = (info: EntryInfo) => void;
+/**
+ * @see {@link MatcherStream} uses it for the "end" event.
+ *
+ * @since 0.0.6
+ */
+export type EndListener = (ctx: MatcherContext) => void;
+/**
+ * @see {@link MatcherStream} uses it for its event map.
+ *
+ * @since 0.0.6
+ */
+export type EventMap = {
+    dirent: [EntryInfo];
+    end: [MatcherContext];
+};
+/**
+ * Event emitter.
+ * @extends EventEmitter
+ *
+ * @since 0.0.6
+ */
+export declare class MatcherStream extends EventEmitter<EventMap> {
+}

package/out/patterns/matcherStream.js

@@ -0,0 +1,9 @@
+import { EventEmitter } from "node:events";
+/**
+ * Event emitter.
+ * @extends EventEmitter
+ *
+ * @since 0.0.6
+ */
+export class MatcherStream extends EventEmitter {
+}

package/out/patterns/packagejson.d.ts

@@ -1,3 +1,9 @@
-import { type } from 'arktype';
-import type { Source } from './matcher.js';
-export declare function extractPackageJson(source: Source, content: Buffer<ArrayBuffer>): type.errors | undefined;
+import { type Source } from "./source.js";
+/**
+ * Extracts and compiles patterns from the file.
+ *
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
+export declare function extractPackageJson(source: Source, content: Buffer): void | "none";

package/out/patterns/packagejson.js

@@ -1,25 +1,32 @@
-import { type } from 'arktype';
+import { type } from "arktype";
+import { signedPatternCompile } from "./resolveSources.js";
+import { sourcePushNegatable } from "./source.js";
 const nodeJsManifest = type({
-    files: 'string[]?',
+    files: "string[]?",
 });
-const parse = nodeJsManifest.pipe((s) => JSON.parse(s));
+const parse = type("string")
+    .pipe((s) => JSON.parse(s))
+    .pipe(nodeJsManifest);
+/**
+ * Extracts and compiles patterns from the file.
+ *
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
 export function extractPackageJson(source, content) {
     source.inverted = true;
     const dist = parse(content.toString());
     if (dist instanceof type.errors) {
-        return dist;
+        source.error = new Error("Invalid '" + source.path + "': " + dist.summary, { cause: dist });
+        return;
     }
     if (!dist.files) {
-        return;
+        return "none";
     }
-    for (const p of dist.files) {
-        if (p.startsWith('!')) {
-            source.pattern.exclude.push(...p.substring(1));
-        }
-        else {
-            source.pattern.include.push(...p);
-        }
+    for (const pattern of dist.files) {
+        sourcePushNegatable(source, pattern);
     }
-    return;
+    signedPatternCompile(source.pattern);
 }
 extractPackageJson;

package/out/patterns/pattern.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Compiled pattern.
+ *
+ * @see {@link stringCompile}
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
+export type PatternMinimatch = {
+    re: RegExp;
+    /**
+     * The original pattern string this minimatch was compiled from.
+     *
+     * @since 0.0.6
+     */
+    pattern: string;
+    /**
+     * The original pattern list this pattern was compiled from.
+     *
+     * @since 0.0.6
+     */
+    patternContext: Pattern;
+};
+/**
+ * Safely calls RegExp.test.
+ *
+ * @since 0.0.6
+ */
+export declare function patternMinimatchTest(pattern: PatternMinimatch, path: string): boolean;
+/**
+ * Represents a list of positive minimatch patterns.
+ *
+ * @since 0.0.6
+ */
+export type Pattern = string[];
+/**
+ * Compiles the {@link Pattern}.
+ *
+ * @see {@link stringCompile}
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
+export declare function patternCompile(pattern: Pattern): PatternMinimatch[];

package/out/patterns/pattern.js

@@ -0,0 +1,21 @@
+import { stringCompile } from "./stringCompile.js";
+/**
+ * Safely calls RegExp.test.
+ *
+ * @since 0.0.6
+ */
+export function patternMinimatchTest(pattern, path) {
+    pattern.re.lastIndex = 0;
+    return pattern.re.test(path);
+}
+/**
+ * Compiles the {@link Pattern}.
+ *
+ * @see {@link stringCompile}
+ * @see {@link signedPatternCompile}
+ *
+ * @since 0.0.6
+ */
+export function patternCompile(pattern) {
+    return pattern.map(stringCompile);
+}

package/out/patterns/patternMatcher.d.ts

@@ -0,0 +1,23 @@
+import type { SignedPattern } from "./signedPattern.js";
+/**
+ * Combined internal and external patterns for matching.
+ *
+ * @see {@link signedPatternIgnores}
+ *
+ * @since 0.0.6
+ */
+export type PatternMatcher = {
+    /**
+     * Internal patterns are provided by the target.
+     * Almost always they are predefined.
+     *
+     * @since 0.0.6
+     */
+    internal: SignedPattern;
+    /**
+     * External patterns are sourced from existing project files at runtime.
+     *
+     * @since 0.0.6
+     */
+    external: SignedPattern;
+};

package/out/patterns/patternMatcher.js

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

package/out/patterns/resolveSources.d.ts

@@ -0,0 +1,34 @@
+import type { PatternFinderOptions } from "./extractor.js";
+import type { SignedPattern } from "./signedPattern.js";
+/**
+ * Compiles the {@link SignedPattern} (forced).
+ * Can be compiled at any time.
+ * Extractors are compiling it.
+ *
+ * @see {@link patternCompile}
+ *
+ * @since 0.0.6
+ */
+export declare function signedPatternCompile(signedPattern: SignedPattern): SignedPattern;
+/**
+ * @see {@link resolveSources}
+ *
+ * @since 0.0.6
+ */
+export interface ResolveSourcesOptions extends PatternFinderOptions {
+    /**
+     * Relative directory path.
+     *
+     * @example
+     * "dir/subdir"
+     *
+     * @since 0.0.6
+     */
+    dir: string;
+}
+/**
+ * Populates the {@link MatcherContext.external} map with {@link Source} objects.
+ *
+ * @since 0.0.6
+ */
+export declare function resolveSources(options: ResolveSourcesOptions): Promise<void>;