checkly 0.0.0-pr.1006.2fb1ffc

package/dist/services/check-parser/collector.d.ts

@@ -0,0 +1,33 @@
+export type UnsupportedNpmDependencies = {
+    file: string;
+    unsupportedDependencies: string[];
+};
+export type ParseError = {
+    file: string;
+    error: string;
+};
+export declare class Collector {
+    entrypoint: string;
+    entrypointContent: string;
+    missingFiles: string[];
+    parseErrors: ParseError[];
+    unsupportedNpmDependencies: UnsupportedNpmDependencies[];
+    dependencies: Map<string, string>;
+    constructor(entrypoint: string, entrypointContent: string);
+    hasDependency(path: string): boolean;
+    addDependency(path: string, content: string): void;
+    addUnsupportedNpmDependencies(file: string, unsupportedDependencies: string[]): void;
+    addParsingError(file: string, message: string): void;
+    addMissingFile(filePath: string): void;
+    validate(): void;
+    getItems(): {
+        entrypoint: {
+            filePath: string;
+            content: string;
+        };
+        dependencies: {
+            filePath: string;
+            content: string;
+        }[];
+    };
+}

package/dist/services/check-parser/collector.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collector = void 0;
+const errors_1 = require("./errors");
+class Collector {
+    constructor(entrypoint, entrypointContent) {
+        this.missingFiles = [];
+        this.parseErrors = [];
+        this.unsupportedNpmDependencies = [];
+        this.dependencies = new Map();
+        this.entrypoint = entrypoint;
+        this.entrypointContent = entrypointContent;
+    }
+    hasDependency(path) {
+        return this.dependencies.has(path);
+    }
+    addDependency(path, content) {
+        this.dependencies.set(path, content);
+    }
+    addUnsupportedNpmDependencies(file, unsupportedDependencies) {
+        this.unsupportedNpmDependencies.push({ file, unsupportedDependencies });
+    }
+    addParsingError(file, message) {
+        this.parseErrors.push({ file, error: message });
+    }
+    addMissingFile(filePath) {
+        this.missingFiles.push(filePath);
+    }
+    validate() {
+        if (this.missingFiles.length || this.parseErrors.length || this.unsupportedNpmDependencies.length) {
+            throw new errors_1.DependencyParseError(this.entrypoint, this.missingFiles, this.unsupportedNpmDependencies, this.parseErrors);
+        }
+    }
+    getItems() {
+        return {
+            entrypoint: {
+                filePath: this.entrypoint,
+                content: this.entrypointContent,
+            },
+            dependencies: Array.from(this.dependencies.entries(), ([key, value]) => ({
+                filePath: key,
+                content: value,
+            })),
+        };
+    }
+}
+exports.Collector = Collector;
+//# sourceMappingURL=collector.js.map

package/dist/services/check-parser/collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.js","sourceRoot":"","sources":["../../../src/services/check-parser/collector.ts"],"names":[],"mappings":";;;AAAA,qCAA+C;AAY/C,MAAa,SAAS;IAQpB,YAAa,UAAkB,EAAE,iBAAyB;QAL1D,iBAAY,GAAa,EAAE,CAAA;QAC3B,gBAAW,GAAiB,EAAE,CAAA;QAC9B,+BAA0B,GAAiC,EAAE,CAAA;QAC7D,iBAAY,GAAG,IAAI,GAAG,EAAkB,CAAA;QAGtC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;IAC5C,CAAC;IAED,aAAa,CAAE,IAAY;QACzB,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACpC,CAAC;IAED,aAAa,CAAE,IAAY,EAAE,OAAe;QAC1C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IACtC,CAAC;IAED,6BAA6B,CAAE,IAAY,EAAE,uBAAiC;QAC5E,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,CAAA;IACzE,CAAC;IAED,eAAe,CAAE,IAAY,EAAE,OAAe;QAC5C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAA;IACjD,CAAC;IAED,cAAc,CAAE,QAAgB;QAC9B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAClC,CAAC;IAED,QAAQ;QACN,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,IAAI,CAAC,0BAA0B,CAAC,MAAM,EAAE,CAAC;YAClG,MAAM,IAAI,6BAAoB,CAC5B,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,0BAA0B,EAC/B,IAAI,CAAC,WAAW,CACjB,CAAA;QACH,CAAC;IACH,CAAC;IAED,QAAQ;QACN,OAAO;YACL,UAAU,EAAE;gBACV,QAAQ,EAAE,IAAI,CAAC,UAAU;gBACzB,OAAO,EAAE,IAAI,CAAC,iBAAiB;aAChC;YACD,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvE,QAAQ,EAAE,GAAG;gBACb,OAAO,EAAE,KAAK;aACf,CAAC,CAAC;SACJ,CAAA;IACH,CAAC;CACF;AAxDD,8BAwDC"}

