@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/topology/ts-oracle.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImportability = checkImportability;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_loader_1 = require("./tsconfig-loader");
+const ts_oracle_host_1 = require("./ts-oracle-host");
+function checkImportability(request) {
+    const startedAt = Date.now();
+    const workspaceRoot = path.resolve(request.workspaceRoot);
+    const fromFile = path.resolve(workspaceRoot, request.fromFile);
+    const toFile = path.resolve(workspaceRoot, request.toFile);
+    const diagnostics = [];
+    if (!(0, tsconfig_loader_1.fileExists)(fromFile)) {
+        diagnostics.push({ code: "TS_ORACLE_FROM_NOT_FOUND", message: "Importer file does not exist.", file: toDisplayPath(workspaceRoot, fromFile) });
+    }
+    if (!(0, tsconfig_loader_1.fileExists)(toFile)) {
+        diagnostics.push({ code: "TS_ORACLE_TO_NOT_FOUND", message: "Target file does not exist.", file: toDisplayPath(workspaceRoot, toFile) });
+    }
+    const configStartedAt = Date.now();
+    const config = (0, tsconfig_loader_1.findParsedTsConfigForFile)(workspaceRoot, fromFile, diagnostics);
+    const configMs = Date.now() - configStartedAt;
+    if (!config) {
+        return result({
+            request,
+            workspaceRoot,
+            fromFile,
+            toFile,
+            diagnostics: [
+                ...diagnostics,
+                { code: "TS_ORACLE_TSCONFIG_NOT_FOUND", message: "No discovered tsconfig includes the importer file.", file: toDisplayPath(workspaceRoot, fromFile) }
+            ],
+            resolution: "unresolved",
+            project: "not-checked",
+            status: "unknown",
+            configMs,
+            resolutionMs: 0,
+            programMs: 0,
+            startedAt
+        });
+    }
+    const resolutionStartedAt = Date.now();
+    const resolved = typescript_1.default.resolveModuleName(request.specifier, fromFile, config.parsed.options, (0, ts_oracle_host_1.createWorkspaceModuleResolutionHost)(workspaceRoot)).resolvedModule;
+    const resolutionMs = Date.now() - resolutionStartedAt;
+    const resolvedFile = resolved?.resolvedFileName ? path.resolve(resolved.resolvedFileName) : undefined;
+    const resolution = !resolvedFile
+        ? "unresolved"
+        : sameSourceFile(resolvedFile, toFile)
+            ? "resolved"
+            : "target-mismatch";
+    const shouldCheckProject = request.checkProject !== false && resolution === "resolved";
+    const programStartedAt = Date.now();
+    const project = shouldCheckProject
+        ? checkProjectValidity(config.file, config.parsed, fromFile, request.specifier, diagnostics)
+        : "not-checked";
+    const programMs = Date.now() - programStartedAt;
+    return result({
+        request,
+        workspaceRoot,
+        fromFile,
+        toFile,
+        diagnostics,
+        resolution,
+        project,
+        status: statusFor(resolution, project),
+        configMs,
+        resolutionMs,
+        programMs,
+        startedAt,
+        tsconfig: config.file,
+        ...(resolvedFile ? { resolvedFile } : {})
+    });
+}
+function checkProjectValidity(tsconfig, parsed, fromFile, specifier, diagnostics) {
+    const fromInProject = parsed.fileNames.some((file) => sameSourceFile(file, fromFile));
+    if (!fromInProject) {
+        diagnostics.push({
+            code: "TS_ORACLE_FROM_NOT_IN_PROJECT",
+            message: "Importer file is not part of the parsed TypeScript project.",
+            file: fromFile
+        });
+        return "invalid";
+    }
+    const originalSource = typescript_1.default.sys.readFile(fromFile);
+    if (originalSource === undefined) {
+        diagnostics.push({
+            code: "TS_ORACLE_FROM_UNREADABLE",
+            message: "Could not read importer file.",
+            file: fromFile
+        });
+        return "invalid";
+    }
+    const virtualSource = `${originalSource}\nimport ${JSON.stringify(specifier)};\n`;
+    const baseline = collectProjectDiagnostics(parsed, fromFile);
+    const baselineKeys = new Set(baseline.map(diagnosticKey));
+    const relevant = collectProjectDiagnostics(parsed, fromFile, virtualSource)
+        .filter((diagnostic) => !baselineKeys.has(diagnosticKey(diagnostic)))
+        .filter((diagnostic) => !isBenignOracleDiagnostic(diagnostic, tsconfig));
+    for (const diagnostic of relevant) {
+        diagnostics.push((0, tsconfig_loader_1.toOracleDiagnostic)("TS_ORACLE_PROJECT_DIAGNOSTIC", diagnostic));
+    }
+    return relevant.length === 0 ? "valid" : "invalid";
+}
+function collectProjectDiagnostics(parsed, fromFile, virtualSource) {
+    const host = typescript_1.default.createCompilerHost(parsed.options, true);
+    const baseGetSourceFile = host.getSourceFile.bind(host);
+    host.readFile = (fileName) => virtualSource && sameSourceFile(fileName, fromFile) ? virtualSource : typescript_1.default.sys.readFile(fileName);
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        if (virtualSource && sameSourceFile(fileName, fromFile)) {
+            return typescript_1.default.createSourceFile(fileName, virtualSource, languageVersionOrOptions, true);
+        }
+        return baseGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    };
+    const program = typescript_1.default.createProgram(parsed.fileNames, parsed.options, host);
+    const source = program.getSourceFile(fromFile);
+    return [
+        ...program.getOptionsDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...(source ? program.getSyntacticDiagnostics(source) : []),
+        ...(source ? program.getSemanticDiagnostics(source) : [])
+    ];
+}
+function diagnosticKey(diagnostic) {
+    return [
+        diagnostic.code,
+        diagnostic.file?.fileName ?? "",
+        diagnostic.start ?? "",
+        diagnostic.length ?? "",
+        typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+    ].join("|");
+}
+function statusFor(resolution, project) {
+    if (resolution === "unresolved") {
+        return "unresolved";
+    }
+    if (resolution === "target-mismatch") {
+        return "target-mismatch";
+    }
+    if (project === "invalid") {
+        return "resolves-but-project-invalid";
+    }
+    return "valid";
+}
+function isBenignOracleDiagnostic(diagnostic, tsconfig) {
+    if (diagnostic.code === 18003) {
+        return false;
+    }
+    if (diagnostic.code === 5069 || diagnostic.code === 5070) {
+        return false;
+    }
+    return diagnostic.file?.fileName === tsconfig && diagnostic.category === typescript_1.default.DiagnosticCategory.Message;
+}
+function result(args) {
+    return {
+        status: args.status,
+        resolution: args.resolution,
+        project: args.project,
+        fromFile: toDisplayPath(args.workspaceRoot, args.fromFile),
+        toFile: toDisplayPath(args.workspaceRoot, args.toFile),
+        specifier: args.request.specifier,
+        ...(args.tsconfig ? { tsconfig: toDisplayPath(args.workspaceRoot, args.tsconfig) } : {}),
+        ...(args.resolvedFile ? { resolvedFile: toDisplayPath(args.workspaceRoot, args.resolvedFile) } : {}),
+        diagnostics: args.diagnostics.map((diagnostic) => ({
+            ...diagnostic,
+            ...(diagnostic.file ? { file: toDisplayPath(args.workspaceRoot, diagnostic.file) } : {})
+        })),
+        timings: {
+            totalMs: Date.now() - args.startedAt,
+            configMs: args.configMs,
+            resolutionMs: args.resolutionMs,
+            programMs: args.programMs
+        }
+    };
+}
+function sameSourceFile(left, right) {
+    return normalizeSourceFile(left) === normalizeSourceFile(right);
+}
+function normalizeSourceFile(file) {
+    const resolved = path.resolve(file).replace(/\\/g, "/").toLowerCase();
+    return resolved.endsWith(".d.ts") ? resolved.slice(0, -5) : withoutSourceExtension(resolved);
+}
+function withoutSourceExtension(file) {
+    return file.replace(/\.(d\.)?[cm]?[tj]sx?$/i, "");
+}
+function toDisplayPath(root, file) {
+    const relative = path.relative(root, path.resolve(file)).replace(/\\/g, "/");
+    return relative === "" ? "." : relative.startsWith("..") ? path.resolve(file) : relative;
+}

