view-ignored 0.10.0 → 0.11.0

package/out/targets/npmManifest.d.ts

@@ -1,46 +1,18 @@
-export declare const npmManifest: import("arktype/internal/variants/object.ts").ObjectType<{
-    main?: string | undefined;
-    module?: string | undefined;
-    browser?: string | undefined;
-    files?: string[] | undefined;
-    bin?: string | Record<string, string> | undefined;
-    optionalDependencies?: Record<string, string> | undefined;
-    devDependencies?: Record<string, string> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    bundleDependencies?: string[] | undefined;
-    bundledDependencies?: undefined;
-} | {
-    main?: string | undefined;
-    module?: string | undefined;
-    browser?: string | undefined;
-    files?: string[] | undefined;
-    bin?: string | Record<string, string> | undefined;
-    optionalDependencies?: Record<string, string> | undefined;
-    devDependencies?: Record<string, string> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    bundledDependencies?: string[] | undefined;
-    bundleDependencies?: undefined;
-}, {}>;
-export declare const npmManifestParse: import("arktype/internal/variants/object.ts").ObjectType<(In: string) => import("arktype/internal/attributes.ts").To<{
-    main?: string | undefined;
-    module?: string | undefined;
-    browser?: string | undefined;
-    files?: string[] | undefined;
-    bin?: string | Record<string, string> | undefined;
-    optionalDependencies?: Record<string, string> | undefined;
-    devDependencies?: Record<string, string> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    bundleDependencies?: string[] | undefined;
-    bundledDependencies?: undefined;
-}> | import("arktype/internal/attributes.ts").To<{
-    main?: string | undefined;
-    module?: string | undefined;
-    browser?: string | undefined;
-    files?: string[] | undefined;
-    bin?: string | Record<string, string> | undefined;
-    optionalDependencies?: Record<string, string> | undefined;
-    devDependencies?: Record<string, string> | undefined;
-    dependencies?: Record<string, string> | undefined;
-    bundledDependencies?: string[] | undefined;
-    bundleDependencies?: undefined;
-}>, {}>;
+export interface PackageJson {
+    name: string;
+    version: string;
+    private?: boolean;
+    engines?: Record<string, string>;
+    scripts?: Record<string, string>;
+    bin?: string | Record<string, string>;
+    browser?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    files?: string[];
+    main?: string;
+    module?: string;
+    optionalDependencies?: Record<string, string>;
+    bundleDependencies?: string[];
+    bundledDependencies?: string[];
+}
+export declare function npmManifestParse(s: string): PackageJson;

package/out/targets/npmManifest.js

@@ -1,23 +1,96 @@
-import { type } from "arktype";
-const baseManifest = type({
-    "main?": "string",
-    "module?": "string",
-    "browser?": "string",
-    "files?": "string[]",
-    "bin?": "string | Record<string, string>",
-    "optionalDependencies?": "Record<string, string>",
-    "devDependencies?": "Record<string, string>",
-    "dependencies?": "Record<string, string>",
-});
-const withBundle = baseManifest.and({
-    "bundleDependencies?": "string[]",
-    "bundledDependencies?": "never",
-});
-const withBundled = baseManifest.and({
-    "bundledDependencies?": "string[]",
-    "bundleDependencies?": "never",
-});
-export const npmManifest = withBundle.or(withBundled);
-export const npmManifestParse = type("string")
-    .pipe((s) => JSON.parse(s))
-    .pipe(npmManifest);
+function isValidNpmName(name) {
+    if (name.trim() !== name || name.length === 0 || name.length > 214) {
+        return false;
+    }
+    if (name.startsWith("@")) {
+        const parts = name.slice(1).split("/");
+        if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+            return false;
+        }
+        return isValidNameComponent(parts[0]) && isValidNameComponent(parts[1]);
+    }
+    return isValidNameComponent(name);
+}
+function isValidNameComponent(part) {
+    if (part.startsWith(".") || part.startsWith("_") || part !== part.toLowerCase()) {
+        return false;
+    }
+    if (/[~!'()* ]/.test(part)) {
+        return false;
+    }
+    try {
+        return encodeURIComponent(part) === part;
+    }
+    catch {
+        return false;
+    }
+}
+function isRecordOfStrings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((v) => typeof v === "string");
+}
+function isArrayOfStrings(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+export function npmManifestParse(s) {
+    const parsed = JSON.parse(s);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("npm manifest must be a JSON object");
+    }
+    if ("private" in parsed && typeof parsed.private !== "boolean") {
+        throw new Error("'private' field must be a boolean");
+    }
+    if (!parsed.private) {
+        if (typeof parsed.name !== "string") {
+            throw new Error("Manifest must have a non-empty string 'name'");
+        }
+        if (typeof parsed.version !== "string") {
+            throw new Error("Manifest must have a non-empty string 'version'");
+        }
+        if (!isValidNpmName(parsed.name)) {
+            throw new Error(`'${parsed.name}' is not a valid npm package name`);
+        }
+        // Strict SemVer verification
+        if (!SEMVER_REGEX.test(parsed.version)) {
+            throw new Error(`'${parsed.version}' is not a valid SemVer version (expected format: X.Y.Z)`);
+        }
+    }
+    if ("bundleDependencies" in parsed && "bundledDependencies" in parsed) {
+        throw new Error("Manifest cannot contain both 'bundleDependencies' and 'bundledDependencies'");
+    }
+    const stringFields = ["browser", "main", "module"];
+    for (const field of stringFields) {
+        if (field in parsed && typeof parsed[field] !== "string") {
+            throw new Error(`'${field}' field must be a string`);
+        }
+    }
+    const recordFields = [
+        "engines",
+        "scripts",
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+    ];
+    for (const field of recordFields) {
+        if (field in parsed && !isRecordOfStrings(parsed[field])) {
+            throw new Error(`'${field}' field must be an object with string values`);
+        }
+    }
+    const arrayFields = ["files", "bundleDependencies", "bundledDependencies"];
+    for (const field of arrayFields) {
+        if (field in parsed && !isArrayOfStrings(parsed[field])) {
+            throw new Error(`'${field}' field must be an array of strings`);
+        }
+    }
+    if ("bin" in parsed) {
+        const binValue = parsed.bin;
+        const isValidBin = typeof binValue === "string" || isRecordOfStrings(binValue);
+        if (!isValidBin) {
+            throw new Error("'bin' field must be a string or an object with string values");
+        }
+    }
+    return parsed;
+}