package/dist/services/check-parser/errors.d.ts

@@ -0,0 +1,8 @@
+import { ParseError, UnsupportedNpmDependencies } from './collector';
+export declare class DependencyParseError extends Error {
+    entrypoint: string;
+    missingFiles: string[];
+    unsupportedNpmDependencies: UnsupportedNpmDependencies[];
+    parseErrors: ParseError[];
+    constructor(entrypoint: string, missingFiles: string[], unsupportedNpmDependencies: UnsupportedNpmDependencies[], parseErrors: ParseError[]);
+}

package/dist/services/check-parser/errors.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyParseError = void 0;
+class DependencyParseError extends Error {
+    constructor(entrypoint, missingFiles, unsupportedNpmDependencies, parseErrors) {
+        let message = `Encountered an error parsing check files for ${entrypoint}.`;
+        if (missingFiles.length) {
+            message += '\n\nThe following dependencies weren\'t found:\n';
+            for (const missingFile of missingFiles) {
+                message += `\t${missingFile}\n`;
+            }
+        }
+        if (unsupportedNpmDependencies.length) {
+            if (unsupportedNpmDependencies.some(d => d.unsupportedDependencies.some(ud => ud === 'checkly/constructs'))) {
+                message += '\n\nIt looks like you\'re trying to use checkly/constructs in a browser check file. ' +
+                    'checkly/constructs should only be used in check files: files ending in .check.ts and .check.js, ' +
+                    'or the checkMatch pattern set in your configuration. For more information see on the difference between ' +
+                    'test files and check files, see https://www.checklyhq.com/docs/cli/\n';
+            }
+            else {
+                message += '\n\nThe following NPM dependencies were used, but aren\'t supported in the runtimes.\n';
+                message += 'For more information, see https://www.checklyhq.com/docs/runtimes/.\n';
+                for (const { file, unsupportedDependencies } of unsupportedNpmDependencies) {
+                    message += `\t${file} imports unsupported dependencies:\n`;
+                    for (const unsupportedDependency of unsupportedDependencies) {
+                        message += `\t\t${unsupportedDependency}\n`;
+                    }
+                }
+            }
+        }
+        if (parseErrors.length) {
+            message += '\n\nThe following files couldn\'t be parsed:\n';
+            for (const { file, error } of parseErrors) {
+                message += `\t${file} - ${error}\n`;
+            }
+        }
+        super(message);
+        this.entrypoint = entrypoint;
+        this.missingFiles = missingFiles;
+        this.unsupportedNpmDependencies = unsupportedNpmDependencies;
+        this.parseErrors = parseErrors;
+    }
+}
+exports.DependencyParseError = DependencyParseError;
+//# sourceMappingURL=errors.js.map

