api-tests-coverage 1.0.0

package/dist/src/compatibilityCoverage.js

@@ -0,0 +1,501 @@
+"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.loadSpec = loadSpec;
+exports.compareSpecs = compareSpecs;
+exports.parseContractFiles = parseContractFiles;
+exports.verifyContracts = verifyContracts;
+exports.computeCompatibilityPercent = computeCompatibilityPercent;
+exports.computeContractCoveragePercent = computeContractCoveragePercent;
+exports.buildCompatibilityReport = buildCompatibilityReport;
+exports.generateCompatibilityReports = generateCompatibilityReports;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'];
+function extractEndpoints(api) {
+    var _a;
+    const results = [];
+    const paths = (_a = api.paths) !== null && _a !== void 0 ? _a : {};
+    for (const [p, pathItem] of Object.entries(paths)) {
+        if (!pathItem)
+            continue;
+        for (const method of HTTP_METHODS) {
+            const op = pathItem[method];
+            if (op && typeof op === 'object') {
+                results.push({ method, path: p, operation: op });
+            }
+        }
+    }
+    return results;
+}
+function getResponseCodes(op) {
+    var _a;
+    return Object.keys((_a = op.responses) !== null && _a !== void 0 ? _a : {});
+}
+function getParameters(op) {
+    var _a;
+    return ((_a = op.parameters) !== null && _a !== void 0 ? _a : []);
+}
+function paramKey(p) {
+    return `${p.in}:${p.name}`;
+}
+// ─── Spec comparison ──────────────────────────────────────────────────────────
+/**
+ * Load and dereference an OpenAPI/Swagger spec from a file path.
+ */
+async function loadSpec(specPath) {
+    const api = await swagger_parser_1.default.dereference(specPath);
+    return api;
+}
+/**
+ * Compare two API specs and return a list of detected changes.
+ */
+function compareSpecs(oldApi, newApi) {
+    var _a, _b;
+    const changes = [];
+    const oldEndpoints = extractEndpoints(oldApi);
+    const newEndpoints = extractEndpoints(newApi);
+    const oldMap = new Map();
+    for (const ep of oldEndpoints) {
+        oldMap.set(`${ep.method}:${ep.path}`, ep);
+    }
+    const newMap = new Map();
+    for (const ep of newEndpoints) {
+        newMap.set(`${ep.method}:${ep.path}`, ep);
+    }
+    // Removed endpoints (breaking)
+    for (const [key, oldEp] of oldMap) {
+        if (!newMap.has(key)) {
+            changes.push({
+                method: oldEp.method,
+                path: oldEp.path,
+                changeType: 'removed',
+                breaking: true,
+                description: `Endpoint removed: ${oldEp.method.toUpperCase()} ${oldEp.path}`,
+            });
+        }
+    }
+    // Added endpoints (non-breaking)
+    for (const [key, newEp] of newMap) {
+        if (!oldMap.has(key)) {
+            changes.push({
+                method: newEp.method,
+                path: newEp.path,
+                changeType: 'added',
+                breaking: false,
+                description: `Endpoint added: ${newEp.method.toUpperCase()} ${newEp.path}`,
+            });
+        }
+    }
+    // Changed endpoints
+    for (const [key, oldEp] of oldMap) {
+        const newEp = newMap.get(key);
+        if (!newEp)
+            continue;
+        // Check response codes
+        const oldCodes = new Set(getResponseCodes(oldEp.operation));
+        const newCodes = new Set(getResponseCodes(newEp.operation));
+        const removedCodes = [...oldCodes].filter((c) => !newCodes.has(c));
+        if (removedCodes.length > 0) {
+            changes.push({
+                method: oldEp.method,
+                path: oldEp.path,
+                changeType: 'changed-response-codes',
+                breaking: true,
+                description: `Response codes removed from ${oldEp.method.toUpperCase()} ${oldEp.path}: ${removedCodes.join(', ')}`,
+            });
+        }
+        // Check parameters
+        const oldParams = getParameters(oldEp.operation);
+        const newParams = getParameters(newEp.operation);
+        const newParamMap = new Map(newParams.map((p) => [paramKey(p), p]));
+        for (const oldParam of oldParams) {
+            const newParam = newParamMap.get(paramKey(oldParam));
+            if (!newParam) {
+                // Parameter removed — breaking if it was required
+                changes.push({
+                    method: oldEp.method,
+                    path: oldEp.path,
+                    changeType: 'changed-parameter',
+                    breaking: oldParam.required === true,
+                    description: `Parameter removed from ${oldEp.method.toUpperCase()} ${oldEp.path}: ${oldParam.in} '${oldParam.name}'${oldParam.required ? ' (required)' : ''}`,
+                });
+                continue;
+            }
+            // Parameter type/format changed — breaking
+            const oldSchema = ((_a = oldParam.schema) !== null && _a !== void 0 ? _a : {});
+            const newSchema = ((_b = newParam.schema) !== null && _b !== void 0 ? _b : {});
+            if (oldSchema['type'] !== newSchema['type'] || oldSchema['format'] !== newSchema['format']) {
+                changes.push({
+                    method: oldEp.method,
+                    path: oldEp.path,
+                    changeType: 'changed-parameter',
+                    breaking: true,
+                    description: `Parameter type/format changed for ${oldEp.method.toUpperCase()} ${oldEp.path}: '${oldParam.name}' (${oldSchema['type']}/${oldSchema['format']} → ${newSchema['type']}/${newSchema['format']})`,
+                });
+            }
+            // Required flag changed from optional to required — breaking
+            if (!oldParam.required && newParam.required) {
+                changes.push({
+                    method: oldEp.method,
+                    path: oldEp.path,
+                    changeType: 'changed-parameter',
+                    breaking: true,
+                    description: `Parameter '${oldParam.name}' became required in ${oldEp.method.toUpperCase()} ${oldEp.path}`,
+                });
+            }
+        }
+        // New required parameters added — breaking
+        const oldParamMap = new Map(oldParams.map((p) => [paramKey(p), p]));
+        for (const newParam of newParams) {
+            if (!oldParamMap.has(paramKey(newParam)) && newParam.required) {
+                changes.push({
+                    method: newEp.method,
+                    path: newEp.path,
+                    changeType: 'changed-parameter',
+                    breaking: true,
+                    description: `Required parameter added to ${newEp.method.toUpperCase()} ${newEp.path}: ${newParam.in} '${newParam.name}'`,
+                });
+            }
+        }
+    }
+    return changes;
+}
+// ─── Contract parsing ─────────────────────────────────────────────────────────
+/**
+ * Parse Pact-format JSON contract files matching the given glob pattern or directory.
+ */
+async function parseContractFiles(contractsGlob) {
+    let pattern = contractsGlob;
+    // If the provided path is a directory, search recursively for JSON files inside it
+    if (fs.existsSync(contractsGlob) && fs.statSync(contractsGlob).isDirectory()) {
+        pattern = path.join(contractsGlob, '**/*.json').replace(/\\/g, '/');
+    }
+    const files = await (0, fast_glob_1.default)(pattern, { absolute: true });
+    const contracts = [];
+    for (const filePath of files) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const contract = parsePactContract(raw, filePath);
+            if (contract)
+                contracts.push(contract);
+        }
+        catch {
+            // Skip invalid files
+        }
+    }
+    return contracts;
+}
+function parsePactContract(raw, filePath) {
+    var _a, _b;
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const obj = raw;
+    if (!obj['interactions'] || !Array.isArray(obj['interactions']))
+        return null;
+    const consumer = typeof obj['consumer'] === 'object' && obj['consumer'] !== null
+        ? (_a = obj['consumer']['name']) !== null && _a !== void 0 ? _a : 'unknown'
+        : 'unknown';
+    const provider = typeof obj['provider'] === 'object' && obj['provider'] !== null
+        ? (_b = obj['provider']['name']) !== null && _b !== void 0 ? _b : 'unknown'
+        : 'unknown';
+    const interactions = [];
+    for (const item of obj['interactions']) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const interaction = item;
+        const request = interaction['request'];
+        const response = interaction['response'];
+        if (!request)
+            continue;
+        const method = typeof request['method'] === 'string' ? request['method'].toLowerCase() : '';
+        const interactionPath = typeof request['path'] === 'string' ? request['path'] : '';
+        if (!method || !interactionPath)
+            continue;
+        const expectedStatus = typeof (response === null || response === void 0 ? void 0 : response['status']) === 'number' ? response['status'] : 200;
+        interactions.push({
+            description: typeof interaction['description'] === 'string' ? interaction['description'] : '',
+            method,
+            path: interactionPath,
+            requestBody: request['body'],
+            expectedStatus,
+            expectedBody: response === null || response === void 0 ? void 0 : response['body'],
+        });
+    }
+    return { consumer, provider, interactions, filePath };
+}
+// ─── Contract verification ────────────────────────────────────────────────────
+/**
+ * Normalise a path template by replacing Pact-style `:param` segments with
+ * OpenAPI-style `{param}` segments so the two formats can be compared.
+ */
+function normalisePath(p) {
+    return p.replace(/:([^/]+)/g, '{$1}');
+}
+/**
+ * Check whether a path from a contract matches an OpenAPI spec path,
+ * accounting for path parameter placeholders in different styles.
+ */
+function pathMatchesSpec(contractPath, specPath) {
+    const normalised = normalisePath(contractPath);
+    if (normalised === specPath)
+        return true;
+    // Build a regex from the spec path template and test the contract path
+    const regexStr = '^' + specPath.replace(/\{[^}]+\}/g, '[^/]+') + '$';
+    return new RegExp(regexStr).test(contractPath);
+}
+/**
+ * Verify consumer contracts against a new API spec.
+ */
+function verifyContracts(contracts, newApi) {
+    const endpoints = extractEndpoints(newApi);
+    return contracts.map((contract) => {
+        const interactionResults = contract.interactions.map((interaction) => {
+            // Find matching endpoint in spec
+            const match = endpoints.find((ep) => ep.method === interaction.method && pathMatchesSpec(interaction.path, ep.path));
+            if (!match) {
+                return {
+                    interaction,
+                    passed: false,
+                    reason: `Endpoint not found in new spec: ${interaction.method.toUpperCase()} ${interaction.path}`,
+                };
+            }
+            // Check expected response status code is present in spec
+            const responseCodes = getResponseCodes(match.operation);
+            const statusStr = String(interaction.expectedStatus);
+            if (!responseCodes.includes(statusStr) &&
+                !responseCodes.includes('default')) {
+                return {
+                    interaction,
+                    passed: false,
+                    reason: `Expected response status ${interaction.expectedStatus} not defined for ${interaction.method.toUpperCase()} ${interaction.path} in new spec`,
+                };
+            }
+            return { interaction, passed: true };
+        });
+        const passed = interactionResults.every((r) => r.passed);
+        return { contract, interactionResults, passed };
+    });
+}
+// ─── Metrics ──────────────────────────────────────────────────────────────────
+/**
+ * Compute compatibility percentage based on detected breaking changes.
+ */
+function computeCompatibilityPercent(totalOldEndpoints, breakingChanges) {
+    if (totalOldEndpoints === 0)
+        return 100;
+    // Count uniquely affected old endpoints (by method+path)
+    const affectedKeys = new Set(breakingChanges
+        .filter((c) => c.changeType !== 'added')
+        .map((c) => `${c.method}:${c.path}`));
+    const unaffected = Math.max(0, totalOldEndpoints - affectedKeys.size);
+    return parseFloat(((unaffected / totalOldEndpoints) * 100).toFixed(2));
+}
+/**
+ * Compute what fraction of new spec endpoints are covered by at least one
+ * contract interaction.
+ */
+function computeContractCoveragePercent(contracts, newApi) {
+    const endpoints = extractEndpoints(newApi);
+    const coveredKeys = new Set();
+    for (const contract of contracts) {
+        for (const interaction of contract.interactions) {
+            const match = endpoints.find((ep) => ep.method === interaction.method && pathMatchesSpec(interaction.path, ep.path));
+            if (match)
+                coveredKeys.add(`${match.method}:${match.path}`);
+        }
+    }
+    const total = endpoints.length;
+    const covered = coveredKeys.size;
+    const coveragePercent = total === 0 ? 100 : parseFloat(((covered / total) * 100).toFixed(2));
+    return { coveredEndpoints: covered, totalEndpoints: total, coveragePercent };
+}
+// ─── Report builder ───────────────────────────────────────────────────────────
+function buildCompatibilityReport(oldApi, newApi, changes, verificationResults, oldSpecPath, newSpecPath) {
+    const oldEndpoints = extractEndpoints(oldApi);
+    const breakingChanges = changes.filter((c) => c.breaking);
+    const nonBreakingChanges = changes.filter((c) => !c.breaking);
+    const compatibilityPercent = computeCompatibilityPercent(oldEndpoints.length, breakingChanges);
+    const coverageMetrics = computeContractCoveragePercent(verificationResults.map((r) => r.contract), newApi);
+    return {
+        generatedAt: new Date().toISOString(),
+        oldSpecPath,
+        newSpecPath,
+        totalOldEndpoints: oldEndpoints.length,
+        breakingChanges,
+        nonBreakingChanges,
+        compatibilityPercent,
+        contractVerificationResults: verificationResults,
+        totalNewEndpoints: coverageMetrics.totalEndpoints,
+        contractCoveredEndpoints: coverageMetrics.coveredEndpoints,
+        contractCoveragePercent: coverageMetrics.coveragePercent,
+    };
+}
+// ─── Report writers ───────────────────────────────────────────────────────────
+function writeCompatibilityJson(report, reportsDir) {
+    const outPath = path.join(reportsDir, 'compatibility-contracts.json');
+    fs.writeFileSync(outPath, JSON.stringify(report, null, 2), 'utf-8');
+}
+function writeCompatibilityHtml(report, reportsDir) {
+    const breakingRows = report.breakingChanges
+        .map((c) => `    <tr class="breaking">
+      <td>${c.method.toUpperCase()}</td>
+      <td>${c.path}</td>
+      <td>${c.changeType}</td>
+      <td>${c.description}</td>
+    </tr>`)
+        .join('\n');
+    const nonBreakingRows = report.nonBreakingChanges
+        .map((c) => `    <tr class="non-breaking">
+      <td>${c.method.toUpperCase()}</td>
+      <td>${c.path}</td>
+      <td>${c.changeType}</td>
+      <td>${c.description}</td>
+    </tr>`)
+        .join('\n');
+    const contractRows = report.contractVerificationResults
+        .flatMap((r) => r.interactionResults.map((ir) => {
+        var _a;
+        return `    <tr class="${ir.passed ? 'pass' : 'fail'}">
+      <td>${r.contract.consumer}</td>
+      <td>${r.contract.provider}</td>
+      <td>${ir.interaction.description}</td>
+      <td>${ir.interaction.method.toUpperCase()} ${ir.interaction.path}</td>
+      <td>${ir.passed ? '✅ Pass' : '❌ Fail'}</td>
+      <td>${(_a = ir.reason) !== null && _a !== void 0 ? _a : ''}</td>
+    </tr>`;
+    }))
+        .join('\n');
+    const compatColor = report.compatibilityPercent >= 80
+        ? '#e6ffe6'
+        : report.compatibilityPercent >= 50
+            ? '#fff9e6'
+            : '#ffe6e6';
+    const coverageColor = report.contractCoveragePercent >= 80
+        ? '#e6ffe6'
+        : report.contractCoveragePercent >= 50
+            ? '#fff9e6'
+            : '#ffe6e6';
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Compatibility &amp; Contract Report</title>
+  <style>
+    body { font-family: sans-serif; padding: 2rem; background: #fafafa; }
+    h1 { margin-bottom: 0.25rem; }
+    h2 { margin-top: 2rem; }
+    .meta { color: #666; font-size: 0.9rem; margin-bottom: 1.5rem; }
+    table { border-collapse: collapse; width: 100%; max-width: 1000px; margin-bottom: 1.5rem; }
+    th, td { border: 1px solid #ccc; padding: 0.5rem 1rem; text-align: left; }
+    th { background: #f0f0f0; }
+    tr.breaking { background: #ffe6e6; }
+    tr.non-breaking { background: #e6ffe6; }
+    tr.pass { background: #e6ffe6; }
+    tr.fail { background: #ffe6e6; }
+    .summary-box { display: inline-block; padding: 1rem 2rem; border-radius: 6px; margin-right: 1rem; font-size: 1.2rem; font-weight: bold; }
+  </style>
+</head>
+<body>
+  <h1>Compatibility &amp; Contract Report</h1>
+  <p class="meta">Generated: ${report.generatedAt} | Old: ${report.oldSpecPath} | New: ${report.newSpecPath}</p>
+
+  <div>
+    <div class="summary-box" style="background:${compatColor}">
+      Compatibility: ${report.compatibilityPercent}%
+      (${report.breakingChanges.length} breaking change${report.breakingChanges.length !== 1 ? 's' : ''})
+    </div>
+    <div class="summary-box" style="background:${coverageColor}">
+      Contract Coverage: ${report.contractCoveragePercent}%
+      (${report.contractCoveredEndpoints}/${report.totalNewEndpoints} endpoints)
+    </div>
+  </div>
+
+  <h2>Breaking Changes</h2>
+  ${report.breakingChanges.length === 0
+        ? '<p>No breaking changes detected. ✅</p>'
+        : `<table>
+    <thead>
+      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Description</th></tr>
+    </thead>
+    <tbody>
+${breakingRows}
+    </tbody>
+  </table>`}
+
+  <h2>Non-Breaking Changes</h2>
+  ${report.nonBreakingChanges.length === 0
+        ? '<p>No non-breaking changes detected.</p>'
+        : `<table>
+    <thead>
+      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Description</th></tr>
+    </thead>
+    <tbody>
+${nonBreakingRows}
+    </tbody>
+  </table>`}
+
+  <h2>Contract Verification</h2>
+  ${report.contractVerificationResults.length === 0
+        ? '<p>No consumer contracts provided.</p>'
+        : `<table>
+    <thead>
+      <tr><th>Consumer</th><th>Provider</th><th>Interaction</th><th>Endpoint</th><th>Result</th><th>Reason</th></tr>
+    </thead>
+    <tbody>
+${contractRows}
+    </tbody>
+  </table>`}
+</body>
+</html>`;
+    const outPath = path.join(reportsDir, 'compatibility-contracts.html');
+    fs.writeFileSync(outPath, html, 'utf-8');
+}
+/**
+ * Generate JSON and HTML compatibility reports.
+ */
+function generateCompatibilityReports(report, reportsDir) {
+    if (!fs.existsSync(reportsDir)) {
+        fs.mkdirSync(reportsDir, { recursive: true });
+    }
+    writeCompatibilityJson(report, reportsDir);
+    writeCompatibilityHtml(report, reportsDir);
+}

package/dist/src/config/defaultConfig.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Central config — built-in default values.
+ *
+ * Every config field has a default here.  No scanning module may use an
+ * inline fallback; all defaults live in this single file.
+ */
+import type { AnalyzerConfig } from './types';
+export declare const DEFAULT_CONFIG: AnalyzerConfig;
+//# sourceMappingURL=defaultConfig.d.ts.map

package/dist/src/config/defaultConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConfig.d.ts","sourceRoot":"","sources":["../../../src/config/defaultConfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAO9C,eAAO,MAAM,cAAc,EAAE,cA+F5B,CAAC"}

package/dist/src/config/defaultConfig.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Central config — built-in default values.
+ *
+ * Every config field has a default here.  No scanning module may use an
+ * inline fallback; all defaults live in this single file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+const schema_1 = require("./schema");
+exports.DEFAULT_CONFIG = {
+    version: 1,
+    project: {
+        name: undefined,
+    },
+    analysis: {
+        defaultMode: 'full',
+        failOnConfigMissing: false,
+        warnOnConfigMissing: true,
+        agnosticDiscovery: true,
+        inferBusinessRules: true,
+        inferIntegrationFlows: true,
+        ast: {
+            enabled: true,
+            fallbackHeuristics: true,
+            maxCallDepth: 4,
+            assertionAware: true,
+            languages: {
+                java: { enabled: true },
+                kotlin: { enabled: true },
+                python: { enabled: true },
+                ruby: { enabled: true },
+                javascript: { enabled: true },
+                typescript: { enabled: true },
+                cucumber: { enabled: true },
+            },
+        },
+    },
+    scans: {
+        coverage: {
+            enabled: true,
+            types: [...schema_1.VALID_COVERAGE_TYPES],
+            deepAnalysis: {
+                enabled: true,
+                maxCallDepth: 4,
+                resolveConstants: true,
+                resolveEnums: true,
+                resolveStringTemplates: true,
+                resolveWrappers: true,
+                resolveRequestBuilders: true,
+                resolveClientMappings: true,
+                assertionAware: true,
+                clientMappings: [],
+            },
+        },
+        security: {
+            enabled: true,
+            scanners: [...schema_1.VALID_SECURITY_SCANNERS],
+        },
+        intelligence: {
+            enabled: true,
+            types: [...schema_1.VALID_INTELLIGENCE_TYPES],
+        },
+    },
+    mcp: {
+        // MCP is disabled by default when config is missing to avoid unexpected
+        // network calls.  Users must explicitly opt in via config.yaml.
+        enabled: false,
+        defaultTransport: 'stdio',
+        timeoutMs: 30000,
+        servers: {},
+    },
+    thresholds: {
+        global: 80,
+    },
+    qualityGate: {
+        enabled: true,
+        failBuildOnThresholdMiss: false,
+        mode: 'warn',
+    },
+    reports: {
+        outputDir: 'reports',
+        formats: ['json'],
+    },
+    publishing: {
+        enabled: false,
+        githubPages: {
+            enabled: false,
+        },
+    },
+    dashboard: {
+        aiSummary: {
+            enabled: true,
+            collapsedByDefault: true,
+        },
+    },
+};

package/dist/src/config/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Central config module — public barrel export.
+ *
+ * Import from here; do not import from individual sub-files.
+ */
+export * from './types';
+export * from './schema';
+export { DEFAULT_CONFIG } from './defaultConfig';
+export { validateConfig, } from './validateConfig';
+export { mergeConfig, } from './mergeConfig';
+export { loadConfig, DEFAULT_CONFIG_FILENAME, DEFAULT_CONFIG_PATH, LEGACY_CONFIG_FILENAME, MISSING_CONFIG_WARNING, LEGACY_CONFIG_WARNING, } from './loadConfig';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,cAAc,GACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,UAAU,EACV,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,cAAc,CAAC"}

package/dist/src/config/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Central config module — public barrel export.
+ *
+ * Import from here; do not import from individual sub-files.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_CONFIG_WARNING = exports.MISSING_CONFIG_WARNING = exports.LEGACY_CONFIG_FILENAME = exports.DEFAULT_CONFIG_PATH = exports.DEFAULT_CONFIG_FILENAME = exports.loadConfig = exports.mergeConfig = exports.validateConfig = exports.DEFAULT_CONFIG = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./schema"), exports);
+var defaultConfig_1 = require("./defaultConfig");
+Object.defineProperty(exports, "DEFAULT_CONFIG", { enumerable: true, get: function () { return defaultConfig_1.DEFAULT_CONFIG; } });
+var validateConfig_1 = require("./validateConfig");
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return validateConfig_1.validateConfig; } });
+var mergeConfig_1 = require("./mergeConfig");
+Object.defineProperty(exports, "mergeConfig", { enumerable: true, get: function () { return mergeConfig_1.mergeConfig; } });
+var loadConfig_1 = require("./loadConfig");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return loadConfig_1.loadConfig; } });
+Object.defineProperty(exports, "DEFAULT_CONFIG_FILENAME", { enumerable: true, get: function () { return loadConfig_1.DEFAULT_CONFIG_FILENAME; } });
+Object.defineProperty(exports, "DEFAULT_CONFIG_PATH", { enumerable: true, get: function () { return loadConfig_1.DEFAULT_CONFIG_PATH; } });
+Object.defineProperty(exports, "LEGACY_CONFIG_FILENAME", { enumerable: true, get: function () { return loadConfig_1.LEGACY_CONFIG_FILENAME; } });
+Object.defineProperty(exports, "MISSING_CONFIG_WARNING", { enumerable: true, get: function () { return loadConfig_1.MISSING_CONFIG_WARNING; } });
+Object.defineProperty(exports, "LEGACY_CONFIG_WARNING", { enumerable: true, get: function () { return loadConfig_1.LEGACY_CONFIG_WARNING; } });