typescript 7.1.0-dev.20260923.1 → 7.1.0-dev.20260925.1

package/dist/api/async/api.js

@@ -20,7 +20,7 @@ import { TypePredicateKind } from "#enums/typePredicateKind";
 import { ModifierFlags, unescapeLeadingUnderscores, } from "../../ast/index.js";
 import { assertNever } from "../../internal/utils.js";
 import { encodeNode, uint8ArrayToBase64, } from "../node/encoder.js";
-import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, RemoteSourceFile, } from "../node/node.js";
+import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, readSourceFileLease, RemoteSourceFile, } from "../node/node.js";
 import { Wtf8Decoder } from "../node/wtf8.js";
 import { createGetCanonicalFileName, toPath, } from "../path.js";
 import { resolveFileName, toCreateSnapshotRequest, } from "../proto.js";
@@ -29,6 +29,22 @@ 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, ScriptKind, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+let nextModuleResolutionCallbackId = 0;
+function registerModuleResolutionCallback(client, callback, getSnapshot) {
+    const name = `resolveModuleName/${++nextModuleResolutionCallbackId}`;
+    const dispose = client.registerCallback(name, params => {
+        const { moduleName, containingDirectory, resolutionMode, snapshot: snapshotId, inProgressSnapshot } = params;
+        let snapshot = snapshotId === undefined ? undefined : getSnapshot(snapshotId);
+        if (snapshotId !== undefined && snapshot === undefined) {
+            throw new Error(`Snapshot ${snapshotId} is inactive`);
+        }
+        if (inProgressSnapshot !== undefined) {
+            snapshot = -inProgressSnapshot;
+        }
+        return callback(moduleName, containingDirectory, resolutionMode, { snapshot });
+    });
+    return { name, dispose };
+}
 // @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";
@@ -43,7 +59,8 @@ export class API {
     getCanonicalFileNameWorker;
     initialized = false;
     initializing;
-    activeSnapshots = new Set();
+    activeSnapshots = new Map();
+    activeSourceFileLeases = new Map();
     printer;
     internal;
     constructor(options = {}) {
@@ -122,21 +139,55 @@ export class API {
         await this.ensureInitialized();
         return this.client.apiRequest("parseJsonConfigFileContent", { json, ...options });
     }
+    /**
+     * Create and retain a source file independently of a program.
+     * Dispose the returned lease when the source file no longer needs to remain available remotely.
+     */
     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());
+        return this.retainSourceFileResponse(data);
     }
+    /**
+     * Read, create, and retain a source file independently of a program.
+     * Dispose the returned lease when the source file no longer needs to remain available remotely.
+     */
     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());