package/dist/services/check-parser/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/services/check-parser/errors.ts"],"names":[],"mappings":";;;AAEA,MAAa,oBAAqB,SAAQ,KAAK;IAK7C,YACE,UAAkB,EAClB,YAAsB,EACtB,0BAAwD,EACxD,WAAyB;QAEzB,IAAI,OAAO,GAAG,gDAAgD,UAAU,GAAG,CAAA;QAC3E,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;YACxB,OAAO,IAAI,kDAAkD,CAAA;YAC7D,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;gBACvC,OAAO,IAAI,KAAK,WAAW,IAAI,CAAA;YACjC,CAAC;QACH,CAAC;QACD,IAAI,0BAA0B,CAAC,MAAM,EAAE,CAAC;YACtC,IAAI,0BAA0B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,oBAAoB,CAAC,CAAC,EAAE,CAAC;gBAC5G,OAAO,IAAI,sFAAsF;oBAC/F,kGAAkG;oBAClG,0GAA0G;oBAC1G,uEAAuE,CAAA;YAC3E,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI,wFAAwF,CAAA;gBACnG,OAAO,IAAI,uEAAuE,CAAA;gBAClF,KAAK,MAAM,EAAE,IAAI,EAAE,uBAAuB,EAAE,IAAI,0BAA0B,EAAE,CAAC;oBAC3E,OAAO,IAAI,KAAK,IAAI,sCAAsC,CAAA;oBAC1D,KAAK,MAAM,qBAAqB,IAAI,uBAAuB,EAAE,CAAC;wBAC5D,OAAO,IAAI,OAAO,qBAAqB,IAAI,CAAA;oBAC7C,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QACD,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;YACvB,OAAO,IAAI,gDAAgD,CAAA;YAC3D,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,WAAW,EAAE,CAAC;gBAC1C,OAAO,IAAI,KAAK,IAAI,MAAM,KAAK,IAAI,CAAA;YACrC,CAAC;QACH,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;QAChC,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAA;QAC5D,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;IAChC,CAAC;CACF;AA/CD,oDA+CC"}

package/dist/services/check-parser/package-files/index.d.ts

@@ -0,0 +1 @@
+export { PackageFilesResolver } from './resolver';

package/dist/services/check-parser/package-files/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageFilesResolver = void 0;
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "PackageFilesResolver", { enumerable: true, get: function () { return resolver_1.PackageFilesResolver; } });
+//# sourceMappingURL=index.js.map

package/dist/services/check-parser/package-files/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/check-parser/package-files/index.ts"],"names":[],"mappings":";;;AAAA,uCAAiD;AAAxC,gHAAA,oBAAoB,OAAA"}

package/dist/services/check-parser/package-files/jsconfig-json-file.d.ts

@@ -0,0 +1,17 @@
+import { TSConfigFile, Schema } from './tsconfig-json-file';
+import { JsonSourceFile } from './json-source-file';
+/**
+ * JSConfigFile is essentially the exact same as TSConfigFile but with
+ * allowJs implicitly enabled.
+ *
+ * While we could handle jsconfig.json with just TSConfigFile, it's not that
+ * much extra trouble to have a separate wrapper for it and doing it this way
+ * may enable some interesting features later.
+ */
+export declare class JSConfigFile extends TSConfigFile {
+    #private;
+    static FILENAME: string;
+    readonly id: number;
+    static filePath(dirPath: string): string;
+    static loadFromJsonSourceFile(jsonFile: JsonSourceFile<Schema>): JSConfigFile | undefined;
+}

package/dist/services/check-parser/package-files/jsconfig-json-file.js

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _JSConfigFile_id;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSConfigFile = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const tsconfig_json_file_1 = require("./tsconfig-json-file");
+/**
+ * JSConfigFile is essentially the exact same as TSConfigFile but with
+ * allowJs implicitly enabled.
+ *
+ * While we could handle jsconfig.json with just TSConfigFile, it's not that
+ * much extra trouble to have a separate wrapper for it and doing it this way
+ * may enable some interesting features later.
+ */
+class JSConfigFile extends tsconfig_json_file_1.TSConfigFile {
+    constructor() {
+        var _b, _c;
+        super(...arguments);
+        this.id = __classPrivateFieldSet(_b = _a, _a, (_c = __classPrivateFieldGet(_b, _a, "f", _JSConfigFile_id), ++_c), "f", _JSConfigFile_id);
+    }
+    static filePath(dirPath) {
+        return node_path_1.default.join(dirPath, _a.FILENAME);
+    }
+    static loadFromJsonSourceFile(jsonFile) {
+        return new _a(jsonFile);
+    }
+}
+exports.JSConfigFile = JSConfigFile;
+_a = JSConfigFile;
+JSConfigFile.FILENAME = 'jsconfig.json';
+_JSConfigFile_id = { value: 0 };
+//# sourceMappingURL=jsconfig-json-file.js.map