package/out/targets/target.d.ts

@@ -1,6 +1,6 @@
 import type { Extractor } from "../patterns/extractor.js";
-import type { Ignores } from "../patterns/ignores.js";
-import type { Init } from "../patterns/init.js";
+import type { IgnoresCb } from "../patterns/ignores.js";
+import type { InitCb } from "../patterns/init.js";
 import type { Rule } from "../patterns/rule.js";
 /**
  * Contains the matcher used for scanning.
@@ -29,23 +29,15 @@ export interface Target {
      */
     extractors: Extractor[];
     /**
-     * Glob-pattern parser.
+     * @see {@link IgnoresCb}
      *
-     * @see {@link Ignores}
-     *
-     * @since 0.6.0
+     * @since 0.11.0
      */
-    ignores: Ignores;
+    ignores: IgnoresCb;
     /**
-     * Initialization function.
-     * Called by the scanner method.
-     *
-     * @example
-     * scan({ target: { ...Git, init: undefined } })
-     *
-     * @see {@link Init}
+     * @see {@link InitCb}
      *
-     * @since 0.8.0
+     * @since 0.11.0
      */
-    init?: Init;
+    init?: InitCb;
 }

package/out/targets/vsce.js

@@ -1,7 +1,6 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJson, extractGitignore, } from "../patterns/index.js";
 import { unixify } from "../unixify.js";
-import { npmManifest } from "./npmManifest.js";
+import { vsceManifestParse } from "./vsceManifest.js";
 const extractors = [
     {
         extract: extractPackageJson,
@@ -18,6 +17,7 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/microsoft/vscode-vsce/blob/main/src/package.ts#L1633
@@ -53,38 +53,31 @@ const internal = [
             ".vscode-test",
             ".vscode-test-web",
         ],
-        compiled: null,
     }),
 ];
-const vsceManifest = npmManifest.and({
-    engines: {
-        // https://github.com/microsoft/vscode-vsce/blob/main/src/validation.ts#L52
-        vscode: "/^\\*$|^(\\^|>=)?((\\d+)|x)\\.((\\d+)|x)\\.((\\d+)|x)(\\-.*)?$/",
-    },
-});
-const vsceManifestParse = type("string")
-    .pipe((s) => JSON.parse(s))
-    .pipe(vsceManifest);
 /**
  * @since 0.6.0
  */
 export const VSCE = {
-    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 VSCE", { cause: error });
-        }
-        const dist = vsceManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid 'package.json': " + dist.summary, { cause: dist });
-        }
+        fs.readFile(normalCwd + "/package.json", (err, content) => {
+            if (err) {
+                cb(new Error("Error while initializing VSCE", { cause: err }));
+                return;
+            }
+            try {
+                vsceManifestParse(content.toString());
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/targets/vsceManifest.d.ts

@@ -0,0 +1,7 @@
+import { type PackageJson } from "./npmManifest.js";
+export interface VsceManifest extends PackageJson {
+    engines: {
+        vscode: string;
+    };
+}
+export declare function vsceManifestParse(s: string): VsceManifest;

package/out/targets/vsceManifest.js

@@ -0,0 +1,18 @@
+import { npmManifestParse } from "./npmManifest.js";
+// Regex source: https://github.com/microsoft/vscode-vsce/blob/main/src/validation.ts#L52
+const VSCODE_ENGINE_REGEX = /^\*$|^(\^|>=)?((\d+)|x)\.((\d+)|x)\.((\d+)|x)(-.*)?$/;
+export function vsceManifestParse(s) {
+    const parsed = npmManifestParse(s);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("VSCE manifest must be a JSON object");
+    }
+    if (!parsed.engines ||
+        typeof parsed.engines !== "object" ||
+        typeof parsed.engines.vscode !== "string") {
+        throw new Error("VSCE manifest must include an 'engines.vscode' string");
+    }
+    if (!VSCODE_ENGINE_REGEX.test(parsed.engines.vscode)) {
+        throw new Error(`Invalid 'engines.vscode' version format: "${parsed.engines.vscode}"`);
+    }
+    return parsed;
+}

package/out/targets/yarn.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJsonNocase, extractGitignoreNocase, } 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: [],
-    compiled: [],
 };
 const internal = [
     internalInclude,
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L26
@@ -37,9 +37,9 @@ const internal = [
             ".#*",
             ".DS_Store",
         ],
-        compiled: null,
     }),
     ruleCompile({
+        compiled: null,
         excludes: false,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L10
@@ -51,49 +51,58 @@ const internal = [
             "/LICENCE",
             "/LICENCE.*",
         ],
-        compiled: null,
     }, { nocase: true }),
 ];
 /**
  * @since 0.6.0
  */
 export const Yarn = {
-    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 Yarn", { cause: error });
-        }
-        const dist = npmManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid 'package.json': " + dist.summary, { cause: dist });
-        }
-        // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L215-L231
-        const set = new Set();
-        function normal(path) {
-            const result = unixify(join(normalCwd, path)).substring(normalCwd.length);
-            return result;
-        }
-        if (dist.main)
-            set.add(normal(dist.main));
-        if (dist.module)
-            set.add(normal(dist.module));
-        if (dist.browser)
-            set.add(normal(dist.browser));
-        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)));
-        }
-        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();
+                    return;
+                }
+                cb(new Error("Error while initializing Yarn", { cause: error }));
+                return;
+            }
+            let dist;
+            try {
+                dist = npmManifestParse(content.toString());
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            const set = new Set();
+            function normal(path) {
+                return unixify(join(normalCwd, path)).substring(normalCwd.length);
+            }
+            if (typeof dist.main === "string")
+                set.add(normal(dist.main));
+            if (typeof dist.module === "string")
+                set.add(normal(dist.module));
+            if (typeof dist.browser === "string")
+                set.add(normal(dist.browser));
+            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) => {
+                    if (typeof binPath === "string")
+                        set.add(normal(binPath));
+                });
+            }
+            internalInclude.pattern = Array.from(set);
+            ruleCompile(internalInclude, { nocase: true });
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/targets/yarnClassic.js

@@ -1,4 +1,3 @@
-import { type } from "arktype";
 import { ruleTest, ruleCompile, extractPackageJsonNocase, extractGitignoreNocase, } from "../patterns/index.js";
 import { unixify } from "../unixify.js";
 import { npmManifestParse } from "./npmManifest.js";
@@ -22,6 +21,7 @@ const extractors = [
 ];
 const internal = [
     ruleCompile({
+        compiled: null,
         excludes: true,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L26
@@ -53,9 +53,9 @@ const internal = [
             ".gitignore",
             ".DS_Store",
         ],
-        compiled: null,
     }, { nocase: true }),
     ruleCompile({
+        compiled: null,
         excludes: false,
         pattern: [
             // https://github.com/yarnpkg/berry/blob/master/packages/plugin-pack/sources/packUtils.ts#L10
@@ -67,29 +67,31 @@ const internal = [
             "/changelog*",
             "/history*",
         ],
-        compiled: null,
     }, { nocase: true }),
 ];
 /**
  * @since 0.8.0
  */
 export const YarnClassic = {
-    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 Yarn classic", { cause: error });
-        }
-        const dist = npmManifestParse(content.toString());
-        if (dist instanceof type.errors) {
-            throw new Error("Invalid 'package.json': " + dist.summary, { cause: dist });
-        }
+        fs.readFile(normalCwd + "/package.json", (err, content) => {
+            if (err) {
+                cb(new Error("Error while initializing Yarn classic", { cause: err }));
+                return;
+            }
+            try {
+                npmManifestParse(content.toString());
+            }
+            catch (error) {
+                cb(new Error("Invalid 'package.json'", { cause: error }));
+                return;
+            }
+            cb();
+        });
     },