+        return this.retainSourceFileResponse(data);
+    }
+    retainSourceFileResponse(data) {
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const lease = readSourceFileLease(view);
+        try {
+            const decoded = new RemoteSourceFile(data, this.decoder, this.client.getTimingCollector());
+            const sourceFile = this.sourceFileCache.setForLease(decoded.path, decoded, readParseOptionsKey(view), readSourceFileHash(view), lease);
+            const retained = new RetainedSourceFile(sourceFile, lease, this.client, () => {
+                this.activeSourceFileLeases.delete(lease);
+                this.sourceFileCache.releaseLease(lease);
+            });
+            this.activeSourceFileLeases.set(lease, retained);
+            return retained;
+        }
+        catch (error) {
+            // @sync-skip-block-start
+            void this.client.apiRequest("releaseSourceFile", { lease }).catch(() => { });
+            // @sync-skip-block-end
+            // @sync-only-start
+            // try {
+            //     this.client.apiRequest("releaseSourceFile", { lease });
+            // }
+            // catch {}
+            // @sync-only-end
+            throw error;
+        }
     }
     async transpileModule(input, options = {}) {
         await this.ensureInitialized();
@@ -156,23 +207,23 @@ export class API {
     }
     async createSnapshot(params) {
         await this.ensureInitialized();
-        const requestParams = toCreateSnapshotRequest(params);
+        const requestParams = toCreateSnapshotRequest(this.prepareCreateSnapshotParams(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.activeSnapshots.delete(snapshot.id);
             this.sourceFileCache.releaseSnapshot(snapshot.id);
         }, this.createSnapshotUpdater(() => snapshot), undefined);
-        this.activeSnapshots.add(snapshot);
+        this.activeSnapshots.set(snapshot.id, snapshot);
         return snapshot;
     }
     async updateSnapshot(baseSnapshot, params) {
         await this.ensureInitialized();
-        if (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+        if (this.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
             throw new Error("Cannot update an inactive snapshot");
         }
         const data = await this.client.apiRequest("updateSnapshot", {
             snapshot: baseSnapshot.id,
-            changes: toCreateSnapshotRequest(params),
+            changes: toCreateSnapshotRequest(this.prepareCreateSnapshotParams(params)),
         });
         if (data.snapshot === baseSnapshot.id) {
             await this.client.apiRequest("release", { snapshot: data.snapshot });
@@ -180,12 +231,37 @@ export class API {
         }
         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.activeSnapshots.delete(snapshot.id);
             this.sourceFileCache.releaseSnapshot(snapshot.id);
         }, this.createSnapshotUpdater(() => snapshot), baseSnapshot);
-        this.activeSnapshots.add(snapshot);
+        this.activeSnapshots.set(snapshot.id, snapshot);
         return snapshot;
     }
+    prepareCreateSnapshotParams(params) {
+        if (!params)
+            return undefined;
+        const prepareOptions = (options) => {
+            if (!options)
+                return undefined;
+            const { moduleResolver, ...rest } = options;
+            moduleResolver?.ensureNotDisposed();
+            return {
+                ...rest,
+                moduleResolver: moduleResolver?.id,
+            };
+        };
+        return {
+            ...params,
+            createPrograms: params.createPrograms?.map(program => ({ ...program, options: prepareOptions(program.options) })),
+            reconfigurePrograms: params.reconfigurePrograms?.map(program => ({ ...program, options: prepareOptions(program.options) })),
+        };
+    }
+    prepareLanguageServerSnapshotChanges(changes) {
+        if (!changes)
+            return undefined;
+        const prepared = this.prepareCreateSnapshotParams(changes);
+        return prepared;
+    }
     createSnapshotUpdater(getSnapshot) {
         const update = params => this.updateSnapshot(getSnapshot(), params); // @sync: const update = ((params: CreateSnapshotParams) => this.updateSnapshot(getSnapshot(), params)) as SnapshotUpdater;
         // @sync-only-start
@@ -198,21 +274,21 @@ export class API {
         await this.ensureInitialized();
         const changes = args[0];
         const baseSnapshot = args[1];
-        if (baseSnapshot && (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+        if (baseSnapshot && (this.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed())) {
             throw new Error("Cannot use an inactive snapshot as a response base");
         }
         const data = await this.client.apiRequest("getCurrentLanguageServerSnapshot", {
             baseSnapshot: baseSnapshot?.id,
-            changes,
+            changes: this.prepareLanguageServerSnapshotChanges(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);
+            this.activeSnapshots.delete(snapshot.id);
             this.sourceFileCache.releaseSnapshot(snapshot.id);
         }, this.createSnapshotUpdater(() => snapshot), baseSnapshot);
-        this.activeSnapshots.add(snapshot);
+        this.activeSnapshots.set(snapshot.id, snapshot);
         return snapshot;
     }
     async [globalThis.Symbol.asyncDispose]() {
@@ -220,15 +296,39 @@ export class API {
     }
     async close() {
         await this.initializing?.catch(() => { }); // @sync-skip
-        // Dispose all active snapshots
         try {
-            for (const snapshot of [...this.activeSnapshots]) {
-                await snapshot.dispose();
+            for (const retained of [...this.activeSourceFileLeases.values()]) {
+                await retained.dispose();
             }
-            this.sourceFileCache.clear();
         }
         finally {
-            await this.client.close(); // always close the underlying connection
+            try {
+                for (const snapshot of [...this.activeSnapshots.values()]) {
+                    await snapshot.dispose();
+                }
+                this.sourceFileCache.clear();
+            }
+            finally {
+                await this.client.close(); // always close the underlying connection
+            }
+        }
+    }
+    async createModuleResolver(compilerOptions, options) {
+        await this.ensureInitialized();
+        const callback = options?.resolveModuleName
+            ? registerModuleResolutionCallback(this.client, options.resolveModuleName, id => this.activeSnapshots.get(id))
+            : undefined;
+        try {
+            const id = await this.client.apiRequest("createModuleResolver", {
+                compilerOptions,
+                moduleResolutions: options?.moduleResolutions,
+                resolveModuleNameCallback: callback?.name,
+            });
+            return new ModuleResolver(id, this.client, callback?.dispose);
+        }
+        catch (error) {
+            callback?.dispose();
+            throw error;
         }
     }
     clearSourceFileCache() {
@@ -236,7 +336,7 @@ export class API {
     }
     async runWithTemporaryFileUpdate(baseSnapshot, file, newText, cb) {
         await this.ensureInitialized();
-        if (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+        if (this.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
             throw new Error("Cannot run a temporary file update on an inactive snapshot");
         }
         const snapshot = await baseSnapshot.update({
@@ -286,6 +386,38 @@ export class API {
         return program;
     }
 }
+/** An independently retained source file and its disposable remote-lifetime lease. */
+export class RetainedSourceFile {
+    sourceFile;
+    lease;
+    client;
+    onDispose;
+    disposed = false;
+    disposePromise;
+    constructor(sourceFile, lease, client, onDispose) {
+        this.sourceFile = sourceFile;
+        this.lease = lease;
+        this.client = client;
+        this.onDispose = onDispose;
+    }
+    [globalThis.Symbol.asyncDispose]() {
+        return this.dispose(); // @sync: this.dispose();
+    }
+    dispose() {
+        return this.disposePromise ??= this.disposeWorker();
+    }
+    async disposeWorker() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            await this.client.apiRequest("releaseSourceFile", { lease: this.lease });
+        }
+        finally {
+            this.onDispose();
+        }
+    }
+}
 export class InternalAPI {
     client;
     ensureInitialized;
@@ -421,6 +553,46 @@ export class Snapshot {
         return project;
     }
 }
+export class ModuleResolver {
+    id;
+    client;
+    disposeCallback;
+    disposed = false;
+    constructor(id, client, disposeCallback) {
+        this.id = id;
+        this.client = client;
+        this.disposeCallback = disposeCallback;
+    }
+    async resolveModuleName(moduleName, containingDirectory, resolutionMode, options) {
+        this.ensureNotDisposed();
+        if (options?.snapshot instanceof Snapshot && options.snapshot.isDisposed()) {
+            throw new Error("Snapshot is disposed");
+        }
+        return this.client.apiRequest("resolveModuleName", {
+            snapshot: options?.snapshot instanceof Snapshot ? options.snapshot.id : undefined,
+            inProgressSnapshot: typeof options?.snapshot === "number" ? -options.snapshot : undefined,
+            resolver: this.id,
+            moduleName,
+            containingDirectory,
+            resolutionMode,
+        });
+    }
+    [globalThis.Symbol.asyncDispose]() {
+        return this.dispose();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        await this.client.apiRequest("releaseModuleResolver", { resolver: this.id });
+        this.disposed = true;
+        this.disposeCallback?.();
+    }
+    /** @internal */
+    ensureNotDisposed() {
+        if (this.disposed)
+            throw new Error("ModuleResolver is disposed");
+    }
+}
 class SnapshotObjectRegistry {
     symbols = new Map();
     client;
@@ -1714,13 +1886,7 @@ export class Checker {
         } : undefined;
     }
     async getIndexTypeOfType(type, kind) {
-        const data = await this.client.apiRequest("getIndexTypeOfTypeByKind", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
-            kind,
-        });
-        return data ? this.objectRegistry.getOrCreateType(data) : undefined;
+        return kind === IndexKind.String ? type.getStringIndexType() : type.getNumberIndexType();
     }
     async getTypeOfPropertyOfType(type, propertyName) {
         const data = await this.client.apiRequest("getTypeOfPropertyOfType", {
@@ -2165,6 +2331,7 @@ class TypeObject {
     constructSignatures;
     indexInfos;
     baseTypes;
+    types;
     stringIndexType;
     numberIndexType;
     constructor(data, objectRegistry) {
@@ -2261,6 +2428,7 @@ class TypeObject {
         this.constructSignatures = false;
         this.indexInfos = false;
         this.baseTypes = false;
+        this.types = false;
         this.stringIndexType = false;
         this.numberIndexType = false;
     }
@@ -2354,7 +2522,10 @@ class TypeObject {
         if (!(this.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
             return undefined;
         }
-        return this.objectRegistry.fetchTypes(this, "getTypesOfType");
+        if (this.types === false) {
+            this.types = await this.objectRegistry.fetchTypes(this, "getTypesOfType");
+        }
+        return this.types;
     }
     async getTypeParameters() {
         return this.objectRegistry.fetchTypes(this, "getTypeParametersOfType", this.typeParameters);