package/dist/services/check-parser/package-files/jsconfig-json-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsconfig-json-file.js","sourceRoot":"","sources":["../../../../src/services/check-parser/package-files/jsconfig-json-file.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAE5B,6DAA2D;AAG3D;;;;;;;GAOG;AACH,MAAa,YAAa,SAAQ,iCAAY;IAA9C;;;QAIW,OAAE,GAAG,oCAAA,CAAE,0DAAgB,EAAlB,IAAkB,CAAA,wBAAA,CAAA;IASlC,CAAC;IAPC,MAAM,CAAC,QAAQ,CAAE,OAAe;QAC9B,OAAO,mBAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAY,CAAC,QAAQ,CAAC,CAAA;IAClD,CAAC;IAED,MAAM,CAAC,sBAAsB,CAAE,QAAgC;QAC7D,OAAO,IAAI,EAAY,CAAC,QAAQ,CAAC,CAAA;IACnC,CAAC;;AAZH,oCAaC;;AAZQ,qBAAQ,GAAG,eAAe,AAAlB,CAAkB;AAE1B,4BAAM,CAAC,EAAJ,CAAI"}

package/dist/services/check-parser/package-files/json-source-file.d.ts

@@ -0,0 +1,10 @@
+import { SourceFile } from './source-file';
+export declare class JsonSourceFile<Schema> {
+    #private;
+    readonly id: number;
+    sourceFile: SourceFile;
+    data: Schema;
+    private constructor();
+    get meta(): import("./source-file").FileMeta;
+    static loadFromSourceFile<Schema>(sourceFile: SourceFile): JsonSourceFile<Schema> | undefined;
+}

package/dist/services/check-parser/package-files/json-source-file.js

@@ -0,0 +1,38 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _a, _JsonSourceFile_id;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSourceFile = void 0;
+class JsonSourceFile {
+    constructor(sourceFile, data) {
+        var _b, _c;
+        this.id = __classPrivateFieldSet(_b = _a, _a, (_c = __classPrivateFieldGet(_b, _a, "f", _JsonSourceFile_id), ++_c), "f", _JsonSourceFile_id);
+        this.sourceFile = sourceFile;
+        this.data = data;
+    }
+    get meta() {
+        return this.sourceFile.meta;
+    }
+    static loadFromSourceFile(sourceFile) {
+        try {
+            const data = JSON.parse(sourceFile.contents);
+            return new _a(sourceFile, data);
+        }
+        catch (err) {
+        }
+    }
+}
+exports.JsonSourceFile = JsonSourceFile;
+_a = JsonSourceFile;
+_JsonSourceFile_id = { value: 0 };
+//# sourceMappingURL=json-source-file.js.map

package/dist/services/check-parser/package-files/json-source-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-source-file.js","sourceRoot":"","sources":["../../../../src/services/check-parser/package-files/json-source-file.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,MAAa,cAAc;IAOzB,YAAqB,UAAsB,EAAE,IAAY;;QALhD,OAAE,GAAG,oCAAA,CAAE,4DAAkB,EAApB,IAAoB,CAAA,0BAAA,CAAA;QAMhC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAA;IAC7B,CAAC;IAED,MAAM,CAAC,kBAAkB,CAAU,UAAsB;QACvD,IAAI,CAAC;YACH,MAAM,IAAI,GAAW,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAA;YAEpD,OAAO,IAAI,EAAc,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;QAC7C,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;;AAvBH,wCAwBC;;AAvBQ,8BAAM,CAAC,EAAJ,CAAI"}

package/dist/services/check-parser/package-files/loader.d.ts

@@ -0,0 +1,7 @@
+export type LoadFile<T> = (filePath: string) => T | undefined;
+export declare class FileLoader<T> {
+    loader: LoadFile<T>;
+    cache: Map<string, T | undefined>;
+    constructor(loader: LoadFile<T>);
+    load(filePath: string): T | undefined;
+}

