@esportsplus/typescript 0.31.1 → 0.33.0

package/build/tsconfig.js

@@ -3,6 +3,18 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { stripJsonc } from './jsonc.js';
 let require = createRequire(import.meta.url);
+function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override;
+    }
+    let result = { ...base };
+    for (let key of Object.keys(override)) {
+        result[key] = key in result
+            ? deepMerge(result[key], override[key])
+            : override[key];
+    }
+    return result;
+}
 function extendsTarget(specifier, fromDir) {
     if (typeof specifier !== 'string') {
         return null;
@@ -30,97 +42,15 @@ function extendsTarget(specifier, fromDir) {
         }
     }
 }
-function legacyStripJsonc(text) {
-    let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
-    for (let i = 0, n = text.length; i < n; i++) {
-        let char = text[i], next = text[i + 1];
-        if (inLineComment) {
-            if (char === '\n') {
-                inLineComment = false;
-                stripped += char;
-            }
-            continue;
-        }
-        if (inBlockComment) {
-            if (char === '*' && next === '/') {
-                inBlockComment = false;
-                i++;
-            }
-            continue;
-        }
-        if (inString) {
-            stripped += char;
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === '\\') {
-                escaped = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            stripped += char;
-            continue;
-        }
-        if (char === '/' && next === '/') {
-            inLineComment = true;
-            i++;
-            continue;
-        }
-        if (char === '/' && next === '*') {
-            inBlockComment = true;
-            i++;
-            continue;
-        }
-        stripped += char;
-    }
-    escaped = false;
-    inString = false;
-    let result = '';
-    for (let i = 0, n = stripped.length; i < n; i++) {
-        let char = stripped[i];
-        if (inString) {
-            result += char;
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === '\\') {
-                escaped = true;
-            }
-            else if (char === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            result += char;
-            continue;
-        }
-        if (char === ',') {
-            let j = i + 1;
-            while (j < n && /\s/.test(stripped[j])) {
-                j++;
-            }
-            if (stripped[j] === ']' || stripped[j] === '}') {
-                continue;
-            }
-        }
-        result += char;
-    }
-    return result;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-void legacyStripJsonc;
-const readPlugins = (tsconfigPath) => {
-    let seen = new Set();
-    function read(configPath) {
-        let id = path.resolve(configPath);
+function walkExtends(tsconfigPath, fold) {
+    const seen = new Set();
+    function read(configPath, inherited) {
+        const id = path.resolve(configPath);
         if (seen.has(id)) {
-            return undefined;
+            return inherited;
         }
         seen.add(id);
         let config;
@@ -128,23 +58,35 @@ const readPlugins = (tsconfigPath) => {
             config = JSON.parse(stripJsonc(fs.readFileSync(id, 'utf8')));
         }
         catch {
-            return undefined;
+            return inherited;
         }
-        let plugins;
         if (config.extends !== undefined) {
-            let bases = Array.isArray(config.extends) ? config.extends : [config.extends];
-            for (let base of bases) {
-                let target = extendsTarget(base, path.dirname(id));
+            const bases = Array.isArray(config.extends) ? config.extends : [config.extends];
+            for (const base of bases) {
+                const target = extendsTarget(base, path.dirname(id));
                 if (target) {
-                    let inherited = read(target);
-                    if (inherited !== undefined) {
-                        plugins = inherited;
-                    }
+                    inherited = read(target, inherited);
                 }
             }
         }
-        return Array.isArray(config.compilerOptions?.plugins) ? config.compilerOptions.plugins : plugins;
+        return fold(config, inherited);
+    }
+    return read(tsconfigPath, undefined);
+}
+const readPlugins = (tsconfigPath) => walkExtends(tsconfigPath, (config, inherited) => {
+    const compilerOptions = config['compilerOptions'];
+    const plugins = isPlainObject(compilerOptions)
+        ? compilerOptions['plugins']
+        : undefined;
+    return Array.isArray(plugins) ? plugins : inherited;
+});
+const readGuardConfig = (tsconfigPath) => walkExtends(tsconfigPath, (config, inherited) => {
+    const own = config['tsc-guard'];
+    if (!isPlainObject(own)) {
+        return inherited;
     }
-    return read(tsconfigPath);
-};
-export { readPlugins };
+    return inherited === undefined
+        ? own
+        : deepMerge(inherited, own);
+});
+export { readPlugins, readGuardConfig };

package/package.json

@@ -10,15 +10,15 @@
   "dependencies": {
     "@esportsplus/cli-passthrough": "^0.0.15",
     "@esportsplus/utilities": "^0.28.0",
-    "@types/node": "^26.1.1",
-    "tsc-alias": "^1.9.1",
+    "@types/node": "^26.4.1",
+    "tsc-alias": "^1.9.4",
     "typescript": "7.0.2",
-    "vscode-languageserver": "^10.1.0",
-    "vscode-languageserver-textdocument": "^1.0.12"
+    "vscode-languageserver": "^10.1.1",
+    "vscode-languageserver-textdocument": "^1.0.14"
   },
   "devDependencies": {
-    "vite": "^8.1.5",
-    "vitest": "^4.1.10"
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -60,13 +60,13 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.31.1",
+  "version": "0.33.0",
   "scripts": {
     "agent:bench": "pnpm bench:run",
     "agent:build": "pnpm build",
     "agent:test": "pnpm typecheck && pnpm test",
     "bench:run": "vitest bench --run",
-    "build": "tsc -p tsconfig.package.json && tsc-alias -p tsconfig.package.json && node -e \"const fs=require('fs');fs.cpSync('src/probe/overlay','build/probe/overlay',{recursive:true,filter:(s)=>!/\\.[cm]?tsx?$/.test(s)})\"",
+    "build": "tsc -p tsconfig.package.json && tsc-alias -p tsconfig.package.json && node -e \"const fs=require('fs');fs.cpSync('src/guard/overlay','build/guard/overlay',{recursive:true,filter:(s)=>!/\\.[cm]?tsx?$/.test(s)})\"",
     "test": "vitest run",
     "typecheck": "tsc"
   }

package/tsconfig.base.json

@@ -23,25 +23,6 @@
                 "${configDir}/storage/*"
             ]
         },
-        "plugins": [
-            {
-                "name": "ts-probe",
-                // Editor squiggle color; "warn" opts down. CLI/build ignore this.
-                "severity": "error",
-                // Fail the tsc/build run when there are findings.
-                "failOnFindings": true,
-                "channels": {
-                    "exceptions": {
-                        "enabled": true,
-                        "report": "consumers",
-                        // Flag `throw`s inside `catch` that drop the caught error's cause.
-                        "errorCause": true
-                    }
-                },
-                // Model third-party throw behavior: "node", "express".
-                "presets": ["node"]
-            }
-        ],
         "removeComments": true,
         "resolveJsonModule": true,
         "rootDir": "${configDir}/src",
@@ -54,5 +35,17 @@
     ],
     "tsc-alias": {
         "resolveFullPaths": true
+    },
+    "tsc-guard": {
+        "exceptions": {
+            "severity": "error",
+            "report": "cross-module"
+        },
+        "resources": {
+            "severity": "error"
+        },
+        "async": {
+            "severity": "info"
+        }
     }
 }

