typescript 7.1.0-dev.20260922.1 → 7.1.0-dev.20260924.1

package/dist/api/sync/api.js

@@ -30,6 +30,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 };
+}
 export { all, defer } from "./generatorSupport.js";
 import { sourceFileResponseToUint8Array } from "../node/encoder.js";
 import { executeRequestGenerators, } from "./generatorSupport.js";
@@ -42,7 +58,7 @@ export class API {
     getCanonicalFileNameWorker;
     initialized = false;
     initializing;
-    activeSnapshots = new Set();
+    activeSnapshots = new Map();
     printer;
     internal;
     constructor(options = {}) {
@@ -249,24 +265,24 @@ export class API {
         const owner = this;
         function createSnapshot(params) {
             owner.ensureInitialized();
-            const requestParams = toCreateSnapshotRequest(params);
+            const requestParams = toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params));
             const data = owner.client.apiRequest("createSnapshot", requestParams);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), undefined);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         function* gen(params) {
             yield* owner.ensureInitialized.gen();
-            const requestParams = toCreateSnapshotRequest(params);
+            const requestParams = toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params));
             const data = yield* apiRequest("createSnapshot", requestParams);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), undefined);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         return cacheGeneratorMethod(owner, "createSnapshot", createSnapshot, gen);
@@ -275,12 +291,12 @@ export class API {
         const owner = this;
         return cacheGeneratorMethod(owner, "updateSnapshot", function (baseSnapshot, params) {
             owner.ensureInitialized();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
             const data = owner.client.apiRequest("updateSnapshot", {
                 snapshot: baseSnapshot.id,
-                changes: toCreateSnapshotRequest(params),
+                changes: toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params)),
             });
             if (data.snapshot === baseSnapshot.id) {
                 owner.client.apiRequest("release", { snapshot: data.snapshot });
@@ -288,19 +304,19 @@ export class API {
             }
             owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }, function* (baseSnapshot, params) {
             yield* owner.ensureInitialized.gen();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
             const data = yield* apiRequest("updateSnapshot", {
                 snapshot: baseSnapshot.id,
-                changes: toCreateSnapshotRequest(params),
+                changes: toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params)),
             });
             if (data.snapshot === baseSnapshot.id) {
                 yield* apiRequest("release", { snapshot: data.snapshot });
@@ -308,13 +324,38 @@ export class API {
             }
             owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.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));
         const owner = this;
