tsc-ts 0.0.4 → 0.0.6

package/dist/api/library/nodes.d.ts

@@ -0,0 +1,51 @@
+import type { JSDoc, LineAndCharacter, ModifierList, Node, NodeList, SourceFile } from './ast.js';
+import type { ModifierFlags, NodeFlags, SyntaxKind } from './enums.generated.js';
+import type { Diagnostic } from './types.js';
+/**
+ * Calls `cbNode` for each child of `node`, in source order, or `cbNodes` for each list of children when it
+ * is given; returns the first truthy value a callback answers. JSDoc is not visited (`getJSDoc`).
+ */
+export declare function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeList) => T | undefined): T | undefined;
+/**
+ * Visits `root` and its descendants in preorder, with `depth` the number of levels below `root`, without
+ * recursion. The callback may answer 'skip' to leave a node's children unvisited, or 'stop' to end the walk.
+ */
+export declare function walkPreorder(root: Node, cb: (node: Node, depth: number) => void | 'skip' | 'stop'): void;
+/**
+ * The start of the first token of `node`, after its leading trivia; with `includeJSDoc`, the start of its
+ * first JSDoc comment where it has one.
+ */
+export declare function tokenStartOfNode(node: Node, includeJSDoc?: boolean): number;
+/** The source file `node` is in: the root of its parents. */
+export declare function getSourceFileOfNode(node: Node): SourceFile;
+/**
+ * The text of `node` in its source file, from the start of its first token (`tokenStartOfNode`) to its end:
+ * TypeScript's `node.getText()`.
+ */
+export declare function getTextOfNode(node: Node): string;
+/** The JSDoc comments of `node`, as the JSDoc nodes TypeScript 7 attaches to it (parsed on first use). */
+export declare function getJSDoc(node: Node): readonly JSDoc[];
+/** The modifiers of a declaration, decorators included, as TypeScript 7 keeps them. */
+export declare function getModifiers(node: Node): ModifierList | undefined;
+/** Whether a node of this kind can have modifiers (TypeScript 7's CanHaveModifiers). */
+export declare function canHaveModifiers(node: Node): boolean;
+/**
+ * The modifier flags of a declaration with those of the declarations it is part of: for a binding element,
+ * of the declaration of its outermost pattern; for a variable declaration, of its list and statement.
+ */
+export declare function getCombinedModifierFlags(node: Node): ModifierFlags;
+/** The node flags of a declaration with those of the declarations it is part of, as getCombinedModifierFlags. */
+export declare function getCombinedNodeFlags(node: Node): NodeFlags;
+/** The UTF-16 offset at which each line of the file starts. */
+export declare function getLineStarts(file: SourceFile): readonly number[];
+/** The 0-based line and character of a UTF-16 position in the file. */
+export declare function getLineAndCharacterOfPosition(file: SourceFile, position: number): LineAndCharacter;
+/** The UTF-16 position of a 0-based line and character in the file. */
+export declare function getPositionOfLineAndCharacter(file: SourceFile, line: number, character: number): number;
+/** The text of a punctuation or keyword token kind, or undefined for other kinds. */
+export declare function tokenToString(kind: SyntaxKind): string | undefined;
+/**
+ * A diagnostic's text with its chain of messages, each on its own line, indented two spaces per level of
+ * the chain, as TypeScript prints them.
+ */
+export declare function flattenDiagnosticMessageText(diagnostic: Diagnostic | string | undefined, newLine: string, indent?: number): string;

package/dist/api/library/nodes.js

