@esportsplus/typescript 0.28.5 → 0.29.0

package/build/cli/tsc.js

@@ -22,7 +22,7 @@ async function build(config, tsconfig, pluginConfigs) {
         if (!sourceFile) {
             continue;
         }
-        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, shared);
+        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, root, shared);
         if (result.changed) {
             transformedFiles.set(normalizePath(fileName), result.code);
         }

package/build/compiler/coordinator.d.ts

@@ -6,8 +6,7 @@ type CoordinatorResult = {
     sourceFile: ts.SourceFile;
 };
 declare const _default: {
-    createPatchedProgram: (baseProgram: ts.Program, fileName: string, newContent: string) => ts.Program;
-    transform: (plugins: Plugin[], code: string, file: ts.SourceFile, program: ts.Program, shared: SharedContext) => {
+    transform: (plugins: Plugin[], code: string, file: ts.SourceFile, program: ts.Program, root: string, shared: SharedContext) => {
         changed: boolean;
         code: string;
         sourceFile: ts.SourceFile;

package/build/compiler/coordinator.js

@@ -1,5 +1,6 @@
 import { ts } from '../index.js';
 import imports from './imports.js';
+import languageService from './language-service.js';
 function applyImports(code, file, intents) {
     for (let i = 0, n = intents.length; i < n; i++) {
         let intent = intents[i];
@@ -111,25 +112,11 @@ function replaceReverse(code, replacements) {
     }
     return result;
 }
-const createPatchedProgram = (baseProgram, fileName, newContent) => {
-    let baseHost = ts.createCompilerHost(baseProgram.getCompilerOptions()), options = baseProgram.getCompilerOptions();
-    return ts.createProgram(baseProgram.getRootFileNames(), options, {
-        ...baseHost,
-        getSourceFile: (name, languageVersion) => {
-            if (name === fileName || name === fileName.replace(/\\/g, '/')) {
-                return ts.createSourceFile(name, newContent, languageVersion, true);
-            }
-            return baseProgram.getSourceFile(name) ?? baseHost.getSourceFile(name, languageVersion);
-        },
-        fileExists: (name) => baseHost.fileExists(name),
-        readFile: (name) => name === fileName ? newContent : baseHost.readFile(name)
-    }, baseProgram);
-};
-const transform = (plugins, code, file, program, shared) => {
+const transform = (plugins, code, file, program, root, shared) => {
     if (plugins.length === 0) {
         return { changed: false, code, sourceFile: file };
     }
-    let changed = false, currentCode = code, currentFile = file, currentProgram = program, fileName = file.fileName;
+    let changed = false, currentCode = code, currentFile = file, currentProgram = program, fileName = file.fileName, 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)) {
@@ -156,8 +143,8 @@ const transform = (plugins, code, file, program, shared) => {
         }
         if (pluginChanged) {
             changed = true;
-            if (i < n - 1) {
-                currentProgram = createPatchedProgram(program, fileName, currentCode);
+            if (i < last) {
+                currentProgram = languageService.update(root, fileName, currentCode);
                 currentFile = currentProgram.getSourceFile(fileName) ||
                     ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
             }
@@ -168,4 +155,4 @@ const transform = (plugins, code, file, program, shared) => {
     }
     return { changed, code: currentCode, sourceFile: currentFile };
 };
-export default { createPatchedProgram, transform };
+export default { transform };

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

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+declare const get: (root: string) => ts.Program;
+declare const invalidate: (root: string, fileName: string) => void;
+declare const update: (root: string, fileName: string, content: string) => ts.Program;
+declare const _default: {
+    delete: (root: string) => void;
+    get: (root: string) => ts.Program;
+    invalidate: (root: string, fileName: string) => void;
+    update: (root: string, fileName: string, content: string) => ts.Program;
+};
+export default _default;
+export { get, invalidate, update };

package/build/compiler/language-service.js

@@ -0,0 +1,83 @@
+import path from 'path';
+import ts from 'typescript';
+import { PACKAGE_NAME } from '../constants.js';
+let cache = new Map();
+function create(root) {
+    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+    if (!tsconfig) {
+        throw new Error(`${PACKAGE_NAME}: tsconfig.json not found`);
+    }
+    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    if (file.error) {
+        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
+    }
+    let parsed = ts.parseJsonConfigFileContent(file.config, ts.sys, path.dirname(tsconfig));
+    if (parsed.errors.length > 0) {
+        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
+    }
+    let contents = new Map(), rootFiles = new Set(parsed.fileNames.map(f => f.replace(/\\/g, '/'))), versions = new Map();
+    for (let fileName of rootFiles) {
+        versions.set(fileName, 0);
+    }
+    let host = {
+        fileExists: ts.sys.fileExists,
+        getCompilationSettings: () => parsed.options,
+        getCurrentDirectory: () => root,
+        getDefaultLibFileName: ts.getDefaultLibFilePath,
+        getScriptFileNames: () => [...rootFiles],
+        getScriptSnapshot: (fileName) => {
+            let content = contents.get(fileName);
+            if (content !== undefined) {
+                return ts.ScriptSnapshot.fromString(content);
+            }
+            if (!ts.sys.fileExists(fileName)) {
+                return undefined;
+            }
+            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName) || '');
+        },
+        getScriptVersion: (fileName) => String(versions.get(fileName) || 0),
+        readFile: ts.sys.readFile
+    };
+    return { contents, host, rootFiles, service: ts.createLanguageService(host), versions };
+}
+function getEntry(root) {
+    let entry = cache.get(root);
+    if (!entry) {
+        entry = create(root);
+        cache.set(root, entry);
+    }
+    return entry;
+}
+const del = (root) => {
+    cache.delete(root);
+};
+const get = (root) => {
+    let entry = getEntry(root), program = entry.service.getProgram();
+    if (!program) {
+        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    }
+    return program;
+};
+const invalidate = (root, fileName) => {
+    let entry = cache.get(root);
+    if (entry) {
+        let normalized = fileName.replace(/\\/g, '/');
+        entry.contents.delete(normalized);
+        entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+    }
+};
+const update = (root, fileName, content) => {
+    let entry = getEntry(root), normalized = fileName.replace(/\\/g, '/');
+    if (!entry.rootFiles.has(normalized)) {
+        entry.rootFiles.add(normalized);
+    }
+    entry.contents.set(normalized, content);
+    entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+    let program = entry.service.getProgram();
+    if (!program) {
+        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    }
+    return program;
+};
+export default { delete: del, get, invalidate, update };
+export { get, invalidate, update };

package/build/compiler/plugins/vite.js

@@ -1,9 +1,8 @@
 import { ts } from '../../index.js';
 import coordinator from '../coordinator.js';
-import program from '../program.js';
-const FILE_REGEX = /\.[tj]sx?$/;
+import languageService from '../language-service.js';
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
-const LINE_ENDINGS_REGEX = /\r\n/g;
+const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
 export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
@@ -18,15 +17,11 @@ export default ({ name, onWatchChange, plugins }) => {
                     return null;
                 }
                 try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = program.get(root || ''), sourceFile = prog.getSourceFile(normalizedId) || prog.getSourceFile(id);
-                    if (sourceFile && sourceFile.getText().replace(LINE_ENDINGS_REGEX, '\n') !== code.replace(LINE_ENDINGS_REGEX, '\n')) {
-                        sourceFile = undefined;
-                    }
+                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = languageService.update(root || '', normalizedId, code), sourceFile = prog.getSourceFile(normalizedId);
                     if (!sourceFile) {
-                        prog = coordinator.createPatchedProgram(prog, normalizedId, code);
-                        sourceFile = prog.getSourceFile(normalizedId) || ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                        sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, prog, contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''));
+                    let result = coordinator.transform(plugins, code, sourceFile, prog, root || '', contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || ''));
                     if (!result.changed) {
                         return null;
                     }
@@ -41,7 +36,7 @@ export default ({ name, onWatchChange, plugins }) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    program.delete(root || '');
+                    languageService.invalidate(root || '', id);
                 }
             }
         };