package/tsconfig.package.json

@@ -11,5 +11,10 @@
             "node"
         ]
     },
-    "extends": "./tsconfig.base.json"
+    "extends": "./tsconfig.base.json",
+    "tsc-guard": {
+        "exceptions": {
+            "report": "consumers"
+        }
+    }
 }

package/build/probe/channels.d.ts

@@ -1,4 +0,0 @@
-import type { Channel } from './kernel/types.js';
-declare function channelFor(name: string, config: unknown): Channel<unknown> | undefined;
-declare function implementedChannels(): ReadonlyArray<string>;
-export { channelFor, implementedChannels };

package/build/probe/channels.js

@@ -1,16 +0,0 @@
-import { createAsyncChannel } from './async/channel.js';
-import { createExceptionsChannel } from './exceptions/channel.js';
-import { createResourcesChannel } from './resources/channel.js';
-const FACTORIES = {
-    async: (config) => createAsyncChannel(config),
-    exceptions: () => createExceptionsChannel(),
-    resources: (config) => createResourcesChannel(config),
-};
-function channelFor(name, config) {
-    const factory = FACTORIES[name];
-    return factory ? factory(config) : undefined;
-}
-function implementedChannels() {
-    return Object.keys(FACTORIES);
-}
-export { channelFor, implementedChannels };

