view-ignored 0.10.1 → 0.11.1

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: ".",
 };

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: ".",
 };