@esportsplus/typescript 0.29.6 → 0.31.1

package/build/compiler/coordinator.js

@@ -1,6 +1,8 @@
-import { ts } from '../index.js';
+import { isImportDeclaration } from 'typescript/unstable/ast/is';
 import imports from './imports.js';
 import languageService from './language-service.js';
+import sourcemap from './sourcemap.js';
+import uid from './uid.js';
 function applyImports(code, file, intents) {
     let merged = new Map();
     for (let i = 0, n = intents.length; i < n; i++) {
@@ -24,33 +26,35 @@ function applyImports(code, file, intents) {
             });
         }
     }
-    let keys = [...merged.keys()];
+    let edits = [], keys = [...merged.keys()];
     for (let i = 0, n = keys.length; i < n; i++) {
-        code = modify(code, file, keys[i], merged.get(keys[i]));
-        if (i < n - 1) {
-            file = ts.createSourceFile(file.fileName, code, file.languageVersion, true);
-        }
+        let result = modify(code, file, keys[i], merged.get(keys[i]));
+        edits.push(...result.edits);
+    }
+    if (edits.length === 0) {
+        return { batches: [], code };
     }
-    return code;
+    return { batches: [{ before: code, edits }], code: replaceReverse(code, edits) };
 }
 function applyIntents(code, file, intents) {
     if (intents.length === 0) {
-        return code;
+        return { code, edits: [] };
     }
-    return replaceReverse(code, intents.map(intent => ({
+    let edits = intents.map(intent => ({
         end: intent.node.end,
         newText: intent.generate(file),
         start: intent.node.getStart(file)
-    })));
+    }));
+    return { code: replaceReverse(code, edits), edits };
 }
 function applyPrepend(code, file, prepend) {
     if (prepend.length === 0) {
-        return code;
+        return { code, edits: [] };
     }
     let position = 0;
     for (let i = 0, n = file.statements.length; i < n; i++) {
         let stmt = file.statements[i];
-        if (ts.isImportDeclaration(stmt)) {
+        if (isImportDeclaration(stmt)) {
             position = stmt.end;
         }
         else {
@@ -58,9 +62,11 @@ function applyPrepend(code, file, prepend) {
         }
     }
     if (position === 0) {
-        return prepend.join('\n') + '\n' + code;
+        let newText = prepend.join('\n') + '\n';
+        return { code: newText + code, edits: [{ end: 0, newText, start: 0 }] };
     }
-    return code.slice(0, position) + '\n' + prepend.join('\n') + '\n' + code.slice(position);
+    let newText = '\n' + prepend.join('\n') + '\n';
+    return { code: code.slice(0, position) + newText + code.slice(position), edits: [{ end: position, newText, start: position }] };
 }
 function hasPattern(code, patterns) {
     for (let i = 0, n = patterns.length; i < n; i++) {
@@ -72,9 +78,12 @@ function hasPattern(code, patterns) {
 }
 function modify(code, file, pkg, options) {
     if (!options.add && !options.namespace && !options.remove) {
-        return code;
+        return { code, edits: [] };
     }
     let { namespace } = options, add = options.add ? new Set(options.add) : null, found = imports.all(file, pkg);
+    if (namespace && !add && !options.remove && found.some(info => info.namespace === namespace)) {
+        return { code, edits: [] };
+    }
     if (found.length === 0) {
         let statements = [];
         if (namespace) {
@@ -84,11 +93,12 @@ function modify(code, file, pkg, options) {
             statements.push(`import { ${[...add].sort().join(', ')} } from '${pkg}';`);
         }
         if (statements.length === 0) {
-            return code;
+            return { code, edits: [] };
         }
-        return statements.join('\n') + '\n' + code;
+        let newText = statements.join('\n') + '\n';
+        return { code: newText + code, edits: [{ end: 0, newText, start: 0 }] };
     }
-    let remove = options.remove ? new Set(options.remove) : null, specifiers = new Set();
+    let remove = options.remove ? new Set(options.remove) : null, specifiers = new Set(), nonNamespace = found.filter(info => !info.namespace), existingNamespace = found.some(info => info.namespace === namespace), defaultImport = nonNamespace.find(info => info.defaultName), target = defaultImport ?? nonNamespace[0];
     for (let i = 0, n = found.length; i < n; i++) {
         for (let [name, alias] of found[i].specifiers) {
             if (!remove || (!remove.has(name) && !remove.has(alias))) {
@@ -103,21 +113,35 @@ function modify(code, file, pkg, options) {
         }
     }
     let statements = [];
-    if (namespace) {
+    if (namespace && !existingNamespace) {
         statements.push(`import * as ${namespace} from '${pkg}';`);
     }
-    if (specifiers.size > 0) {
+    if (target) {
+        let named = specifiers.size > 0 ? `{ ${[...specifiers].sort().join(', ')} }` : '', defaultName = target.defaultName, clause = defaultName && named ? `${defaultName}, ${named}` : defaultName ?? named;
+        if (clause) {
+            statements.push(`import ${clause} from '${pkg}';`);
+        }
+    }
+    else if (specifiers.size > 0) {
         statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${pkg}';`);
     }
     let replacements = [];
     for (let i = 0, n = found.length; i < n; i++) {
+        let info = found[i];
+        if (info.namespace) {
+            continue;
+        }
         replacements.push({
-            end: found[i].end,
-            newText: i === 0 ? statements.join('\n') : '',
-            start: found[i].start
+            end: info.end,
+            newText: info === target ? statements.join('\n') : info.defaultName ? `import ${info.defaultName} from '${pkg}';` : '',
+            start: info.start
         });
     }
-    return replaceReverse(code, replacements);
+    if (!target && statements.length > 0) {
+        let first = found[0];
+        replacements.push({ end: first.start, newText: statements.join('\n') + '\n', start: first.start });
+    }
+    return { code: replaceReverse(code, replacements), edits: replacements };
 }
 function replaceReverse(code, replacements) {
     if (replacements.length === 0) {
@@ -138,53 +162,63 @@ function replaceReverse(code, replacements) {
     }
     return parts.reverse().join('');
 }
-const transform = (plugins, code, file, program, root, shared) => {
+const transform = (plugins, code, file, project, root, shared) => {
     if (plugins.length === 0) {
-        return { changed: false, code, sourceFile: file };
+        return { changed: false, code, map: { generations: [] } };
     }
-    let changed = false, currentCode = code, currentFile = file, currentProgram = program, fileName = file.fileName, last = plugins.length - 1;
+    uid.scope(root, file.fileName, code);
+    let changed = false, currentCode = code, currentFile = file, currentProject = project, fileName = file.fileName, generations = [], last = plugins.length - 1;
     for (let i = 0, n = plugins.length; i < n; i++) {
         let plugin = plugins[i];
         if (plugin.patterns && !hasPattern(currentCode, plugin.patterns)) {
             continue;
         }
         let { imports, prepend, replacements } = plugin.transform({
-            checker: currentProgram.getTypeChecker(),
+            checker: currentProject.checker,
             code: currentCode,
-            program: currentProgram,
+            program: currentProject.program,
             shared,
             sourceFile: currentFile
         }), pluginChanged = false;
         if (replacements?.length) {
-            currentCode = applyIntents(currentCode, currentFile, replacements);
+            let before = currentCode, result = applyIntents(currentCode, currentFile, replacements);
+            if (result.edits.length > 0) {
+                generations.push(sourcemap.buildGeneration(before, result.edits));
+            }
+            currentCode = result.code;
             pluginChanged = true;
         }
         if (prepend?.length) {
             if (pluginChanged) {
-                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+                currentFile = languageService.parse(fileName, currentCode);
             }
-            currentCode = applyPrepend(currentCode, currentFile, prepend);
+            let before = currentCode, result = applyPrepend(currentCode, currentFile, prepend);
+            if (result.edits.length > 0) {
+                generations.push(sourcemap.buildGeneration(before, result.edits));
+            }
+            currentCode = result.code;
             pluginChanged = true;
         }
         if (imports?.length) {
             if (pluginChanged) {
-                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+                currentFile = languageService.parse(fileName, currentCode);
+            }
+            let result = applyImports(currentCode, currentFile, imports);
+            for (let j = 0, m = result.batches.length; j < m; j++) {
+                generations.push(sourcemap.buildGeneration(result.batches[j].before, result.batches[j].edits));
             }
-            currentCode = applyImports(currentCode, currentFile, imports);
+            currentCode = result.code;
             pluginChanged = true;
         }
         if (pluginChanged) {
             changed = true;
             if (i < last) {
-                currentProgram = languageService.update(root, fileName, currentCode);
-                currentFile = currentProgram.getSourceFile(fileName) ||
-                    ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
-            }
-            else {
-                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+                currentProject = languageService.update(project.configPath ?? languageService.findConfig(root) ?? root, fileName, currentCode);
+                currentFile = currentProject.program.getSourceFile(fileName) ??
+                    languageService.parse(fileName, currentCode);
             }
         }
     }
-    return { changed, code: currentCode, sourceFile: currentFile };
+    return { changed, code: currentCode, map: { generations } };
 };
 export default { transform };

package/build/compiler/imports.d.ts

@@ -1,6 +1,9 @@
-import { ts } from '../index.js';
+import type { Node, SourceFile } from 'typescript/unstable/ast';
+import type { Checker } from 'typescript/unstable/sync';
 type ImportInfo = {
+    defaultName?: string;
     end: number;
+    namespace?: string;
     specifiers: Map<string, string>;
     typeOnly: Set<string>;
     start: number;
@@ -10,9 +13,11 @@ type ModifyOptions = {
     namespace?: string;
     remove?: Iterable<string>;
 };
+declare const all: (file: SourceFile, pkg: string) => ImportInfo[];
+declare const includes: (checker: Checker, node: Node, pkg: string, symbolName?: string) => boolean;
 declare const _default: {
-    all: (file: ts.SourceFile, pkg: string) => ImportInfo[];
-    includes: (checker: ts.TypeChecker, node: ts.Node, pkg: string, symbolName?: string) => boolean;
+    all: typeof all;
+    includes: typeof includes;
 };
 export default _default;
 export type { ImportInfo, ModifyOptions };

package/build/compiler/imports.js

@@ -1,4 +1,6 @@
-import { ts } from '../index.js';
+import { SyntaxKind } from 'typescript/unstable/ast';
+import { isIdentifier, isImportDeclaration, isNamedImports, isNamespaceImport, isStringLiteral } from 'typescript/unstable/ast/is';
+import { SymbolFlags } from 'typescript/unstable/sync';
 let cache = new WeakMap();
 function fileNameMatchesPackage(fileName, pkg) {
     let normalized = fileName.replace(/\\/g, '/'), marker = `/node_modules/${pkg}/`;
@@ -8,15 +10,15 @@ const all = (file, pkg) => {
     let imports = [];
     for (let i = 0, n = file.statements.length; i < n; i++) {
         let stmt = file.statements[i];
-        if (!ts.isImportDeclaration(stmt)) {
+        if (!isImportDeclaration(stmt)) {
             continue;
         }
         let moduleSpecifier = stmt.moduleSpecifier;
-        if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
+        if (!isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
             continue;
         }
-        let bindings = stmt.importClause?.namedBindings, declTypeOnly = stmt.importClause?.isTypeOnly ?? false, specifiers = new Map(), typeOnly = new Set();
-        if (bindings && ts.isNamedImports(bindings)) {
+        let bindings = stmt.importClause?.namedBindings, declTypeOnly = stmt.importClause?.phaseModifier === SyntaxKind.TypeKeyword, specifiers = new Map(), typeOnly = new Set();
+        if (bindings && isNamedImports(bindings)) {
             for (let j = 0, m = bindings.elements.length; j < m; j++) {
                 let element = bindings.elements[j], name = element.name.text, propertyName = element.propertyName?.text || name;
                 specifiers.set(propertyName, name);
@@ -25,12 +27,19 @@ const all = (file, pkg) => {
                 }
             }
         }
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file), typeOnly });
+        imports.push({
+            defaultName: stmt.importClause?.name?.text,
+            end: stmt.end,
+            namespace: bindings && isNamespaceImport(bindings) ? bindings.name.text : undefined,
+            specifiers,
+            start: stmt.getStart(file),
+            typeOnly
+        });
     }
     return imports;
 };
 const includes = (checker, node, pkg, symbolName) => {
-    if (!ts.isIdentifier(node)) {
+    if (!isIdentifier(node)) {
         return false;
     }
     if (symbolName && node.text !== symbolName) {
@@ -55,54 +64,55 @@ const includes = (checker, node, pkg, symbolName) => {
     if (names.has(node.text)) {
         let symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
-            let declarations = symbol.getDeclarations();
+            let declarations = symbol.declarations;
             if (declarations && declarations.length > 0) {
                 for (let i = 0, n = declarations.length; i < n; i++) {
-                    let decl = declarations[i];
-                    if (ts.isImportSpecifier(decl)) {
-                        let importDecl = decl.parent?.parent?.parent;
-                        if (importDecl && ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
-                            if (importDecl.moduleSpecifier.text === pkg) {
-                                return true;
+                    let handle = declarations[i];
+                    if (handle.kind === SyntaxKind.ImportSpecifier) {
+                        let decl = handle.resolve();
+                        if (decl) {
+                            let importDecl = decl.parent?.parent?.parent;
+                            if (importDecl && isImportDeclaration(importDecl) && isStringLiteral(importDecl.moduleSpecifier)) {
+                                if (importDecl.moduleSpecifier.text === pkg) {
+                                    return true;
+                                }
                             }
                         }
                     }
-                    if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
+                    if (fileNameMatchesPackage(handle.path, pkg)) {
                         return true;
                     }
                 }
             }
         }
-        return true;
+        return false;
     }
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) {
         return false;
     }
-    let declarations = symbol.getDeclarations();
+    let declarations = symbol.declarations;
     if (declarations && declarations.length > 0) {
         for (let i = 0, n = declarations.length; i < n; i++) {
-            let decl = declarations[i];
-            if (fileNameMatchesPackage(decl.getSourceFile().fileName, pkg)) {
+            let handle = declarations[i];
+            if (fileNameMatchesPackage(handle.path, pkg)) {
                 return true;
             }
         }
     }
-    try {
+    if ((symbol.flags & SymbolFlags.Alias) !== 0) {
         let aliased = checker.getAliasedSymbol(symbol);
         if (aliased && aliased !== symbol) {
-            let aliasedDecls = aliased.getDeclarations();
+            let aliasedDecls = aliased.declarations;
             if (aliasedDecls) {
                 for (let i = 0, n = aliasedDecls.length; i < n; i++) {
-                    if (fileNameMatchesPackage(aliasedDecls[i].getSourceFile().fileName, pkg)) {
+                    if (fileNameMatchesPackage(aliasedDecls[i].path, pkg)) {
                         return true;
                     }
                 }
             }
         }
     }
-    catch {
-    }
     return false;
 };
 export default { all, includes };

package/build/compiler/index.d.ts

@@ -2,6 +2,9 @@ export { default as ast } from './ast.js';
 export { default as code } from './code.js';
 export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';
+export { default as languageService } from './language-service.js';
 export { default as plugin } from './plugins/index.js';
 export { default as uid } from './uid.js';
+export type { OffsetAnchor, PositionMapping, SourceMapV3 } from './sourcemap.js';
+export type { ScratchResult, UpdateResult } from './language-service.js';
 export type * from './types.js';

package/build/compiler/index.js

@@ -2,5 +2,6 @@ export { default as ast } from './ast.js';
 export { default as code } from './code.js';
 export { default as coordinator } from './coordinator.js';
 export { default as imports } from './imports.js';
+export { default as languageService } from './language-service.js';
 export { default as plugin } from './plugins/index.js';
 export { default as uid } from './uid.js';

package/build/compiler/language-service.d.ts

@@ -1,9 +1,39 @@
-import { ts } from '../index.js';
-declare const invalidate: (root: string, fileName: string) => void;
-declare const update: (root: string, fileName: string, content: string) => ts.Program;
+import type { SourceFile } from 'typescript/unstable/ast';
+import type { FileSystem } from 'typescript/unstable/fs';
+import { API, type Checker, type Program, type Project, type Snapshot } from 'typescript/unstable/sync';
+type ScratchResult = {
+    checker: Checker;
+    program: Program;
+    sourceFile: SourceFile;
+};
+type UpdateResult = {
+    checker: Checker;
+    program: Program;
+};
+type OpenProject = {
+    api: API;
+    dispose: () => void;
+    project: Project;
+    snapshot: Snapshot;
+};
+declare function open(configPath: string, overlay?: FileSystem): OpenProject;
+declare const dispose: (root?: string) => void;
+declare const findConfig: (startDir: string) => string | null;
+declare const invalidate: (configFileName: string, fileName: string) => void;
+declare const parse: (fileName: string, content: string) => SourceFile;
+declare const scratch: (fileName: string, content: string) => ScratchResult;
+declare const update: (configFileName: string, fileName: string, content: string) => UpdateResult;
+declare const updateMany: (configFileName: string, updates: Map<string, string>) => UpdateResult;
 declare const _default: {
-    invalidate: (root: string, fileName: string) => void;
-    update: (root: string, fileName: string, content: string) => ts.Program;
+    dispose: typeof dispose;
+    findConfig: typeof findConfig;
+    invalidate: typeof invalidate;
+    open: typeof open;
+    parse: typeof parse;
+    scratch: typeof scratch;
+    update: typeof update;
+    updateMany: typeof updateMany;
 };
 export default _default;
-export { invalidate, update };
+export { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };
+export type { ScratchResult, UpdateResult };