@esportsplus/typescript 0.29.5 → 0.31.0

package/build/compiler/ast.js

@@ -1,10 +1,10 @@
-import { ts } from '../index.js';
+import { isIdentifier, isPropertyAccessExpression } from 'typescript/unstable/ast/is';
 const expression = {
     name: (node) => {
-        if (ts.isIdentifier(node)) {
+        if (isIdentifier(node)) {
             return node.text;
         }
-        if (ts.isPropertyAccessExpression(node)) {
+        if (isPropertyAccessExpression(node)) {
             return property.path(node);
         }
         return null;
@@ -22,11 +22,11 @@ const inRange = (ranges, start, end) => {
 const property = {
     path: (node) => {
         let current = node, parts = [];
-        while (ts.isPropertyAccessExpression(current)) {
+        while (isPropertyAccessExpression(current)) {
             parts.push(current.name.text);
             current = current.expression;
         }
-        if (ts.isIdentifier(current)) {
+        if (isIdentifier(current)) {
             parts.push(current.text);
             return parts.reverse().join('.');
         }
@@ -37,6 +37,6 @@ const test = (node, fn) => {
     if (fn(node)) {
         return true;
     }
-    return !!ts.forEachChild(node, child => test(child, fn) || undefined);
+    return !!node.forEachChild(child => test(child, fn) || undefined);
 };
 export default { expression, inRange, property, test };

package/build/compiler/code.d.ts

@@ -1,5 +1,6 @@
-declare const code: {
-    (literals: TemplateStringsArray, ...values: unknown[]): string;
-    escape(str: string): string;
-};
+declare function code(literals: TemplateStringsArray, ...values: unknown[]): string;
+declare namespace code {
+    var _a: (str: string) => string;
+    export { _a as escape };
+}
 export default code;

package/build/compiler/code.js

@@ -1,3 +1,8 @@
+const BACKSLASH_REGEX = /\\/g;
+const CR_REGEX = /\r/g;
+const LINE_SEPARATOR_REGEX = /\u2028/g;
+const NEWLINE_REGEX = /\n/g;
+const PARAGRAPH_SEPARATOR_REGEX = /\u2029/g;
 const SINGLE_QUOTE_REGEX = /'/g;
 const code = (literals, ...values) => {
     let buffer = '';
@@ -12,6 +17,12 @@ const code = (literals, ...values) => {
     return buffer;
 };
 code.escape = (str) => {
-    return str.replace(SINGLE_QUOTE_REGEX, "\\'");
+    return str
+        .replace(BACKSLASH_REGEX, '\\\\')
+        .replace(SINGLE_QUOTE_REGEX, "\\'")
+        .replace(NEWLINE_REGEX, '\\n')
+        .replace(CR_REGEX, '\\r')
+        .replace(LINE_SEPARATOR_REGEX, '\\u2028')
+        .replace(PARAGRAPH_SEPARATOR_REGEX, '\\u2029');
 };
 export default code;

package/build/compiler/coordinator.d.ts

@@ -1,16 +1,26 @@
+import type { SourceFile } from 'typescript/unstable/ast';
+import type { Checker, Program } from 'typescript/unstable/sync';
 import type { Plugin, SharedContext } from './types.js';
-import { ts } from '../index.js';
+import type { OffsetAnchor, PositionMapping } from './sourcemap.js';
 type CoordinatorResult = {
     changed: boolean;
     code: string;
-    sourceFile: ts.SourceFile;
+    map: PositionMapping;
+    sourceFile: SourceFile;
 };
-declare const _default: {
-    transform: (plugins: Plugin[], code: string, file: ts.SourceFile, program: ts.Program, root: string, shared: SharedContext) => {
-        changed: boolean;
-        code: string;
-        sourceFile: ts.SourceFile;
+declare const transform: (plugins: Plugin[], code: string, file: SourceFile, project: {
+    checker: Checker;
+    program: Program;
+}, root: string, shared: SharedContext) => {
+    changed: boolean;
+    code: string;
+    map: {
+        generations: OffsetAnchor[][];
     };
+    sourceFile: SourceFile;
+};
+declare const _default: {
+    transform: typeof transform;
 };
 export default _default;
 export type { CoordinatorResult };

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,38 @@ function applyImports(code, file, intents) {
             });
         }
     }
-    let keys = [...merged.keys()];
+    let batches = [], keys = [...merged.keys()];
     for (let i = 0, n = keys.length; i < n; i++) {
-        code = modify(code, file, keys[i], merged.get(keys[i]));
+        let before = code, result = modify(code, file, keys[i], merged.get(keys[i]));
+        code = result.code;
+        if (result.edits.length > 0) {
+            batches.push({ before, edits: result.edits });
+        }
         if (i < n - 1) {
-            file = ts.createSourceFile(file.fileName, code, file.languageVersion, true);
+            file = languageService.parse(file.fileName, code);
         }
     }
-    return code;
+    return { batches, code };
 }
 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 +65,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,7 +81,7 @@ 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 (found.length === 0) {
@@ -84,15 +93,17 @@ 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();
     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))) {
-                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+                let base = name === alias ? name : `${name} as ${alias}`;
+                specifiers.add(found[i].typeOnly.has(name) ? `type ${base}` : base);
             }
         }
     }
@@ -116,7 +127,7 @@ function modify(code, file, pkg, options) {
             start: found[i].start
         });
     }
-    return replaceReverse(code, replacements);
+    return { code: replaceReverse(code, replacements), edits: replacements };
 }
 function replaceReverse(code, replacements) {
     if (replacements.length === 0) {
@@ -137,53 +148,66 @@ 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: [] }, sourceFile: file };
     }
