@esportsplus/typescript 0.29.6 → 0.31.1

package/build/compiler/language-service.js

@@ -1,73 +1,267 @@
+import { API, DiagnosticCategory } from 'typescript/unstable/sync';
 import { PACKAGE_NAME } from '../constants.js';
-import { ts } from '../index.js';
+import fs from 'fs';
 import path from 'path';
-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);
+const backslashes = /\\/g;
+let cache = new Map(), scratchEntry = null;
+function advance(entry, changed) {
+    let snapshot = entry.api.updateSnapshot({ fileChanges: { changed } });
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.clearSourceFileCache();
+    entry.project = resolveProject(snapshot, entry.configFileName);
+    entry.snapshot = snapshot;
+}
+function advanceScratch(id, content) {
+    if (!scratchEntry) {
+        scratchEntry = createScratch(id);
+    }
+    else if (scratchEntry.file !== id) {
+        reseedScratch(scratchEntry, id);
+    }
+    let entry = scratchEntry;
+    entry.contents.set(id, content);
+    let snapshot = entry.api.updateSnapshot({ fileChanges: { changed: [id] } });
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.clearSourceFileCache();
+    entry.project = resolveProject(snapshot, entry.config);
+    entry.snapshot = snapshot;
+    return entry;
+}
+function createEntry(configFileName) {
+    let root = path.dirname(configFileName);
+    let contents = new Map(), opened = open(configFileName, overlayFileSystem(contents)), { api, project, snapshot } = opened;
+    for (let diagnostic of project.program.getConfigFileParsingDiagnostics()) {
+        if (diagnostic.category === DiagnosticCategory.Error) {
+            snapshot.dispose();
+            api.close();
+            throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${diagnostic.text}`);
+        }
+    }
+    return { api, configFileName, contents, pending: new Set(), project, root, seen: seed(project.program), snapshot };
+}
+function createScratch(file) {
+    let config = normalize(process.cwd()) + '/tsconfig.tsparse.json', contents = new Map();
+    contents.set(config, scratchConfig(file));
+    let api = new API({ cwd: process.cwd(), fs: overlayFileSystem(contents) }), snapshot = api.updateSnapshot({ openProjects: [config] }), project = resolveProject(snapshot, config);
+    return { api, config, contents, file, project, snapshot };
+}
+function disposeEntry(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+}
+function disposeScratch(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+}
+function getEntry(configFileName) {
+    let entry = cache.get(configFileName);
+    if (!entry) {
+        entry = createEntry(configFileName);
+        cache.set(configFileName, entry);
+    }
+    return entry;
+}
+function normalize(fileName) {
+    return fileName.replace(backslashes, '/');
+}
+function open(configPath, overlay) {
+    let configFileName = normalize(path.resolve(configPath)), entry = overlay === undefined ? getEntry(configFileName) : undefined, api = entry?.api ?? new API({ cwd: path.dirname(configFileName), fs: overlay }), snapshot = entry?.snapshot ?? api.updateSnapshot({ openProjects: [configFileName] }), project = entry?.project ?? resolveProject(snapshot, configFileName);
+    if (entry) {
+        return {
+            api,
+            dispose: () => dispose(configFileName),
+            project,
+            snapshot
+        };
+    }
+    return {
+        api,
+        dispose: () => {
+            if (!snapshot.isDisposed()) {
+                snapshot.dispose();
             }
-            if (!ts.sys.fileExists(fileName)) {
+            api.close();
+        },
+        project,
+        snapshot,
+    };
+}
+function overlayFileSystem(contents) {
+    return {
+        fileExists: (fileName) => {
+            if (contents.has(normalize(fileName))) {
+                return true;
+            }
+            return undefined;
+        },
+        getAccessibleEntries: (directoryName) => {
+            let directory = normalize(directoryName), extra = [];
+            for (let key of contents.keys()) {
+                if (key.slice(0, key.lastIndexOf('/')) === directory) {
+                    extra.push(key.slice(key.lastIndexOf('/') + 1));
+                }
+            }
+            if (extra.length === 0) {
                 return undefined;
             }
-            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName) || '');
+            let directories = [], files = [];
+            try {
+                for (let entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                    (entry.isDirectory() ? directories : files).push(entry.name);
+                }
+            }
+            catch {
+            }
+            return { directories, files: [...new Set([...files, ...extra])] };
         },
-        getScriptVersion: (fileName) => String(versions.get(fileName) || 0),
-        readFile: ts.sys.readFile
+        readFile: (fileName) => {
+            let content = contents.get(normalize(fileName));
+            if (content !== undefined) {
+                return content;
+            }
+            return undefined;
+        }
     };
-    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);
+function recreate(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
     }
-    return entry;
+    entry.api.close();
+    entry.api = new API({ cwd: entry.root, fs: overlayFileSystem(entry.contents) });
+    entry.snapshot = entry.api.updateSnapshot({ openProjects: [entry.configFileName] });
+    entry.project = resolveProject(entry.snapshot, entry.configFileName);
+    entry.seen = seed(entry.project.program);
+}
+function reseedScratch(entry, file) {
+    entry.contents.delete(entry.file);
+    entry.contents.set(entry.config, scratchConfig(file));
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+    entry.api = new API({ cwd: process.cwd(), fs: overlayFileSystem(entry.contents) });
+    entry.file = file;
+    entry.snapshot = entry.api.updateSnapshot({ openProjects: [entry.config] });
+    entry.project = resolveProject(entry.snapshot, entry.config);
+}
+function resolveProject(snapshot, configFileName) {
+    let project = snapshot.getProject(configFileName);
+    if (!project) {
+        throw new Error(`${PACKAGE_NAME}: project not found for ${configFileName}`);
+    }
+    return project;
+}
+function scratchConfig(file) {
+    return JSON.stringify({
+        compilerOptions: {
+            allowJs: true,
+            module: 'esnext',
+            moduleResolution: 'bundler',
+            skipLibCheck: true,
+            target: 'es2024'
+        },
+        files: [file]
+    });
+}
+function seed(program) {
+    let seen = new Set();
+    for (let name of program.getSourceFileNames()) {
+        seen.add(normalize(name));
+    }
+    return seen;
 }
-const invalidate = (root, fileName) => {
+const dispose = (root) => {
+    if (root === undefined) {
+        for (let entry of cache.values()) {
+            disposeEntry(entry);
+        }
+        cache.clear();
+        if (scratchEntry) {
+            disposeScratch(scratchEntry);
+            scratchEntry = null;
+        }
+        return;
+    }
     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);
+        disposeEntry(entry);
+        cache.delete(root);
+    }
+};
+const findConfig = (startDir) => {
+    let current = path.resolve(startDir);
+    while (true) {
+        let candidate = path.join(current, 'tsconfig.json');
+        if (fs.existsSync(candidate)) {
+            return normalize(candidate);
+        }
+        let parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+};
+const invalidate = (configFileName, fileName) => {
+    let entry = cache.get(configFileName);
+    if (!entry) {
+        return;
+    }
+    let id = normalize(fileName);
+    entry.contents.delete(id);
+    entry.pending.add(id);
+};
+const parse = (fileName, content) => {
+    return scratch(fileName, content).sourceFile;
+};
+const scratch = (fileName, content) => {
+    let id = normalize(fileName), entry = advanceScratch(id, content), source = entry.project.program.getSourceFile(id);
+    if (!source) {
+        throw new Error(`${PACKAGE_NAME}: failed to parse ${fileName}`);
     }
+    return { checker: entry.project.checker, program: entry.project.program, sourceFile: source };
 };
-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;
+const update = (configFileName, fileName, content) => {
+    return updateMany(configFileName, new Map([[fileName, content]]));
+};
+const updateMany = (configFileName, updates) => {
+    let entry = getEntry(configFileName), ids = [];
+    for (let [fileName, content] of updates) {
+        let id = normalize(fileName);
+        entry.contents.set(id, content);
+        ids.push(id);
+    }
+    if (ids.every(id => entry.seen.has(id))) {
+        for (let i = 0, n = ids.length; i < n; i++) {
+            entry.pending.add(ids[i]);
+        }
+        let changed = [...entry.pending];
+        entry.pending.clear();
+        advance(entry, changed);
+    }
+    else {
+        recreate(entry);
+        entry.pending.clear();
+        for (let i = 0, n = ids.length; i < n; i++) {
+            entry.seen.add(ids[i]);
+        }
+    }
+    for (let i = 0, n = ids.length; i < n; i++) {
+        let id = ids[i], source = entry.project.program.getSourceFile(id), content = entry.contents.get(id);
+        if (!source || source.text !== content) {
+            throw new Error(`${PACKAGE_NAME}: failed to load ${id} into the program`);
+        }
+    }
+    return { checker: entry.project.checker, program: entry.project.program };
 };
-export default { invalidate, update };
-export { invalidate, update };
+export default { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };
+export { dispose, findConfig, invalidate, open, parse, scratch, update, updateMany };

package/build/compiler/plugins/index.d.ts

@@ -7,12 +7,14 @@ declare const _default: {
     }) => ({ root }?: {
         root?: string;
     }) => {
+        closeBundle: () => void;
+        closeWatcher: () => void;
         configResolved: (config: unknown) => void;
-        enforce: "pre";
+        enforce: 'pre';
         name: string;
         transform: (code: string, id: string) => {
             code: string;
-            map: null;
+            map: import("../index.js").SourceMapV3;
         } | null;
         watchChange: (id: string) => void;
     };

package/build/compiler/plugins/tsc.d.ts

@@ -1,3 +1,3 @@
 import type { Plugin } from '../types.js';
-declare const _default: (plugins: Plugin[]) => () => Plugin[];
 export default _default;
+declare function _default(plugins: Plugin[]): () => Plugin[];

package/build/compiler/plugins/vite.d.ts

@@ -1,11 +1,14 @@
 import type { Plugin } from '../types.js';
+import type { SourceMapV3 } from '../sourcemap.js';
 type VitePlugin = {
+    closeBundle: () => void;
+    closeWatcher: () => void;
     configResolved: (config: unknown) => void;
     enforce: 'pre';
     name: string;
     transform: (code: string, id: string) => {
         code: string;
-        map: null;
+        map: SourceMapV3;
     } | null;
     watchChange: (id: string) => void;
 };
@@ -14,7 +17,7 @@ type VitePluginOptions = {
     onWatchChange?: () => void;
     plugins: Plugin[];
 };
-declare const _default: ({ name, onWatchChange, plugins }: VitePluginOptions) => ({ root }?: {
+export default _default;
+declare function _default({ name, onWatchChange, plugins }: VitePluginOptions): ({ root }?: {
     root?: string;
 }) => VitePlugin;
-export default _default;

package/build/compiler/plugins/vite.js

@@ -1,14 +1,24 @@
-import { ts } from '../../index.js';
 import coordinator from '../coordinator.js';
 import languageService from '../language-service.js';
+import sourcemap from '../sourcemap.js';
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
 const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
 export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
+        let tsconfig = null;
         return {
+            closeBundle() {
+                languageService.dispose(tsconfig ?? '');
+                contexts.delete(root || '');
+            },
+            closeWatcher() {
+                languageService.dispose(tsconfig ?? '');
+                contexts.delete(root || '');
+            },
             configResolved(config) {
                 root ??= config.root;
+                tsconfig = languageService.findConfig(root);
             },
             enforce: 'pre',
             name: `${name}/compiler/vite`,
@@ -17,20 +27,17 @@ export default ({ name, onWatchChange, plugins }) => {
                     return null;
                 }
                 try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = languageService.update(root || '', normalizedId, code), sourceFile = prog.getSourceFile(normalizedId);
-                    if (!sourceFile) {
-                        sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true);
-                    }
+                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), configPath = tsconfig ?? languageService.findConfig(root || ''), { checker, program } = languageService.update(configPath ?? '', normalizedId, code), sourceFile = program.getSourceFile(normalizedId) ?? languageService.parse(normalizedId, code);
                     let key = root || '', ctx = contexts.get(key);
                     if (!ctx) {
                         ctx = new Map();
                         contexts.set(key, ctx);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, prog, key, ctx);
+                    let result = coordinator.transform(plugins, code, sourceFile, { checker, configPath: configPath ?? undefined, program }, key, ctx);
                     if (!result.changed) {
                         return null;
                     }
-                    return { code: result.code, map: null };
+                    return { code: result.code, map: sourcemap.toSourceMapV3(result.map, result.code, code, normalizedId) };
                 }
                 catch (error) {
                     console.error(`${name}: error transforming ${id}:`, error);
@@ -41,7 +48,7 @@ export default ({ name, onWatchChange, plugins }) => {
                 if (FILE_REGEX.test(id)) {
                     onWatchChange?.();
                     contexts.delete(root || '');
-                    languageService.invalidate(root || '', id);
+                    languageService.invalidate(tsconfig ?? '', id);
                 }
             }
         };

package/build/compiler/sourcemap.d.ts

@@ -0,0 +1,52 @@
+type Edit = {
+    end: number;
+    newText: string;
+    start: number;
+};
+type OffsetAnchor = {
+    afterEnd: number;
+    afterStart: number;
+    beforeStart: number;
+    identity: boolean;
+};
+type PositionMapping = {
+    generations: OffsetAnchor[][];
+};
+type Segment = {
+    genColumn: number;
+    name?: number;
+    originalColumn?: number;
+    originalLine?: number;
+    source?: number;
+};
+type SourceMapV3 = {
+    file?: string;
+    mappings: string;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+};
+declare function resolveOffset(mapping: PositionMapping, offset: number): number;
+declare const buildGeneration: (beforeText: string, edits: Edit[]) => OffsetAnchor[];
+declare const composeEmittedMap: (map: SourceMapV3, mapping: PositionMapping, transformedText: string, originalText: string) => SourceMapV3;
+declare const decode: (mappings: string) => number[][][];
+declare const encode: (decoded: number[][][]) => string;
+declare const originalPositionFor: (mapping: PositionMapping, transformedText: string, originalText: string, line: number, column: number) => {
+    column: number;
+    line: number;
+};
+declare const toSourceMapV3: (mapping: PositionMapping, transformedText: string, originalText: string, source: string) => SourceMapV3;
+declare const _default: {
+    buildGeneration: typeof buildGeneration;
+    composeEmittedMap: typeof composeEmittedMap;
+    decode: typeof decode;
+    encode: typeof encode;
+    originalPositionFor: typeof originalPositionFor;
+    resolveOffset: typeof resolveOffset;
+    toSourceMapV3: typeof toSourceMapV3;
+};
+export default _default;
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };
+export type { Edit, OffsetAnchor, PositionMapping, Segment, SourceMapV3 };