package/dist/services/check-parser/package-files/loader.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLoader = void 0;
+class FileLoader {
+    constructor(loader) {
+        this.cache = new Map();
+        this.loader = loader;
+    }
+    load(filePath) {
+        if (this.cache.has(filePath)) {
+            return this.cache.get(filePath);
+        }
+        const file = this.loader(filePath);
+        this.cache.set(filePath, file);
+        return file;
+    }
+}
+exports.FileLoader = FileLoader;
+//# sourceMappingURL=loader.js.map

package/dist/services/check-parser/package-files/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../../src/services/check-parser/package-files/loader.ts"],"names":[],"mappings":";;;AAEA,MAAa,UAAU;IAIrB,YAAa,MAAmB;QAFhC,UAAK,GAAG,IAAI,GAAG,EAAyB,CAAA;QAGtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAED,IAAI,CAAE,QAAgB;QACpB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QACjC,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAClC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;QAC9B,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAhBD,gCAgBC"}

package/dist/services/check-parser/package-files/package-json-file.d.ts

@@ -0,0 +1,20 @@
+import { JsonSourceFile } from './json-source-file';
+type ExportCondition = 'node-addons' | 'node' | 'import' | 'require' | 'module-sync' | 'default';
+type Schema = {
+    main?: string;
+    exports?: string | string[] | Record<string, string> | Record<ExportCondition, Record<string, string>>;
+};
+export declare class PackageJsonFile {
+    #private;
+    static FILENAME: string;
+    readonly id: number;
+    jsonFile: JsonSourceFile<Schema>;
+    basePath: string;
+    mainPaths: string[];
+    private constructor();
+    get meta(): import("./source-file").FileMeta;
+    static loadFromJsonSourceFile(jsonFile: JsonSourceFile<Schema>): PackageJsonFile | undefined;
+    static filePath(dirPath: string): string;
+    supportsPackageRelativePaths(): boolean;
+}
+export {};

package/dist/services/check-parser/package-files/package-json-file.js

@@ -0,0 +1,48 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _PackageJsonFile_id;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageJsonFile = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class PackageJsonFile {
+    constructor(jsonFile) {
+        var _b, _c;
+        this.id = __classPrivateFieldSet(_b = _a, _a, (_c = __classPrivateFieldGet(_b, _a, "f", _PackageJsonFile_id), ++_c), "f", _PackageJsonFile_id);
+        this.jsonFile = jsonFile;
+        this.basePath = jsonFile.meta.dirname;
+        const fallbackMainPath = node_path_1.default.resolve(this.basePath, 'index.js');
+        this.mainPaths = jsonFile.data.main !== undefined
+            ? [node_path_1.default.resolve(this.basePath, jsonFile.data.main), fallbackMainPath]
+            : [fallbackMainPath];
+    }
+    get meta() {
+        return this.jsonFile.meta;
+    }
+    static loadFromJsonSourceFile(jsonFile) {
+        return new _a(jsonFile);
+    }
+    static filePath(dirPath) {
+        return node_path_1.default.join(dirPath, _a.FILENAME);
+    }
+    supportsPackageRelativePaths() {
+        return this.jsonFile.data.exports === undefined;
+    }
+}
+exports.PackageJsonFile = PackageJsonFile;
+_a = PackageJsonFile;
+PackageJsonFile.FILENAME = 'package.json';
+_PackageJsonFile_id = { value: 0 };
+//# sourceMappingURL=package-json-file.js.map

package/dist/services/check-parser/package-files/package-json-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json-file.js","sourceRoot":"","sources":["../../../../src/services/check-parser/package-files/package-json-file.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAY5B,MAAa,eAAe;IAU1B,YAAqB,QAAgC;;QAN5C,OAAE,GAAG,oCAAA,CAAE,6DAAmB,EAArB,IAAqB,CAAA,2BAAA,CAAA;QAOjC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAA;QAErC,MAAM,gBAAgB,GAAG,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QAEhE,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS;YAC/C,CAAC,CAAC,CAAC,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;YACrE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAA;IACxB,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAA;IAC3B,CAAC;IAED,MAAM,CAAC,sBAAsB,CAAE,QAAgC;QAC7D,OAAO,IAAI,EAAe,CAAC,QAAQ,CAAC,CAAA;IACtC,CAAC;IAED,MAAM,CAAC,QAAQ,CAAE,OAAe;QAC9B,OAAO,mBAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAe,CAAC,QAAQ,CAAC,CAAA;IACrD,CAAC;IAED,4BAA4B;QAC1B,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAA;IACjD,CAAC;;AAnCH,0CAoCC;;AAnCQ,wBAAQ,GAAG,cAAc,AAAjB,CAAiB;AAEzB,+BAAM,CAAC,EAAJ,CAAI"}