package/build/probe/kernel/analyze.js

@@ -1,68 +0,0 @@
-import { channelFor } from '../channels.js';
-import { buildCallGraph } from './graph.js';
-import { buildProgram } from './program.js';
-import { runChannel } from './fixpoint.js';
-import { loadOverlays } from '../overlay/load.js';
-function analyzeProgram(program, checker, config) {
-    const overlays = loadOverlays(config);
-    const effectiveConfig = {
-        ...config,
-        handlerBoundaries: [
-            ...config.handlerBoundaries,
-            ...overlays.boundariesFromPresets(),
-        ],
-    };
-    const graph = buildCallGraph(program, checker, effectiveConfig, overlays);
-    const analysis = {
-        program,
-        checker,
-        config: effectiveConfig,
-        overlays,
-        graph,
-    };
-    const diagnostics = [];
-    const runnable = new Map();
-    for (const [name, channelConfig] of Object.entries(effectiveConfig.channels)) {
-        if (!channelConfig.enabled) {
-            continue;
-        }
-        runnable.set(name, {
-            config: channelConfig,
-            channel: channelFor(name, channelConfig.options),
-        });
-    }
-    const ordered = [];
-    const placed = new Set();
-    const place = (name, stack) => {
-        if (placed.has(name) || !runnable.has(name) || stack.has(name)) {
-            return;
-        }
-        const next = new Set(stack).add(name);
-        for (const dep of runnable.get(name).channel.dependsOn ?? []) {
-            place(dep, next);
-        }
-        placed.add(name);
-        ordered.push(name);
-    };
-    for (const name of runnable.keys()) {
-        place(name, new Set());
-    }
-    const peers = new Map();
-    for (const name of ordered) {
-        const { config, channel } = runnable.get(name);
-        const result = runChannel(analysis, channel, config.dispatch, config.options, peers);
-        peers.set(name, result.store);
-        diagnostics.push(...result.diagnostics);
-    }
-    return { diagnostics };
-}
-function analyze(config) {
-    const built = buildProgram(config.tsconfigPath);
-    try {
-        return analyzeProgram(built.program, built.checker, config);
-    }
-    finally {
-        built.dispose();
-    }
-}
-export { analyze, analyzeProgram };

package/build/probe/kernel/ast.d.ts

@@ -1,11 +0,0 @@
-import * as ts from '../../probe/adapter.js';
-import type { FunctionLike } from './types.js';
-type UnwrapOptions = {
-    assertions?: boolean;
-    awaits?: boolean;
-};
-declare const bodyOf: (node: FunctionLike) => ts.Node | undefined;
-declare const calleeSelectors: (callee: ts.Expression) => Set<string>;
-declare const paramSymbols: (checker: ts.TypeChecker, fn: FunctionLike) => Map<ts.Symbol, number>;
-declare const unwrap: (expr: ts.Expression, options?: UnwrapOptions) => ts.Expression;
-export { bodyOf, calleeSelectors, paramSymbols, unwrap };

package/build/probe/kernel/ast.js

@@ -1,49 +0,0 @@
-import * as ts from '../../probe/adapter.js';
-function shouldUnwrap(expr, options) {
-    return (ts.isParenthesizedExpression(expr) ||
-        (options.assertions === true &&
-            (ts.isAsExpression(expr) || ts.isNonNullExpression(expr))) ||
-        (options.awaits === true && ts.isAwaitExpression(expr)));
-}
-const bodyOf = (node) => {
-    return node.body;
-};
-const calleeSelectors = (callee) => {
-    let selectors = new Set();
-    if (ts.isIdentifier(callee)) {
-        selectors.add(callee.text);
-    }
-    else if (ts.isPropertyAccessExpression(callee)) {
-        let member = callee.name.text;
-        selectors.add(member);
-        if (ts.isIdentifier(callee.expression)) {
-            selectors.add(`${callee.expression.text}.${member}`);
-            selectors.add(`${callee.expression.text}#${member}`);
-        }
-    }
-    return selectors;
-};
-const paramSymbols = (checker, fn) => {
-    let symbols = new Map();
-    let params = fn
-        .parameters;
-    if (params) {
-        params.forEach((param, index) => {
-            if (ts.isIdentifier(param.name)) {
-                let symbol = checker.getSymbolAtLocation(param.name);
-                if (symbol) {
-                    symbols.set(symbol, index);
-                }
-            }
-        });
-    }
-    return symbols;
-};
-const unwrap = (expr, options = {}) => {
-    let unwrapped = expr;
-    while (shouldUnwrap(unwrapped, options)) {
-        unwrapped = unwrapped.expression;
-    }
-    return unwrapped;
-};
-export { bodyOf, calleeSelectors, paramSymbols, unwrap };

