vouchington-tooling 0.35.0 → 0.36.0

package/dist/api-contract-discovery/request-validation-match.mjs

@@ -1,47 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { attributionFunctionSymbol, resolveSymbol } from './response-contract-symbols.mjs';
-/** Resolves a callee through aliases and re-exports to the symbol it ultimately names. */
-export function calleeSymbol(callee, checker) {
-    const target = unwrapTransparentExpression(callee);
-    const name = ts.isPropertyAccessExpression(target) ? target.name : target;
-    const symbol = ts.isIdentifier(name) ? checker.getSymbolAtLocation(name) : undefined;
-    return symbol && resolveSymbol(symbol, checker);
-}
-const stripExtension = (path) => path.replace(/\.d\.[cm]?ts$/, '').replace(/\.[cm]?[jt]sx?$/, '');
-/** Compares extension-less paths, so `.ts`, `.js`, `.mts` and `.d.ts` spellings all agree. */
-function moduleMatches(fileName, module) {
-    const path = fileName.replaceAll('\\', '/');
-    return (path.includes(`/node_modules/${module}/`) ||
-        stripExtension(path).endsWith(`/${stripExtension(module.replace(/^\.?\//, ''))}`));
-}
-/** True when the symbol is the configured export of a declaration file matching the module. */
-function matchesExport(symbol, config, checker) {
-    return (symbol.declarations ?? []).some((declaration) => {
-        const file = declaration.getSourceFile();
-        if (!moduleMatches(file.fileName, config.module))
-            return false;
-        const moduleSymbol = checker.getSymbolAtLocation(file);
-        const exported = moduleSymbol
-            ? checker
-                .getExportsOfModule(moduleSymbol)
-                .find((item) => item.getName() === config.exportName)
-            : undefined;
-        return !!exported && resolveSymbol(exported, checker) === symbol;
-    });
-}
-export function findConfig(callee, configs, checker) {
-    const symbol = calleeSymbol(callee, checker);
-    return symbol ? configs.find((config) => matchesExport(symbol, config, checker)) : undefined;
-}
-/** True when the node sits inside the implementation of a configured export. */
-export function insideConfiguredImplementation(node, configs, checker) {
-    for (let current = node; current; current = current.parent) {
-        const symbol = ts.isFunctionLike(current)
-            ? attributionFunctionSymbol(current, checker)
-            : undefined;
-        if (symbol && configs.some((config) => matchesExport(symbol, config, checker)))
-            return true;
-    }
-    return false;
-}

package/dist/api-contract-discovery/request-validation-mutation.d.mts

@@ -1,7 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-/**
- * True when a property of the const object an identifier names may have been written before the
- * use: in the use's own function, or anywhere in the declaring function or module when that
- * differs. `const` fixes the binding, not the object, so a written object is not its initializer.
- */
-export declare function hasPropertyWriteBefore(identifier: ts.Identifier, symbol: ts.Symbol, checker: ts.TypeChecker): boolean;

package/dist/api-contract-discovery/request-validation-mutation.mjs

@@ -1,80 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { resolveSymbol } from './response-contract-symbols.mjs';
-const MUTATORS = new Set(['assign', 'defineProperty', 'defineProperties', 'setPrototypeOf']);
-const UPDATES = new Set([ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken]);
-/**
- * Property-write start positions per symbol, per function (or source file). Symbols belong to one
- * checker, so the memo is keyed by checker and never leaks between programs.
- */
-const writesByChecker = new WeakMap();
-const isMember = (node) => ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node);
-/** The identifier an `a.b[c]` chain starts from, through parentheses, `!` and `as`. */
-function rootIdentifier(target) {
-    let current = unwrapTransparentExpression(target);
-    while (isMember(current))
-        current = unwrapTransparentExpression(current.expression);
-    return ts.isIdentifier(current) ? current : undefined;
-}
-/** The object a node writes a property of: `o.p = v`, `delete o.p`, `o.p++`, `Object.assign(o)`. */
-function mutatedObject(node) {
-    let target;
-    if (ts.isBinaryExpression(node) &&
-        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-        node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
-        target = node.left;
-    else if (ts.isDeleteExpression(node))
-        target = node.expression;
-    else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-        UPDATES.has(node.operator))
-        target = node.operand;
-    if (target)
-        return isMember(target) ? rootIdentifier(target) : undefined;
-    const callee = ts.isCallExpression(node) ? node.expression : undefined;
-    const mutates = callee &&
-        ts.isPropertyAccessExpression(callee) &&
-        ts.isIdentifier(callee.expression) &&
-        callee.expression.text === 'Object' &&
-        MUTATORS.has(callee.name.text);
-    const [first] = mutates ? node.arguments : [];
-    return first ? rootIdentifier(first) : undefined;
-}
-function propertyWrites(scope, checker) {
-    const scopes = writesByChecker.get(checker) ?? new WeakMap();
-    writesByChecker.set(checker, scopes);
-    const cached = scopes.get(scope);
-    if (cached)
-        return cached;
-    const found = new Map();
-    const scan = (node) => {
-        if (node !== scope && ts.isFunctionLike(node))
-            return;
-        const object = mutatedObject(node);
-        const symbol = object && checker.getSymbolAtLocation(object);
-        if (symbol)
-            found.set(symbol, [...(found.get(symbol) ?? []), node.getStart()]);
-        ts.forEachChild(node, scan);
-    };
-    scan(scope);
-    scopes.set(scope, found);
-    return found;
-}
-function ownerOf(node) {
-    let current = node.parent;
-    while (current && !ts.isFunctionLike(current))
-        current = current.parent;
-    return current ?? node.getSourceFile();
-}
-/**
- * True when a property of the const object an identifier names may have been written before the
- * use: in the use's own function, or anywhere in the declaring function or module when that
- * differs. `const` fixes the binding, not the object, so a written object is not its initializer.
- */
-export function hasPropertyWriteBefore(identifier, symbol, checker) {
-    const resolved = resolveSymbol(symbol, checker);
-    const useScope = ownerOf(identifier);
-    const declaration = resolved.declarations.find(ts.isVariableDeclaration);
-    return [...new Set([useScope, ownerOf(declaration)])].some((scope) => [symbol, resolved].some((candidate) => propertyWrites(scope, checker)
-        .get(candidate)
-        ?.some((start) => scope !== useScope || start < identifier.getStart())));
-}

package/dist/api-contract-discovery/request-validation-origin.d.mts

@@ -1,20 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Carrier } from './request-validation-types.mts';
-/** What a value is relative to the handler's request context. */
-export type RootKind = 'context' | 'request' | 'query' | 'path' | 'header';
-/** A value bound to a parameter at a call site, with the request carriers it derives from. */
-export type Bound = {
-    kind?: RootKind | undefined;
-    origins: readonly Carrier[];
-    unresolved?: string | undefined;
-    /** The argument expression the call passed, for resolving object literals through it. */
-    expression?: ts.Expression | undefined;
-};
-export type RootBindings = ReadonlyMap<ts.Symbol, Bound>;
-/** The carrier object a named member of a context or request object denotes. */
-export declare function memberKind(base: RootKind | undefined, name: string): RootKind | undefined;
-export declare function rootKind(expression: ts.Expression, roots: RootBindings, checker: ts.TypeChecker, seen?: Set<ts.Symbol>): RootKind | undefined;
-/** `X.request.json()` and its siblings, where X is the request context. */
-export declare function isBodyRead(call: ts.CallExpression, roots: RootBindings, checker: ts.TypeChecker): boolean;
-/** `ctx.get(name)`. */
-export declare function isHeaderGet(call: ts.CallExpression, roots: RootBindings, checker: ts.TypeChecker): boolean;

package/dist/api-contract-discovery/request-validation-origin.mjs

@@ -1,71 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { identifierSymbol } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-const BODY_READERS = new Set(['json', 'text', 'buffer', 'formData', 'arrayBuffer', 'blob']);
-/** The carrier object a named member of a context or request object denotes. */
-export function memberKind(base, name) {
-    if (base === 'context' && (name === 'request' || name === 'req'))
-        return 'request';
-    if ((base === 'context' || base === 'request') && name === 'query')
-        return 'query';
-    if (base === 'context' && name === 'params')
-        return 'path';
-    if ((base === 'context' || base === 'request') && (name === 'headers' || name === 'header'))
-        return 'header';
-    return undefined;
-}
-/** The const initializer an identifier aliases, with the destructured key when it is a member. */
-function aliasSource(symbol) {
-    for (const declaration of symbol.declarations ?? []) {
-        const owner = ts.isBindingElement(declaration) ? declaration.parent.parent : declaration;
-        if (!ts.isVariableDeclaration(owner) ||
-            !owner.initializer ||
-            !(ts.getCombinedNodeFlags(owner) & ts.NodeFlags.Const))
-            continue;
-        if (!ts.isBindingElement(declaration))
-            return { initializer: owner.initializer };
-        const name = declaration.propertyName ?? declaration.name;
-        const member = ts.isObjectBindingPattern(declaration.parent) && !declaration.dotDotDotToken;
-        const named = ts.isIdentifier(name) || ts.isStringLiteral(name);
-        return { initializer: owner.initializer, key: member && named ? name.text : null };
-    }
-    return undefined;
-}
-export function rootKind(expression, roots, checker, seen = new Set()) {
-    const value = unwrapTransparentExpression(expression);
-    if (ts.isPropertyAccessExpression(value))
-        return memberKind(rootKind(value.expression, roots, checker, seen), value.name.text);
-    if (ts.isElementAccessExpression(value))
-        return ts.isStringLiteralLike(value.argumentExpression)
-            ? memberKind(rootKind(value.expression, roots, checker, seen), value.argumentExpression.text)
-            : undefined;
-    if (!ts.isIdentifier(value))
-        return undefined;
-    const symbol = identifierSymbol(value, checker);
-    if (!symbol || seen.has(symbol))
-        return undefined;
-    const bound = roots.get(symbol);
-    if (bound)
-        return bound.kind;
-    const alias = aliasSource(symbol);
-    if (!alias)
-        return undefined;
-    const base = rootKind(alias.initializer, roots, checker, new Set(seen).add(symbol));
-    if (alias.key === undefined)
-        return base;
-    return alias.key === null ? undefined : memberKind(base, alias.key);
-}
-/** `X.request.json()` and its siblings, where X is the request context. */
-export function isBodyRead(call, roots, checker) {
-    const callee = unwrapTransparentExpression(call.expression);
-    return (ts.isPropertyAccessExpression(callee) &&
-        BODY_READERS.has(callee.name.text) &&
-        rootKind(callee.expression, roots, checker) === 'request');
-}
-/** `ctx.get(name)`. */
-export function isHeaderGet(call, roots, checker) {
-    const callee = unwrapTransparentExpression(call.expression);
-    return (ts.isPropertyAccessExpression(callee) &&
-        callee.name.text === 'get' &&
-        rootKind(callee.expression, roots, checker) === 'context');
-}

package/dist/api-contract-discovery/request-validation-reads.d.mts

@@ -1,13 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type KeyBindings } from './request-validation-keys.mts';
-import { type RootBindings } from './request-validation-origin.mts';
-import type { CarrierRead } from './request-validation-types.mts';
-export type RawRead = Omit<CarrierRead, 'source'>;
-type Scope = {
-    checker: ts.TypeChecker;
-    roots: RootBindings;
-    keys: KeyBindings;
-};
-/** The raw request reads made by exactly this node, not by its children. */
-export declare function rawReadsAt(node: ts.Node, scope: Scope): RawRead[];
-export {};

package/dist/api-contract-discovery/request-validation-reads.mjs

@@ -1,88 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { resolveKey } from './request-validation-keys.mjs';
-import { isBodyRead, isHeaderGet, rootKind, } from './request-validation-origin.mjs';
-const carrierRoot = (node, scope) => {
-    const kind = rootKind(node, scope.roots, scope.checker);
-    return kind === 'query' || kind === 'path' || kind === 'header' ? kind : undefined;
-};
-const isTransparent = (node) => ts.isParenthesizedExpression(node) ||
-    ts.isAsExpression(node) ||
-    ts.isNonNullExpression(node) ||
-    ts.isSatisfiesExpression(node) ||
-    ts.isTypeAssertionExpression(node);
-/** True when an identifier sits where it declares or names a property rather than reads a value. */
-function namesSomething(node) {
-    const { name, propertyName } = node.parent;
-    return (name === node && !ts.isShorthandPropertyAssignment(node.parent)) || propertyName === node;
-}
-/** True when the carrier expression is consumed as a value, not indexed, aliased or destructured. */
-function consumedAsValue(node) {
-    if (ts.isIdentifier(node) && namesSomething(node))
-        return false;
-    let outer = node;
-    while (isTransparent(outer.parent))
-        outer = outer.parent;
-    const parent = outer.parent;
-    if (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent))
-        return parent.expression !== outer;
-    if (ts.isVariableDeclaration(parent) && parent.initializer === outer)
-        return !(ts.isObjectBindingPattern(parent.name) ||
-            (ts.isIdentifier(parent.name) && !!(ts.getCombinedNodeFlags(parent) & ts.NodeFlags.Const)));
-    return !ts.isExpressionStatement(parent);
-}
-/** A whole-carrier read: the carrier object itself used as a value, as in `consume(ctx.query)`. */
-function wholeRead(node, scope) {
-    if (!ts.isExpression(node) || isTransparent(node))
-        return [];
-    const carrier = carrierRoot(node, scope);
-    return carrier && consumedAsValue(node) ? [{ carrier, key: null, access: 'whole' }] : [];
-}
-function destructuredRead(element, carrier) {
-    const name = element.propertyName ?? element.name;
-    if (element.dotDotDotToken)
-        return { carrier, key: null, access: 'whole' };
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
-        return { carrier, key: name.text, access: 'key' };
-    return { carrier, key: null, access: 'computed' };
-}
-/** True for the target of a plain assignment or `delete`, which replaces without reading. */
-function isWriteTarget(node) {
-    let outer = node;
-    while (isTransparent(outer.parent))
-        outer = outer.parent;
-    const parent = outer.parent;
-    return (ts.isDeleteExpression(parent) ||
-        (ts.isBinaryExpression(parent) &&
-            parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-            parent.left === outer));
-}
-/** The raw request reads made by exactly this node, not by its children. */
-export function rawReadsAt(node, scope) {
-    const keyed = (carrier, expression) => {
-        const key = resolveKey(expression, scope.checker, scope.keys) ?? null;
-        return { carrier, key, access: key === null ? 'computed' : 'key' };
-    };
-    if (ts.isCallExpression(node)) {
-        if (isBodyRead(node, scope.roots, scope.checker))
-            return [{ carrier: 'body', key: null, access: 'whole' }];
-        return isHeaderGet(node, scope.roots, scope.checker) ? [keyed('header', node.arguments[0])] : [];
-    }
-    if ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
-        isWriteTarget(node))
-        return [];
-    if (ts.isPropertyAccessExpression(node)) {
-        const carrier = carrierRoot(node.expression, scope);
-        if (carrier)
-            return [{ carrier, key: node.name.text, access: 'key' }];
-    }
-    if (ts.isElementAccessExpression(node)) {
-        const carrier = carrierRoot(node.expression, scope);
-        if (carrier)
-            return [keyed(carrier, node.argumentExpression)];
-    }
-    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer) {
-        const carrier = carrierRoot(node.initializer, scope);
-        return carrier ? node.name.elements.map((element) => destructuredRead(element, carrier)) : [];
-    }
-    return wholeRead(node, scope);
-}

package/dist/api-contract-discovery/request-validation-registration.d.mts

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type Scope } from './request-validation-follow.mts';
-import { type WalkState } from './request-validation-state-key.mts';
-/**
- * Finds configured factory calls in registration-time expressions, without entering handlers.
- * Validators evaluated here run while the handler is built, not per request, so only the walk of
- * the handler itself reports them.
- */
-export declare function createRegistrationScanner(scopeOf: (state: WalkState) => Scope, reportFactory: (call: ts.CallExpression, state: WalkState) => boolean): (node: ts.Node, state?: WalkState) => void;

package/dist/api-contract-discovery/request-validation-registration.mjs

@@ -1,32 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { followedImplementations } from './request-validation-follow.mjs';
-import { bindArguments } from './request-validation-trace.mjs';
-import { returnedValues } from './request-validation-trace-helpers.mjs';
-import { emptyState } from './request-validation-state-key.mjs';
-/**
- * Finds configured factory calls in registration-time expressions, without entering handlers.
- * Validators evaluated here run while the handler is built, not per request, so only the walk of
- * the handler itself reports them.
- */
-export function createRegistrationScanner(scopeOf, reportFactory) {
-    const scanning = new Set();
-    function scan(node, state = emptyState) {
-        if (ts.isFunctionLike(node))
-            return;
-        if (ts.isCallExpression(node) && reportFactory(node, state))
-            return;
-        if (ts.isCallExpression(node))
-            // A helper that builds the handler: follow its returned values with bound arguments.
-            for (const fn of followedImplementations(node, scopeOf(state))) {
-                if (scanning.has(fn))
-                    continue;
-                scanning.add(fn);
-                const { keys, roots } = bindArguments(fn, node, scopeOf(state));
-                for (const value of returnedValues(fn))
-                    scan(value, { ...state, keys, roots });
-                scanning.delete(fn);
-            }
-        ts.forEachChild(node, (child) => scan(child, state));
-    }
-    return scan;
-}

package/dist/api-contract-discovery/request-validation-report.d.mts

@@ -1,3 +0,0 @@
-import type ts from '../contract-schema/typescript-api.mts';
-/** Collects facts once per originating AST node and fact; a repeat returns the fact reported. */
-export declare function createReporter(): <T extends object>(kind: string, target: T[], item: T, node?: ts.Node, identity?: object) => T;

package/dist/api-contract-discovery/request-validation-report.mjs

@@ -1,21 +0,0 @@
-/** Collects facts once per originating AST node and fact; a repeat returns the fact reported. */
-export function createReporter() {
-    const reported = new Map();
-    const nodeIds = new Map();
-    const nodeId = (node) => {
-        if (!node)
-            return '';
-        if (!nodeIds.has(node))
-            nodeIds.set(node, nodeIds.size);
-        return nodeIds.get(node);
-    };
-    return (kind, target, item, node, identity = item) => {
-        const key = `${kind}${nodeId(node)}${JSON.stringify(identity)}`;
-        const existing = reported.get(key);
-        if (existing)
-            return existing;
-        reported.set(key, item);
-        target.push(item);
-        return item;
-    };
-}

package/dist/api-contract-discovery/request-validation-request-origin.d.mts

@@ -1,5 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import { type RootBindings } from './request-validation-origin.mts';
-import type { Carrier } from './request-validation-types.mts';
-/** The carrier a node reads directly from the request context, if it is such a read. */
-export declare function requestOrigin(node: ts.Node, roots: RootBindings, checker: ts.TypeChecker): Carrier | undefined;

package/dist/api-contract-discovery/request-validation-request-origin.mjs

@@ -1,13 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { isBodyRead, isHeaderGet, rootKind, } from './request-validation-origin.mjs';
-/** The carrier a node reads directly from the request context, if it is such a read. */
-export function requestOrigin(node, roots, checker) {
-    const kind = ts.isExpression(node) ? rootKind(node, roots, checker) : undefined;
-    if (kind === 'query' || kind === 'path' || kind === 'header')
-        return kind;
-    if (!ts.isCallExpression(node))
-        return undefined;
-    if (isBodyRead(node, roots, checker))
-        return 'body';
-    return isHeaderGet(node, roots, checker) ? 'header' : undefined;
-}

package/dist/api-contract-discovery/request-validation-select.d.mts

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Scope } from './request-validation-follow.mts';
-/** The property name or array position a destructured binding selects, when it is static. */
-export declare function bindingKey(element: ts.BindingElement): string | number | undefined;
-/**
- * The expression a literal (or a const naming one) holds at a property or position: `null` when
- * nothing is there, `undefined` when it cannot be resolved statically.
- */
-export declare function literalMember(node: ts.Node, key: string | number, scope: Scope, seen?: Set<ts.Node>): ts.Expression | null | undefined;

package/dist/api-contract-discovery/request-validation-select.mjs

