typescript 7.1.0-dev.20260916.1 → 7.1.0-dev.20260918.1

package/dist/api/async/api.js

@@ -10,6 +10,7 @@ import { ModuleResolutionKind } from "#enums/moduleResolutionKind";
 import { NewLineKind } from "#enums/newLineKind";
 import { NodeBuilderFlags } from "#enums/nodeBuilderFlags";
 import { ObjectFlags } from "#enums/objectFlags";
+import { ScriptKind } from "#enums/scriptKind";
 import { SignatureFlags } from "#enums/signatureFlags";
 import { SignatureKind } from "#enums/signatureKind";
 import { SymbolFlags } from "#enums/symbolFlags";
@@ -22,30 +23,33 @@ import { encodeNode, uint8ArrayToBase64, } from "../node/encoder.js";
 import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, RemoteSourceFile, } from "../node/node.js";
 import { Wtf8Decoder } from "../node/wtf8.js";
 import { createGetCanonicalFileName, toPath, } from "../path.js";
-import { resolveFileName, toUpdateSnapshotRequest, } from "../proto.js";
+import { resolveFileName, toCreateSnapshotRequest, } from "../proto.js";
 import { SourceFileCache } from "../sourceFileCache.js";
 import { Client, } from "./client.js";
 export { formatDiagnostics, formatDiagnosticsWithColorAndContext } from "../diagnosticFormatter.js";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.js";
-export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, IndexKind, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, IndexKind, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, ScriptKind, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
 // @sync-only-start
 // export { all, defer, type APIRequestGenerator, type AnyAPIRequestGenerator, type AllAPIRequestGenerator, type DeferredAPIRequestGenerator, type ExecutedGeneratorsResults } from "./generatorSupport.ts";
 // import {executeRequestGenerators, type ExecutedGeneratorsResults, type AnyAPIRequestGenerator} from "./generatorSupport.ts";
+// import { sourceFileResponseToUint8Array } from "../node/encoder.ts";
 // @sync-only-end
 export class API {
     client;
     sourceFileCache;
     toPath;
     currentDirectory;
+    decoder = new Wtf8Decoder();
     getCanonicalFileNameWorker;
     initialized = false;
     initializing;
     activeSnapshots = new Set();
-    latestSnapshot;
+    printer;
     internal;
     constructor(options = {}) {
         this.client = new Client(options);
         this.sourceFileCache = new SourceFileCache();
+        this.printer = new Printer(this.client);
         this.internal = new InternalAPI(this.client, () => this.ensureInitialized()); // @sync: this.internal = new InternalAPI(this.client, this.ensureInitialized);
     }
     /**
@@ -118,6 +122,22 @@ export class API {
         await this.ensureInitialized();
         return this.client.apiRequest("parseJsonConfigFileContent", { json, ...options });
     }
+    async createSourceFile(fileName, sourceText, options = {}) {
+        await this.ensureInitialized();
+        const data = await this.client.apiRequestBinary("createSourceFile", { fileName, sourceText, options });
+        if (!data) {
+            throw new Error("createSourceFile returned no source file");
+        }
+        return new RemoteSourceFile(data, this.decoder, this.client.getTimingCollector());
+    }
+    async createSourceFileFromFile(file, options = {}) {
+        await this.ensureInitialized();
+        const data = await this.client.apiRequestBinary("createSourceFileFromFile", { fileName: resolveFileName(file), options });
+        if (!data) {
+            throw new Error("createSourceFileFromFile returned no source file");
+        }
+        return new RemoteSourceFile(data, this.decoder, this.client.getTimingCollector());
+    }
     async transpileModule(input, options = {}) {
         await this.ensureInitialized();
         return this.client.apiRequest("transpileModule", { input, options });
@@ -134,39 +154,60 @@ export class API {
         await this.ensureInitialized();
         return this.client.apiRequest("transpileDeclarationFromFile", { fileName: resolveFileName(file), options });
     }
-    async updateSnapshot(params) {
-        return this.updateSnapshotWorker(params);
+    async createSnapshot(params) {
+        await this.ensureInitialized();
+        const requestParams = toCreateSnapshotRequest(params);
+        const data = await this.client.apiRequest("createSnapshot", requestParams);
+        const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
+            this.activeSnapshots.delete(snapshot);
+            this.sourceFileCache.releaseSnapshot(snapshot.id);
+        }, this.createSnapshotUpdater(() => snapshot), undefined);
+        this.activeSnapshots.add(snapshot);
+        return snapshot;
     }
-    /** @internal */
-    async updateSnapshotFrom(baseSnapshot, params) {
+    async updateSnapshot(baseSnapshot, params) {
+        await this.ensureInitialized();
         if (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
             throw new Error("Cannot update an inactive snapshot");
         }
-        if (baseSnapshot !== this.latestSnapshot) {
-            // TODO: Support forking active memory/cache snapshots once the server-side
-            // ownership, project state, and cache semantics have been worked out.
-            throw new Error("Snapshot.update can only update the latest snapshot");
-        }
-        return this.updateSnapshotWorker(params, baseSnapshot);
+        const data = await this.client.apiRequest("updateSnapshot", {
+            snapshot: baseSnapshot.id,
+            changes: toCreateSnapshotRequest(params),
+        });
+        this.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
+        const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
+            this.activeSnapshots.delete(snapshot);
+            this.sourceFileCache.releaseSnapshot(snapshot.id);
+        }, this.createSnapshotUpdater(() => snapshot), baseSnapshot);
+        this.activeSnapshots.add(snapshot);
+        return snapshot;
     }
