vouchington-tooling 0.20.0 → 0.22.0

package/dist/api-contract-discovery/response-contract-media.d.mts

@@ -0,0 +1,3 @@
+import ts from '../contract-schema/typescript-api.mts';
+export declare function isXmlResponseCall(call: ts.CallExpression): boolean;
+export declare function streamingTextMediaType(call: ts.CallExpression): 'application/xml' | 'text/csv' | undefined;

package/dist/api-contract-discovery/response-contract-media.mjs

@@ -0,0 +1,46 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { isContextMethod } from './response-contract-route-analysis.mjs';
+export function isXmlResponseCall(call) {
+    const expression = call.expression;
+    return (ts.isPropertyAccessExpression(expression) &&
+        expression.name.text === 'xml' &&
+        isContextMethod(expression.expression, 'response'));
+}
+export function streamingTextMediaType(call) {
+    let statement = call;
+    while (!ts.isStatement(statement))
+        statement = statement.parent;
+    const contentType = precedingContentType(statement);
+    return contentType === 'unsupported' ? undefined : contentType;
+}
+function precedingContentType(statement) {
+    const block = statement.parent;
+    if (!ts.isBlock(block))
+        return undefined;
+    const index = block.statements.indexOf(statement);
+    for (let i = index - 1; i >= 0; i--) {
+        const contentType = contentTypeStatement(block.statements[i]);
+        if (contentType)
+            return contentType;
+    }
+    const enclosing = block.parent;
+    return ts.isStatement(enclosing) ? precedingContentType(enclosing) : undefined;
+}
+function contentTypeStatement(statement) {
+    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
+        return undefined;
+    const setter = statement.expression;
+    if (!isContextMethod(setter.expression, 'set'))
+        return undefined;
+    const [name, value] = setter.arguments;
+    if (!name || !ts.isStringLiteral(name) || name.text.toLowerCase() !== 'content-type')
+        return undefined;
+    if (!value || !ts.isStringLiteral(value))
+        return 'unsupported';
+    const contentType = value.text.toLowerCase();
+    if (contentType.startsWith('text/csv'))
+        return 'text/csv';
+    if (contentType.startsWith('application/xml'))
+        return 'application/xml';
+    return 'unsupported';
+}

package/dist/api-contract-discovery/response-contract-registration.d.mts

@@ -0,0 +1,11 @@
+import ts from '../contract-schema/typescript-api.mts';
+import type { ExtractedResponseContract, ExtractContractSchemaOptions } from '../contract-schema/index.mts';
+import type { BackendResponseContract } from './response-contract-types.mts';
+export declare function responseBodyExpression(call: ts.CallExpression): ts.Expression | undefined;
+export declare function containsResponseMarker(node: ts.Node): boolean;
+export declare function extractBodyContract(call: ts.CallExpression, checker: ts.TypeChecker, sourceFile: ts.SourceFile, location: string, options?: ExtractContractSchemaOptions): ExtractedResponseContract;
+export declare function registerContract(contracts: Map<string, BackendResponseContract>, key: string, contract: BackendResponseContract): void;
+export declare function noContentContract(source: string): ExtractedResponseContract;
+export declare function binaryContentContract(source: string): ExtractedResponseContract;
+export declare function sourceLocation(sourceFile: ts.SourceFile, _node: ts.Node): string;
+export declare function contractError(sourceFile: ts.SourceFile, node: ts.Node, message: string): Error;

package/dist/api-contract-discovery/response-contract-registration.mjs

