view-ignored 0.10.1 → 0.11.1

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());
+}

package/out/stream.d.ts

@@ -2,7 +2,12 @@ import type { MatcherStream } from "./patterns/matcherStream.js";
 import type { ScanOptions } from "./types.js";
 export type * from "./types.js";
 /**
- * @see {@link scan}
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @returns A stream containing the scan results.
  *
  * @since 0.6.0
  */

package/out/stream.js

@@ -2,11 +2,16 @@ import * as nodefs from "node:fs";
 import * as process from "node:process";
 import { scanStream as browserStream } from "./browser_stream.js";
 /**
- * @see {@link scan}
+ * Scan the directory for included files based on the provided targets.
+ *
+ * It also normalizes paths to use forward slashes.
+ *
+ * @param options Scan options.
+ * @returns A stream containing the scan results.
  *
  * @since 0.6.0
  */
 export function scanStream(options) {
     const { cwd = process.cwd(), fs = nodefs } = options;
-    return browserStream({ fs, cwd, ...options });
+    return browserStream({ cwd, fs, ...options });
 }

package/out/targets/bun.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJson, extractGitignore, } from "../patterns/index.js";
 import { join, unixify } from "../unixify.js";
 import { npmManifestParse } from "./npmManifest.js";
@@ -17,13 +16,14 @@ const extractors = [
     },
 ];
 const internalInclude = {
+    compiled: [],
     excludes: false,
     pattern: [], // filled within init
-    compiled: [],
 };
 const internal = [
     internalInclude,
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/oven-sh/bun/blob/main/src/cli/pack_command.zig#L180
@@ -58,9 +58,9 @@ const internal = [
             // https://github.com/oven-sh/bun/blob/main/src/cli/pack_command.zig#L285
             "node_modules",
         ],
-        compiled: null,
     }), // nocase should be false here
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/oven-sh/bun/blob/main/src/cli/pack_command.zig#L2586
@@ -73,46 +73,53 @@ const internal = [
             "README",
             "README.*",
         ],
-        compiled: null,
     }, { nocase: true }),
 ];
 /**
  * @since 0.8.1
  */
 export const Bun = {
-    internalRules: internal,
     extractors,
-    root: ".",
-    async init({ fs, cwd }) {
-        let content;
+    ignores: ruleTest,
+    init({ fs, cwd }, cb) {
         const normalCwd = unixify(cwd);
-        try {
-            content = await fs.promises.readFile(normalCwd + "/" + "package.json");
-        }
-        catch (error) {
-            throw new Error("Error while initializing Bun", { cause: error });
-        }
-        const dist = npmManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid 'package.json': " + dist.summary, { cause: dist });
-        }
-        const set = new Set();
-        function normal(path) {
-            const result = unixify(join(normalCwd, path)).substring(normalCwd.length);
-            return result;
-        }
-        // https://github.com/oven-sh/bun/blob/main/src/cli/pack_command.zig#L1440
-        if (typeof dist.bin === "string") {
-            set.add(normal(dist.bin));
-        }
-        else if (typeof dist.bin === "object" && dist.bin !== null) {
-            Object.values(dist.bin).forEach((binPath) => set.add(normal(binPath)));
-        }
-        // TODO: Bun should include bundled deps
-        // nothing else
-        // link zig code
-        internalInclude.pattern = Array.from(set);
-        ruleCompile(internalInclude, { nocase: true });
+        fs.readFile(normalCwd + "/" + "package.json", (err, content) => {
+            if (err) {
+                cb(new Error("Error while initializing Bun", { cause: err }));
+                return;
+            }
+            let dist;
+            try {
+                dist = npmManifestParse(content.toString());
+                // const set = new Set<string>()
+                // TODO: NPM should include bundled deps
+                // internalInclude.pattern = Array.from(set)
+                // ruleCompile(internalInclude, { nocase: true })
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            const set = new Set();
+            function normal(path) {
+                const result = unixify(join(normalCwd, path)).substring(normalCwd.length);
+                return result;
+            }
+            // https://github.com/oven-sh/bun/blob/main/src/cli/pack_command.zig#L1440
+            if (typeof dist.bin === "string") {
+                set.add(normal(dist.bin));
+            }
+            else if (typeof dist.bin === "object") {
+                Object.values(dist.bin).forEach((binPath) => set.add(normal(binPath)));
+            }
+            // TODO: Bun should include bundled deps
+            // nothing else
+            // link zig code
+            internalInclude.pattern = Array.from(set);
+            ruleCompile(internalInclude, { nocase: true });
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/targets/deno.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractJsrJson, extractJsrJsonc, extractPackageJson, } from "../patterns/index.js";
 import { unixify } from "../unixify.js";
 import { jsrManifestParse } from "./jsrManifest.js";
@@ -26,40 +25,43 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [".git", ".DS_Store"],
-        compiled: null,
     }),
 ];
 /**
  * @since 0.8.1
  */
 export const Deno = {
-    internalRules: internal,
     extractors,
-    root: ".",
-    async init({ fs, cwd }) {
-        let content;
+    ignores: ruleTest,
+    init({ fs, cwd }, cb) {
         const normalCwd = unixify(cwd);
-        let path;
-        for (const [i, { path: p }] of extractors.entries()) {
-            path = p;
-            try {
-                content = await fs.promises.readFile(normalCwd + "/" + path);
+        let i = 0;
+        function next() {
+            if (i >= extractors.length) {
+                cb(new Error("Error while initializing Deno: No valid manifest found"));
+                return;
             }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    if (i < extractors.length - 1) {
-                        continue;
-                    }
+            const extractor = extractors[i++];
+            fs.readFile(normalCwd + "/" + extractor.path, (err, data) => {
+                if (err) {
+                    next();
+                    return;
                 }
-                throw new Error("Error while initializing Deno", { cause: error });
-            }
-        }
-        const dist = jsrManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid '" + path + "': " + dist.summary, { cause: dist });
+                try {
+                    jsrManifestParse(data.toString());
+                }
+                catch (error) {
+                    cb(new Error("Invalid '" + extractor.path + "'", { cause: error }));
+                    return;
+                }
+                cb();
+            });
         }
+        next();
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/targets/git.js

@@ -11,18 +11,18 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [".git", ".DS_Store"],
-        compiled: null,
     }),
 ];
 /**
  * @since 0.6.0
  */
 export const Git = {
-    internalRules: internal,
     extractors,
-    root: "/",
     // TODO: Git should read configs
     ignores: ruleTest,
+    internalRules: internal,
+    root: "/",
 };

package/out/targets/jsr.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractJsrJson, extractJsrJsonc, } from "../patterns/index.js";
 import { unixify } from "../unixify.js";
 import { jsrManifestParse } from "./jsrManifest.js";