package/dist/services/check-parser/package-files/paths.d.ts

@@ -0,0 +1,80 @@
+type Paths = Record<string, Array<string>>;
+declare class TargetPathSpec {
+    /**
+     * Prefix is the part of the path before an asterisk (wildcard), or the
+     * whole path if there's no asterisk.
+     *
+     * Examples of possible values:
+     *   - `"./foo/*"` (from `"./foo/"`)
+     *   - `"./bar/foo-"` (from `"./bar/foo-*.js"`)
+     *   - `"./bar."` (from `"./bar.*.ts"`)
+     *   - `""` (from `"*"`)
+     */
+    prefix: string;
+    /**
+     * Suffix is the part of the path after the asterisk (wildcard), if any.
+     */
+    suffix?: string;
+    protected constructor(prefix: string, suffix?: string);
+    toPath(joker?: string): string;
+    static create(spec: string): TargetPathSpec;
+}
+export type TargetPathResult = {
+    spec: TargetPathSpec;
+    path: string;
+};
+declare class PathMatchResult {
+    ok: boolean;
+    results: TargetPathResult[];
+    private constructor();
+    static some(results: TargetPathResult[]): PathMatchResult;
+    static none(): PathMatchResult;
+}
+interface PathMatcher {
+    get prefixLength(): number;
+    match(importPath: string): PathMatchResult;
+}
+declare class SourcePathSpec {
+    /**
+     * Prefix is the part of the path before an asterisk (wildcard), or the
+     * whole path if there's no asterisk.
+     *
+     * Examples of possible values:
+     *   - `"@/"` (from `"@/*"`)
+     *   - `"app/foo-"` (from `"app/foo-*.js"`)
+     *   - `"bar."` (from `"bar.*.ts"`)
+     *   - `""` (from `"*"`)
+     */
+    prefix: string;
+    /**
+     * Suffix is the part of the path after the asterisk (wildcard), if any.
+     */
+    suffix?: string;
+    protected constructor(prefix: string, suffix?: string);
+    get moduleLikeName(): string | undefined;
+    matcherForTarget(target: TargetPathSpec[]): PathMatcher;
+    static create(spec: string): SourcePathSpec;
+}
+type SourcePathSpecMatcher = {
+    spec: SourcePathSpec;
+    matcher: PathMatcher;
+};
+export type SourcePathResult = {
+    spec: SourcePathSpec;
+    path: string;
+};
+export type PathResult = {
+    source: SourcePathResult;
+    target: TargetPathResult;
+};
+export type ResolveResult = PathResult[];
+export declare class PathResolver {
+    baseUrl: string;
+    matchers: SourcePathSpecMatcher[];
+    private constructor();
+    resolve(importPath: string): ResolveResult;
+    static createFromPaths(baseUrl: string, paths: Paths): PathResolver;
+    private static matcherForPath;
+}
+export declare function isLocalPath(importPath: string): boolean;
+export {};