@@ -0,0 +1,196 @@
+// Node functions of tsc-ts's public API, with TypeScript 7's behavior.
+import { getModifiers as compilerGetModifiers, NodeVisitor, } from '../compiler/ast.js';
+import { getTokenPosOfNode } from '../compiler/astnav.js';
+import { getCombinedModifierFlags as compilerModifierFlags, getCombinedNodeFlags as compilerNodeFlags, getSourceFileOfNode as compilerSourceFileOfNode, } from '../compiler/binder-utilities.js';
+import { getJSDoc as compilerGetJSDoc } from '../compiler/parser.js';
+import { computeLineOfPosition, tokenToString as compilerTokenToString } from '../compiler/scanner.js';
+const compilerNode = (node) => node;
+/** Visits the children of a node; stops at the first callback that answers a truthy value. */
+class CallbackVisitor extends NodeVisitor {
+    cbNode;
+    cbNodes;
+    result = undefined;
+    constructor(cbNode, cbNodes) {
+        super();
+        this.cbNode = cbNode;
+        this.cbNodes = cbNodes;
+    }
+    visitNode(node) {
+        const result = this.cbNode(node);
+        if (!result)
+            return false;
+        this.result = result;
+        return true;
+    }
+    visitList(list) {
+        if (this.cbNodes === undefined)
+            return super.visitList(list);
+        const result = this.cbNodes(list);
+        if (!result)
+            return false;
+        this.result = result;
+        return true;
+    }
+    visitModifiers(list) {
+        return this.visitList(list);
+    }
+}
+/**
+ * Calls `cbNode` for each child of `node`, in source order, or `cbNodes` for each list of children when it
+ * is given; returns the first truthy value a callback answers. JSDoc is not visited (`getJSDoc`).
+ */
+export function forEachChild(node, cbNode, cbNodes) {
+    const visitor = new CallbackVisitor(cbNode, cbNodes);
+    compilerNode(node).forEachChild(visitor);
+    return visitor.result;
+}
+/** Collects the children of a node, in source order. */
+class ChildCollector extends NodeVisitor {
+    children = [];
+    visitNode(node) {
+        this.children.push(node);
+        return false;
+    }
+}
+/**
+ * Visits `root` and its descendants in preorder, with `depth` the number of levels below `root`, without
+ * recursion. The callback may answer 'skip' to leave a node's children unvisited, or 'stop' to end the walk.
+ */
+export function walkPreorder(root, cb) {
+    const stack = [compilerNode(root)];
+    const depths = [0];
+    const collector = new ChildCollector();
+    // Declared outside the loop: scriptc compiles the node's conversion to the public Node from a variable there.
+    let node;
+    while (stack.length > 0) {
+        node = stack.pop();
+        const depth = depths.pop();
+        const verdict = cb(node, depth);
+        if (verdict === 'stop')
+            return;
+        if (verdict === 'skip')
+            continue;
+        collector.children.length = 0;
+        node.forEachChild(collector);
+        const children = collector.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+            stack.push(children[i]);
+            depths.push(depth + 1);
+        }
+    }
+}
+/**
+ * The start of the first token of `node`, after its leading trivia; with `includeJSDoc`, the start of its
+ * first JSDoc comment where it has one.
+ */
+export function tokenStartOfNode(node, includeJSDoc = false) {
+    const file = compilerSourceFileOfNode(compilerNode(node));
+    return getTokenPosOfNode(compilerNode(node), file, includeJSDoc);
+}
+/** The source file `node` is in: the root of its parents. */
+export function getSourceFileOfNode(node) {
+    let current = node;
+    while (current.parent !== undefined)
+        current = current.parent;
+    return current;
+}
+/**
+ * The text of `node` in its source file, from the start of its first token (`tokenStartOfNode`) to its end:
+ * TypeScript's `node.getText()`.
+ */
+export function getTextOfNode(node) {
+    const file = compilerSourceFileOfNode(compilerNode(node));
+    return file.text.substring(getTokenPosOfNode(compilerNode(node), file, false), node.end);
+}
+/** The JSDoc comments of `node`, as the JSDoc nodes TypeScript 7 attaches to it (parsed on first use). */
+export function getJSDoc(node) {
+    const file = compilerSourceFileOfNode(compilerNode(node));
+    return compilerGetJSDoc(file, compilerNode(node));
+}
+/** The modifiers of a declaration, decorators included, as TypeScript 7 keeps them. */
+export function getModifiers(node) {
+    return compilerGetModifiers(compilerNode(node));
+}
+/** Whether a node of this kind can have modifiers (TypeScript 7's CanHaveModifiers). */
+export function canHaveModifiers(node) {
+    switch (compilerNode(node).kind) {
+        case 169 /* CompilerSyntaxKind.TypeParameter */:
+        case 170 /* CompilerSyntaxKind.Parameter */:
+        case 172 /* CompilerSyntaxKind.PropertySignature */:
+        case 173 /* CompilerSyntaxKind.PropertyDeclaration */:
+        case 174 /* CompilerSyntaxKind.MethodSignature */:
+        case 175 /* CompilerSyntaxKind.MethodDeclaration */:
+        case 177 /* CompilerSyntaxKind.Constructor */:
+        case 178 /* CompilerSyntaxKind.GetAccessor */:
+        case 179 /* CompilerSyntaxKind.SetAccessor */:
+        case 182 /* CompilerSyntaxKind.IndexSignature */:
+        case 186 /* CompilerSyntaxKind.ConstructorType */:
+        case 219 /* CompilerSyntaxKind.FunctionExpression */:
+        case 220 /* CompilerSyntaxKind.ArrowFunction */:
+        case 232 /* CompilerSyntaxKind.ClassExpression */:
+        case 244 /* CompilerSyntaxKind.VariableStatement */:
+        case 263 /* CompilerSyntaxKind.FunctionDeclaration */:
+        case 264 /* CompilerSyntaxKind.ClassDeclaration */:
+        case 265 /* CompilerSyntaxKind.InterfaceDeclaration */:
+        case 266 /* CompilerSyntaxKind.TypeAliasDeclaration */:
+        case 267 /* CompilerSyntaxKind.EnumDeclaration */:
+        case 268 /* CompilerSyntaxKind.ModuleDeclaration */:
+        case 272 /* CompilerSyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* CompilerSyntaxKind.ImportDeclaration */:
+        case 346 /* CompilerSyntaxKind.JSImportDeclaration */:
+        case 278 /* CompilerSyntaxKind.ExportAssignment */:
+        case 279 /* CompilerSyntaxKind.ExportDeclaration */:
+            return true;
+    }
+    return false;
+}
+/**
+ * The modifier flags of a declaration with those of the declarations it is part of: for a binding element,
+ * of the declaration of its outermost pattern; for a variable declaration, of its list and statement.
+ */
+export function getCombinedModifierFlags(node) {
+    return compilerModifierFlags(compilerNode(node));
+}
+/** The node flags of a declaration with those of the declarations it is part of, as getCombinedModifierFlags. */
+export function getCombinedNodeFlags(node) {
+    return compilerNodeFlags(compilerNode(node));
+}
+/** The UTF-16 offset at which each line of the file starts. */
+export function getLineStarts(file) {
+    return file.lineStarts();
+}
+/** The 0-based line and character of a UTF-16 position in the file. */
+export function getLineAndCharacterOfPosition(file, position) {
+    const lineStarts = getLineStarts(file);
+    const line = computeLineOfPosition(lineStarts, position);
+    return { line, character: position - lineStarts[line] };
+}
+/** The UTF-16 position of a 0-based line and character in the file. */
+export function getPositionOfLineAndCharacter(file, line, character) {
+    return getLineStarts(file)[line] + character;
+}
+/** The text of a punctuation or keyword token kind, or undefined for other kinds. */
+export function tokenToString(kind) {
+    const text = compilerTokenToString(kind);
+    return text === '' ? undefined : text;
+}
+/**
+ * A diagnostic's text with its chain of messages, each on its own line, indented two spaces per level of
+ * the chain, as TypeScript prints them.
+ */
+export function flattenDiagnosticMessageText(diagnostic, newLine, indent = 0) {
+    if (diagnostic === undefined)
+        return '';
+    if (typeof diagnostic === 'string')
+        return diagnostic;
+    let result = '';
+    if (indent > 0) {
+        result += newLine;
+        for (let i = 0; i < indent; i++)
+            result += '  ';
+    }
+    result += diagnostic.text;
+    for (const child of diagnostic.messageChain)
+        result += flattenDiagnosticMessageText(child, newLine, indent + 1);
+    return result;
+}