-    async updateSnapshotWorker(params, baseSnapshot) {
+    createSnapshotUpdater(getSnapshot) {
+        const update = params => this.updateSnapshot(getSnapshot(), params); // @sync: const update = ((params: CreateSnapshotParams) => this.updateSnapshot(getSnapshot(), params)) as SnapshotUpdater;
+        // @sync-only-start
+        // const owner = this;
+        // update.gen = function* (params: CreateSnapshotParams) { return yield* owner.updateSnapshot.gen(getSnapshot(), params); };
+        // @sync-only-end
+        return update;
+    }
+    async getCurrentLanguageServerSnapshot(...args) {
         await this.ensureInitialized();
-        const requestParams = toUpdateSnapshotRequest(params, baseSnapshot?.id);
-        const data = await this.client.apiRequest("updateSnapshot", requestParams);
-        // Retain cached source files from previous snapshot for unchanged files
-        if (this.latestSnapshot) {
-            this.sourceFileCache.retainForSnapshot(data.snapshot, this.latestSnapshot.id, data.changes);
-            if (this.latestSnapshot.isDisposed()) {
-                this.sourceFileCache.releaseSnapshot(this.latestSnapshot.id);
-            }
+        const changes = args[0];
+        const baseSnapshot = args[1];
+        if (baseSnapshot && (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+            throw new Error("Cannot use an inactive snapshot as a response base");
+        }
+        const data = await this.client.apiRequest("getCurrentLanguageServerSnapshot", {
+            ...(baseSnapshot ? { baseSnapshot: baseSnapshot.id } : {}),
+            ...(changes ? { changes } : {}),
+        });
+        if (baseSnapshot) {
+            this.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
         }
         const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
             this.activeSnapshots.delete(snapshot);
-            if (snapshot !== this.latestSnapshot) {
-                this.sourceFileCache.releaseSnapshot(snapshot.id);
-            }
-        });
-        this.latestSnapshot = snapshot;
+            this.sourceFileCache.releaseSnapshot(snapshot.id);
+        }, this.createSnapshotUpdater(() => snapshot), baseSnapshot);
         this.activeSnapshots.add(snapshot);
         return snapshot;
     }
