view-ignored 0.10.0 → 0.11.0

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;

package/out/targets/jsrManifest.js

@@ -1,9 +1,40 @@
-import { type } from "arktype";
-export const jsrManifest = type({
-    name: "string",
-    version: "string",
-    exports: "string | Record<string, string>",
-});
-export const jsrManifestParse = type("string")
-    .pipe((s) => JSON.parse(s))
-    .pipe(jsrManifest);
+function isArrayOfStrings(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+export function jsrManifestParse(s) {
+    const parsed = JSON.parse(s);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("JSR manifest must be a JSON object");
+    }
+    // Basic runtime validation for required fields
+    const { name, version, exports, include, exclude, publish } = parsed;
+    if (typeof name !== "string") {
+        throw new Error("Missing or invalid 'name' in manifest");
+    }
+    if (typeof version !== "string") {
+        throw new Error("Missing or invalid 'version' in manifest");
+    }
+    if (typeof exports !== "string" && (typeof exports !== "object" || exports === null)) {
+        throw new Error("Missing or invalid 'exports' in manifest");
+    }
+    // Validation for include / exclude
+    if ("include" in parsed && !isArrayOfStrings(include)) {
+        throw new Error("'include' field must be an array of strings");
+    }
+    if ("exclude" in parsed && !isArrayOfStrings(exclude)) {
+        throw new Error("'exclude' field must be an array of strings");
+    }
+    // Validation for publish block
+    if ("publish" in parsed) {
+        if (!publish || typeof publish !== "object" || Array.isArray(publish)) {
+            throw new Error("'publish' field must be an object");
+        }
+        if ("include" in publish && !isArrayOfStrings(publish.include)) {
+            throw new Error("'publish.include' field must be an array of strings");
+        }
+        if ("exclude" in publish && !isArrayOfStrings(publish.exclude)) {
+            throw new Error("'publish.exclude' field must be an array of strings");
+        }
+    }
+    return parsed;
+}

package/out/targets/npm.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJson, extractGitignore, } from "../patterns/index.js";
 import { 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/npm/npm-packlist/blob/main/lib/index.js#L16
@@ -54,9 +54,9 @@ const internal = [
             "/pnpm-lock.yaml",
             "/bun.lockb",
         ],
-        compiled: null,
     }),
     ruleCompile({
+        compiled: null,
         excludes: false,
         pattern: [
             // https://github.com/npm/npm-packlist/blob/main/lib/index.js#L287
@@ -71,33 +71,40 @@ const internal = [
             "LICENSE.*",
             "LICENCE.*",
         ],
-        compiled: null,
     }),
 ];
 /**
  * @since 0.6.0
  */
 export const NPM = {
-    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 NPM", { 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<string>()
-        // TODO: NPM should include bundled deps
-        // internalInclude.pattern = Array.from(set)
-        // ruleCompile(internalInclude, { nocase: true })
+        fs.readFile(normalCwd + "/package.json", (err, content) => {
+            if (err) {
+                const error = err;
+                if (error.code === "ENOENT") {
+                    cb(new Error("'package.json' not found", { cause: error }));
+                    return;
+                }
+                cb(new Error("Error while initializing NPM", { cause: error }));
+                return;
+            }
+            try {
+                npmManifestParse(content.toString());
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            // const set = new Set<string>()
+            // TODO: NPM should include bundled deps
+            // internalInclude.pattern = Array.from(set)
+            // ruleCompile(internalInclude, { nocase: true })
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };