@esportsplus/typescript 0.31.1 → 0.33.0

package/build/probe/kernel/graph.js

@@ -1,507 +0,0 @@
-import * as ts from '../../probe/adapter.js';
-import { isFunctionLike, makeFunctionInfo } from './ids.js';
-function buildCallGraph(program, checker, config, overlays) {
-    const sourceFiles = ts.getSourceFiles(program);
-    const programFiles = new Set(sourceFiles);
-    const reached = new Map();
-    const byId = new Map();
-    const boundaryIds = new Set();
-    const worklist = [];
-    const wholeProject = config.entryPoints.length === 0;
-    const coreCache = new Map();
-    const resolutionCache = new Map();
-    const callsCache = new Map();
-    const calleesCache = new Map();
-    const boundaries = config.handlerBoundaries.map((boundary) => ({
-        boundary,
-        selector: parseSelector(boundary.callee),
-    }));
-    function isAnalyzable(node) {
-        const sf = node.getSourceFile();
-        return (!sf.isDeclarationFile &&
-            programFiles.has(sf) &&
-            node.body != null);
-    }
-    function intern(node) {
-        if (!isAnalyzable(node)) {
-            return undefined;
-        }
-        const existing = reached.get(node);
-        if (existing) {
-            return existing;
-        }
-        const info = makeFunctionInfo(node, node.getSourceFile());
-        reached.set(node, info);
-        byId.set(info.id, info);
-        worklist.push(info);
-        return info;
-    }
-    function calleeSymbol(call) {
-        let sym = checker.getSymbolAtLocation(call.expression);
-        if (sym && sym.flags & ts.SymbolFlags.Alias) {
-            sym = checker.getAliasedSymbol(sym);
-        }
-        return sym;
-    }
-    function functionLikesFromSymbol(sym, isNew) {
-        const out = [];
-        for (const decl of ts.symbolDeclarations(sym)) {
-            if (isFunctionLike(decl)) {
-                out.push(decl);
-                continue;
-            }
-            if (ts.isVariableDeclaration(decl) &&
-                decl.initializer &&
-                isFunctionLike(decl.initializer)) {
-                out.push(decl.initializer);
-                continue;
-            }
-            if (isNew && ts.isClassLike(decl)) {
-                const members = decl.members ?? [];
-                for (const member of members) {
-                    if (ts.isConstructorDeclaration(member)) {
-                        out.push(member);
-                    }
-                }
-            }
-        }
-        return out;
-    }
-    function isAbstract(node) {
-        const mods = node.modifiers;
-        return (mods?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false);
-    }
-    function argExpressions(call) {
-        return call.arguments ? Array.from(call.arguments) : [];
-    }
-    function computeCore(call) {
-        const isNew = ts.isNewExpression(call);
-        const sym = calleeSymbol(call);
-        let functionArgs;
-        const resolveFunctionArgs = () => {
-            if (functionArgs) {
-                return functionArgs;
-            }
-            const resolved = new Map();
-            functionArgs = resolved;
-            argExpressions(call).forEach((arg, index) => {
-                const infos = resolveFunctionValue(arg);
-                if (infos.length > 0) {
-                    resolved.set(index, infos);
-                }
-            });
-            return functionArgs;
-        };
-        if (!sym) {
-            return {
-                symbol: undefined,
-                targets: [],
-                functionArgs: resolveFunctionArgs,
-                unresolved: true,
-            };
-        }
-        const fns = functionLikesFromSymbol(sym, isNew);
-        const seen = new Set();
-        const targets = [];
-        for (const fn of fns) {
-            const info = intern(fn);
-            if (info && !seen.has(info.id)) {
-                seen.add(info.id);
-                targets.push(info);
-            }
-        }
-        if (targets.length > 0) {
-            return { symbol: sym, targets, functionArgs: resolveFunctionArgs, unresolved: false };
-        }
-        if (fns.length === 0) {
-            return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: true };
-        }
-        if (fns.some(isAbstract)) {
-            return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: true };
-        }
-        return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: false };
-    }
-    function getCore(call) {
-        let core = coreCache.get(call);
-        if (!core) {
-            core = computeCore(call);
-            coreCache.set(call, core);
-        }
-        return core;
-    }
-    function unwrap(expr) {
-        let e = expr;
-        while (true) {
-            if (ts.isParenthesizedExpression(e) ||
-                ts.isNonNullExpression(e) ||
-                ts.isAsExpression(e)) {
-                e = e.expression;
-                continue;
-            }
-            if (ts.isSatisfiesExpression(e)) {
-                e = e.expression;
-                continue;
-            }
-            break;
-        }
-        return e;
-    }
-    function resolveFunctionValue(expr) {
-        const e = unwrap(expr);
-        if (isFunctionLike(e)) {
-            const info = intern(e);
-            return info ? [info] : [];
-        }
-        if (ts.isIdentifier(e) ||
-            ts.isPropertyAccessExpression(e) ||
-            ts.isElementAccessExpression(e)) {
-            let sym = checker.getSymbolAtLocation(e);
-            if (sym && sym.flags & ts.SymbolFlags.Alias) {
-                sym = checker.getAliasedSymbol(sym);
-            }
-            if (!sym) {
-                return [];
-            }
-            const seen = new Set();
-            const out = [];
-            for (const fn of functionLikesFromSymbol(sym, false)) {
-                const info = intern(fn);
-                if (info && !seen.has(info.id)) {
-                    seen.add(info.id);
-                    out.push(info);
-                }
-            }
-            return out;
-        }
-        return [];
-    }
-    function callsIn(fn) {
-        const cached = callsCache.get(fn.id);
-        if (cached) {
-            return cached;
-        }
-        const calls = [];
-        const visit = (node) => {
-            if (node !== fn.node && isFunctionLike(node)) {
-                return;
-            }
-            if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-                calls.push(node);
-            }
-            ts.forEachChild(node, visit);
-        };
-        const body = fn.node.body;
-        if (body) {
-            visit(body);
-        }
-        for (const param of fn.node.parameters) {
-            if (param.initializer) {
-                visit(param.initializer);
-            }
-        }
-        callsCache.set(fn.id, calls);
-        return calls;
-    }
-    function modulesOfSymbol(sym) {
-        const mods = new Set();
-        for (const decl of ts.symbolDeclarations(sym)) {
-            const sf = decl.getSourceFile();
-            const parts = sf.fileName.split(/node_modules\//);
-            if (parts.length > 1) {
-                const tail = parts[parts.length - 1];
-                const seg = tail.startsWith('@')
-                    ? tail.split('/').slice(0, 2).join('/')
-                    : tail.split('/')[0];
-                mods.add(seg.startsWith('@types/')
-                    ? seg.slice('@types/'.length)
-                    : seg);
-            }
-            let p = decl.parent;
-            while (p) {
-                if (ts.isModuleDeclaration(p) && ts.isStringLiteral(p.name)) {
-                    mods.add(p.name.text);
-                }
-                p = p.parent;
-            }
-        }
-        return Array.from(mods);
-    }
-    function ownerNames(sym) {
-        const names = new Set();
-        for (const decl of ts.symbolDeclarations(sym)) {
-            let p = decl.parent;
-            while (p) {
-                if ((ts.isClassLike(p) ||
-                    ts.isInterfaceDeclaration(p) ||
-                    ts.isModuleDeclaration(p) ||
-                    ts.isTypeAliasDeclaration(p)) &&
-                    'name' in p &&
-                    p.name &&
-                    ts.isIdentifier(p.name)) {
-                    names.add(p.name.text);
-                }
-                p = p.parent;
-            }
-        }
-        return Array.from(names);
-    }
-    function isLocalSymbol(sym) {
-        for (const decl of ts.symbolDeclarations(sym)) {
-            const sf = decl.getSourceFile();
-            if (!sf.isDeclarationFile && programFiles.has(sf)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function matchesSelector(sym, selector) {
-        if (selector.names.length === 0) {
-            return false;
-        }
-        const last = selector.names[selector.names.length - 1];
-        if (sym.name !== last) {
-            return false;
-        }
-        if (selector.module !== undefined && !isLocalSymbol(sym)) {
-            if (!modulesOfSymbol(sym).includes(selector.module)) {
-                return false;
-            }
-        }
-        const owners = ownerNames(sym);
-        for (const name of selector.names.slice(0, -1)) {
-            if (!owners.includes(name)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    function markBoundaryCallbacks(call) {
-        const sym = getCore(call).symbol;
-        if (!sym) {
-            return;
-        }
-        const args = argExpressions(call);
-        for (const { boundary, selector } of boundaries) {
-            if (!matchesSelector(sym, selector)) {
-                continue;
-            }
-            for (const index of boundary.callbackArgs) {
-                const arg = args[index];
-                if (!arg) {
-                    continue;
-                }
-                for (const info of resolveFunctionValue(arg)) {
-                    boundaryIds.add(info.id);
-                }
-            }
-        }
-    }
-    function functionLikesOfSymbol(symbol) {
-        const out = [];
-        for (const decl of ts.symbolDeclarations(symbol)) {
-            if (decl.getSourceFile().isDeclarationFile) {
-                continue;
-            }
-            if (isFunctionLike(decl)) {
-                if (!ts.isFunctionDeclaration(decl) || decl.body) {
-                    out.push(decl);
-                }
-            }
-            else if (ts.isVariableDeclaration(decl) &&
-                decl.initializer &&
-                isFunctionLike(decl.initializer)) {
-                out.push(decl.initializer);
-            }
-            else if (ts.isExportAssignment(decl) &&
-                isFunctionLike(decl.expression)) {
-                out.push(decl.expression);
-            }
-        }
-        return out;
-    }
-    function allFunctionLikesIn(sf) {
-        const out = [];
-        const visit = (node) => {
-            if (isFunctionLike(node) &&
-                (!ts.isFunctionDeclaration(node) || node.body)) {
-                out.push(node);
-            }
-            ts.forEachChild(node, visit);
-        };
-        ts.forEachChild(sf, visit);
-        return out;
-    }
-    function entryFunctionsOf(sf) {
-        if (wholeProject) {
-            return allFunctionLikesIn(sf);
-        }
-        const moduleSymbol = checker.getSymbolAtLocation(sf);
-        if (!moduleSymbol) {
-            return [];
-        }
-        const out = [];
-        for (const exported of checker.getExportsOfModule(moduleSymbol)) {
-            const resolved = exported.flags & ts.SymbolFlags.Alias
-                ? checker.getAliasedSymbol(exported)
-                : exported;
-            out.push(...functionLikesOfSymbol(resolved));
-        }
-        return out;
-    }
-    function entryFiles() {
-        if (wholeProject) {
-            return sourceFiles.filter((sf) => !sf.isDeclarationFile &&
-                !sf.fileName.includes('/node_modules/'));
-        }
-        const root = normalizeSlashes(config.projectRoot).replace(/\/+$/, '');
-        const patterns = config.entryPoints.map((glob) => {
-            const g = normalizeSlashes(glob);
-            const absolute = /^([a-zA-Z]:)?\//.test(g) ? g : `${root}/${g}`;
-            return globToRegExp(absolute);
-        });
-        const files = [];
-        for (const sf of sourceFiles) {
-            if (sf.isDeclarationFile) {
-                continue;
-            }
-            if (patterns.some((re) => re.test(sf.fileName))) {
-                files.push(sf);
-            }
-        }
-        return files;
-    }
-    for (const sf of entryFiles()) {
-        for (const node of entryFunctionsOf(sf)) {
-            const info = intern(node);
-            if (info) {
-                boundaryIds.add(info.id);
-            }
-        }
-    }
-    for (let workIndex = 0; workIndex < worklist.length; workIndex++) {
-        const fn = worklist[workIndex];
-        for (const call of callsIn(fn)) {
-            getCore(call);
-            markBoundaryCallbacks(call);
-        }
-    }
-    const reachedList = Array.from(reached.values());
-    function resolveCall(call, channel) {
-        let cached = resolutionCache.get(call)?.get(channel);
-        if (cached) {
-            return cached;
-        }
-        const core = getCore(call);
-        let result;
-        if (core.targets.length > 0) {
-            result = {
-                targets: core.targets,
-                overlay: undefined,
-                get functionArgs() { return core.functionArgs(); },
-                unresolved: false,
-            };
-        }
-        else {
-            const overlay = core.symbol
-                ? overlays.lookup(core.symbol, channel)
-                : undefined;
-            result = overlay ? {
-                targets: [],
-                overlay,
-                get functionArgs() { return core.functionArgs(); },
-                unresolved: false,
-            } : {
-                targets: [],
-                overlay: undefined,
-                get functionArgs() { return core.functionArgs(); },
-                unresolved: core.unresolved,
-            };
-        }
-        let resolutions = resolutionCache.get(call);
-        if (!resolutions) {
-            resolutions = new Map();
-            resolutionCache.set(call, resolutions);
-        }
-        resolutions.set(channel, result);
-        return result;
-    }
-    function calleesOf(fn) {
-        const cached = calleesCache.get(fn.id);
-        if (cached) {
-            return cached;
-        }
-        const seen = new Set();
-        const out = [];
-        for (const call of callsIn(fn)) {
-            for (const target of getCore(call).targets) {
-                if (reached.has(target.node) && !seen.has(target.id)) {
-                    seen.add(target.id);
-                    out.push(target);
-                }
-            }
-        }
-        calleesCache.set(fn.id, out);
-        return out;
-    }
-    return {
-        reachedFunctions() {
-            return reachedList;
-        },
-        boundaries() {
-            return boundaryIds;
-        },
-        calleesOf,
-        resolveCall,
-        resolveFunctionValue,
-    };
-}
-function normalizeSlashes(p) {
-    return p.replace(/\\/g, '/');
-}
-function globToRegExp(glob) {
-    let re = '';
-    let i = 0;
-    const n = glob.length;
-    while (i < n) {
-        const ch = glob[i];
-        if (ch === '*') {
-            if (glob[i + 1] === '*') {
-                if (glob[i + 2] === '/') {
-                    re += '(?:[^/]*(?:/|$))*';
-                    i += 3;
-                }
-                else {
-                    re += '.*';
-                    i += 2;
-                }
-            }
-            else {
-                re += '[^/]*';
-                i += 1;
-            }
-            continue;
-        }
-        if (ch === '?') {
-            re += '[^/]';
-            i += 1;
-            continue;
-        }
-        re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        i += 1;
-    }
-    return new RegExp(`^${re}$`, 'i');
-}
-function parseSelector(selector) {
-    const hashIndex = selector.indexOf('#');
-    const dotted = hashIndex >= 0 ? selector.slice(0, hashIndex) : selector;
-    const method = hashIndex >= 0 ? selector.slice(hashIndex + 1) : undefined;
-    const segments = dotted.split('.').filter(Boolean);
-    const hasModule = segments.length > 1;
-    const module = hasModule ? segments[0] : undefined;
-    const names = hasModule ? segments.slice(1) : segments.slice(0);
-    if (method) {
-        names.push(method);
-    }
-    return { module, names };
-}
-export { buildCallGraph };

package/build/probe/overlay/presets/express.jsonc

@@ -1,25 +0,0 @@
-// Express preset bundle. `handlerBoundaries` promote route callbacks to
-// analysis boundaries (loadOverlays exposes them via boundariesFromPresets()).
-// `overlay` follows the channel -> section -> key shape.
-{
-  "handlerBoundaries": [
-    { "callee": "express.Router#get", "callbackArgs": [1] },
-    { "callee": "express.Router#post", "callbackArgs": [1] },
-    { "callee": "express.Router#put", "callbackArgs": [1] },
-    { "callee": "express.Router#patch", "callbackArgs": [1] },
-    { "callee": "express.Router#delete", "callbackArgs": [1] },
-    { "callee": "express.Router#all", "callbackArgs": [1] },
-    { "callee": "express.Router#use", "callbackArgs": [0, 1] },
-    { "callee": "express.Application#get", "callbackArgs": [1] },
-    { "callee": "express.Application#post", "callbackArgs": [1] },
-    { "callee": "express.Application#use", "callbackArgs": [0, 1] }
-  ],
-  "overlay": {
-    "exceptions": {
-      "express": {
-        "Response#json": { "exceptions": ["TypeError"] },
-        "Response#sendFile": { "exceptions": ["TypeError"] }
-      }
-    }
-  }
-}

package/build/probe/overlay/presets/node.jsonc

@@ -1,17 +0,0 @@
-// Node preset bundle. `overlay` is keyed by channel, then section (module),
-// then overlay key. A couple of node:fs / node:path throwers prove the shape.
-{
-  "overlay": {
-    "exceptions": {
-      "node:fs": {
-        "readFileSync": { "exceptions": ["Error"] },
-        "writeFileSync": { "exceptions": ["Error"] },
-        "mkdirSync": { "exceptions": ["Error"] }
-      },
-      "node:path": {
-        "relative": { "exceptions": ["TypeError"] },
-        "resolve": { "exceptions": ["TypeError"] }
-      }
-    }
-  }
-}