@@ -0,0 +1,61 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { extractContractSchema, hashContractSchema } from '../contract-schema/index.mjs';
+import { isContextMethod, responseMarker, visit } from './response-contract-route-analysis.mjs';
+export function responseBodyExpression(call) {
+    if (isContextMethod(call.expression, 'json'))
+        return call.arguments[0];
+    if (!isContextMethod(call.expression, 'pipeline'))
+        return undefined;
+    const pipelineBody = call.arguments[0];
+    if (!pipelineBody ||
+        !ts.isCallExpression(pipelineBody) ||
+        !ts.isIdentifier(pipelineBody.expression) ||
+        pipelineBody.expression.text !== 'streamJsonObject') {
+        return undefined;
+    }
+    return pipelineBody.arguments[0];
+}
+export function containsResponseMarker(node) {
+    let found = false;
+    visit(node, (child) => {
+        if (ts.isCallExpression(child) && responseMarker(child.expression))
+            found = true;
+    });
+    return found;
+}
+export function extractBodyContract(call, checker, sourceFile, location, options = {}) {
+    const body = call.arguments[1];
+    if (!body)
+        throw contractError(sourceFile, call, 'apiResponse requires a response body');
+    return extractContractSchema(checker.getTypeAtLocation(body), checker, location, options);
+}
+export function registerContract(contracts, key, contract) {
+    const existing = contracts.get(key);
+    if (!existing) {
+        contracts.set(key, contract);
+        return;
+    }
+    if (existing.hash !== contract.hash) {
+        throw new Error(`Backend response contract "${key}" resolves to multiple backend response schemas at ${existing.source} and ${contract.source}`);
+    }
+}
+export function noContentContract(source) {
+    const schema = { root: { type: 'null' }, definitions: {} };
+    return { source, schema, hash: hashContractSchema(schema) };
+}
+export function binaryContentContract(source) {
+    const schema = {
+        root: { type: 'string', format: 'binary' },
+        definitions: {},
+    };
+    return { source, schema, hash: hashContractSchema(schema) };
+}
+export function sourceLocation(sourceFile, _node) {
+    return normalizePath(sourceFile.fileName);
+}
+export function contractError(sourceFile, node, message) {
+    return new Error(`${sourceLocation(sourceFile, node)}: ${message}`);
+}
+function normalizePath(path) {
+    return path.replaceAll('\\', '/');
+}

package/dist/api-contract-discovery/response-contract-registry.d.mts