@@ -1,36 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { ABSENT, findProperty, stableConstInitializer } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-/** The property name or array position a destructured binding selects, when it is static. */
-export function bindingKey(element) {
-    if (element.dotDotDotToken)
-        return undefined;
-    if (ts.isArrayBindingPattern(element.parent))
-        return element.parent.elements.indexOf(element);
-    const name = element.propertyName ?? element.name;
-    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
-}
-/**
- * The expression a literal (or a const naming one) holds at a property or position: `null` when
- * nothing is there, `undefined` when it cannot be resolved statically.
- */
-export function literalMember(node, key, scope, seen = new Set()) {
-    const value = unwrapTransparentExpression(node);
-    if (seen.has(value))
-        return undefined;
-    if (ts.isIdentifier(value)) {
-        const initializer = stableConstInitializer(value, scope.checker);
-        return initializer && literalMember(initializer, key, scope, new Set(seen).add(value));
-    }
-    if (typeof key === 'number') {
-        if (!ts.isArrayLiteralExpression(value))
-            return undefined;
-        if (value.elements.slice(0, key + 1).some(ts.isSpreadElement))
-            return undefined;
-        return value.elements[key] ?? null;
-    }
-    if (!ts.isObjectLiteralExpression(value))
-        return undefined;
-    const found = findProperty(value, key, scope.checker, scope.roots, new Set([value]));
-    return found === ABSENT ? null : found;
-}

package/dist/api-contract-discovery/request-validation-sites.d.mts

@@ -1,9 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { Scope } from './request-validation-follow.mts';
-import { type FactoryConfig, type FactorySite, type ValidatorConfig, type ValidatorSite } from './request-validation-types.mts';
-export declare function sourceOf(node: ts.Node): string;
-export declare function validatorSite(call: ts.CallExpression, config: ValidatorConfig, scope: Scope, conditional: boolean): {
-    site: ValidatorSite;
-    inputNodes: ts.Node[];
-};
-export declare function factorySite(call: ts.CallExpression, config: FactoryConfig, scope: Scope, conditional: boolean): FactorySite;

package/dist/api-contract-discovery/request-validation-sites.mjs

@@ -1,77 +0,0 @@
-import ts from '../contract-schema/typescript-api.mjs';
-import { ABSENT, findProperty, resolveKey, resolveObject, resolveOptionString, } from './request-validation-keys.mjs';
-import { unwrapTransparentExpression } from './response-contract-route-syntax.mjs';
-import { resolveInput } from './request-validation-input.mjs';
-import {} from './request-validation-types.mjs';
-export function sourceOf(node) {
-    const file = node.getSourceFile();
-    return `${file.fileName}:${file.getLineAndCharacterOfPosition(node.getStart()).line + 1}`;
-}
-/** Whether the options object ends with `property: true`, applying spreads in order. */
-function optionEnabled(options, property, scope) {
-    if (!options)
-        return { enabled: false };
-    const object = resolveObject(options, scope.checker, scope.roots);
-    if (!object)
-        return {
-            enabled: false,
-            unresolved: `options \`${options.getText()}\` are not statically resolvable`,
-        };
-    const found = findProperty(object, property, scope.checker, scope.roots, new Set([object]));
-    if (found === undefined)
-        return { enabled: false, unresolved: `option "${property}" is not statically resolvable` };
-    return {
-        enabled: found !== ABSENT && unwrapTransparentExpression(found).kind === ts.SyntaxKind.TrueKeyword,
-    };
-}
-function fixedInput(config, call, scope) {
-    const options = (config.optionCarriers ?? []).map((option) => ({
-        option,
-        ...optionEnabled(call.arguments[option.argument], option.property, scope),
-    }));
-    const added = options.filter((item) => item.enabled).map((item) => item.option.carrier);
-    const unresolved = options.find((item) => item.unresolved)?.unresolved;
-    return {
-        carriers: [...new Set([...config.carriers, ...added])].map((carrier) => ({
-            carrier,
-            origins: [carrier],
-        })),
-        ...(unresolved && { unresolved }),
-        nodes: [],
-    };
-}
-export function validatorSite(call, config, scope, conditional) {
-    const argument = call.arguments[config.operationArgument];
-    const operation = resolveKey(argument, scope.checker, scope.keys) ?? null;
-    const input = config.carriers.kind === 'input-object'
-        ? resolveInput(call.arguments[config.carriers.argument], scope)
-        : fixedInput(config.carriers, call, scope);
-    const site = {
-        exportName: config.exportName,
-        source: sourceOf(call),
-        operation,
-        ...(operation === null && { unresolvedReason: unresolved(argument) }),
-        carriers: input.carriers,
-        ...(input.unresolved && { unresolvedCarriers: input.unresolved }),
-        conditional,
-    };
-    return { site, inputNodes: input.nodes };
-}
-export function factorySite(call, config, scope, conditional) {
-    const operation = resolveOptionString(call.arguments[config.optionsArgument], config.operationProperty, scope.checker, scope.keys, scope.roots) ?? null;
-    return {
-        exportName: config.exportName,
-        source: sourceOf(call),
-        operation,
-        ...(operation === null && {
-            unresolvedReason: `option "${config.operationProperty}" is not statically resolvable`,
-        }),
-        carriers: [...config.carriers],
-        conditional,
-    };
-}
-function unresolved(argument) {
-    return argument
-        ? `operation key \`${argument.getText()}\` is not statically resolvable`
-        : 'operation argument is missing';
-}