-    ignores: ruleTest,
+    internalRules: internal,
+    root: ".",
 };

package/out/types.d.ts

@@ -6,10 +6,11 @@ import type { Target } from "./targets/target.js";
  * @since 0.6.0
  */
 export interface FsAdapter {
-    promises: {
-        opendir: typeof fs.promises.opendir;
-        readFile: typeof fs.promises.readFile;
-    };
+    /**
+     * `readdir` is better than `opendir`.
+     */
+    readdir: typeof fs.readdir;
+    readFile: typeof fs.readFile;
 }
 /**
  * Used in multiple methods, primarily `scan`, `scanStream`, and their browser versions.
@@ -76,10 +77,10 @@ export type ScanOptions = {
      * {@link MatcherContext.totalDirs},
      * {@link MatcherContext.totalFiles},
      * {@link MatcherContext.totalMatchedFiles}
-     * and {@link MatcherContext.depthPaths}.
+     * and {@link MatcherContext.depthPaths} numbers.
      *
      * It's recommended to use this option unless you
-     * need precise statistics
+     * care about these stats.
      *
      * @default `false`
      *
@@ -97,7 +98,7 @@ export type ScanOptions = {
      * and {@link MatcherContext.depthPaths}.
      *
      * It's recommended to use this option unless the target
-     * allows overriding internal patterns.
+     * allows overriding internal patterns and you don't care about these stats.
      * This option should never affect {@link MatcherContext.totalMatchedFiles}.
      *
      * @default `false`

package/out/unixify.d.ts

@@ -1,4 +1,4 @@
 export declare function unixify(path: string): string;
 export declare function join(from: string, p2: string): string;
 export declare function relative(base: string, to: string): string;
-export declare function base(path: string): string;
+export declare function dirname(path: string): string;

package/out/unixify.js

@@ -1,38 +1,57 @@
 const strippedCwd = strip(process.cwd());
 export function unixify(path) {
-    let result = strip(path);
-    if (result.startsWith("./")) {
-        result = strippedCwd + result.substring(1);
+    const result = strip(path);
+    const c0 = result.charCodeAt(0);
+    if (c0 === 46 && result.charCodeAt(1) === 47) {
+        // "./"
+        return strippedCwd + result.substring(1);
     }
-    else if (!result.startsWith("/")) {
-        result = strippedCwd + "/" + result;
+    if (c0 !== 47 && c0 !== 92) {
+        // not starts with "/" or "\"
+        return strippedCwd + "/" + result;
     }
     return result;
 }
 export function join(from, p2) {
-    if (p2 === "." || p2 === "./") {
+    if (p2 === "." || p2 === "./")
         return from;
+    const p2startsDotSlash = p2.charCodeAt(0) === 46 && p2.charCodeAt(1) === 47;
+    const start = p2startsDotSlash ? 2 : 0;
+    let res = from;
+    if (from.charCodeAt(0) === 46 && from.charCodeAt(1) === 47) {
+        res = from.substring(2);
     }
-    let start = 0;
-    if (p2.startsWith("./")) {
-        start = 2;
+    const resLen = res.length;
+    if (resLen > 0 && res.charCodeAt(resLen - 1) !== 47) {
+        res += "/";
     }
-    if (!from.endsWith("/")) {
-        from += "/";
-    }
-    from += p2.substring(start);
-    return from;
+    return res + p2.substring(start);
 }
 export function relative(base, to) {
-    if (!base.endsWith("/")) {
+    const blen = base.length;
+    if (blen > 0 && base.charCodeAt(blen - 1) !== 47) {
         base += "/";
     }
-    const result = to.replace(base, "");
-    return result;
-}
-export function base(path) {
-    return path.substring(path.lastIndexOf("/") + 1);
+    return to.replace(base, "");
 }
 function strip(path) {
-    return path.replaceAll("\\", "/").replace(/^[a-zA-Z]:/, "");
+    let res = path.indexOf("\\") === -1 ? path : path.replaceAll("\\", "/");
+    if (res.length > 1 && res.charCodeAt(1) === 58) {
+        // X:
+        res = res.substring(2);
+    }
+    return res;
+}
+export function dirname(path) {
+    if (path === "/" || path === ".")
+        return path;
+    const len = path.length;
+    const lastIdx = len - 1;
+    const endsWithSlash = path.charCodeAt(lastIdx) === 47;
+    const lastSlash = path.lastIndexOf("/", endsWithSlash ? lastIdx - 1 : lastIdx);
+    if (lastSlash === -1)
+        return ".";
+    if (lastSlash === 0)
+        return "/";
+    return path.substring(0, lastSlash);
 }