package/dist/services/check-parser/package-files/paths.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalPath = exports.PathResolver = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class TargetPathSpec {
+    constructor(prefix, suffix) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+    toPath(joker) {
+        if (this.suffix === undefined) {
+            return this.prefix;
+        }
+        if (joker === undefined) {
+            return this.prefix + this.suffix;
+        }
+        return this.prefix + joker + this.suffix;
+    }
+    static create(spec) {
+        const parts = spec.split('*', 2);
+        if (parts.length === 1) {
+            return new TargetPathSpec(spec);
+        }
+        const [prefix, suffix] = parts;
+        return new TargetPathSpec(prefix, suffix);
+    }
+}
+class PathMatchResult {
+    constructor(ok, results) {
+        this.ok = ok;
+        this.results = results;
+    }
+    static some(results) {
+        return new PathMatchResult(true, results);
+    }
+    static none() {
+        return new PathMatchResult(false, []);
+    }
+}
+class ExactPathMatcher {
+    constructor(prefix, target) {
+        this.prefix = prefix;
+        this.target = target;
+    }
+    get prefixLength() {
+        return this.prefix.length;
+    }
+    match(importPath) {
+        if (importPath === this.prefix) {
+            return PathMatchResult.some(this.target.map(target => {
+                return {
+                    spec: target,
+                    path: target.toPath(),
+                };
+            }));
+        }
+        return PathMatchResult.none();
+    }
+}
+class WildcardPathMatcher {
+    constructor(prefix, suffix, target) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.target = target;
+    }
+    get prefixLength() {
+        return this.prefix.length;
+    }
+    match(importPath) {
+        if (importPath.startsWith(this.prefix) && importPath.endsWith(this.suffix)) {
+            const joker = importPath.substring(this.prefix.length, importPath.length - this.suffix.length);
+            return PathMatchResult.some(this.target.map(target => {
+                return {
+                    spec: target,
+                    path: target.toPath(joker),
+                };
+            }));
+        }
+        return PathMatchResult.none();
+    }
+}
+class SourcePathSpec {
+    constructor(prefix, suffix) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+    get moduleLikeName() {
+        if (this.suffix === undefined) {
+            return this.prefix;
+        }
+        // If prefix is already a directory (ends with `/`), path.dirname will
+        // not return the desired result as it will strip the last component
+        // entirely. However, we can circumvent this by adding a dummy value to
+        // the prefix which ensures that we always get the whole dirname
+        // regardless of whether there is already filename or not.
+        const moduleLike = node_path_1.default.dirname(this.prefix + 'x');
+        if (moduleLike === '') {
+            // Reduce mistakes by returning undefined for this special case.
+            return undefined;
+        }
+        return moduleLike;
+    }
+    matcherForTarget(target) {
+        if (this.suffix === undefined) {
+            return new ExactPathMatcher(this.prefix, target);
+        }
+        return new WildcardPathMatcher(this.prefix, this.suffix, target);
+    }
+    static create(spec) {
+        const parts = spec.split('*', 2);
+        if (parts.length === 1) {
+            return new SourcePathSpec(spec);
+        }
+        const [prefix, suffix] = parts;
+        return new SourcePathSpec(prefix, suffix);
+    }
+}
+class PathResolver {
+    constructor(baseUrl, matchers) {
+        this.baseUrl = baseUrl;
+        // Sort by longest prefix now, then we don't have to care about it later.
+        matchers.sort((a, b) => b.matcher.prefixLength - a.matcher.prefixLength);
+        this.matchers = matchers;
+    }
+    resolve(importPath) {
+        for (const { spec, matcher } of this.matchers) {
+            const match = matcher.match(importPath);
+            if (match.ok) {
+                // We can just return the first match since matchers are already
+                // sorted by longest prefix.
+                return match.results.map(result => {
+                    return {
+                        source: {
+                            spec,
+                            path: importPath,
+                        },
+                        target: result,
+                    };
+                });
+            }
+        }
+        return [];
+    }
+    static createFromPaths(baseUrl, paths) {
+        const matchers = [];
+        for (const path in paths) {
+            matchers.push(PathResolver.matcherForPath(path, paths[path]));
+        }
+        return new PathResolver(baseUrl, matchers);
+    }
+    static matcherForPath(spec, target) {
+        const pathSpec = SourcePathSpec.create(spec);
+        const matcher = pathSpec.matcherForTarget(target.map(TargetPathSpec.create));
+        return {
+            spec: pathSpec,
+            matcher,
+        };
+    }
+}
+exports.PathResolver = PathResolver;
+function isLocalPath(importPath) {
+    if (importPath.startsWith('/')) {
+        return true;
+    }
+    if (importPath.startsWith('./')) {
+        return true;
+    }
+    if (importPath.startsWith('../')) {
+        return true;
+    }
+    return false;
+}
+exports.isLocalPath = isLocalPath;
+//# sourceMappingURL=paths.js.map