@buildvision/nest-sdk-generator 2.3.1 → 3.0.0

package/build/engine/ast.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file AST helpers reproducing the semantics of the ts-morph methods used by the legacy analyzer
+ */
+import { AnalysisHost, TsNode } from './host';
+/** ts-morph's `node.getText()`: the node's source text, without leading trivia */
+export declare function nodeText(node: TsNode, sourceFile: TsNode): string;
+/** ts-morph's `node.getName()` for named and nameable declarations (class, function, method, parameter...) */
+export declare function nodeName(node: TsNode, sourceFile: TsNode): string | undefined;
+/** ts-morph's `node.getDecorators()` */
+export declare function getDecorators(host: AnalysisHost, node: TsNode): TsNode[];
+/** ts-morph's `decorator.getCallExpression()` */
+export declare function decoratorCallExpression(host: AnalysisHost, decorator: TsNode): TsNode | undefined;
+/** ts-morph's `decorator.getArguments()` */
+export declare function decoratorArguments(host: AnalysisHost, decorator: TsNode): TsNode[];
+/** ts-morph's `decorator.getName()` */
+export declare function decoratorName(host: AnalysisHost, decorator: TsNode, sourceFile: TsNode): string;
+/** ts-morph's `Node.isStringLiteral()` */
+export declare function isStringLiteral(host: AnalysisHost, node: TsNode): boolean;
+/** ts-morph's `classDeclaration.getMembers()` */
+export declare function getClassMembers(host: AnalysisHost, decl: TsNode, sourceFile: TsNode): TsNode[];
+/** ts-morph's `classDeclaration.getProperties()` / `interfaceDeclaration.getProperties()` */
+export declare function getDeclarationProperties(host: AnalysisHost, decl: TsNode, sourceFile: TsNode): TsNode[];
+/** ts-morph's `classDeclaration.getExtends()` (first type only) / `interfaceDeclaration.getExtends()` (all types) */
+export declare function getExtendsTypeNodes(host: AnalysisHost, decl: TsNode): TsNode[];