@@ -180,11 +221,6 @@ export class API {
             for (const snapshot of [...this.activeSnapshots]) {
                 await snapshot.dispose();
             }
-            // Release the latest snapshot's cache refs if still held
-            if (this.latestSnapshot) {
-                this.sourceFileCache.releaseSnapshot(this.latestSnapshot.id);
-                this.latestSnapshot = undefined;
-            }
             this.sourceFileCache.clear();
         }
         finally {
@@ -199,16 +235,13 @@ export class API {
         if (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
             throw new Error("Cannot run a temporary file update on an inactive snapshot");
         }
-        const data = await this.client.apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
-        // Retain cached source files from the base snapshot for files unchanged by
-        // the temporary update. The temporary snapshot is not the latest snapshot, so
-        // we never release the latest snapshot's cache here.
-        this.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
-        const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
-            this.activeSnapshots.delete(snapshot);
-            this.sourceFileCache.releaseSnapshot(snapshot.id);
+        const snapshot = await baseSnapshot.update({
+            fileSystem: {
+                kind: "layer",
+                files: { [resolveFileName(file)]: newText },
+            },
+            ensurePrograms: true,
         });
-        this.activeSnapshots.add(snapshot);
         try {
             await cb(snapshot);
         }
@@ -234,42 +267,18 @@ export class API {
     resetTimingInfo() {
         return this.client.resetTimingInfo();
     }
-    isProgramActive(program) {
-        const project = program.getProject();
-        for (const snapshot of this.activeSnapshots) {
-            if (!snapshot.isDisposed() && snapshot.getProject(project.configFileName)?.program === program) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Creates a program from current filesystem state, or derives one from oldProgram after applying fileChanges.
-     */
-    async createProgram(rootFiles, createProgramOptions, oldProgram, fileChanges) {
+    /** Creates a program from current filesystem state. */
+    async createProgram(rootFiles, createProgramOptions) {
         await this.ensureInitialized();
-        if (fileChanges && !oldProgram) {
-            throw new Error("fileChanges requires an oldProgram");
-        }
-        if (oldProgram && !this.isProgramActive(oldProgram)) {
-            throw new Error("oldProgram must belong to this API instance and reference an active snapshot");
-        }
-        const data = await this.client.apiRequest("createProgram", {
-            rootFiles,
-            createProgramOptions,
-            oldProgram: oldProgram ? { snapshot: oldProgram.snapshotId, project: oldProgram.getProject().id } : undefined,
-            fileChanges,
+        const snapshot = await this.createSnapshot({
+            createPrograms: [{ rootFiles, options: createProgramOptions }],
         });
-        if (!data.project) {
+        const program = snapshot.operation.createdPrograms[0];
+        if (!program) {
+            await snapshot.dispose();
             throw new Error("createProgram did not return a project");
         }
-        const snapshot = new Snapshot({ snapshot: data.snapshot, projects: [data.project] }, this.client, this.sourceFileCache, this.toPath, this, () => {
-            this.activeSnapshots.delete(snapshot);
-            this.sourceFileCache.releaseSnapshot(snapshot.id);
-        });
-        const program = snapshot.getProjects()[0].program;
         program.setOwnedSnapshot(snapshot);
-        this.activeSnapshots.add(snapshot);
         return program;
     }
 }
@@ -298,37 +307,68 @@ export class InternalAPI {
 }
 export class Snapshot {
     id;
+    operation;
     projectMap;
     toPath;
     client;
     disposed = false;
     disposePromise;
     onDispose;
-    api;
     snapshotRegistry;
+    projectDataMap;
+    updateSnapshot;
     internal;
-    constructor(data, client, sourceFileCache, toPath, api, onDispose) {
+    constructor(data, client, sourceFileCache, toPath, formatDiagnosticsHost, onDispose, updateSnapshot, baseSnapshot) {
         this.id = data.snapshot;
         this.client = client;
         this.toPath = toPath;
-        this.api = api;
         this.onDispose = onDispose;
+        this.updateSnapshot = updateSnapshot;
         this.projectMap = new Map();
+        const projectDataMap = new Map(baseSnapshot?.projectDataMap);
+        for (const projectId of data.changes?.removedProjects ?? []) {
+            projectDataMap.delete(projectId);
+        }
+        for (const projectData of data.projects) {
+            projectDataMap.set(projectData.id, projectData);
+        }
+        this.projectDataMap = new Map([...projectDataMap].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
         this.snapshotRegistry = new SnapshotObjectRegistry(client, this.id, projectId => this.projectMap.get(projectId));
-        for (const projData of data.projects) {
-            const project = new Project(projData, this.id, client, sourceFileCache, toPath, api, this.snapshotRegistry);
-            this.projectMap.set(toPath(projData.configFileName), project);
+        for (const projData of this.projectDataMap.values()) {
+            const project = new Project(projData, this.id, client, sourceFileCache, toPath, formatDiagnosticsHost, this.snapshotRegistry);
+            this.projectMap.set(projData.id, project);
         }
+        this.operation = {
+            ...(data.operation.createdPrograms ? { createdPrograms: data.operation.createdPrograms.map(projectId => this.requireProject(projectId).program) } : {}),
+            ...(data.operation.openedFiles ? { openedFiles: data.operation.openedFiles.map(result => ({ project: this.requireProject(result.project) })) } : {}),
+        };
         this.internal = new SnapshotInternalAPI(this.id, client);
     }
     getProjects() {
         this.ensureNotDisposed();
         return [...this.projectMap.values()];
     }
-    getProject(configFileName) {
+    getConfiguredProject(configFileName) {
         this.ensureNotDisposed();
         return this.projectMap.get(this.toPath(configFileName));
     }
+    getProject(projectId) {
+        this.ensureNotDisposed();
+        return this.projectMap.get(projectId);
+    }
+    getProgram(projectId) {
+        return this.getProject(projectId)?.program;
+    }
+    update(params) {
+        this.ensureNotDisposed();
+        return this.updateSnapshot(params);
+    }
+    /**
+     * Gets the default project for a given file from the configured projects and
+     * inferred project already loaded in the snapshot. Synthetic projects are not
+     * considered. Files that have been opened with `openFiles` are guaranteed to
+     * have a result.
+     */
     async getDefaultProjectForFile(file) {
         this.ensureNotDisposed();
         const data = await this.client.apiRequest("getDefaultProjectForFile", {
@@ -337,15 +377,7 @@ export class Snapshot {
         });
         if (!data)
             return undefined;
-        return this.projectMap.get(this.toPath(data.configFileName));
-    }
-    /**
-     * Creates the next snapshot, layering its filesystem over this snapshot's
-     * filesystem. This snapshot must still be active and be the latest snapshot.
-     */
-    async update(params) {
-        this.ensureNotDisposed();
-        return this.api.updateSnapshotFrom(this, params);
+        return this.projectMap.get(data.id);
     }
     [globalThis.Symbol.dispose]() {
         void this.dispose();
@@ -377,6 +409,13 @@ export class Snapshot {
             throw new Error("Snapshot is disposed");
         }
     }
+    requireProject(projectId) {
+        const project = this.projectMap.get(projectId);
+        if (!project) {
+            throw new Error(`Snapshot operation returned unknown project '${projectId}'`);
+        }
+        return project;
+    }
 }
 class SnapshotObjectRegistry {
     symbols = new Map();
@@ -388,7 +427,7 @@ class SnapshotObjectRegistry {
         this.snapshotId = snapshotId;
         this.resolveProject = resolveProject;
     }
-    /** Resolve a project id (a config file path) to its Project within this snapshot. */
+    /** Resolve a project ID to its Project within this snapshot. */
     getProject(projectId) {
         return this.resolveProject(projectId);
     }
@@ -639,6 +678,7 @@ export class Project {
     id;
     configFileName;
     currentDirectory;
+    dirty;
     parsedCommandLine;
     /** @deprecated Use `parsedCommandLine.options`. */
     compilerOptions;
@@ -646,7 +686,6 @@ export class Project {
     rootFiles;
     program;
     checker;
-    emitter;
     languageService;
     client;
     snapshotId;
@@ -654,6 +693,7 @@ export class Project {
         this.id = data.id;
         this.configFileName = data.configFileName;
         this.currentDirectory = data.currentDirectory;
+        this.dirty = data.dirty;
         if (!data.parsedCommandLine?.options) {
             throw new Error(`Project '${data.configFileName}' has no parsed command line`);
         }
@@ -665,7 +705,6 @@ export class Project {
         this.program = new Program(snapshotId, this, client, sourceFileCache, toPath, formatDiagnosticsHost);
         const objectRegistry = new ProjectObjectRegistry(client, snapshotId, this, snapshotRegistry);
         this.checker = new Checker(snapshotId, this, client, objectRegistry);
-        this.emitter = new Emitter(client);
         this.languageService = new LanguageService(snapshotId, this, client, objectRegistry);
     }
     /** @deprecated Use `languageService.getImportAdderEdits`. */
@@ -777,6 +816,7 @@ export class LanguageService {
 export class Program {
     /** @internal */
     snapshotId;
+    id;
     project;
     client;
     sourceFileCache;
@@ -788,6 +828,7 @@ export class Program {
     disposePromise;
     constructor(snapshotId, project, client, sourceFileCache, toPath, formatDiagnosticsHost) {
         this.snapshotId = snapshotId;
+        this.id = project.id;
         this.project = project;
         this.client = client;
         this.sourceFileCache = sourceFileCache;
@@ -856,6 +897,22 @@ export class Program {
         });
         return result ?? undefined;
     }
+    async getModeForUsageLocation(file, usage) {
+        return this.client.apiRequest("getModeForUsageLocation", {
+            snapshot: this.snapshotId,
+            project: this.project.id,
+            file,
+            usage: getNodeId(usage),
+        });
+    }
+    async getModeForResolutionAtIndex(file, index) {
+        return this.client.apiRequest("getModeForResolutionAtIndex", {
+            snapshot: this.snapshotId,
+            project: this.project.id,
+            file,
+            index,
+        });
+    }
     async getResolvedModuleFromModuleSpecifier(moduleSpecifier, sourceFile) {
         const result = await this.client.apiRequest("getResolvedModuleFromModuleSpecifier", {
             snapshot: this.snapshotId,
@@ -1703,7 +1760,19 @@ export class Checker {
             project: this.project.id,
             location: getNodeId(node),
         });
-        return typeof data === "string" || typeof data === "number" ? data : undefined;
+        if (!data || (typeof data.value !== "string" && typeof data.value !== "number")) {
+            return undefined;
+        }
+        if (data.isNumber && typeof data.value === "string") {
+            if (data.value === "+Infinity") {
+                return Infinity;
+            }
+            else if (data.value === "-Infinity") {
+                return -Infinity;
+            }
+            return NaN;
+        }
+        return data.value;
     }
     /** Get the signature of a function-like declaration. Always returns a signature. */
     async getSignatureFromDeclaration(node) {
@@ -1870,7 +1939,7 @@ export class Checker {
         return data ? data.map(d => this.objectRegistry.getOrCreateType(d)) : [];
     }
 }
-export class Emitter {
+export class Printer {
     client;
     constructor(client) {
         this.client = client;
@@ -1885,6 +1954,16 @@ export class Emitter {
             terminateUnterminatedLiterals: options.terminateUnterminatedLiterals,
         });
     }
+    async printFile(sourceFile, options = {}) {
+        const encoded = encodeNode(sourceFile);
+        const base64 = uint8ArrayToBase64(encoded);
+        return this.client.apiRequest("printNode", {
+            data: base64,
+            preserveSourceNewlines: options.preserveSourceNewlines,
+            neverAsciiEscape: options.neverAsciiEscape,
+            terminateUnterminatedLiterals: options.terminateUnterminatedLiterals,
+        });
+    }
 }
 export class SnapshotInternalAPI {
     snapshotId;
@@ -2092,7 +2171,24 @@ class TypeObject {
             // BigInt literal values are serialized as decimal strings (e.g. "-123") because
             // JSON cannot represent bigint. Decode them back into a real bigint here.
             const value = data.value;
-            this.value = (data.flags & TypeFlags.BigIntLiteral) ? BigInt(value) : value;
+            if (data.flags & TypeFlags.BigIntLiteral) {
+                this.value = BigInt(value);
+            }
+            // JSON cannot represent infinities, so the API serializes them as strings.
+            else if (data.flags & TypeFlags.NumberLiteral && typeof value === "string") {
+                if (value === "+Infinity") {
+                    this.value = Infinity;
+                }
+                else if (value === "-Infinity") {
+                    this.value = -Infinity;
+                }
+                else {
+                    this.value = NaN;
+                }
+            }
+            else {
+                this.value = value;
+            }
         }
         if (data.intrinsicName !== undefined)
             this.intrinsicName = data.intrinsicName;