tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-modules.d.ts

@@ -0,0 +1,85 @@
+import { type Node, type SourceFile } from './ast.js';
+import { type DiagnosticMessage } from './diagnostics.js';
+import { ModuleKind } from './options.js';
+import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
+import { type Checker, type CheckerHost } from './checker.js';
+import { type Type } from './checker-types.js';
+/** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
+export declare function resolveExternalModuleName(c: Checker, location: Node, moduleReference: Node | undefined, ignoreErrors: boolean): Symbol | undefined;
+export declare function resolveExternalModuleNameWorker(c: Checker, location: Node, moduleReference: Node | undefined, moduleNotFoundError: DiagnosticMessage | undefined, ignoreErrors: boolean, isForAugmentation: boolean): Symbol | undefined;
+export declare function resolveExternalModule(c: Checker, location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node | undefined, isForAugmentation: boolean): Symbol | undefined;
+/** A message with its arguments, the elaboration of a diagnostic before it has a location. */
+export declare class DiagnosticDetails {
+    readonly message: DiagnosticMessage;
+    readonly args: string[];
+    constructor(message: DiagnosticMessage, args: string[]);
+}
+/**
+ * How to make the CommonJS file `file` an ES module, elaborating an error about importing one from
+ * it; also what an incremental build recomputes for a stored diagnostic (`RepopulateKind.ModeMismatch`).
+ */
+export declare function modeMismatchDetails(host: CheckerHost, file: SourceFile): DiagnosticDetails;
+/**
+ * Where types for `moduleReference`, imported by `file`, might come from; also what an incremental
+ * build recomputes for a stored diagnostic (`RepopulateKind.ModuleNotFound`).
+ */
+export declare function moduleNotFoundDetails(host: CheckerHost, file: SourceFile, moduleReference: string, mode: ModuleKind, packageNameIn: string): DiagnosticDetails;
+export declare function tryFindAmbientModule(c: Checker, moduleName: string, withAugmentations: boolean): Symbol | undefined;
+/** The `export =` target of a module, or the module itself. */
+export declare function resolveExternalModuleSymbol(c: Checker, moduleSymbol: Symbol | undefined, dontResolveAlias: boolean): Symbol | undefined;
+/** The module as a namespace: removes call and construct signatures, or wraps it with a synthetic default. */
+export declare function resolveESModuleSymbol(c: Checker, moduleSymbol: Symbol | undefined, node: Node, moduleSpecifier: Node): Symbol | undefined;
+/** The symbol an alias declaration refers to, without resolving further aliases. */
+export declare function getTargetOfAliasDeclaration(c: Checker, node: Node | undefined): Symbol | undefined;
+/**
+ * Resolves the entity name of `import a = b.c`: `b` alone or the left part of a longer name is a
+ * namespace, the whole name any meaning.
+ */
+export declare function getSymbolOfPartOfRightHandSideOfImportEquals(c: Checker, entityName: Node): Symbol | undefined;
+/** The export `specifier` names from the module of the import or export declaration `node`. */
+export declare function getExternalModuleMember(c: Checker, node: Node, specifier: Node, dontResolveAlias: boolean): Symbol | undefined;
+export declare function getTargetOfExportSpecifier(c: Checker, node: Node, meaning: SymbolFlags, dontResolveAlias: boolean): Symbol | undefined;
+/** Whether the declaration itself is written `import type` or `export type`. */
+export declare function isTypeOnlyImportOrExportDeclaration(node: Node): boolean;
+/** Marks the alias declaration an entity name is part of, if it is type-only. */
+export declare function markAliasDeclarationOfNameIfTypeOnly(c: Checker, name: Node): void;
+/** Resolves an alias whose target is an alias, carrying over the target's type-only declaration. */
+export declare function resolveIndirectionAlias(c: Checker, source: Symbol, target: Symbol): Symbol;
+export declare function getTypeOnlyAliasDeclaration(c: Checker, symbol: Symbol): Node | undefined;
+/** The first type-only declaration along the alias chain of `symbol` before one with `meaning`. */
+export declare function getTypeOnlyAliasDeclarationOfMeaning(c: Checker, symbol: Symbol, meaning: SymbolFlags): Node | undefined;
+/** Reports a value use of a name that only resolves to a value through a type-only import or export. */
+export declare function checkTypeOnlyAliasUse(c: Checker, location: Node, result: Symbol, name: string): void;
+export declare function isValidTypeOnlyAliasUseSite(useSite: Node): boolean;
+/** Marks the aliases an identifier in an expression uses as referenced. */
+export declare function markIdentifierAliasReferencedInExpression(c: Checker, node: Node): void;
+/** Resolves the alias side of a referenced symbol, which may also be a local variable. */
+export declare function resolveAliasOfReference(c: Checker, symbol: Symbol): void;
+/**
+ * Marks the alias on the left of a property access as referenced, unless the access reads a const
+ * enum (or a module of only const enums) that is inlined.
+ */
+export declare function markPropertyAliasReferenced(c: Checker, location: Node, prop: Symbol | undefined, leftType: Type): void;
+/** Own exports plus those re-exported with `export *`; own exports shadow re-exported ones. */
+export declare function getExportsOfModuleWorker(c: Checker, moduleSymbol: Symbol): SymbolTable;
+/** The type of `import("m")`, `import("m").T` or `typeof import("m").v`. */
+export declare function getTypeFromImportTypeNode(c: Checker, node: Node): Type;
+/** `import(specifier, options)`: a promise of the module namespace. */
+export declare function checkImportCallExpression(c: Checker, node: Node): Type;
+/** The symbol a `{@link}` name refers to, as an entity or a member of one. */
+export declare function resolveJSDocMemberName(c: Checker, name: Node | undefined): Symbol | undefined;
+export declare function getHostSignatureFromJSDoc(node: Node): Node | undefined;
+/** `import.meta` and `new.target`. */
+export declare function checkMetaProperty(c: Checker, node: Node): Type;
+export declare function checkNewTargetMetaProperty(c: Checker, node: Node): Type;
+export declare function checkImportDeclaration(c: Checker, node: Node): void;
+export declare function checkImportEqualsDeclaration(c: Checker, node: Node): void;
+export declare function checkExportDeclaration(c: Checker, node: Node): void;
+export declare function getDeclarationContainer(node: Node): Node;
+/** `export = e` and `export default e`; the grammar checker reports misplaced ones. */
+export declare function checkExportAssignment(c: Checker, node: Node): void;
+/** Reports aliases that conflict with local declarations, and type-only rules of isolated modules. */
+export declare function checkAliasSymbol(c: Checker, node: Node): void;
+export declare function getIsolatedModulesLikeFlagName(c: Checker): string;
+/** The file a module declaration or import names. */
+export declare function getExternalModuleFileFromDeclaration(c: Checker, declaration: Node): SourceFile | undefined;