package/dist/api-contract-discovery/request-validation-state-key.d.mts

@@ -1,13 +0,0 @@
-import type ts from '../contract-schema/typescript-api.mts';
-import type { KeyBindings } from './request-validation-keys.mts';
-import type { RootBindings } from './request-validation-origin.mts';
-export type WalkState = {
-    keys: KeyBindings;
-    roots: RootBindings;
-    conditional: boolean;
-    /** The calls this walk was entered through, innermost last; a call may build a validator input. */
-    via: ReadonlySet<ts.Node>;
-};
-export declare const emptyState: WalkState;
-/** A stable identity for the bindings a function is walked with, used to stop repeat walks. */
-export declare function createStateKey(): (state: WalkState) => string;

package/dist/api-contract-discovery/request-validation-state-key.mjs

@@ -1,30 +0,0 @@
-export const emptyState = {
-    keys: new Map(),
-    roots: new Map(),
-    conditional: false,
-    via: new Set(),
-};
-/** A stable identity for the bindings a function is walked with, used to stop repeat walks. */
-export function createStateKey() {
-    const symbolIds = new Map();
-    const symbolId = (symbol) => {
-        if (!symbolIds.has(symbol))
-            symbolIds.set(symbol, symbolIds.size);
-        return symbolIds.get(symbol);
-    };
-    const nodeIds = new Map();
-    const nodeId = (node) => {
-        if (!nodeIds.has(node))
-            nodeIds.set(node, nodeIds.size);
-        return nodeIds.get(node);
-    };
-    const bound = (value) => JSON.stringify(value, (name, item) => name === 'expression' ? nodeId(item) : item);
-    return (state) => [
-        ...[...state.keys].map(([symbol, value]) => JSON.stringify(['k', symbolId(symbol), value])),
-        ...[...state.roots].map(([symbol, value]) => bound(['r', symbolId(symbol), value])),
-        JSON.stringify(state.conditional),
-        JSON.stringify([...state.via].map(nodeId).toSorted((left, right) => left - right)),
-    ]
-        .toSorted((left, right) => left.localeCompare(right))
-        .join('|');
-}

package/dist/api-contract-discovery/request-validation-trace-helpers.d.mts

@@ -1,14 +0,0 @@
-import ts from '../contract-schema/typescript-api.mts';
-import type { ProtocolCache } from './protocol-analysis-cache.mts';
-import type { Followable } from './request-validation-follow.mts';
-/**
- * The assignments that can supply a value at the use: property writes, plus reassignments of the
- * identifier itself made earlier in the same function. An unconditional reassignment replaces
- * everything before it, including the initializer; conditional ones merge.
- */
-export declare function reachingWrites(use: ts.Node, symbol: ts.Symbol, checker: ts.TypeChecker, cache?: ProtocolCache): {
-    writes: ts.Expression[];
-    initializer: boolean;
-};
-/** Returned expressions of a function, including an arrow function's expression body. */
-export declare function returnedValues(fn: Followable): ts.Node[];