@@ -0,0 +1,7 @@
+import ts from '../contract-schema/typescript-api.mts';
+import { type DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
+import type { BackendResponseContract } from './response-contract-types.mts';
+export type { BackendResponseContract } from './response-contract-types.mts';
+export type { DiscoverApiResponseContractsOptions } from './response-contract-lenient.mts';
+export declare function discoverApiResponseContracts(program: ts.Program, sourceFiles: readonly ts.SourceFile[], requestedKeys?: ReadonlySet<string>, options?: DiscoverApiResponseContractsOptions): Record<string, BackendResponseContract>;
+export declare function enclosingResponseEmission(call: ts.CallExpression): ts.CallExpression | undefined;

package/dist/api-contract-discovery/response-contract-registry.mjs

@@ -0,0 +1,76 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { discoverImplicitContract } from './response-contract-implicit.mjs';
+import { registerRouteContract, } from './response-contract-lenient.mjs';
+import { binaryContentContract, contractError, extractBodyContract, noContentContract, sourceLocation, } from './response-contract-registration.mjs';
+import { collectHandlerBindings, enclosingRouteBinding, isContextMethod, responseMarker, visit, } from './response-contract-route-analysis.mjs';
+import { resolveEmissionStatus } from './response-contract-status.mjs';
+export function discoverApiResponseContracts(program, sourceFiles, requestedKeys, options) {
+    const checker = program.getTypeChecker();
+    const contracts = new Map();
+    const handlerBindings = collectHandlerBindings(sourceFiles, checker);
+    for (const sourceFile of sourceFiles) {
+        visit(sourceFile, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            const marker = responseMarker(node.expression);
+            if (!marker)
+                return;
+            const keyNode = node.arguments[0];
+            if (!keyNode || !ts.isStringLiteral(keyNode)) {
+                throw contractError(sourceFile, node, `${marker} requires a literal contract key`);
+            }
+            const binding = enclosingRouteBinding(node, checker, handlerBindings);
+            if (!binding)
+                throw contractError(sourceFile, node, `${marker} must be inside an app.route handler`);
+            const expectedPrefix = `${binding.method}:${binding.routeTemplate}`;
+            if (keyNode.text !== expectedPrefix && !keyNode.text.startsWith(`${expectedPrefix}#`)) {
+                throw contractError(sourceFile, keyNode, `Contract key "${keyNode.text}" does not match enclosing route ${expectedPrefix}`);
+            }
+            const location = sourceLocation(sourceFile, node);
+            const responseEmission = enclosingResponseEmission(node) ?? node;
+            const status = resolveEmissionStatus(responseEmission);
+            const rawMediaType = rawResponseMediaType(marker, node, sourceFile);
+            registerRouteContract(contracts, keyNode.text, binding, location, {
+                bodyKind: marker === 'apiNoContent' ? 'none' : 'content',
+                ...(marker === 'apiResponse'
+                    ? { mediaType: 'application/json', mediaTypeKnowledge: 'known' }
+                    : rawMediaType
+                        ? { mediaType: rawMediaType, mediaTypeKnowledge: 'known' }
+                        : { mediaTypeKnowledge: 'none' }),
+                ...status,
+            }, () => marker === 'apiNoContent'
+                ? noContentContract(location)
+                : marker === 'apiOpenApiRawResponse'
+                    ? binaryContentContract(location)
+                    : extractBodyContract(node, checker, sourceFile, location, options), options);
+        });
+    }
+    for (const sourceFile of sourceFiles) {
+        visit(sourceFile, (node) => {
+            if (!ts.isCallExpression(node) || responseMarker(node.expression))
+                return;
+            discoverImplicitContract(node, checker, sourceFile, contracts, handlerBindings, requestedKeys, options);
+        });
+    }
+    return Object.fromEntries([...contracts.entries()].toSorted(([left], [right]) => left.localeCompare(right)));
+}
+function rawResponseMediaType(marker, node, sourceFile) {
+    if (marker !== 'apiOpenApiRawResponse')
+        return undefined;
+    const mediaType = node.arguments[1];
+    if (!mediaType || !ts.isStringLiteral(mediaType)) {
+        throw contractError(sourceFile, node, 'apiOpenApiRawResponse requires a literal media type');
+    }
+    return mediaType.text;
+}
+export function enclosingResponseEmission(call) {
+    let current = call.parent;
+    while (current && !ts.isStatement(current)) {
+        if (ts.isCallExpression(current) &&
+            (isContextMethod(current.expression, 'json') ||
+                isContextMethod(current.expression, 'pipeline')))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}

package/dist/api-contract-discovery/response-contract-route-analysis.d.mts

@@ -0,0 +1,13 @@
+import ts from '../contract-schema/typescript-api.mts';
+export { isContextMethod, isContextResponseBufferCall, isContextResponseEmptyCall, responseMarker, } from './response-contract-ctx-analysis.mts';
+export type RouteBinding = {
+    method: string;
+    routeTemplate: string;
+};
+export type HandlerBindings = Map<ts.Symbol, RouteBinding>;
+export declare function requestedKeyForBinding(binding: RouteBinding, requestedKeys?: ReadonlySet<string>): string | undefined;
+export declare function enclosingRouteBinding(node: ts.Node, checker: ts.TypeChecker, handlerBindings: HandlerBindings): RouteBinding | undefined;
+export declare function collectHandlerBindings(sourceFiles: readonly ts.SourceFile[], checker: ts.TypeChecker): HandlerBindings;
+export declare function routeTemplateFromExpression(expression: ts.Expression): string | undefined;
+export declare function propertyName(expression: ts.Expression): string | undefined;
+export declare function visit(node: ts.Node, callback: (node: ts.Node) => void): void;

package/dist/api-contract-discovery/response-contract-route-analysis.mjs

@@ -0,0 +1,144 @@
+import ts from '../contract-schema/typescript-api.mjs';
+export { isContextMethod, isContextResponseBufferCall, isContextResponseEmptyCall, responseMarker, } from './response-contract-ctx-analysis.mjs';
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+export function requestedKeyForBinding(binding, requestedKeys) {
+    if (!requestedKeys)
+        return `${binding.method}:${binding.routeTemplate}`;
+    const exact = `${binding.method}:${binding.routeTemplate}`;
+    if (requestedKeys.has(exact))
+        return exact;
+    const bindingShape = routeShape(binding.routeTemplate);
+    return [...requestedKeys]
+        .filter((key) => !key.includes('#'))
+        .find((key) => {
+        const separator = key.indexOf(':');
+        return (key.slice(0, separator) === binding.method &&
+            routeShape(key.slice(separator + 1)) === bindingShape);
+    });
+}
+function routeShape(routeTemplate) {
+    return routeTemplate.replace(/:[^/]+/g, ':');
+}
+export function enclosingRouteBinding(node, checker, handlerBindings) {
+    let current = node;
+    while (current) {
+        if (isFunctionLike(current) && ts.isCallExpression(current.parent)) {
+            const handlerCall = current.parent;
+            const method = propertyName(handlerCall.expression)?.toUpperCase();
+            if (method && HTTP_METHODS.has(method)) {
+                const routeTemplate = routeTemplateFromExpression(handlerCall.expression);
+                if (routeTemplate)
+                    return { method, routeTemplate };
+            }
+        }
+        const handlerSymbol = functionSymbol(current, checker);
+        if (handlerSymbol) {
+            const binding = handlerBindings.get(resolveSymbol(handlerSymbol, checker));
+            if (binding)
+                return binding;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+export function collectHandlerBindings(sourceFiles, checker) {
+    const bindingsBySymbol = new Map();
+    for (const sourceFile of sourceFiles) {
+        visit(sourceFile, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            const method = propertyName(node.expression)?.toUpperCase();
+            if (!method || !HTTP_METHODS.has(method))
+                return;
+            const routeTemplate = routeTemplateFromExpression(node.expression);
+            if (!routeTemplate)
+                return;
+            const binding = { method, routeTemplate };
+            for (const symbol of handlerArgumentSymbols(node, checker)) {
+                const resolved = resolveSymbol(symbol, checker);
+                const candidates = bindingsBySymbol.get(resolved) ?? [];
+                candidates.push(binding);
+                bindingsBySymbol.set(resolved, candidates);
+            }
+        });
+    }
+    const bindings = new Map();
+    for (const [symbol, candidates] of bindingsBySymbol) {
+        const [first] = candidates;
+        const unambiguous = candidates.every((candidate) => candidate.method === first.method && candidate.routeTemplate === first.routeTemplate);
+        // A symbol bound to more than one distinct route (a genuinely shared handler function) can't
+        // be attributed to either one — recording an arbitrary winner would misdocument whichever
+        // route lost.
+        if (unambiguous)
+            bindings.set(symbol, first);
+    }
+    return bindings;
+}
+/**
+ * Symbols a route registration call directly implicates: identifiers passed by reference
+ * (`app.route(...).post(handleThing)`), and — for an inline handler argument — every plain named
+ * function it calls directly, e.g. `app.route(...).post(async ctx => { await handleThing(ctx) })`.
+ * `enclosingRouteBinding`'s lexical walk can't see through the latter case on its own, since
+ * `handleThing`'s body isn't lexically nested inside the route registration at all; recording its
+ * symbol here lets the same `handlerBindings` lookup resolve it.
+ */
+function handlerArgumentSymbols(node, checker) {
+    const symbols = [];
+    for (const argument of node.arguments) {
+        if (ts.isIdentifier(argument)) {
+            const symbol = checker.getSymbolAtLocation(argument);
+            if (symbol)
+                symbols.push(symbol);
+            continue;
+        }
+        if (isFunctionLike(argument)) {
+            visit(argument, (child) => {
+                if (!ts.isCallExpression(child) || !ts.isIdentifier(child.expression))
+                    return;
+                const symbol = checker.getSymbolAtLocation(child.expression);
+                if (symbol)
+                    symbols.push(symbol);
+            });
+        }
+    }
+    return symbols;
+}
+function functionSymbol(node, checker) {
+    if (ts.isFunctionDeclaration(node) && node.name)
+        return checker.getSymbolAtLocation(node.name);
+    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+        ts.isVariableDeclaration(node.parent) &&
+        ts.isIdentifier(node.parent.name)) {
+        return checker.getSymbolAtLocation(node.parent.name);
+    }
+    return undefined;
+}
+function resolveSymbol(symbol, checker) {
+    return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+export function routeTemplateFromExpression(expression) {
+    if (!ts.isPropertyAccessExpression(expression))
+        return undefined;
+    return findRouteCall(expression.expression);
+}
+function findRouteCall(expression) {
+    if (!ts.isCallExpression(expression))
+        return undefined;
+    if (!ts.isPropertyAccessExpression(expression.expression))
+        return undefined;
+    if (expression.expression.name.text === 'route') {
+        const route = expression.arguments[0];
+        return route && ts.isStringLiteral(route) ? route.text : undefined;
+    }
+    return findRouteCall(expression.expression.expression);
+}
+export function propertyName(expression) {
+    return ts.isPropertyAccessExpression(expression) ? expression.name.text : undefined;
+}
+function isFunctionLike(node) {
+    return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+}
+export function visit(node, callback) {
+    callback(node);
+    node.forEachChild((child) => visit(child, callback));
+}

package/dist/api-contract-discovery/response-contract-status.d.mts

@@ -0,0 +1,27 @@
+import ts from '../contract-schema/typescript-api.mts';
+import type { BackendResponseContract } from './response-contract-types.mts';
+export declare function responseStatusCodesForContract(contract: BackendResponseContract): number[];
+/**
+ * Maps `METHOD:/route` to the non-error static `ctx.setStatus(NNN)` literal(s) found for that
+ * route binding: a plain literal contributes one status; `ctx.setStatus(cond ? A : B)` with both
+ * branches numeric contributes both (the doc can't know which branch fires at request time, so
+ * both are valid statuses for the operation). Statuses >= 400 are dropped per-branch: they mark
+ * hand-rolled error branches (the shared `default` -> `components/responses/Error` already
+ * documents error responses), and capturing them here would misattribute an error status to the
+ * whole operation. A route absent from the map never sets a non-error status explicitly (callers
+ * fall back to 200, or 204 when the response schema's root is `null`).
+ */
+/**
+ * Resolves the status documented for one specific `apiResponse`/`apiNoContent` marker call: the
+ * nearest preceding sibling `ctx.setStatus(NNN)` literal, walking outward through enclosing
+ * blocks (mirroring `response-contract-implicit.mts`'s `precededByErrorStatus` walk). Unlike
+ * `collectRouteStatusCodes`, this has no `>=400` filter: an explicit `#variant` marker is a
+ * deliberate author opt-in to document that exact status (e.g. 422 for a `#validation` variant),
+ * and the route-wide map (keyed only on `method:routeTemplate`) can't tell two markers in the
+ * same route apart when they're preceded by different statuses.
+ */
+export declare function resolveEmissionStatus(call: ts.CallExpression): {
+    statusCodes?: readonly [number, ...number[]];
+    statusKnowledge: 'default' | 'explicit' | 'unknown';
+    unavailableReason?: string;
+};

package/dist/api-contract-discovery/response-contract-status.mjs

@@ -0,0 +1,80 @@
+import ts from '../contract-schema/typescript-api.mjs';
+import { isContextMethod } from './response-contract-route-analysis.mjs';
+export function responseStatusCodesForContract(contract) {
+    if (contract.statusKnowledge === 'unknown')
+        return [];
+    if (contract.statusCodes)
+        return [...new Set(contract.statusCodes)].toSorted((a, b) => a - b);
+    const bodyKind = contract.bodyKind ?? (contract.schema.root.type === 'null' ? 'none' : 'content');
+    return [bodyKind === 'none' ? 204 : 200];
+}
+/**
+ * Maps `METHOD:/route` to the non-error static `ctx.setStatus(NNN)` literal(s) found for that
+ * route binding: a plain literal contributes one status; `ctx.setStatus(cond ? A : B)` with both
+ * branches numeric contributes both (the doc can't know which branch fires at request time, so
+ * both are valid statuses for the operation). Statuses >= 400 are dropped per-branch: they mark
+ * hand-rolled error branches (the shared `default` -> `components/responses/Error` already
+ * documents error responses), and capturing them here would misattribute an error status to the
+ * whole operation. A route absent from the map never sets a non-error status explicitly (callers
+ * fall back to 200, or 204 when the response schema's root is `null`).
+ */
+/**
+ * Resolves the status documented for one specific `apiResponse`/`apiNoContent` marker call: the
+ * nearest preceding sibling `ctx.setStatus(NNN)` literal, walking outward through enclosing
+ * blocks (mirroring `response-contract-implicit.mts`'s `precededByErrorStatus` walk). Unlike
+ * `collectRouteStatusCodes`, this has no `>=400` filter: an explicit `#variant` marker is a
+ * deliberate author opt-in to document that exact status (e.g. 422 for a `#validation` variant),
+ * and the route-wide map (keyed only on `method:routeTemplate`) can't tell two markers in the
+ * same route apart when they're preceded by different statuses.
+ */
+export function resolveEmissionStatus(call) {
+    if (isContextMethod(call.expression, 'setStatus'))
+        return statusArgument(call.arguments[0]);
+    let statement = call;
+    while (!ts.isStatement(statement))
+        statement = statement.parent;
+    return precedingStatus(statement);
+}
+function precedingStatus(statement) {
+    const block = statement.parent;
+    if (!ts.isBlock(block))
+        return { statusKnowledge: 'default' };
+    const index = block.statements.indexOf(statement);
+    for (let i = index - 1; i >= 0; i--) {
+        const status = statusStatement(block.statements[i]);
+        if (status)
+            return status;
+    }
+    const enclosing = block.parent;
+    return ts.isStatement(enclosing) ? precedingStatus(enclosing) : { statusKnowledge: 'default' };
+}
+function statusStatement(statement) {
+    if (!ts.isExpressionStatement(statement))
+        return undefined;
+    const expression = statement.expression;
+    if (!ts.isCallExpression(expression) || !isContextMethod(expression.expression, 'setStatus'))
+        return undefined;
+    return statusArgument(expression.arguments[0]);
+}
+/** A `ctx.setStatus` argument's possible numeric literal value(s): one for a bare literal, up to two (sorted ascending) for `cond ? A : B` when both branches are numeric literals. */
+function statusArgument(argument) {
+    if (!argument)
+        return {
+            statusKnowledge: 'unknown',
+            unavailableReason: 'ctx.setStatus has no statically known status',
+        };
+    if (ts.isNumericLiteral(argument))
+        return { statusCodes: [Number(argument.text)], statusKnowledge: 'explicit' };
+    if (ts.isConditionalExpression(argument) &&
+        ts.isNumericLiteral(argument.whenTrue) &&
+        ts.isNumericLiteral(argument.whenFalse)) {
+        const values = [
+            ...new Set([Number(argument.whenTrue.text), Number(argument.whenFalse.text)]),
+        ].toSorted((a, b) => a - b);
+        return { statusCodes: values, statusKnowledge: 'explicit' };
+    }
+    return {
+        statusKnowledge: 'unknown',
+        unavailableReason: 'nearest ctx.setStatus value is dynamic',
+    };
+}

package/dist/api-contract-discovery/response-contract-types.d.mts

@@ -0,0 +1,16 @@
+import type { ExtractedResponseContract } from '../contract-schema/index.mts';
+export type BackendResponseContract = ExtractedResponseContract & {
+    method: string;
+    routeTemplate: string;
+    /** Statuses owned by this response emission. Defaults to 200, or 204 for an unannotated empty emission. */
+    statusCodes?: readonly [number, ...number[]];
+    /** Distinguishes a known framework default from an explicitly set or genuinely unknown status. */
+    statusKnowledge?: 'default' | 'explicit' | 'unknown';
+    bodyKind?: 'content' | 'none';
+    /** Required for content emissions and absent for bodyless emissions. */
+    mediaType?: string;
+    /** Raw buffers and arbitrary streams have an unknown media type; bodyless emissions have none. */
+    mediaTypeKnowledge?: 'known' | 'none' | 'unknown';
+    /** Set when the route's response schema could not be extracted (lenient discovery mode). */
+    unavailableReason?: string;
+};

package/dist/api-contract-discovery/response-contract-types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/api-contract-discovery/test-setup.test-helpers.d.mts

@@ -0,0 +1,3 @@
+export { buildVirtualProgramMatrix } from '../contract-schema/virtual-program.mts';
+export type { VirtualProgramMatrix } from '../contract-schema/virtual-program.mts';
+export declare const COLD_VIRTUAL_PROGRAM_TIMEOUT_MS = 15000;

package/dist/api-contract-discovery/test-setup.test-helpers.mjs

@@ -0,0 +1,2 @@
+export { buildVirtualProgramMatrix } from '../contract-schema/virtual-program.mjs';
+export const COLD_VIRTUAL_PROGRAM_TIMEOUT_MS = 15_000;

package/dist/ast-grep-examples/companion-parity-compare.d.mts

@@ -0,0 +1,3 @@
+export declare function compareCodeUnits(left: string, right: string): number;
+export declare function assertJsonValue(value: unknown, ancestors?: WeakSet<object>): void;
+export declare function compare(base: unknown, companion: unknown, path: string, difference: (path: string, base: unknown, companion: unknown) => void): void;

package/dist/ast-grep-examples/companion-parity-compare.mjs

@@ -0,0 +1,58 @@
+export function compareCodeUnits(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+function pointer(path, key) {
+    const segment = String(key).replaceAll('~', '~0').replaceAll('/', '~1');
+    return `${path}/${segment}`;
+}
+function isRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype;
+}
+export function assertJsonValue(value, ancestors = new WeakSet()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        if (ancestors.has(value))
+            throw new Error('unsupported cyclic YAML value');
+        ancestors.add(value);
+        for (const item of value)
+            assertJsonValue(item, ancestors);
+        ancestors.delete(value);
+        return;
+    }
+    if (isRecord(value)) {
+        if (ancestors.has(value))
+            throw new Error('unsupported cyclic YAML value');
+        ancestors.add(value);
+        for (const item of Object.values(value))
+            assertJsonValue(item, ancestors);
+        ancestors.delete(value);
+        return;
+    }
+    throw new Error('unsupported non-JSON YAML value');
+}
+export function compare(base, companion, path, difference) {
+    if (Object.is(base, companion))
+        return;
+    if (Array.isArray(base) && Array.isArray(companion)) {
+        const length = Math.max(base.length, companion.length);
+        for (let index = 0; index < length; index++)
+            compare(base[index], companion[index], pointer(path, index), difference);
+        return;
+    }
+    if (isRecord(base) && isRecord(companion)) {
+        for (const key of [...new Set([...Object.keys(base), ...Object.keys(companion)])].toSorted(compareCodeUnits))
+            compare(base[key], companion[key], pointer(path, key), difference);
+        return;
+    }
+    difference(path, base, companion);
+}

package/dist/ast-grep-examples/companion-parity.d.mts

@@ -1,3 +1,5 @@
+import { compareCodeUnits } from './companion-parity-compare.mts';
+export { compareCodeUnits };
 export interface AstGrepCompanionDifference {
     readonly baseFile: string;
     readonly companionFile: string;
@@ -14,6 +16,5 @@ export interface AstGrepCompanionContext {
     readonly file: string;
     readonly role: 'base' | 'companion';
 }
-export declare function compareCodeUnits(left: string, right: string): number;
 /** Compares recursive `<name>.yml`/`.yaml` rules with `<name>-tsx` companions. */
 export declare function compareAstGrepCompanions(options: AstGrepCompanionParityOptions): AstGrepCompanionDifference[];

package/dist/ast-grep-examples/companion-parity.mjs

@@ -1,14 +1,9 @@
 import * as fs from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { parse as yamlLoad } from 'yaml';
+import { assertJsonValue, compare, compareCodeUnits } from './companion-parity-compare.mjs';
+export { compareCodeUnits };
 const YAML_EXTENSION = /\.ya?ml$/u;
-export function compareCodeUnits(left, right) {
-    if (left < right)
-        return -1;
-    if (left > right)
-        return 1;
-    return 0;
-}
 function assertPhysicalPath(path) {
     let ancestor = path;
     while (true) {
@@ -49,57 +44,6 @@ function loadDocument(rules, file) {
 function stem(file) {
     return file.replace(YAML_EXTENSION, '');
 }
-function pointer(path, key) {
-    const segment = String(key).replaceAll('~', '~0').replaceAll('/', '~1');
-    return `${path}/${segment}`;
-}
-function isRecord(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === null || prototype === Object.prototype;
-}
-function assertJsonValue(value, ancestors = new WeakSet()) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean')
-        return;
-    if (typeof value === 'number' && Number.isFinite(value))
-        return;
-    if (Array.isArray(value)) {
-        if (ancestors.has(value))
-            throw new Error('unsupported cyclic YAML value');
-        ancestors.add(value);
-        for (const item of value)
-            assertJsonValue(item, ancestors);
-        ancestors.delete(value);
-        return;
-    }
-    if (isRecord(value)) {
-        if (ancestors.has(value))
-            throw new Error('unsupported cyclic YAML value');
-        ancestors.add(value);
-        for (const item of Object.values(value))
-            assertJsonValue(item, ancestors);
-        ancestors.delete(value);
-        return;
-    }
-    throw new Error('unsupported non-JSON YAML value');
-}
-function compare(base, companion, path, difference) {
-    if (Object.is(base, companion))
-        return;
-    if (Array.isArray(base) && Array.isArray(companion)) {
-        const length = Math.max(base.length, companion.length);
-        for (let index = 0; index < length; index++)
-            compare(base[index], companion[index], pointer(path, index), difference);
-        return;
-    }
-    if (isRecord(base) && isRecord(companion)) {
-        for (const key of [...new Set([...Object.keys(base), ...Object.keys(companion)])].toSorted(compareCodeUnits))
-            compare(base[key], companion[key], pointer(path, key), difference);
-        return;
-    }
-    difference(path, base, companion);
-}
 function assertSuffix(suffix) {
     if (!suffix || /[\\/]/u.test(suffix))
         throw new Error('companionSuffix must be a non-empty filename suffix');