-    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);
+            }
+            let before = currentCode, result = applyPrepend(currentCode, currentFile, prepend);
+            if (result.edits.length > 0) {
+                generations.push(sourcemap.buildGeneration(before, result.edits));
             }
-            currentCode = applyPrepend(currentCode, currentFile, prepend);
+            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);
+                currentProject = languageService.update(root, fileName, currentCode);
+                currentFile = currentProject.program.getSourceFile(fileName) ??
+                    languageService.parse(fileName, currentCode);
             }
             else {
-                currentFile = ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
+                currentFile = languageService.parse(fileName, currentCode);
             }
         }
     }
-    return { changed, code: currentCode, sourceFile: currentFile };
+    return { changed, code: currentCode, map: { generations }, sourceFile: currentFile };
 };
 export default { transform };

package/build/compiler/imports.d.ts

@@ -1,7 +1,9 @@
-import { ts } from '../index.js';
+import type { Node, SourceFile } from 'typescript/unstable/ast';
+import type { Checker } from 'typescript/unstable/sync';
 type ImportInfo = {
     end: number;
     specifiers: Map<string, string>;
+    typeOnly: Set<string>;
     start: number;
 };
 type ModifyOptions = {
@@ -9,9 +11,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, 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,26 +10,29 @@ 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, specifiers = new Map();
-        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);
+                if (declTypeOnly || element.isTypeOnly) {
+                    typeOnly.add(propertyName);
+                }
             }
         }
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file) });
+        imports.push({ end: stmt.end, 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) {
@@ -52,54 +57,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,28 @@
-import { ts } from '../index.js';
+import type { SourceFile } from 'typescript/unstable/ast';
+import { type Checker, type Program } from 'typescript/unstable/sync';
+type ScratchResult = {
+    checker: Checker;
+    program: Program;
+    sourceFile: SourceFile;
+};
+type UpdateResult = {
+    checker: Checker;
+    program: Program;
+};
+declare const dispose: (root?: string) => void;
+declare const findConfig: (startDir: string) => string | null;
 declare const invalidate: (root: string, fileName: string) => void;
-declare const update: (root: string, fileName: string, content: string) => ts.Program;
+declare const parse: (fileName: string, content: string) => SourceFile;
+declare const scratch: (fileName: string, content: string) => ScratchResult;
+declare const update: (root: string, fileName: string, content: 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;
+    parse: typeof parse;
+    scratch: typeof scratch;
+    update: typeof update;
 };
 export default _default;
-export { invalidate, update };
+export { dispose, findConfig, invalidate, parse, scratch, update };
+export type { ScratchResult, UpdateResult };