package/dist/topology/tsconfig-loader.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findParsedTsConfigForFile = findParsedTsConfigForFile;
+exports.parseTsConfig = parseTsConfig;
+exports.toOracleDiagnostic = toOracleDiagnostic;
+exports.fileExists = fileExists;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_discovery_1 = require("../config/tsconfig-discovery");
+function findParsedTsConfigForFile(workspaceRoot, filePath, diagnostics) {
+    const root = path.resolve(workspaceRoot);
+    const file = path.resolve(root, filePath);
+    const candidates = (0, tsconfig_discovery_1.discoverTsconfigFiles)(root).visible
+        .map((configPath) => parseTsConfig(configPath, diagnostics))
+        .filter((config) => config !== null)
+        .filter((config) => ownsFile(config, file))
+        .sort((left, right) => compareOwnerConfigs(left.file, right.file, file));
+    return candidates[0] ?? null;
+}
+function parseTsConfig(configPath, diagnostics) {
+    const file = path.resolve(configPath);
+    const read = typescript_1.default.readConfigFile(file, typescript_1.default.sys.readFile);
+    if (read.error) {
+        diagnostics.push(toOracleDiagnostic("TS_ORACLE_TSCONFIG_READ_FAILED", read.error));
+        return null;
+    }
+    const configDir = path.dirname(file);
+    const parsed = typescript_1.default.parseJsonConfigFileContent(read.config, typescript_1.default.sys, configDir, undefined, file);
+    for (const diagnostic of parsed.errors) {
+        diagnostics.push(toOracleDiagnostic("TS_ORACLE_TSCONFIG_PARSE_DIAGNOSTIC", diagnostic));
+    }
+    return { file, parsed };
+}
+function toOracleDiagnostic(code, diagnostic) {
+    const result = {
+        code,
+        message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+        tsCode: diagnostic.code
+    };
+    if (diagnostic.file) {
+        result.file = diagnostic.file.fileName;
+    }
+    return result;
+}
+function ownsFile(config, file) {
+    const normalized = normalizePath(file);
+    return config.parsed.fileNames.some((candidate) => normalizePath(candidate) === normalized);
+}
+function compareOwnerConfigs(leftConfig, rightConfig, file) {
+    const leftDir = path.dirname(leftConfig);
+    const rightDir = path.dirname(rightConfig);
+    const leftOwnsByDirectory = isPathInsideOrEqual(file, leftDir);
+    const rightOwnsByDirectory = isPathInsideOrEqual(file, rightDir);
+    return Number(rightOwnsByDirectory) - Number(leftOwnsByDirectory) ||
+        rightDir.length - leftDir.length ||
+        path.basename(leftConfig).localeCompare(path.basename(rightConfig)) ||
+        leftConfig.localeCompare(rightConfig);
+}
+function isPathInsideOrEqual(file, dir) {
+    const relative = path.relative(dir, file);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function normalizePath(file) {
+    return path.resolve(file).toLowerCase();
+}
+function fileExists(file) {
+    return fs.existsSync(file);
+}