package/build/engine/ast.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * @file AST helpers reproducing the semantics of the ts-morph methods used by the legacy analyzer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeText = nodeText;
+exports.nodeName = nodeName;
+exports.getDecorators = getDecorators;
+exports.decoratorCallExpression = decoratorCallExpression;
+exports.decoratorArguments = decoratorArguments;
+exports.decoratorName = decoratorName;
+exports.isStringLiteral = isStringLiteral;
+exports.getClassMembers = getClassMembers;
+exports.getDeclarationProperties = getDeclarationProperties;
+exports.getExtendsTypeNodes = getExtendsTypeNodes;
+/** ts-morph's `node.getText()`: the node's source text, without leading trivia */
+function nodeText(node, sourceFile) {
+    return sourceFile.text.substring(node.getStart(sourceFile), node.end);
+}
+/** ts-morph's `node.getName()` for named and nameable declarations (class, function, method, parameter...) */
+function nodeName(node, sourceFile) {
+    return node.name ? nodeText(node.name, sourceFile) : undefined;
+}
+/** ts-morph's `node.getDecorators()` */
+function getDecorators(host, node) {
+    return (node.modifiers ?? []).filter((m) => m.kind === host.SyntaxKind.Decorator);
+}
+/** ts-morph's `decorator._getInnerExpression()` */
+function decoratorInnerExpression(host, decorator) {
+    let expr = decorator.expression;
+    while (expr.kind === host.SyntaxKind.ParenthesizedExpression)
+        expr = expr.expression;
+    return expr;
+}
+/** ts-morph's `decorator.getCallExpression()` */
+function decoratorCallExpression(host, decorator) {
+    const expr = decoratorInnerExpression(host, decorator);
+    return expr.kind === host.SyntaxKind.CallExpression ? expr : undefined;
+}
+/** ts-morph's `decorator.getArguments()` */
+function decoratorArguments(host, decorator) {
+    return decoratorCallExpression(host, decorator)?.arguments ?? [];
+}
+/** ts-morph's `decorator.getName()` */
+function decoratorName(host, decorator, sourceFile) {
+    const callExpression = decoratorCallExpression(host, decorator);
+    let identifier = callExpression ? callExpression.expression : decoratorInnerExpression(host, decorator);
+    if (identifier.kind === host.SyntaxKind.PropertyAccessExpression) {
+        identifier = identifier.name;
+    }
+    if (identifier.kind !== host.SyntaxKind.Identifier) {
+        throw new Error(`Expected the decorator expression '${nodeText(identifier, sourceFile)}' to be an identifier. ` +
+            `Please deal directly with 'getExpression()' on the decorator to handle more complex scenarios.`);
+    }
+    return nodeText(identifier, sourceFile);
+}
+/** ts-morph's `Node.isStringLiteral()` */
+function isStringLiteral(host, node) {
+    return node.kind === host.SyntaxKind.StringLiteral;
+}
+function hasModifier(node, kind) {
+    return (node.modifiers ?? []).some((m) => m.kind === kind);
+}
+/** ts-morph's `classDeclaration.getMembers()` */
+function getClassMembers(host, decl, sourceFile) {
+    const SK = host.SyntaxKind;
+    const isAmbient = hasModifier(decl, SK.DeclareKeyword) || sourceFile.isDeclarationFile;
+    return decl.members
+        .filter((m) => {
+        if (isAmbient)
+            return true;
+        if (m.kind !== SK.Constructor && m.kind !== SK.MethodDeclaration)
+            return true;
+        if (m.kind === SK.MethodDeclaration && hasModifier(m, SK.AbstractKeyword))
+            return true;
+        return m.body != null;
+    })
+        .filter((m) => [
+        SK.MethodDeclaration,
+        SK.PropertyDeclaration,
+        SK.GetAccessor,
+        SK.SetAccessor,
+        SK.Constructor,
+        SK.ClassStaticBlockDeclaration,
+    ].includes(m.kind));
+}
+/** ts-morph's `classDeclaration.getProperties()` / `interfaceDeclaration.getProperties()` */
+function getDeclarationProperties(host, decl, sourceFile) {
+    const SK = host.SyntaxKind;
+    return decl.kind === SK.ClassDeclaration
+        ? getClassMembers(host, decl, sourceFile).filter((m) => m.kind === SK.PropertyDeclaration)
+        : decl.members.filter((m) => m.kind === SK.PropertySignature);
+}
+/** ts-morph's `classDeclaration.getExtends()` (first type only) / `interfaceDeclaration.getExtends()` (all types) */
+function getExtendsTypeNodes(host, decl) {
+    const clause = (decl.heritageClauses ?? []).find((c) => c.token === host.SyntaxKind.ExtendsKeyword);
+    const types = clause?.types ?? [];
+    return decl.kind === host.SyntaxKind.ClassDeclaration ? types.slice(0, 1) : types;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/engine/file-order.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file Order project files the way ts-morph's `project.getSourceFiles()` does
+ *
+ * The order of the source files determines the order controllers are analyzed in, which in turn determines the order
+ * of the generated modules and types.
+ *
+ * ts-morph keeps a tree of the directories containing source files. Directories without a parent in the tree are
+ * "roots", kept in the order they were created (i.e. the order files were added: the tsconfig's files, then the files
+ * they import). The tree is walked breadth-first by depth: at each depth, the roots at that depth come first, then the
+ * children of the previous depth's directories, sorted by name. The files of each directory are sorted by name.
+ */
+/**
+ * Get the project's files, in ts-morph's order
+ * @param rootFiles The tsconfig's files, in the tsconfig's order (absolute paths, forward slashes)
+ * @param programFiles All files of the program (absolute paths, forward slashes)
+ */
+export declare function orderProjectFiles(rootFiles: string[], programFiles: string[]): string[];

package/build/engine/file-order.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * @file Order project files the way ts-morph's `project.getSourceFiles()` does
+ *
+ * The order of the source files determines the order controllers are analyzed in, which in turn determines the order
+ * of the generated modules and types.
+ *
+ * ts-morph keeps a tree of the directories containing source files. Directories without a parent in the tree are
+ * "roots", kept in the order they were created (i.e. the order files were added: the tsconfig's files, then the files
+ * they import). The tree is walked breadth-first by depth: at each depth, the roots at that depth come first, then the
+ * children of the previous depth's directories, sorted by name. The files of each directory are sorted by name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderProjectFiles = orderProjectFiles;
+function compareNames(a, b) {
+    // Same comparison as ts-morph's `LocaleStringComparer`
+    const result = a.localeCompare(b, 'en-us-u-kf-upper');
+    return result < 0 ? -1 : result === 0 ? 0 : 1;
+}
+function dirname(file) {
+    const index = file.lastIndexOf('/');
+    return index <= 0 ? '/' : file.substring(0, index);
+}
+function depth(dir) {
+    return dir.split('/').filter((part) => part.length > 0).length;
+}
+function isProjectFile(file) {
+    // Files ts-morph considers part of the project: anything outside of `node_modules` (and outside of TypeScript's
+    // bundled libraries, which tsgo exposes with non-absolute paths)
+    return (file.startsWith('/') || /^[a-zA-Z]:\//.test(file)) && file.toLowerCase().lastIndexOf('/node_modules/') === -1;
+}
+/**
+ * Get the project's files, in ts-morph's order
+ * @param rootFiles The tsconfig's files, in the tsconfig's order (absolute paths, forward slashes)
+ * @param programFiles All files of the program (absolute paths, forward slashes)
+ */
+function orderProjectFiles(rootFiles, programFiles) {
+    // ts-morph adds the tsconfig's files first, then the files the compiler requested while building the program.
+    // The latter only affect the order of directories outside of the tsconfig's ones: sort them for determinism.
+    const rootFilesSet = new Set(rootFiles);
+    const files = [...new Set([...rootFiles, ...programFiles.filter((file) => !rootFilesSet.has(file)).sort()])].filter(isProjectFile);
+    const filesByDir = new Map();
+    for (const file of files) {
+        const dir = dirname(file);
+        const dirFiles = filesByDir.get(dir);
+        if (dirFiles)
+            dirFiles.push(file);
+        else
+            filesByDir.set(dir, [file]);
+    }
+    // Directories, in creation order
+    const dirs = [...filesByDir.keys()];
+    const dirsSet = new Set(dirs);
+    const hasAncestorInTree = (dir) => {
+        for (let parent = dirname(dir);; parent = dirname(parent)) {
+            if (dirsSet.has(parent))
+                return true;
+            if (parent === '/' || parent === dirname(parent))
+                return false;
+        }
+    };
+    const roots = dirs.filter((dir) => !hasAncestorInTree(dir));
+    // Link every directory to its parent, creating the intermediate directories up to the nearest directory in the tree
+    const children = new Map();
+    for (const dir of dirs) {
+        if (roots.includes(dir))
+            continue;
+        for (let current = dir; !roots.includes(current) && !children.get(dirname(current))?.has(current); current = dirname(current)) {
+            const parent = dirname(current);
+            const siblings = children.get(parent);
+            if (siblings)
+                siblings.add(current);
+            else
+                children.set(parent, new Set([current]));
+        }
+    }
+    // Breadth-first walk, like ts-morph's `DirectoryCache.getAllByDepth()`
+    const levels = new Map();
+    const addToLevel = (dir) => {
+        const level = levels.get(depth(dir));
+        if (level)
+            level.push(dir);
+        else
+            levels.set(depth(dir), [dir]);
+    };
+    roots.forEach(addToLevel);
+    const ordered = [];
+    for (let currentDepth = Math.min(...levels.keys()); levels.size > 0; currentDepth++) {
+        for (const dir of levels.get(currentDepth) ?? []) {
+            ordered.push(...(filesByDir.get(dir) ?? []).sort((a, b) => compareNames(a.substring(dir.length), b.substring(dir.length))));
+            [...(children.get(dir) ?? [])].sort((a, b) => compareNames(a.substring(dir.length), b.substring(dir.length))).forEach(addToLevel);
+        }
+        levels.delete(currentDepth);
+    }
+    return ordered;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1vcmRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbmdpbmUvZmlsZS1vcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7R0FVRzs7O0FBRUgsU0FBUyxZQUFZLENBQUMsQ0FBUyxFQUFFLENBQVM7SUFDeEMsdURBQXVEO0lBQ3ZELE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxFQUFFLGtCQUFrQixDQUFDLENBQUE7SUFDckQsT0FBTyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7QUFDL0MsQ0FBQztBQUVELFNBQVMsT0FBTyxDQUFDLElBQVk7SUFDM0IsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQTtJQUNuQyxPQUFPLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUE7QUFDcEQsQ0FBQztBQUVELFNBQVMsS0FBSyxDQUFDLEdBQVc7SUFDeEIsT0FBTyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUE7QUFDaEUsQ0FBQztBQUVELFNBQVMsYUFBYSxDQUFDLElBQVk7SUFDakMsZ0hBQWdIO0lBQ2hILGlFQUFpRTtJQUNqRSxPQUFPLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLFdBQVcsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO0FBQ3ZILENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsMkJBQWtDLFNBQW1CLEVBQUUsWUFBc0I7SUFDM0UsOEdBQThHO0lBQzlHLDZHQUE2RztJQUM3RyxNQUFNLFlBQVksR0FBRyxJQUFJLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUN2QyxNQUFNLEtBQUssR0FBRyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxHQUFHLFNBQVMsRUFBRSxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQTtJQUVsSSxNQUFNLFVBQVUsR0FBRyxJQUFJLEdBQUcsRUFBb0IsQ0FBQTtJQUU5QyxLQUFLLE1BQU0sSUFBSSxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQ3pCLE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUN6QixNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQ3BDLElBQUksUUFBUTtZQUFFLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7O1lBQzVCLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtJQUNsQyxDQUFDO0lBRUQsaUNBQWlDO0lBQ2pDLE1BQU0sSUFBSSxHQUFHLENBQUMsR0FBRyxVQUFVLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUNuQyxNQUFNLE9BQU8sR0FBRyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUU3QixNQUFNLGlCQUFpQixHQUFHLENBQUMsR0FBVyxFQUFFLEVBQUU7UUFDeEMsS0FBSyxJQUFJLE1BQU0sR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUksTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1lBQzNELElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUM7Z0JBQUUsT0FBTyxJQUFJLENBQUE7WUFDcEMsSUFBSSxNQUFNLEtBQUssR0FBRyxJQUFJLE1BQU0sS0FBSyxPQUFPLENBQUMsTUFBTSxDQUFDO2dCQUFFLE9BQU8sS0FBSyxDQUFBO1FBQ2hFLENBQUM7SUFDSCxDQUFDLENBQUE7SUFFRCxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUE7SUFFM0Qsb0hBQW9IO0lBQ3BILE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxFQUF1QixDQUFBO0lBRS9DLEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDdkIsSUFBSSxLQUFLLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztZQUFFLFNBQVE7UUFFakMsS0FBSyxJQUFJLE9BQU8sR0FBRyxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsT0FBTyxDQUFDLEVBQUUsT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQzlILE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQTtZQUMvQixNQUFNLFFBQVEsR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFBO1lBQ3JDLElBQUksUUFBUTtnQkFBRSxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFBOztnQkFDOUIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsSUFBSSxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDL0MsQ0FBQztJQUNILENBQUM7SUFFRCx1RUFBdUU7SUFDdkUsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQW9CLENBQUE7SUFFMUMsTUFBTSxVQUFVLEdBQUcsQ0FBQyxHQUFXLEVBQUUsRUFBRTtRQUNqQyxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO1FBQ3BDLElBQUksS0FBSztZQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUE7O1lBQ3JCLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQTtJQUNwQyxDQUFDLENBQUE7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBRXpCLE1BQU0sT0FBTyxHQUFhLEVBQUUsQ0FBQTtJQUU1QixLQUFLLElBQUksWUFBWSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxNQUFNLENBQUMsSUFBSSxHQUFHLENBQUMsRUFBRSxZQUFZLEVBQUUsRUFBRSxDQUFDO1FBQ3BGLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQztZQUNqRCxPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FDMUg7WUFBQSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUE7UUFDcEksQ0FBQztRQUVELE1BQU0sQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUE7SUFDN0IsQ0FBQztJQUVELE9BQU8sT0FBTyxDQUFBO0FBQ2hCLENBQUMifQ==

package/build/engine/host.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @file Minimal compiler interface the analyzer needs from a TypeScript engine
+ *
+ * Both the in-process TypeScript compiler API and the TypeScript 7 native (tsgo) API expose the same AST shapes
+ * (`kind`, `statements`, `members`, `modifiers`...) and the same checker operations, so the analyzer is written once
+ * against this interface. Syntax kinds differ between TypeScript versions, so they are provided by the host.
+ */
+/** A compiler AST node (TypeScript JS API or TypeScript 7 API) */
+export type TsNode = any;
+/** A compiler type (TypeScript JS API or TypeScript 7 API) */
+export type TsType = any;
+/**
+ * Flags ts-morph uses by default when printing a type with `Type.getText()`:
+ * UseTypeOfFunction (4096) | NoTruncation (1) | UseFullyQualifiedType (64) | WriteTypeArgumentsOfSignature (32)
+ */
+export declare const TYPE_FORMAT_FLAGS = 4193;
+export interface SyntaxKinds {
+    readonly AbstractKeyword: number;
+    readonly CallExpression: number;
+    readonly ClassDeclaration: number;
+    readonly ClassStaticBlockDeclaration: number;
+    readonly Constructor: number;
+    readonly DeclareKeyword: number;
+    readonly Decorator: number;
+    readonly EnumDeclaration: number;
+    readonly ExtendsKeyword: number;
+    readonly FunctionDeclaration: number;
+    readonly GetAccessor: number;
+    readonly Identifier: number;
+    readonly InterfaceDeclaration: number;
+    readonly MethodDeclaration: number;
+    readonly ParenthesizedExpression: number;
+    readonly PropertyAccessExpression: number;
+    readonly PropertyDeclaration: number;
+    readonly PropertySignature: number;
+    readonly SetAccessor: number;
+    readonly StringLiteral: number;
+    readonly TypeAliasDeclaration: number;
+}
+export interface AnalysisHost {
+    readonly SyntaxKind: SyntaxKinds;
+    /** Release the engine's resources */
+    dispose(): void;
+    /** Equivalent of ts-morph's `type.getStringIndexType()` / `type.getNumberIndexType()` */
+    getIndexType(type: TsType, keyKind: 'string' | 'number'): TsType | undefined;
+    /**
+     * Absolute paths of the project's source files: the files ts-morph would consider part of the project (the tsconfig's
+     * files and the non-`node_modules` files they import), in the order of ts-morph's `project.getSourceFiles()`
+     */
+    getProjectFilePaths(): string[];
+    /** Equivalent of ts-morph's `method.getReturnType()` */
+    getReturnTypeOfDeclaration(node: TsNode): TsType;
+    /** Get a source file of the program, if it exists */
+    getSourceFile(absolutePath: string): TsNode | undefined;
+    /** Equivalent of ts-morph's `node.getType()` */
+    getTypeAtLocation(node: TsNode): TsType;
+    /** Equivalent of ts-morph's `type.isObject()` */
+    isObjectType(type: TsType): boolean;
+    /** Engine name, for logging */
+    readonly name: string;
+    /** Equivalent of ts-morph's `type.getText()` */
+    typeToString(type: TsType): string;
+}

package/build/engine/host.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @file Minimal compiler interface the analyzer needs from a TypeScript engine
+ *
+ * Both the in-process TypeScript compiler API and the TypeScript 7 native (tsgo) API expose the same AST shapes
+ * (`kind`, `statements`, `members`, `modifiers`...) and the same checker operations, so the analyzer is written once
+ * against this interface. Syntax kinds differ between TypeScript versions, so they are provided by the host.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_FORMAT_FLAGS = void 0;
+/**
+ * Flags ts-morph uses by default when printing a type with `Type.getText()`:
+ * UseTypeOfFunction (4096) | NoTruncation (1) | UseFullyQualifiedType (64) | WriteTypeArgumentsOfSignature (32)
+ */
+exports.TYPE_FORMAT_FLAGS = 4193;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbmdpbmUvaG9zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFVSDs7O0dBR0c7QUFDVSxRQUFBLGlCQUFpQixHQUFHLElBQUksQ0FBQSJ9

package/build/engine/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Analysis engines
+ *
+ * - `tsgo` (default): TypeScript 7's native compiler, through its API. Fastest.
+ * - `typescript`: the TypeScript compiler installed for the analyzed API (6.x), running in-process. Generates the same SDK
+ *   as `tsgo`, and is used automatically if `tsgo` can't be started.
+ * - `ts-morph`: the original analyzer, running on the TypeScript 4.8 compiler bundled with ts-morph. Slowest; generates
+ *   the same SDK as previous versions of this tool (which may differ from TypeScript 6+ on some inferred types).
+ */
+import type { SdkContent } from '../analyzer/sdk';
+import { Config } from '../config';
+export declare const ENGINES: readonly ['tsgo', 'typescript', 'ts-morph'];
+export type EngineName = (typeof ENGINES)[number];
+export declare function isEngineName(name: string): name is EngineName;
+export declare function analyze(config: Config, engine: EngineName): Promise<SdkContent>;

package/build/engine/index.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @file Analysis engines
+ *
+ * - `tsgo` (default): TypeScript 7's native compiler, through its API. Fastest.
+ * - `typescript`: the TypeScript compiler installed for the analyzed API (6.x), running in-process. Generates the same SDK
+ *   as `tsgo`, and is used automatically if `tsgo` can't be started.
+ * - `ts-morph`: the original analyzer, running on the TypeScript 4.8 compiler bundled with ts-morph. Slowest; generates
+ *   the same SDK as previous versions of this tool (which may differ from TypeScript 6+ on some inferred types).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINES = void 0;
+exports.isEngineName = isEngineName;
+exports.analyze = analyze;
+/* eslint-disable @typescript-eslint/no-var-requires -- engines are loaded lazily, as loading a compiler is expensive */
+const path = __importStar(require("path"));
+const logging_1 = require("../logging");
+const analyze_1 = require("./analyze");
+exports.ENGINES = ['tsgo', 'typescript', 'ts-morph'];
+/** Internal engine running this analyzer on ts-morph's program, used to verify it matches the legacy analyzer */
+const TS_MORPH_COMPAT_ENGINE = 'ts-morph-compat';
+function isEngineName(name) {
+    return exports.ENGINES.includes(name) || name === TS_MORPH_COMPAT_ENGINE;
+}
+async function analyze(config, engine) {
+    (0, logging_1.debug)('Analysis engine: {yellow}', engine);
+    const sourcePath = path.resolve(process.cwd(), config.apiInputPath);
+    switch (engine) {
+        // Engines are loaded lazily: loading a compiler is expensive
+        case 'ts-morph': {
+            const { analyzerCli } = require('../analyzer');
+            return analyzerCli(config);
+        }
+        case TS_MORPH_COMPAT_ENGINE: {
+            const { createTsMorphCompatHost } = require('./ts-morph-compat-host');
+            return (0, analyze_1.analyzeWithHost)(config, createTsMorphCompatHost);
+        }
+        case 'typescript': {
+            const { createTypeScriptHost, loadTypeScript } = require('./typescript-host');
+            return (0, analyze_1.analyzeWithHost)(config, (tsConfigFilePath) => createTypeScriptHost(loadTypeScript(sourcePath, config.typescriptPath), tsConfigFilePath));
+        }
+        case 'tsgo': {
+            const { createTsgoHost } = require('./tsgo-host');
+            const { createTypeScriptHost, loadTypeScript } = require('./typescript-host');
+            return (0, analyze_1.analyzeWithHost)(config, (tsConfigFilePath) => {
+                try {
+                    return createTsgoHost(tsConfigFilePath);
+                }
+                catch (e) {
+                    // Only startup failures end up here (e.g. no native binary for this platform): analysis errors happen later on
+                    (0, logging_1.notice)('Could not start the {yellow} engine, falling back to the {yellow} engine (same output, slower):\n{}', 'tsgo', 'typescript', e instanceof Error ? e.message : String(e));
+                    return createTypeScriptHost(loadTypeScript(sourcePath, config.typescriptPath), tsConfigFilePath);
+                }
+            });
+        }
+        default:
+            (0, logging_1.panic)('Unknown analysis engine {yellow} (expected one of: {})', engine, exports.ENGINES.join(', '));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/engine/ts-morph-compat-host.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Analysis host running on the TypeScript program built by ts-morph (TypeScript 4.8)
+ *
+ * This is not meant for users: it runs the engine-independent analyzer against the exact same program, type checker
+ * and file order as the legacy ts-morph analyzer, which lets the parity tests verify both analyzers are equivalent.
+ */
+import { AnalysisHost } from './host';
+export declare function createTsMorphCompatHost(tsConfigFilePath: string): AnalysisHost;

package/build/engine/ts-morph-compat-host.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @file Analysis host running on the TypeScript program built by ts-morph (TypeScript 4.8)
+ *
+ * This is not meant for users: it runs the engine-independent analyzer against the exact same program, type checker
+ * and file order as the legacy ts-morph analyzer, which lets the parity tests verify both analyzers are equivalent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTsMorphCompatHost = createTsMorphCompatHost;
+const ts_morph_1 = require("ts-morph");
+const typescript_host_1 = require("./typescript-host");
+function createTsMorphCompatHost(tsConfigFilePath) {
+    // Same project setup as the legacy analyzer (src/analyzer/index.ts)
+    const project = new ts_morph_1.Project({ tsConfigFilePath });
+    const projectFilePaths = project.getSourceFiles().map((file) => file.getFilePath());
+    return (0, typescript_host_1.createProgramHost)('ts-morph-compat', ts_morph_1.ts, project.getProgram().compilerObject, projectFilePaths);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHMtbW9ycGgtY29tcGF0LWhvc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW5naW5lL3RzLW1vcnBoLWNvbXBhdC1ob3N0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7R0FLRzs7O0FBRUgsdUNBQXNDO0FBR3RDLHVEQUFxRDtBQUVyRCxpQ0FBd0MsZ0JBQXdCO0lBQzlELG9FQUFvRTtJQUNwRSxNQUFNLE9BQU8sR0FBRyxJQUFJLGtCQUFPLENBQUMsRUFBRSxnQkFBZ0IsRUFBRSxDQUFDLENBQUE7SUFFakQsTUFBTSxnQkFBZ0IsR0FBRyxPQUFPLENBQUMsY0FBYyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFZLENBQUMsQ0FBQTtJQUU3RixPQUFPLElBQUEsbUNBQWlCLEVBQUMsaUJBQWlCLEVBQUUsYUFBRSxFQUFFLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQyxjQUFjLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtBQUN4RyxDQUFDIn0=

package/build/engine/tsgo-host.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file Analysis host backed by the TypeScript 7 native compiler (tsgo), through its synchronous API
+ */
+import { AnalysisHost } from './host';
+/**
+ * Load the TypeScript 7 API and start a tsgo process
+ * Throws if the API can't be loaded or tsgo can't be started (e.g. unsupported platform)
+ */
+export declare function createTsgoHost(tsConfigFilePath: string): AnalysisHost;

package/build/engine/tsgo-host.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * @file Analysis host backed by the TypeScript 7 native compiler (tsgo), through its synchronous API
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTsgoHost = createTsgoHost;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires -- the TypeScript 7 API is loaded lazily, and can fail to load */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logging_1 = require("../logging");
+const file_order_1 = require("./file-order");
+const host_1 = require("./host");
+/**
+ * The API throws synchronously when the native executable is missing, but if it exists and can't be executed, the
+ * failure surfaces as an unhandled 'error' event of the child process, which would crash instead of falling back
+ */
+function assertTsgoIsExecutable() {
+    if (process.platform === 'win32')
+        return;
+    // Same resolution as TypeScript's lib/getExePath.js
+    const platformPackage = `@typescript/typescript-${process.platform}-${process.arch}`;
+    const packageJson = require.resolve(`${platformPackage}/package.json`, {
+        paths: [path.dirname(require.resolve('typescript/package.json'))],
+    });
+    fs.accessSync(path.join(path.dirname(packageJson), 'lib', 'tsc'), fs.constants.X_OK);
+}
+/**
+ * Stop tsgo
+ * The API's `close()` sends SIGTERM, to which a busy tsgo process responds by logging "context canceled" to the stderr
+ * it shares with this process. tsgo holds no state worth a graceful shutdown, so it is killed with SIGKILL first.
+ */
+function terminate(api) {
+    // Private fields of TypeScript 7.0's synchronous API (the dependency's version is pinned)
+    const client = api.client;
+    const child = client?.channel?.child;
+    if (!child) {
+        api.close();
+        return;
+    }
+    if (child.exitCode === null && child.signalCode === null) {
+        child.kill('SIGKILL');
+    }
+    // Only close the channel: `api.close()` would first ask the (now dead) process to release its snapshots
+    client.close();
+}
+/**
+ * Load the TypeScript 7 API and start a tsgo process
+ * Throws if the API can't be loaded or tsgo can't be started (e.g. unsupported platform)
+ */
+function createTsgoHost(tsConfigFilePath) {
+    // The synchronous API relies on Node.js internals (and the tsgo process it spawns would then never exit)
+    if (process.versions['bun']) {
+        throw new Error("TypeScript 7's API requires the Node.js runtime (run the generator with `bun x` or `npx`, without `--bun`)");
+    }
+    // The API is published as ES modules: this relies on `require(esm)` (Node.js 20.19+ / 22.12+, Bun)
+    const { API, TypeFlags } = require('typescript/unstable/sync');
+    const { SyntaxKind } = require('typescript/unstable/ast');
+    assertTsgoIsExecutable();
+    const api = new API({ cwd: path.dirname(tsConfigFilePath) });
+    // Errors exit the process right away: stop tsgo then too. Prepended, to run before the API's own exit handler.
+    const onExit = () => terminate(api);
+    process.prependListener('exit', onExit);
+    try {
+        const snapshot = api.updateSnapshot({ openProjects: [tsConfigFilePath] });
+        const project = snapshot.getProject(tsConfigFilePath);
+        if (!project) {
+            throw new Error(`tsgo did not load the project for ${tsConfigFilePath}`);
+        }
+        const { checker, program } = project;
+        (0, logging_1.debug)('Using TypeScript {yellow} (native)', String(require('typescript/package.json').version));
+        return {
+            name: 'tsgo',
+            SyntaxKind: SyntaxKind,
+            getProjectFilePaths: () => (0, file_order_1.orderProjectFiles)(project.rootFiles, program.getSourceFileNames()),
+            getSourceFile: (absolutePath) => program.getSourceFile(absolutePath),
+            getTypeAtLocation: (node) => checker.getTypeAtLocation(node),
+            getReturnTypeOfDeclaration(node) {
+                const signature = checker.getSignatureFromDeclaration(node);
+                if (!signature) {
+                    throw new Error('Expected the node to have a signature.');
+                }
+                return checker.getReturnTypeOfSignature(signature);
+            },
+            typeToString: (type) => checker.typeToString(type, undefined, host_1.TYPE_FORMAT_FLAGS),
+            isObjectType: (type) => (type.flags & TypeFlags.Object) !== 0,
+            getIndexType(type, keyKind) {
+                const keyFlag = keyKind === 'string' ? TypeFlags.String : TypeFlags.Number;
+                return checker.getIndexInfosOfType(type).find((info) => (info.keyType.flags & keyFlag) !== 0)?.valueType;
+            },
+            dispose() {
+                process.removeListener('exit', onExit);
+                terminate(api);
+            },
+        };
+    }
+    catch (e) {
+        process.removeListener('exit', onExit);
+        terminate(api);
+        throw e;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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