package/package.json

@@ -39,7 +39,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.28.5",
+  "version": "0.29.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/cli/tsc.ts

@@ -54,6 +54,7 @@ async function build(config: object, tsconfig: string, pluginConfigs: PluginConf
             sourceFile.getFullText(),
             sourceFile,
             program,
+            root,
             shared
         );
 

package/src/compiler/coordinator.ts

@@ -1,6 +1,7 @@
 import type { ImportIntent, Plugin, Replacement, ReplacementIntent, SharedContext } from './types';
 import { ts } from '~/index';
 import imports, { ModifyOptions } from './imports';
+import languageService from './language-service';
 
 
 type CoordinatorResult = {
@@ -169,33 +170,12 @@ function replaceReverse(code: string, replacements: Replacement[]): string {
 }
 
 
-const createPatchedProgram = (baseProgram: ts.Program, fileName: string, newContent: string) => {
-    let baseHost = ts.createCompilerHost(baseProgram.getCompilerOptions()),
-        options = baseProgram.getCompilerOptions();
-
-    return ts.createProgram(
-        baseProgram.getRootFileNames(),
-        options,
-        {
-            ...baseHost,
-            getSourceFile: (name, languageVersion) => {
-                if (name === fileName || name === fileName.replace(/\\/g, '/')) {
-                    return ts.createSourceFile(name, newContent, languageVersion, true);
-                }
-                return baseProgram.getSourceFile(name) ?? baseHost.getSourceFile(name, languageVersion);
-            },
-            fileExists: (name) => baseHost.fileExists(name),
-            readFile: (name) => name === fileName ? newContent : baseHost.readFile(name)
-        },
-        baseProgram
-    );
-};
-
 const transform = (
     plugins: Plugin[],
     code: string,
     file: ts.SourceFile,
     program: ts.Program,
+    root: string,
     shared: SharedContext
 ) => {
     if (plugins.length === 0) {
@@ -206,7 +186,8 @@ const transform = (
         currentCode = code,
         currentFile = file,
         currentProgram = program,
-        fileName = file.fileName;
+        fileName = file.fileName,
+        last = plugins.length - 1;
 
     for (let i = 0, n = plugins.length; i < n; i++) {
         let plugin = plugins[i];
@@ -241,9 +222,9 @@ const transform = (
 
         if (pluginChanged) {
             changed = true;
-            // Create patched program for next plugin
-            if (i < n - 1) {
-                currentProgram = createPatchedProgram(program, fileName, currentCode);
+
+            if (i < last) {
+                currentProgram = languageService.update(root, fileName, currentCode);
                 currentFile = currentProgram.getSourceFile(fileName) ||
                     ts.createSourceFile(fileName, currentCode, file.languageVersion, true);
             }
@@ -257,5 +238,5 @@ const transform = (
 };
 
 
-export default { createPatchedProgram, transform };
+export default { transform };
 export type { CoordinatorResult };

package/src/compiler/language-service.ts

@@ -0,0 +1,135 @@
+import path from 'path';
+import ts from 'typescript';
+import { PACKAGE_NAME } from '~/constants';
+
+
+type LanguageServiceEntry = {
+    contents: Map<string, string>;
+    host: ts.LanguageServiceHost;
+    rootFiles: Set<string>;
+    service: ts.LanguageService;
+    versions: Map<string, number>;
+};
+
+
+let cache = new Map<string, LanguageServiceEntry>();
+
+
+function create(root: string): LanguageServiceEntry {
+    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+
+    if (!tsconfig) {
+        throw new Error(`${PACKAGE_NAME}: tsconfig.json not found`);
+    }
+
+    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
+
+    if (file.error) {
+        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
+    }
+
+    let parsed = ts.parseJsonConfigFileContent(
+            file.config,
+            ts.sys,
+            path.dirname(tsconfig)
+        );
+
+    if (parsed.errors.length > 0) {
+        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
+    }
+
+    let contents = new Map<string, string>(),
+        rootFiles = new Set(parsed.fileNames.map(f => f.replace(/\\/g, '/'))),
+        versions = new Map<string, number>();
+
+    for (let fileName of rootFiles) {
+        versions.set(fileName, 0);
+    }
+
+    let host: ts.LanguageServiceHost = {
+        fileExists: ts.sys.fileExists,
+        getCompilationSettings: () => parsed.options,
+        getCurrentDirectory: () => root,
+        getDefaultLibFileName: ts.getDefaultLibFilePath,
+        getScriptFileNames: () => [...rootFiles],
+        getScriptSnapshot: (fileName: string) => {
+            let content = contents.get(fileName);
+
+            if (content !== undefined) {
+                return ts.ScriptSnapshot.fromString(content);
+            }
+
+            if (!ts.sys.fileExists(fileName)) {
+                return undefined;
+            }
+
+            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName) || '');
+        },
+        getScriptVersion: (fileName: string) => String(versions.get(fileName) || 0),
+        readFile: ts.sys.readFile
+    };
+
+    return { contents, host, rootFiles, service: ts.createLanguageService(host), versions };
+}
+
+function getEntry(root: string): LanguageServiceEntry {
+    let entry = cache.get(root);
+
+    if (!entry) {
+        entry = create(root);
+        cache.set(root, entry);
+    }
+
+    return entry;
+}
+
+
+const del = (root: string): void => {
+    cache.delete(root);
+};
+
+const get = (root: string): ts.Program => {
+    let entry = getEntry(root),
+        program = entry.service.getProgram();
+
+    if (!program) {
+        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    }
+
+    return program;
+};
+
+const invalidate = (root: string, fileName: string): void => {
+    let entry = cache.get(root);
+
+    if (entry) {
+        let normalized = fileName.replace(/\\/g, '/');
+
+        entry.contents.delete(normalized);
+        entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+    }
+};
+
+const update = (root: string, fileName: string, content: string): ts.Program => {
+    let entry = getEntry(root),
+        normalized = fileName.replace(/\\/g, '/');
+
+    if (!entry.rootFiles.has(normalized)) {
+        entry.rootFiles.add(normalized);
+    }
+
+    entry.contents.set(normalized, content);
+    entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+
+    let program = entry.service.getProgram();
+
+    if (!program) {
+        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    }
+
+    return program;
+};
+
+
+export default { delete: del, get, invalidate, update };
+export { get, invalidate, update };

package/src/compiler/plugins/vite.ts

@@ -2,7 +2,7 @@ import type { ResolvedConfig } from 'vite';
 import type { Plugin, SharedContext } from '../types';
 import { ts } from '~/index';
 import coordinator from '../coordinator';
-import program from '../program';
+import languageService from '../language-service';
 
 
 type VitePlugin = {
@@ -20,11 +20,9 @@ type VitePluginOptions = {
 };
 
 
-const FILE_REGEX = /\.[tj]sx?$/;
-
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
 
-const LINE_ENDINGS_REGEX = /\r\n/g;
+const FILE_REGEX = /\.[tj]sx?$/;
 
 
 let contexts = new Map<string, SharedContext>();
@@ -45,17 +43,11 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
 
                 try {
                     let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'),
-                        prog = program.get(root || ''),
-                        sourceFile = prog.getSourceFile(normalizedId) || prog.getSourceFile(id);
-
-                    // Check if file content matches (existing file may have changed)
-                    if (sourceFile && sourceFile.getText().replace(LINE_ENDINGS_REGEX, '\n') !== code.replace(LINE_ENDINGS_REGEX, '\n')) {
-                        sourceFile = undefined;
-                    }
+                        prog = languageService.update(root || '', normalizedId, code),
+                        sourceFile = prog.getSourceFile(normalizedId);
 
                     if (!sourceFile) {
-                        prog = coordinator.createPatchedProgram(prog, normalizedId, code);
-                        sourceFile = prog.getSourceFile(normalizedId) || ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
+                        sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true);
                     }
 
                     let result = coordinator.transform(
@@ -63,6 +55,7 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                             code,
                             sourceFile,
                             prog,
+                            root || '',
                             contexts.get(root || '') ?? contexts.set(root || '', new Map()).get(root || '')!
                         );
 
@@ -81,7 +74,7 @@ export default ({ name, onWatchChange, plugins }: VitePluginOptions) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    program.delete(root || '');
+                    languageService.invalidate(root || '', id);
                 }
             }
         };

package/build/compiler/program.d.ts

@@ -1,6 +0,0 @@
-import ts from 'typescript';
-declare const _default: {
-    get: (root: string) => ts.Program;
-    delete: (root: string) => void;
-};
-export default _default;

package/build/compiler/program.js

@@ -1,34 +0,0 @@
-import path from 'path';
-import ts from 'typescript';
-import { PACKAGE_NAME } from '../constants.js';
-let cache = new Map();
-function create(root) {
-    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
-    if (!tsconfig) {
-        throw new Error('tsconfig.json not found');
-    }
-    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (file.error) {
-        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
-    }
-    let parsed = ts.parseJsonConfigFileContent(file.config, ts.sys, path.dirname(tsconfig));
-    if (parsed.errors.length > 0) {
-        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
-    }
-    return ts.createProgram({
-        options: parsed.options,
-        rootNames: parsed.fileNames
-    });
-}
-const get = (root) => {
-    let program = cache.get(root);
-    if (!program) {
-        program = create(root);
-        cache.set(root, program);
-    }
-    return program;
-};
-const del = (root) => {
-    cache.delete(root);
-};
-export default { get, delete: del };

package/src/compiler/program.ts

@@ -1,55 +0,0 @@
-import path from 'path';
-import ts from 'typescript';
-import { PACKAGE_NAME } from '~/constants';
-
-
-let cache = new Map<string, ts.Program>();
-
-
-function create(root: string): ts.Program {
-    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
-
-    if (!tsconfig) {
-        throw new Error('tsconfig.json not found');
-    }
-
-    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
-
-    if (file.error) {
-        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
-    }
-
-    let parsed = ts.parseJsonConfigFileContent(
-            file.config,
-            ts.sys,
-            path.dirname(tsconfig)
-        );
-
-    if (parsed.errors.length > 0) {
-        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
-    }
-
-    return ts.createProgram({
-        options: parsed.options,
-        rootNames: parsed.fileNames
-    });
-}
-
-
-const get = (root: string): ts.Program => {
-    let program = cache.get(root);
-
-    if (!program) {
-        program = create(root);
-        cache.set(root, program);
-    }
-
-    return program;
-}
-
-const del = (root: string): void => {
-    cache.delete(root);
-}
-
-
-export default { get, delete: del };