@@ -14,40 +13,43 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [".git", ".DS_Store"],
-        compiled: null,
     }),
 ];
 /**
  * @since 0.6.0
  */
 export const JSR = {
-    internalRules: internal,
     extractors,
-    root: ".",
-    async init({ fs, cwd }) {
-        let content;
+    ignores: ruleTest,
+    init({ fs, cwd }, cb) {
         const normalCwd = unixify(cwd);
-        let path;
-        for (const [i, { path: p }] of extractors.entries()) {
-            path = p;
-            try {
-                content = await fs.promises.readFile(normalCwd + "/" + path);
+        let i = 0;
+        function next() {
+            if (i >= extractors.length) {
+                cb(new Error("Error while initializing JSR: No valid manifest found"));
+                return;
             }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    if (i < extractors.length - 1) {
-                        continue;
-                    }
+            const extractor = extractors[i++];
+            fs.readFile(normalCwd + "/" + extractor.path, (err, data) => {
+                if (err) {
+                    next();
+                    return;
                 }
-                throw new Error("Error while initializing Deno", { cause: error });
-            }
-        }
-        const dist = jsrManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid '" + path + "': " + dist.summary, { cause: dist });
+                try {
+                    jsrManifestParse(data.toString());
+                }
+                catch (error) {
+                    cb(new Error("Invalid '" + extractor.path + "'", { cause: error }));
+                    return;
+                }
+                cb();
+            });
         }
+        next();
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/targets/jsrManifest.d.ts

@@ -1,10 +1,11 @@
-export declare const jsrManifest: import("arktype/internal/variants/object.ts").ObjectType<{
+export interface JsrPublishConfig {
+    include?: string[];
+    exclude?: string[];
+}
+export interface JsrManifest extends JsrPublishConfig {
     name: string;
     version: string;
     exports: string | Record<string, string>;
-}, {}>;
-export declare const jsrManifestParse: import("arktype/internal/variants/object.ts").ObjectType<(In: string) => import("arktype/internal/attributes.ts").To<{
-    name: string;
-    version: string;
-    exports: string | Record<string, string>;
-}>, {}>;
+    publish?: JsrPublishConfig;
+}
+export declare function jsrManifestParse(s: string): JsrManifest;