@@ -333,42 +374,42 @@ export class API {
             owner.ensureInitialized();
             const changes = args[0];
             const baseSnapshot = args[1];
-            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+            if (baseSnapshot && (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed())) {
                 throw new Error("Cannot use an inactive snapshot as a response base");
             }
             const data = owner.client.apiRequest("getCurrentLanguageServerSnapshot", {
                 baseSnapshot: baseSnapshot?.id,
-                changes,
+                changes: owner.prepareLanguageServerSnapshotChanges(changes),
             });
             if (baseSnapshot) {
                 owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         function* gen(...args) {
             yield* owner.ensureInitialized.gen();
             const changes = args[0];
             const baseSnapshot = args[1];
-            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+            if (baseSnapshot && (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed())) {
                 throw new Error("Cannot use an inactive snapshot as a response base");
             }
             const data = yield* apiRequest("getCurrentLanguageServerSnapshot", {
                 baseSnapshot: baseSnapshot?.id,
-                changes,
+                changes: owner.prepareLanguageServerSnapshotChanges(changes),
             });
             if (baseSnapshot) {
                 owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         return cacheGeneratorMethod(owner, "getCurrentLanguageServerSnapshot", getCurrentLanguageServerSnapshot, gen);
@@ -381,7 +422,7 @@ export class API {
         return cacheGeneratorMethod(owner, "close", function () {
             // Dispose all active snapshots
             try {
-                for (const snapshot of [...owner.activeSnapshots]) {
+                for (const snapshot of [...owner.activeSnapshots.values()]) {
                     snapshot.dispose();
                 }
                 owner.sourceFileCache.clear();
@@ -392,7 +433,7 @@ export class API {
         }, function* () {
             // Dispose all active snapshots
             try {
-                for (const snapshot of [...owner.activeSnapshots]) {
+                for (const snapshot of [...owner.activeSnapshots.values()]) {
                     yield* snapshot.dispose.gen();
                 }
                 owner.sourceFileCache.clear();
@@ -402,6 +443,44 @@ export class API {
             }
         });
     }
+    get createModuleResolver() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "createModuleResolver", function (compilerOptions, options) {
+            owner.ensureInitialized();
+            const callback = options?.resolveModuleName
+                ? registerModuleResolutionCallback(owner.client, options.resolveModuleName, id => owner.activeSnapshots.get(id))
+                : undefined;
+            try {
+                const id = owner.client.apiRequest("createModuleResolver", {
+                    compilerOptions,
+                    moduleResolutions: options?.moduleResolutions,
+                    resolveModuleNameCallback: callback?.name,
+                });
+                return new ModuleResolver(id, owner.client, callback?.dispose);
+            }
+            catch (error) {
+                callback?.dispose();
+                throw error;
+            }
+        }, function* (compilerOptions, options) {
+            yield* owner.ensureInitialized.gen();
+            const callback = options?.resolveModuleName
+                ? registerModuleResolutionCallback(owner.client, options.resolveModuleName, id => owner.activeSnapshots.get(id))
+                : undefined;
+            try {
+                const id = yield* apiRequest("createModuleResolver", {
+                    compilerOptions,
+                    moduleResolutions: options?.moduleResolutions,
+                    resolveModuleNameCallback: callback?.name,
+                });
+                return new ModuleResolver(id, owner.client, callback?.dispose);
+            }
+            catch (error) {
+                callback?.dispose();
+                throw error;
+            }
+        });
+    }
     clearSourceFileCache() {
         this.sourceFileCache.clear();
     }
@@ -409,7 +488,7 @@ export class API {
         const owner = this;
         return cacheGeneratorMethod(owner, "runWithTemporaryFileUpdate", function (baseSnapshot, file, newText, cb) {
             owner.ensureInitialized();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
             const snapshot = baseSnapshot.update({
@@ -427,7 +506,7 @@ export class API {
             }
         }, function* (baseSnapshot, file, newText, cb) {
             yield* owner.ensureInitialized.gen();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
             const snapshot = yield* baseSnapshot.update.gen({
@@ -701,6 +780,71 @@ 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;
+    }
+    get resolveModuleName() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "resolveModuleName", function (moduleName, containingDirectory, resolutionMode, options) {
+            owner.ensureNotDisposed();
+            if (options?.snapshot instanceof Snapshot && options.snapshot.isDisposed()) {
+                throw new Error("Snapshot is disposed");
+            }
+            return owner.client.apiRequest("resolveModuleName", {
+                snapshot: options?.snapshot instanceof Snapshot ? options.snapshot.id : undefined,
+                inProgressSnapshot: typeof options?.snapshot === "number" ? -options.snapshot : undefined,
+                resolver: owner.id,
+                moduleName,
+                containingDirectory,
+                resolutionMode,
+            });
+        }, function* (moduleName, containingDirectory, resolutionMode, options) {
+            owner.ensureNotDisposed();
+            if (options?.snapshot instanceof Snapshot && options.snapshot.isDisposed()) {
+                throw new Error("Snapshot is disposed");
+            }
+            return yield* apiRequest("resolveModuleName", {
+                snapshot: options?.snapshot instanceof Snapshot ? options.snapshot.id : undefined,
+                inProgressSnapshot: typeof options?.snapshot === "number" ? -options.snapshot : undefined,
+                resolver: owner.id,
+                moduleName,
+                containingDirectory,
+                resolutionMode,
+            });
+        });
+    }
+    [globalThis.Symbol.dispose]() {
+        return this.dispose();
+    }
+    get dispose() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "dispose", function () {
+            if (owner.disposed)
+                return;
+            owner.client.apiRequest("releaseModuleResolver", { resolver: owner.id });
+            owner.disposed = true;
+            owner.disposeCallback?.();
+        }, function* () {
+            if (owner.disposed)
+                return;
+            yield* apiRequest("releaseModuleResolver", { resolver: owner.id });
+            owner.disposed = true;
+            owner.disposeCallback?.();
+        });
+    }
+    /** @internal */
+    ensureNotDisposed() {
+        if (this.disposed)
+            throw new Error("ModuleResolver is disposed");
+    }
+}
 class SnapshotObjectRegistry {
     symbols = new Map();
     client;
@@ -3196,21 +3340,9 @@ export class Checker {
     get getIndexTypeOfType() {
         const owner = this;
         return cacheGeneratorMethod(owner, "getIndexTypeOfType", function (type, kind) {
-            const data = owner.client.apiRequest("getIndexTypeOfTypeByKind", {
-                snapshot: owner.snapshotId,
-                project: owner.project.id,
-                type: type.id,
-                kind,
-            });
-            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            return kind === IndexKind.String ? type.getStringIndexType() : type.getNumberIndexType();
         }, function* (type, kind) {
-            const data = yield* apiRequest("getIndexTypeOfTypeByKind", {
-                snapshot: owner.snapshotId,
-                project: owner.project.id,
-                type: type.id,
-                kind,
-            });
-            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            return kind === IndexKind.String ? (yield* type.getStringIndexType.gen()) : (yield* type.getNumberIndexType.gen());
         });
     }
     get getTypeOfPropertyOfType() {
@@ -3951,6 +4083,10 @@ class TypeObject {
     extendsType;
     baseType;
     substConstraint;
+    typeParameter;
+    constraintType;
+    nameType;
+    templateType;
     // Cached results of lazy fetches, not included in TypeResponse
     // (typically because they require some amount of computation or
     // could cause an arbitrarily large number of types to be cached
@@ -3969,6 +4105,7 @@ class TypeObject {
     constructSignatures;
     indexInfos;
     baseTypes;
+    types;
     stringIndexType;
     numberIndexType;
     constructor(data, objectRegistry) {
@@ -4044,6 +4181,14 @@ class TypeObject {
             this.baseType = data.baseType;
         if (data.substConstraint !== undefined)
             this.substConstraint = data.substConstraint;
+        if (data.typeParameter !== undefined)
+            this.typeParameter = data.typeParameter;
+        if (data.constraintType !== undefined)
+            this.constraintType = data.constraintType;
+        if (data.nameType !== undefined)
+            this.nameType = data.nameType;
+        if (data.templateType !== undefined)
+            this.templateType = data.templateType;
         this.trueType = false;
         this.falseType = false;
         this.constraint = false;
@@ -4057,6 +4202,7 @@ class TypeObject {
         this.constructSignatures = false;
         this.indexInfos = false;
         this.baseTypes = false;
+        this.types = false;
         this.stringIndexType = false;
         this.numberIndexType = false;
     }
@@ -4271,7 +4417,10 @@ class TypeObject {
             if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
                 return undefined;
             }
-            return owner.objectRegistry.fetchTypes(owner, "getTypesOfType");
+            if (owner.types === false) {
+                owner.types = owner.objectRegistry.fetchTypes(owner, "getTypesOfType");
+            }
+            return owner.types;
         }, function* () {
             // Only union, intersection, and template literal types have constituent
             // types; any other kind has none, so return undefined rather than sending
@@ -4279,7 +4428,10 @@ class TypeObject {
             if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
                 return undefined;
             }
-            return yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypesOfType");
+            if (owner.types === false) {
+                owner.types = yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypesOfType");
+            }
+            return owner.types;
         });
     }
     get getTypeParameters() {
@@ -4322,6 +4474,38 @@ class TypeObject {
             return yield* owner.objectRegistry.fetchTypes.gen(owner, "getAliasTypeArgumentsOfType", owner.aliasTypeArguments);
         });
     }
+    get getTypeParameter() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeParameter", function () {
+            return owner.objectRegistry.fetchType(owner, "getTypeParameterOfMappedType", owner.typeParameter);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getTypeParameterOfMappedType", owner.typeParameter);
+        });
+    }
+    get getConstraintType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConstraintType", function () {
+            return owner.objectRegistry.fetchType(owner, "getConstraintTypeOfMappedType", owner.constraintType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getConstraintTypeOfMappedType", owner.constraintType);
+        });
+    }
+    get getNameType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNameType", function () {
+            return owner.objectRegistry.fetchOptionalType(owner, "getNameTypeOfMappedType", owner.nameType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchOptionalType.gen(owner, "getNameTypeOfMappedType", owner.nameType);
+        });
+    }
+    get getTemplateType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTemplateType", function () {
+            return owner.objectRegistry.fetchType(owner, "getTemplateTypeOfMappedType", owner.templateType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getTemplateTypeOfMappedType", owner.templateType);
+        });
+    }
     get getObjectType() {
         const owner = this;
         return cacheGeneratorMethod(owner, "getObjectType", function () {
@@ -4507,6 +4691,9 @@ class TypeObject {
     isTypeParameter() {
         return isTypeParameter(this);
     }
+    isMappedType() {
+        return !!(this.flags & TypeFlags.Object) && !!(this.objectFlags & ObjectFlags.Mapped);
+    }
 }
 export function isUnionType(type) {
     return (type.flags & TypeFlags.Union) !== 0;