package/dist/api/library/options.d.ts

@@ -0,0 +1,144 @@
+import type { CompilerOptions as CompilerOptionsValue } from '../compiler/options.js';
+/**
+ * Compiler options as `tsc-ts --api` returns them, in TypeScript-Go's field order: the public
+ * CompilerOptions, and the options tsgo's API returns besides those.
+ */
+export interface ApiCompilerOptions {
+    allowJs?: boolean;
+    allowArbitraryExtensions?: boolean;
+    allowImportingTsExtensions?: boolean;
+    allowNonTsExtensions?: boolean;
+    allowUmdGlobalAccess?: boolean;
+    allowUnreachableCode?: boolean;
+    allowUnusedLabels?: boolean;
+    assumeChangesOnlyAffectDirectDependencies?: boolean;
+    checkJs?: boolean;
+    customConditions?: string[];
+    composite?: boolean;
+    emitDeclarationOnly?: boolean;
+    emitBOM?: boolean;
+    emitDecoratorMetadata?: boolean;
+    declaration?: boolean;
+    declarationDir?: string;
+    declarationMap?: boolean;
+    deduplicatePackages?: boolean;
+    disableSizeLimit?: boolean;
+    disableSourceOfProjectReferenceRedirect?: boolean;
+    disableSolutionSearching?: boolean;
+    disableReferencedProjectLoad?: boolean;
+    erasableSyntaxOnly?: boolean;
+    exactOptionalPropertyTypes?: boolean;
+    experimentalDecorators?: boolean;
+    forceConsistentCasingInFileNames?: boolean;
+    isolatedModules?: boolean;
+    isolatedDeclarations?: boolean;
+    ignoreConfig?: boolean;
+    ignoreDeprecations?: string;
+    importHelpers?: boolean;
+    inlineSourceMap?: boolean;
+    inlineSources?: boolean;
+    init?: boolean;
+    incremental?: boolean;
+    jsx?: number;
+    jsxFactory?: string;
+    jsxFragmentFactory?: string;
+    jsxImportSource?: string;
+    lib?: string[];
+    libReplacement?: boolean;
+    locale?: string;
+    mapRoot?: string;
+    module?: number;
+    moduleResolution?: number;
+    moduleSuffixes?: string[];
+    moduleDetection?: number;
+    newLine?: number;
+    noEmit?: boolean;
+    noCheck?: boolean;
+    noErrorTruncation?: boolean;
+    noFallthroughCasesInSwitch?: boolean;
+    noImplicitAny?: boolean;
+    noImplicitThis?: boolean;
+    noImplicitReturns?: boolean;
+    noEmitHelpers?: boolean;
+    noLib?: boolean;
+    noPropertyAccessFromIndexSignature?: boolean;
+    noUncheckedIndexedAccess?: boolean;
+    noEmitOnError?: boolean;
+    noUnusedLocals?: boolean;
+    noUnusedParameters?: boolean;
+    noResolve?: boolean;
+    noImplicitOverride?: boolean;
+    noUncheckedSideEffectImports?: boolean;
+    outDir?: string;
+    paths?: Record<string, string[]>;
+    preserveConstEnums?: boolean;
+    preserveSymlinks?: boolean;
+    project?: string;
+    resolveJsonModule?: boolean;
+    resolvePackageJsonExports?: boolean;
+    resolvePackageJsonImports?: boolean;
+    removeComments?: boolean;
+    rewriteRelativeImportExtensions?: boolean;
+    reactNamespace?: string;
+    rootDir?: string;
+    rootDirs?: string[];
+    skipLibCheck?: boolean;
+    stableTypeOrdering?: boolean;
+    strict?: boolean;
+    strictBindCallApply?: boolean;
+    strictBuiltinIteratorReturn?: boolean;
+    strictFunctionTypes?: boolean;
+    strictNullChecks?: boolean;
+    strictPropertyInitialization?: boolean;
+    stripInternal?: boolean;
+    skipDefaultLibCheck?: boolean;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    suppressOutputPathCheck?: boolean;
+    target?: number;
+    traceResolution?: boolean;
+    tsBuildInfoFile?: string;
+    typeRoots?: string[];
+    types?: string[];
+    useDefineForClassFields?: boolean;
+    useUnknownInCatchVariables?: boolean;
+    verbatimModuleSyntax?: boolean;
+    maxNodeModuleJsDepth?: number;
+    allowSyntheticDefaultImports?: boolean;
+    alwaysStrict?: boolean;
+    baseUrl?: string;
+    downlevelIteration?: boolean;
+    esModuleInterop?: boolean;
+    outFile?: string;
+    configFilePath?: string;
+    noDtsResolution?: boolean;
+    pathsBasePath?: string;
+    diagnostics?: boolean;
+    extendedDiagnostics?: boolean;
+    generateCpuProfile?: string;
+    generateTrace?: string;
+    listEmittedFiles?: boolean;
+    listFiles?: boolean;
+    explainFiles?: boolean;
+    listFilesOnly?: boolean;
+    noEmitForJsFiles?: boolean;
+    preserveWatchOutput?: boolean;
+    pretty?: boolean;
+    version?: boolean;
+    watch?: boolean;
+    showConfig?: boolean;
+    build?: boolean;
+    help?: boolean;
+    all?: boolean;
+    pprofDir?: string;
+    singleThreaded?: boolean;
+    quiet?: boolean;
+    checkers?: number;
+}
+/** Compiler options as `tsc-ts --api` returns them: unset strings, enums and path mappings are undefined. */
+export declare function compilerOptionsOf(o: CompilerOptionsValue): ApiCompilerOptions;
+/**
+ * tsc-ts's compiler options for options in the form tsgo's API returns them (`compilerOptionsOf`). `lib`
+ * may name libraries as in tsconfig.json (`es2025`) or by file name (`lib.es2025.d.ts`).
+ */
+export declare function compilerOptionsFromApi(o: ApiCompilerOptions): CompilerOptionsValue;