tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/module-resolution-types.js

@@ -0,0 +1,176 @@
+/**
+ * Options, host and result types for module resolution.
+ */
+import { getAllowJS, getModuleResolutionKind, getResolveJsonModule, ModuleKind, ModuleResolutionKind, } from './options.js';
+import { combinePaths, getDirectoryPath, normalizePath } from './path.js';
+export { ModuleKind, ModuleResolutionKind } from './options.js';
+/** File system access for resolution. Paths passed in are absolute and use `/`. */
+export class ModuleResolutionHost {
+}
+export function packageIdToString(id) {
+    return packageIdName(id) + '@' + id.version + id.peerDependencies;
+}
+export function packageIdName(id) {
+    return id.subModuleName !== '' ? id.name + '/' + id.subModuleName : id.name;
+}
+export const inferredTypesContainingFile = '__inferred type names__.ts';
+//// Option defaults
+export function moduleResolutionKindName(kind) {
+    switch (kind) {
+        case ModuleResolutionKind.Classic:
+            return 'Classic';
+        case ModuleResolutionKind.Node10:
+            return 'Node10';
+        case ModuleResolutionKind.Node16:
+            return 'Node16';
+        case ModuleResolutionKind.NodeNext:
+            return 'NodeNext';
+        case ModuleResolutionKind.Bundler:
+            return 'Bundler';
+        default:
+            throw new Error('unexpected module resolution kind');
+    }
+}
+/** Configured `typeRoots`, or every ancestor `node_modules/@types` of the config directory. */
+export function getEffectiveTypeRoots(options, currentDirectory) {
+    if (options.typeRoots !== undefined)
+        return options.typeRoots;
+    let directory = options.configFilePath !== undefined && options.configFilePath !== ''
+        ? getDirectoryPath(options.configFilePath)
+        : currentDirectory;
+    if (directory === '')
+        throw new Error('cannot get effective type roots without a config file path or current directory');
+    const roots = [];
+    for (;;) {
+        roots.push(combinePaths(combinePaths(directory, 'node_modules'), '@types'));
+        const parent = getDirectoryPath(directory);
+        if (parent === directory)
+            return roots;
+        directory = parent;
+    }
+}
+/** Export/import conditions in priority order. */
+export function getConditions(options, mode) {
+    const kind = getModuleResolutionKind(options);
+    if (mode === ModuleKind.None && kind === ModuleResolutionKind.Bundler)
+        mode = ModuleKind.ESNext;
+    const conditions = [mode === ModuleKind.ESNext ? 'import' : 'require'];
+    if (options.noDtsResolution !== true)
+        conditions.push('types');
+    if (kind !== ModuleResolutionKind.Bundler)
+        conditions.push('node');
+    if (options.customConditions !== undefined)
+        for (const c of options.customConditions)
+            conditions.push(c);
+    return conditions;
+}
+//// Package names
+/** Splits `@scope/name/rest` or `name/rest` into the package name and the rest. */
+export function parsePackageName(moduleName) {
+    let index = moduleName.indexOf('/');
+    if (moduleName.length > 0 && moduleName.charCodeAt(0) === 0x40) {
+        const next = moduleName.indexOf('/', index + 1);
+        index = next;
+    }
+    if (index === -1)
+        return { packageName: moduleName, rest: '' };
+    return { packageName: moduleName.slice(0, index), rest: moduleName.slice(index + 1) };
+}
+/** `@scope/name` becomes `scope__name`, as published under `@types`. */
+export function mangleScopedPackageName(packageName) {
+    if (packageName.length > 0 && packageName.charCodeAt(0) === 0x40) {
+        const index = packageName.indexOf('/');
+        if (index === -1)
+            return packageName;
+        return packageName.slice(1, index) + '__' + packageName.slice(index + 1);
+    }
+    return packageName;
+}
+export function unmangleScopedPackageName(packageName) {
+    const index = packageName.indexOf('__');
+    return index === -1 ? packageName : '@' + packageName.slice(0, index) + '/' + packageName.slice(index + 2);
+}
+export function getTypesPackageName(packageName) {
+    return '@types/' + mangleScopedPackageName(packageName);
+}
+export function getPackageNameFromTypesPackageName(mangledName) {
+    return mangledName.startsWith('@types/') ? unmangleScopedPackageName(mangledName.slice(7)) : mangledName;
+}
+function nextSeparatorIndex(path, previous, isFolder) {
+    const next = previous + 1 <= path.length ? path.indexOf('/', previous + 1) : -1;
+    if (next === -1)
+        return isFolder ? path.length : previous;
+    return next;
+}
+/** The package directory of a path inside `node_modules`, or `''`. */
+export function parseNodeModuleFromPath(resolved, isFolder) {
+    const path = normalizePath(resolved);
+    const index = path.lastIndexOf('/node_modules/');
+    if (index === -1)
+        return '';
+    const afterNodeModules = index + 14;
+    let afterPackageName = nextSeparatorIndex(path, afterNodeModules, isFolder);
+    if (path.charCodeAt(afterNodeModules) === 0x40) {
+        afterPackageName = nextSeparatorIndex(path, afterPackageName, isFolder);
+    }
+    return path.slice(0, afterPackageName);
+}
+/** Orders `exports`/`imports` pattern keys from most to least specific. */
+export function comparePatternKeys(a, b) {
+    const aStar = a.indexOf('*');
+    const bStar = b.indexOf('*');
+    const aBase = aStar === -1 ? a.length : aStar + 1;
+    const bBase = bStar === -1 ? b.length : bStar + 1;
+    if (aBase > bBase)
+        return -1;
+    if (bBase > aBase)
+        return 1;
+    if (aStar === -1)
+        return 1;
+    if (bStar === -1)
+        return -1;
+    if (a.length > b.length)
+        return -1;
+    if (b.length > a.length)
+        return 1;
+    return 0;
+}
+/**
+ * The error for using a resolved module whose extension the options don't allow, or `undefined`.
+ * Arguments are the module name and the resolved file name.
+ */
+export function getResolutionDiagnostic(options, resolved, isDeclarationFile) {
+    const needJsx = options.jsx === undefined;
+    const needAllowJs = !getAllowJS(options) && (options.noImplicitAny ?? options.strict) === true;
+    switch (resolved.extension) {
+        case '.ts':
+        case '.d.ts':
+        case '.mts':
+        case '.d.mts':
+        case '.cts':
+        case '.d.cts':
+            return undefined;
+        case '.tsx':
+            return needJsx ? 1307 /* Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set */ : undefined;
+        case '.jsx':
+            if (needJsx)
+                return 1307 /* Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set */;
+            return needAllowJs
+                ? 1688 /* Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type */
+                : undefined;
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+            return needAllowJs
+                ? 1688 /* Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type */
+                : undefined;
+        case '.json':
+            return getResolveJsonModule(options)
+                ? undefined
+                : 1713 /* Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used */;
+        default:
+            return isDeclarationFile || options.allowArbitraryExtensions === true
+                ? undefined
+                : 1415 /* Diagnostics.Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set */;
+    }
+}