package/build/probe/kernel/config.js

@@ -1,209 +0,0 @@
-import * as NodePath from 'node:path';
-import { readPlugins } from '../../tsconfig.js';
-import { stripJsonc } from '../../jsonc.js';
-const CHANNEL_NAMES = ['exceptions', 'resources', 'async'];
-const DEFAULT_ENABLED = {
-    exceptions: true,
-    resources: false,
-    async: false,
-};
-function fail(message) {
-    throw new Error(`analyze config: ${message}`);
-}
-function legacyStripJsonc(text) {
-    let out = '';
-    let i = 0;
-    const n = text.length;
-    let inString = false;
-    let quote = '';
-    while (i < n) {
-        const ch = text[i];
-        const next = i + 1 < n ? text[i + 1] : '';
-        if (inString) {
-            out += ch;
-            if (ch === '\\') {
-                out += next;
-                i += 2;
-                continue;
-            }
-            if (ch === quote) {
-                inString = false;
-            }
-            i += 1;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            inString = true;
-            quote = ch;
-            out += ch;
-            i += 1;
-            continue;
-        }
-        if (ch === '/' && next === '/') {
-            while (i < n && text[i] !== '\n') {
-                i += 1;
-            }
-            continue;
-        }
-        if (ch === '/' && next === '*') {
-            i += 2;
-            while (i < n && !(text[i] === '*' && text[i + 1] === '/')) {
-                i += 1;
-            }
-            i += 2;
-            continue;
-        }
-        out += ch;
-        i += 1;
-    }
-    return out.replace(/,(\s*[}\]])/g, '$1');
-}
-void legacyStripJsonc;
-function asStringArray(value, field) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string')) {
-        fail(`"${field}" must be an array of strings`);
-    }
-    return value;
-}
-function parseHandlerBoundaries(value) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        fail(`"handlerBoundaries" must be an array`);
-    }
-    return value.map((raw, index) => {
-        if (typeof raw !== 'object' || raw === null) {
-            fail(`handlerBoundaries[${index}] must be an object`);
-        }
-        const entry = raw;
-        if (typeof entry['callee'] !== 'string') {
-            fail(`handlerBoundaries[${index}].callee must be a string`);
-        }
-        const callbackArgs = entry['callbackArgs'];
-        if (!Array.isArray(callbackArgs) ||
-            callbackArgs.some((v) => typeof v !== 'number' || !Number.isInteger(v))) {
-            fail(`handlerBoundaries[${index}].callbackArgs must be an array of integers`);
-        }
-        return {
-            callee: entry['callee'],
-            callbackArgs: callbackArgs,
-        };
-    });
-}
-function parseSinks(value) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        fail(`"sinks" must be an array`);
-    }
-    return value.map((raw, index) => {
-        if (typeof raw !== 'object' || raw === null) {
-            fail(`sinks[${index}] must be an object`);
-        }
-        const entry = raw;
-        if (typeof entry['callee'] !== 'string') {
-            fail(`sinks[${index}].callee must be a string`);
-        }
-        let absorbs;
-        if (entry['absorbs'] !== undefined) {
-            absorbs = asStringArray(entry['absorbs'], `sinks[${index}].absorbs`);
-        }
-        return { callee: entry['callee'], absorbs };
-    });
-}
-function parseDispatch(value, channel) {
-    if (value === undefined) {
-        return 'optimist';
-    }
-    if (value !== 'optimist' && value !== 'pessimist') {
-        fail(`channels.${channel}.dispatch must be "optimist" or "pessimist"`);
-    }
-    return value;
-}
-function parseChannels(value) {
-    const channels = {};
-    const raw = value === undefined ? {} : value;
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-        fail(`"channels" must be an object`);
-    }
-    for (const key of Object.keys(raw)) {
-        if (!CHANNEL_NAMES.includes(key)) {
-            fail(`unknown channel "${key}" (known: ${CHANNEL_NAMES.join(', ')})`);
-        }
-    }
-    for (const name of CHANNEL_NAMES) {
-        const entry = (raw[name] ?? {});
-        if (typeof entry !== 'object' ||
-            entry === null ||
-            Array.isArray(entry)) {
-            fail(`channels.${name} must be an object`);
-        }
-        const enabled = entry['enabled'] === undefined
-            ? DEFAULT_ENABLED[name]
-            : entry['enabled'];
-        if (typeof enabled !== 'boolean') {
-            fail(`channels.${name}.enabled must be a boolean`);
-        }
-        const { enabled: _e, dispatch: _d, ...options } = entry;
-        channels[name] = {
-            enabled,
-            dispatch: parseDispatch(entry['dispatch'], name),
-            options,
-        };
-    }
-    return channels;
-}
-function normalizeConfig(raw, projectRoot) {
-    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-        fail(`root must be a JSON object`);
-    }
-    const tsconfig = raw.tsconfig === undefined ? 'tsconfig.json' : raw.tsconfig;
-    if (typeof tsconfig !== 'string') {
-        fail(`"tsconfig" must be a string`);
-    }
-    return {
-        projectRoot,
-        tsconfigPath: NodePath.resolve(projectRoot, tsconfig),
-        entryPoints: asStringArray(raw.entryPoints, 'entryPoints'),
-        handlerBoundaries: parseHandlerBoundaries(raw.handlerBoundaries),
-        sinks: parseSinks(raw.sinks),
-        presets: asStringArray(raw.presets, 'presets'),
-        overlays: asStringArray(raw.overlays, 'overlays').map((p) => NodePath.resolve(projectRoot, p)),
-        channels: parseChannels(raw.channels),
-        failOnFindings: raw.failOnFindings === true,
-        severity: raw.severity === 'warn' || raw.severity === 'warning'
-            ? 'warning'
-            : 'error',
-    };
-}
-function parseConfig(text, projectRoot) {
-    let parsed;
-    try {
-        parsed = JSON.parse(stripJsonc(text));
-    }
-    catch (error) {
-        fail(`invalid JSONC: ${error.message}`);
-    }
-    return normalizeConfig(parsed, projectRoot);
-}
-function configFromObject(raw, projectRoot) {
-    return normalizeConfig(raw, projectRoot);
-}
-function loadConfigFromTsconfig(tsconfigPath) {
-    const resolved = NodePath.resolve(tsconfigPath);
-    const plugins = readPlugins(resolved) ?? [];
-    const entry = plugins.find((p) => p !== null && typeof p === 'object' && p.name === 'ts-probe');
-    if (!entry) {
-        return undefined;
-    }
-    return {
-        ...configFromObject(entry, NodePath.dirname(resolved)),
-        tsconfigPath: resolved,
-    };
-}
-export { configFromObject, loadConfigFromTsconfig, parseConfig };

package/build/probe/kernel/fixpoint.d.ts

@@ -1,6 +0,0 @@
-import type { Analysis, Channel, Diagnostic, Dispatch, SummaryStore } from './types.js';
-declare function runChannel<V>(analysis: Analysis, channel: Channel<V>, dispatch: Dispatch, channelConfig: unknown, peers: ReadonlyMap<string, SummaryStore<unknown>>): {
-    store: SummaryStore<V>;
-    diagnostics: Diagnostic[];
-};
-export { runChannel };

package/build/probe/kernel/graph.d.ts

@@ -1,4 +0,0 @@
-import * as ts from '../../probe/adapter.js';
-import type { CallGraph, OverlaySet, AnalyzeConfig } from './types.js';
-declare function buildCallGraph(program: ts.Program, checker: ts.TypeChecker, config: AnalyzeConfig, overlays: OverlaySet): CallGraph;
-export { buildCallGraph };