package/dist/api/compiler/module-resolution.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Module and type reference resolution for `node16`, `nodenext` and `bundler`.
+ *
+ * ```ts
+ * const resolver = new Resolver(host, options);
+ * const traces: MessageWithArgs[] = [];
+ * const resolved = resolver.resolveModuleName('pkg', '/app/src/index.ts', ModuleKind.ESNext, undefined, traces);
+ * ```
+ */
+import { type MessageWithArgs } from './diagnostics.js';
+import { ModuleResolutionHost, type ResolutionMode, type ResolvedModule, type ResolvedProjectReference, type ResolvedTypeReferenceDirective } from './module-resolution-types.js';
+import { PackageJsonInfoCache, type PackageJsonInfo } from './package-json.js';
+import { type CompilerOptions } from './options.js';
+export * from './module-resolution-types.js';
+/** A `paths` or `typesVersions` pattern: `text` with an optional `*` at `starIndex`. */
+export interface Pattern {
+    readonly text: string;
+    readonly starIndex: number;
+}
+export interface ParsedPatterns {
+    readonly exact: ReadonlySet<string>;
+    readonly patterns: readonly Pattern[];
+}
+export declare function parsePatterns(paths: ReadonlyMap<string, readonly string[] | undefined>): ParsedPatterns;
+/** The exact key equal to `candidate`, else the matching pattern with the longest prefix. */
+export declare function matchPatternOrExact(parsed: ParsedPatterns, candidate: string): Pattern | undefined;
+export declare class Resolver {
+    readonly host: ModuleResolutionHost;
+    readonly options: CompilerOptions;
+    /** Global typings cache for automatic type acquisition, or `''`. */
+    readonly typingsLocation: string;
+    readonly projectName: string;
+    readonly packageJsonInfoCache: PackageJsonInfoCache;
+    private readonly moduleCache;
+    private readonly typeReferenceCache;
+    private pathPatterns;
+    private shared;
+    constructor(host: ModuleResolutionHost, options: CompilerOptions, 
+    /** Global typings cache for automatic type acquisition, or `''`. */
+    typingsLocation?: string, projectName?: string, packageJsonInfoCache?: PackageJsonInfoCache);
+    /**
+     * Called before the resolver is shared with other threads, which makes it immutable
+     * (parallel-check.ts): from then on, each thread caches the results and `package.json` lookups the
+     * resolver did not have yet in tables of its own.
+     */
+    prepareForSharing(): void;
+    private cachedModule;
+    private cacheModule;
+    private cachedTypeReference;
+    private cacheTypeReference;
+    /** Parsed `paths` of the resolver's own options. */
+    getPathPatterns(): ParsedPatterns;
+    /**
+     * Resolves an import specifier. With `traceResolution` set, trace messages are appended to `traces` and the
+     * result cache is bypassed.
+     */
+    resolveModuleName(moduleName: string, containingFile: string, mode: ResolutionMode, redirect?: ResolvedProjectReference, traces?: MessageWithArgs[]): ResolvedModule;
+    /** Resolves a `/// <reference types>` directive or an entry of `types`. */
+    resolveTypeReferenceDirective(name: string, containingFile: string, mode: ResolutionMode, redirect?: ResolvedProjectReference, traces?: MessageWithArgs[]): ResolvedTypeReferenceDirective;
+    /** Finds the directory of package `moduleName` in the nearest `node_modules`, without loading files. */
+    resolvePackageDirectory(moduleName: string, containingFile: string, mode: ResolutionMode, redirect?: ResolvedProjectReference): ResolvedModule | undefined;
+    /** The nearest `package.json` at or above `directory`. */
+    getPackageScopeForPath(directory: string): PackageJsonInfo | undefined;
+    /** Resolves an `extends` specifier of a tsconfig file. */
+    resolveConfig(moduleName: string, containingFile: string): ResolvedModule;
+    private tryResolveFromTypingsLocation;
+}
+/** Resolves an `extends` specifier of a tsconfig file with `nodenext` rules. */
+export declare function resolveConfig(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModule;
+/** The `types` entries to include automatically, expanding `*` to every package in the type roots. */
+export declare function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[];