deno.land / x / ts_morph@22.0.0 / common / ts_morph_common.d.ts
نووسراو ببینە
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069// @deno-types="./typescript.d.ts"import * as ts from "./typescript.js";
export interface CompilerOptionsFromTsConfigOptions { encoding?: string; fileSystem?: FileSystemHost;}
export interface CompilerOptionsFromTsConfigResult { options: ts.CompilerOptions; errors: ts.Diagnostic[];}
/** * Gets the compiler options from a specified tsconfig.json * @param filePath - File path to the tsconfig.json. * @param options - Options. */export declare function getCompilerOptionsFromTsConfig(filePath: string, options?: CompilerOptionsFromTsConfigOptions): CompilerOptionsFromTsConfigResult;
export declare class TsConfigResolver { #private; constructor(fileSystem: TransactionalFileSystem, tsConfigFilePath: StandardizedFilePath, encoding: string); getCompilerOptions(): ts.CompilerOptions; getErrors(): ts.Diagnostic[]; getPaths(compilerOptions?: ts.CompilerOptions): { filePaths: StandardizedFilePath[]; directoryPaths: StandardizedFilePath[]; }; private _parseJsonConfigFileContent;}
/** * Helper around a Map. * @remarks The use of this class is historical as it served as an abstraction around an ES5 based map and ES6, if available. Eventually * this class should be removed in favour of helper functions around a Map. */export declare class KeyValueCache<T, U> { #private; getSize(): number; getValues(): IterableIterator<U>; getValuesAsArray(): U[]; getKeys(): IterableIterator<T>; getEntries(): IterableIterator<[T, U]>; getOrCreate<TCreate extends U = U>(key: T, createFunc: () => TCreate): TCreate; has(key: T): boolean; get(key: T): U | undefined; set(key: T, value: U): void; replaceKey(key: T, newKey: T): void; removeByKey(key: T): void; clear(): void;}
/** * An array where the values are sorted by a key of one of the values. */export declare class SortedKeyValueArray<TKey, TValue> { #private; constructor(getKey: (value: TValue) => TKey, comparer: Comparer<TKey>); set(value: TValue): void; removeByValue(value: TValue): void; removeByKey(key: TKey): void; getArrayCopy(): TValue[]; hasItems(): boolean; entries(): Generator<TValue, void, undefined>;}
/** * A wrapper around WeakMap. * @remarks The use of this class is historical as it served as an abstraction around an ES5 based weak map and ES6, if available. Eventually * this class should be removed in favour of helper functions around a WeakMap. */export declare class WeakCache<T extends object, U> { #private; getOrCreate<TCreate extends U = U>(key: T, createFunc: () => TCreate): TCreate; has(key: T): boolean; get(key: T): U | undefined; set(key: T, value: U): void; removeByKey(key: T): void;}
/** * Compares two values specifying the sort order. */export interface Comparer<T> { /** * Checks the two items returning -1 if `a` preceeds, 0 if equal, and 1 if `a` follows. * @param a - Item to use. * @param b - Item to compare with. */ compareTo(a: T, b: T): number;}
/** * Converts a comparer to a stored comparer. */export declare class ComparerToStoredComparer<T> implements StoredComparer<T> { #private; /** * Constructor. * @param comparer - Comparer to use. * @param storedValue - Stored value to use as the value to always compare the input of `compareTo` to. */ constructor(comparer: Comparer<T>, storedValue: T); /** @inheritdoc */ compareTo(value: T): number;}
/** * Compares two strings by en-us-u-kf-upper locale. */export declare class LocaleStringComparer implements Comparer<string> { /** Static instance for reuse. */ static readonly instance: LocaleStringComparer; /** @inheritdoc */ compareTo(a: string, b: string): 0 | 1 | -1;}
/** * Compares two values based on one of their properties. */export declare class PropertyComparer<TValue, TProperty> implements Comparer<TValue> { #private; /** * Constructor. * @param getProperty - Gets the property from the value to use for comparisons. * @param comparer - Comparer to compare the properties with. */ constructor(getProperty: (value: TValue) => TProperty, comparer: Comparer<TProperty>); /** @inheritdoc */ compareTo(a: TValue, b: TValue): number;}
/** * A stored comparer that compares a property to a stored value. */export declare class PropertyStoredComparer<TValue, TProperty> implements StoredComparer<TValue> { #private; /** * Constructor. * @param getProperty - Gets the property from the value. * @param comparer - Comparer to compare the property with. */ constructor(getProperty: (value: TValue) => TProperty, comparer: StoredComparer<TProperty>); /** @inheritdoc */ compareTo(value: TValue): number;}
/** * Compares a value against a stored value. */export interface StoredComparer<T> { /** * Checks the value against a stored value returning -1 if the stored value preceeds, 0 if the value is equal, and 1 if follows. * @param value - Value to compare. */ compareTo(value: T): number;}
/** * Creates a language service host and compiler host. * @param options - Options for creating the hosts. */export declare function createHosts(options: CreateHostsOptions): { languageServiceHost: ts.LanguageServiceHost; compilerHost: ts.CompilerHost;};
/** * Options for creating the hosts. */export interface CreateHostsOptions { /** The transactional file system to use. */ transactionalFileSystem: TransactionalFileSystem; /** Container of source files to use. */ sourceFileContainer: TsSourceFileContainer; /** Compiler options container to use. */ compilerOptions: CompilerOptionsContainer; /** Newline kind to use. */ getNewLine: () => "\r\n" | "\n"; /** The resolution host used for resolving modules and type reference directives. */ resolutionHost: ResolutionHost; /** Provides the current project version to be used to tell if source files have * changed. Provide this for a performance improvement. */ getProjectVersion?: () => string; isKnownTypesPackageName?: ts.LanguageServiceHost["isKnownTypesPackageName"]; /** * Set this to true to not load the typescript lib files. * @default false */ skipLoadingLibFiles?: boolean; /** * Specify this to use a custom folder to load the lib files from. * @remarks skipLoadingLibFiles cannot be explicitly false if this is set. */ libFolderPath?: string;}
/** * Creates a module resolution host based on the provided options. * @param options - Options for creating the module resolution host. */export declare function createModuleResolutionHost(options: CreateModuleResolutionHostOptions): ts.ModuleResolutionHost;
/** * Options for creating a module resolution host. */export interface CreateModuleResolutionHostOptions { /** The transactional file system to use. */ transactionalFileSystem: TransactionalFileSystem; /** The source file container to use. */ sourceFileContainer: TsSourceFileContainer; /** Gets the encoding to use. */ getEncoding(): string;}
/** * An implementation of a ts.DocumentRegistry that uses a transactional file system. */export declare class DocumentRegistry implements ts.DocumentRegistry { #private; /** * Constructor. * @param transactionalFileSystem - The transaction file system to use. */ constructor(transactionalFileSystem: TransactionalFileSystem); /** * Creates or updates a source file in the document registry. * @param fileName - File name to create or update. * @param compilationSettings - Compiler options to use. * @param scriptSnapshot - Script snapshot (text) of the file. * @param scriptKind - Script kind of the file. */ createOrUpdateSourceFile(fileName: StandardizedFilePath, compilationSettings: ts.CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, scriptKind: ts.ScriptKind | undefined): ts.SourceFile; /** * Removes the source file from the document registry. * @param fileName - File name to remove. */ removeSourceFile(fileName: StandardizedFilePath): void; /** @inheritdoc */ acquireDocument(fileName: string, compilationSettings: ts.CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ts.ScriptKind | undefined): ts.SourceFile; /** @inheritdoc */ acquireDocumentWithKey(fileName: string, path: ts.Path, compilationSettings: ts.CompilerOptions, key: ts.DocumentRegistryBucketKey, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ts.ScriptKind | undefined): ts.SourceFile; /** @inheritdoc */ updateDocument(fileName: string, compilationSettings: ts.CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ts.ScriptKind | undefined): ts.SourceFile; /** @inheritdoc */ updateDocumentWithKey(fileName: string, path: ts.Path, compilationSettings: ts.CompilerOptions, key: ts.DocumentRegistryBucketKey, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ts.ScriptKind | undefined): ts.SourceFile; /** @inheritdoc */ getKeyForCompilationSettings(settings: ts.CompilerOptions): ts.DocumentRegistryBucketKey; /** @inheritdoc */ releaseDocument(fileName: string, compilationSettings: ts.CompilerOptions): void; /** @inheritdoc */ releaseDocumentWithKey(path: ts.Path, key: ts.DocumentRegistryBucketKey): void; /** @inheritdoc */ reportStats(): string; /** @inheritdoc */ getSourceFileVersion(sourceFile: ts.SourceFile): string;}
/** Host for implementing custom module and/or type reference directive resolution. */export interface ResolutionHost { resolveModuleNames?: ts.LanguageServiceHost["resolveModuleNames"]; getResolvedModuleWithFailedLookupLocationsFromCache?: ts.LanguageServiceHost["getResolvedModuleWithFailedLookupLocationsFromCache"]; resolveTypeReferenceDirectives?: ts.LanguageServiceHost["resolveTypeReferenceDirectives"];}
/** * Factory used to create a resolution host. * @remarks The compiler options are retrieved via a function in order to get the project's current compiler options. */export type ResolutionHostFactory = (moduleResolutionHost: ts.ModuleResolutionHost, getCompilerOptions: () => ts.CompilerOptions) => ResolutionHost;
/** Collection of reusable resolution hosts. */export declare const ResolutionHosts: { deno: ResolutionHostFactory;};
/** * A container of source files. */export interface TsSourceFileContainer { /** * Gets if a source file exists at the specified file path. * @param filePath - File path to check. */ containsSourceFileAtPath(filePath: StandardizedFilePath): boolean; /** * Gets the source file paths of all the source files in the container. */ getSourceFilePaths(): Iterable<StandardizedFilePath>; /** * Gets a source file from a file path, but only if it exists in the container's cache. * @param filePath - File path to get the source file from. */ getSourceFileFromCacheFromFilePath(filePath: StandardizedFilePath): ts.SourceFile | undefined; /** * Asynchronously adds or gets a source file from a file path. * @param filePath - File path to get. * @param opts - Options for adding or getting the file. */ addOrGetSourceFileFromFilePath(filePath: StandardizedFilePath, opts: { markInProject: boolean; scriptKind: ts.ScriptKind | undefined; }): Promise<ts.SourceFile | undefined>; /** * Synchronously adds or gets a source file from a file path. * @param filePath - File path to get. * @param opts - Options for adding or getting the file. */ addOrGetSourceFileFromFilePathSync(filePath: StandardizedFilePath, opts: { markInProject: boolean; scriptKind: ts.ScriptKind | undefined; }): ts.SourceFile | undefined; /** * Gets the source file version of the specified source file. * @param sourceFile - Source file to inspect. */ getSourceFileVersion(sourceFile: ts.SourceFile): string; /** * Gets if the container contains the specified directory. * @param dirPath - Path of the directory to check. */ containsDirectoryAtPath(dirPath: StandardizedFilePath): boolean; /** * Gets the child directories of the specified directory. * @param dirPath - Path of the directory to check. */ getChildDirectoriesOfDirectory(dirPath: StandardizedFilePath): StandardizedFilePath[];}
/** Decorator for memoizing the result of a method or get accessor. */export declare function Memoize(target: any, propertyName: string, descriptor: TypedPropertyDescriptor<any>): void;
/** Collection of helper functions that can be used to throw errors. */export declare namespace errors { /** * Minimal attributes to show a error message with the node source. */ interface Node { getSourceFile(): { getFilePath(): StandardizedFilePath; getFullText(): string; }; getStart(): number; } /** Base error class. */ abstract class BaseError extends Error { protected constructor(); } /** Thrown when there is a problem with a provided argument. */ class ArgumentError extends BaseError { constructor(argName: string, message: string, node?: Node); } /** Thrown when an argument is null or whitespace. */ class ArgumentNullOrWhitespaceError extends ArgumentError { constructor(argName: string, node?: Node); } /** Thrown when an argument is out of range. */ class ArgumentOutOfRangeError extends ArgumentError { constructor(argName: string, value: number, range: [number, number], node?: Node); } /** Thrown when an argument does not match an expected type. */ class ArgumentTypeError extends ArgumentError { constructor(argName: string, expectedType: string, actualType: string, node?: Node); } /** Thrown when a file or directory path was not found. */ class PathNotFoundError extends BaseError { readonly path: StandardizedFilePath; constructor(path: StandardizedFilePath, prefix?: string); readonly code: "ENOENT"; } /** Thrown when a directory was not found. */ class DirectoryNotFoundError extends PathNotFoundError { constructor(dirPath: StandardizedFilePath); } /** Thrown when a file was not found. */ class FileNotFoundError extends PathNotFoundError { constructor(filePath: StandardizedFilePath); } /** Thrown when an action was taken that is not allowed. */ class InvalidOperationError extends BaseError { constructor(message: string, node?: Node); } /** Thrown when a certain behaviour or feature has not been implemented. */ class NotImplementedError extends BaseError { constructor(message?: string, node?: Node); } /** Thrown when an operation is not supported. */ class NotSupportedError extends BaseError { constructor(message: string); } /** * Thows if not a type. * @param value - Value to check the type of. * @param expectedType - Expected type. * @param argName - Argument name. */ function throwIfNotType(value: any, expectedType: string, argName: string): void; /** * Throws if the value is not a string. * @param value - Value to check. * @param argName - Arg name. */ function throwIfNotString(value: string, argName: string): void; /** * Throws if the value is not a string or is whitespace. * @param value - Value to check. * @param argName - Arg name. */ function throwIfWhitespaceOrNotString(value: string, argName: string): void; /** * Throws an ArgumentOutOfRangeError if an argument's value is out of an inclusive range. * @param value - Value. * @param range - Range. * @param argName - Argument name. */ function throwIfOutOfRange(value: number, range: [number, number], argName: string): void; /** * Throws an ArgumentOutOfRangeError if an argument's range value is out of an inclusive range. * * Also throws when the start of the range is greater than the end. * @param actualRange - Range to check. * @param range - Range to check against. * @param argName - Argument name. */ function throwIfRangeOutOfRange(actualRange: [number, number], range: [number, number], argName: string): void; /** * Gets an error saying that a feature is not implemented for a certain syntax kind. * @param kind - Syntax kind that isn't implemented. */ function throwNotImplementedForSyntaxKindError(kind: ts.SyntaxKind, node?: Node): never; /** * Throws an Argument * @param value * @param argName */ function throwIfNegative(value: number, argName: string): void; /** * Throws when the value is null or undefined. * @param value - Value to check. * @param errorMessage - Error message to throw when not defined. */ function throwIfNullOrUndefined<T>(value: T | undefined, errorMessage: string | (() => string), node?: Node): T; /** * Throw if the value should have been the never type. * @param value - Value to check. */ function throwNotImplementedForNeverValueError(value: never, sourceNode?: Node): never; /** * Throws an error if the actual value does not equal the expected value. * @param actual - Actual value. * @param expected - Expected value. * @param description - Message to show in the error. Should be a full sentence that doesn't include the actual and expected values. */ function throwIfNotEqual<T>(actual: T, expected: T, description: string): void; /** * Throws if true. * @param value - Value to check. * @param errorMessage - Error message to throw when true. */ function throwIfTrue(value: boolean | undefined, errorMessage: string): void;}
/** * Represents a file system that can be interacted with. */export interface FileSystemHost { /** Gets if this file system is case sensitive. */ isCaseSensitive(): boolean; /** Asynchronously deletes the specified file or directory. */ delete(path: string): Promise<void>; /** Synchronously deletes the specified file or directory */ deleteSync(path: string): void; /** * Reads all the child directories and files. * @remarks Implementers should have this return the full file path. */ readDirSync(dirPath: string): RuntimeDirEntry[]; /** Asynchronously reads a file at the specified path. */ readFile(filePath: string, encoding?: string): Promise<string>; /** Synchronously reads a file at the specified path. */ readFileSync(filePath: string, encoding?: string): string; /** Asynchronously writes a file to the file system. */ writeFile(filePath: string, fileText: string): Promise<void>; /** Synchronously writes a file to the file system. */ writeFileSync(filePath: string, fileText: string): void; /** Asynchronously creates a directory at the specified path. */ mkdir(dirPath: string): Promise<void>; /** Synchronously creates a directory at the specified path. */ mkdirSync(dirPath: string): void; /** Asynchronously moves a file or directory. */ move(srcPath: string, destPath: string): Promise<void>; /** Synchronously moves a file or directory. */ moveSync(srcPath: string, destPath: string): void; /** Asynchronously copies a file or directory. */ copy(srcPath: string, destPath: string): Promise<void>; /** Synchronously copies a file or directory. */ copySync(srcPath: string, destPath: string): void; /** Asynchronously checks if a file exists. * @remarks Implementers should throw an `errors.FileNotFoundError` when it does not exist. */ fileExists(filePath: string): Promise<boolean>; /** Synchronously checks if a file exists. * @remarks Implementers should throw an `errors.FileNotFoundError` when it does not exist. */ fileExistsSync(filePath: string): boolean; /** Asynchronously checks if a directory exists. */ directoryExists(dirPath: string): Promise<boolean>; /** Synchronously checks if a directory exists. */ directoryExistsSync(dirPath: string): boolean; /** See https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options */ realpathSync(path: string): string; /** Gets the current directory of the environment. */ getCurrentDirectory(): string; /** Uses pattern matching to find files or directories. */ glob(patterns: ReadonlyArray<string>): Promise<string[]>; /** Synchronously uses pattern matching to find files or directories. */ globSync(patterns: ReadonlyArray<string>): string[];}
/** Utilities for working with files. */export declare class FileUtils { #private; static readonly ENOENT = "ENOENT"; private constructor(); /** * Gets if the error is a file not found or directory not found error. * @param err - Error to check. */ static isNotExistsError(err: any): boolean; /** * Joins the paths. * @param paths - Paths to join. */ static pathJoin<T extends string>(basePath: T, ...paths: string[]): T; /** * Gets if the path is absolute. * @param fileOrDirPath - File or directory path. */ static pathIsAbsolute(fileOrDirPath: string): boolean; /** * Gets the standardized absolute path. * @param fileSystem - File system. * @param fileOrDirPath - Path to standardize. * @param relativeBase - Base path to be relative from. */ static getStandardizedAbsolutePath(fileSystem: FileSystemHost, fileOrDirPath: string, relativeBase?: string): StandardizedFilePath; /** * Gets the directory path. * @param fileOrDirPath - Path to get the directory name from. */ static getDirPath<T extends string>(fileOrDirPath: T): T; /** * Gets the last portion of the path. * @param fileOrDirPath - Path to get the base name from. */ static getBaseName(fileOrDirPath: StandardizedFilePath): string; /** * Gets the extension of the file name. * @param fileOrDirPath - Path to get the extension from. */ static getExtension(fileOrDirPath: StandardizedFilePath): string; /** * Changes all back slashes to forward slashes. * @param fileOrDirPath - Path. */ static standardizeSlashes<T extends string>(fileOrDirPath: T): T; /** * Checks if a path ends with a specified search path. * @param fileOrDirPath - Path. * @param endsWithPath - Ends with path. */ static pathEndsWith(fileOrDirPath: string | undefined, endsWithPath: string | undefined): boolean; /** * Checks if a path starts with a specified search path. * @param fileOrDirPath - Path. * @param startsWithPath - Starts with path. */ static pathStartsWith(fileOrDirPath: string | undefined, startsWithPath: string | undefined): boolean; /** * Gets the parent most paths out of the list of paths. * @param paths - File or directory paths. */ static getParentMostPaths(paths: StandardizedFilePath[]): StandardizedFilePath[]; /** * Reads a file or returns false if the file doesn't exist. * @param fileSystem - File System. * @param filePath - Path to file. * @param encoding - File encoding. */ static readFileOrNotExists(fileSystem: FileSystemHost, filePath: StandardizedFilePath, encoding: string): Promise<string | false>; /** * Reads a file synchronously or returns false if the file doesn't exist. * @param fileSystem - File System. * @param filePath - Path to file. * @param encoding - File encoding. */ static readFileOrNotExistsSync(fileSystem: FileSystemHost, filePath: StandardizedFilePath, encoding: string): string | false; /** * Gets the text with a byte order mark. * @param text - Text. */ static getTextWithByteOrderMark(text: string): string; /** * Gets the relative path from one absolute path to another. * @param absoluteDirPathFrom - Absolute directory path from. * @param absolutePathTo - Absolute path to. */ static getRelativePathTo(absoluteDirPathFrom: StandardizedFilePath, absolutePathTo: StandardizedFilePath): StandardizedFilePath; /** * Gets if the path is for the root directory. * @param path - Path. */ static isRootDirPath(dirOrFilePath: string): boolean; /** * Gets the descendant directories of the specified directory. * @param dirPath - Directory path. */ static getDescendantDirectories(fileSystemWrapper: TransactionalFileSystem, dirPath: StandardizedFilePath): IterableIterator<StandardizedFilePath>; /** * Gets the glob as absolute. * @param glob - Glob. * @param cwd - Current working directory. */ static toAbsoluteGlob(glob: string, cwd: string): string; /** * Gets if the glob is a negated glob. * @param glob - Glob. */ static isNegatedGlob(glob: string): boolean;}
/** An implementation of a file system that exists in memory only. */export declare class InMemoryFileSystemHost implements FileSystemHost { #private; /** * Constructor. */ constructor(); /** @inheritdoc */ isCaseSensitive(): boolean; /** @inheritdoc */ delete(path: string): Promise<void>; /** @inheritdoc */ deleteSync(path: string): void; /** @inheritdoc */ readDirSync(dirPath: string): RuntimeDirEntry[]; /** @inheritdoc */ readFile(filePath: string, encoding?: string): Promise<string>; /** @inheritdoc */ readFileSync(filePath: string, encoding?: string): string; /** @inheritdoc */ writeFile(filePath: string, fileText: string): Promise<void>; /** @inheritdoc */ writeFileSync(filePath: string, fileText: string): void; /** @inheritdoc */ mkdir(dirPath: string): Promise<void>; /** @inheritdoc */ mkdirSync(dirPath: string): void; /** @inheritdoc */ move(srcPath: string, destPath: string): Promise<void>; /** @inheritdoc */ moveSync(srcPath: string, destPath: string): void; /** @inheritdoc */ copy(srcPath: string, destPath: string): Promise<void>; /** @inheritdoc */ copySync(srcPath: string, destPath: string): void; /** @inheritdoc */ fileExists(filePath: string): Promise<boolean>; /** @inheritdoc */ fileExistsSync(filePath: string): boolean; /** @inheritdoc */ directoryExists(dirPath: string): Promise<boolean>; /** @inheritdoc */ directoryExistsSync(dirPath: string): boolean; /** @inheritdoc */ realpathSync(path: string): string; /** @inheritdoc */ getCurrentDirectory(): string; /** @inheritdoc */ glob(patterns: ReadonlyArray<string>): Promise<string[]>; /** @inheritdoc */ globSync(patterns: ReadonlyArray<string>): string[];}
/** Checks the specified file paths to see if the match any of the specified patterns. */export declare function matchGlobs(paths: ReadonlyArray<string>, patterns: string | ReadonlyArray<string>, cwd: string): string[];
/** An implementation of a file host that interacts with the actual file system. */export declare class RealFileSystemHost implements FileSystemHost { #private; /** @inheritdoc */ delete(path: string): Promise<void>; /** @inheritdoc */ deleteSync(path: string): void; /** @inheritdoc */ readDirSync(dirPath: string): RuntimeDirEntry[]; /** @inheritdoc */ readFile(filePath: string, encoding?: string): Promise<string>; /** @inheritdoc */ readFileSync(filePath: string, encoding?: string): string; /** @inheritdoc */ writeFile(filePath: string, fileText: string): Promise<void>; /** @inheritdoc */ writeFileSync(filePath: string, fileText: string): void; /** @inheritdoc */ mkdir(dirPath: string): Promise<void>; /** @inheritdoc */ mkdirSync(dirPath: string): void; /** @inheritdoc */ move(srcPath: string, destPath: string): Promise<void>; /** @inheritdoc */ moveSync(srcPath: string, destPath: string): void; /** @inheritdoc */ copy(srcPath: string, destPath: string): Promise<void>; /** @inheritdoc */ copySync(srcPath: string, destPath: string): void; /** @inheritdoc */ fileExists(filePath: string): Promise<boolean>; /** @inheritdoc */ fileExistsSync(filePath: string): boolean; /** @inheritdoc */ directoryExists(dirPath: string): Promise<boolean>; /** @inheritdoc */ directoryExistsSync(dirPath: string): boolean; /** @inheritdoc */ realpathSync(path: string): string; /** @inheritdoc */ getCurrentDirectory(): string; /** @inheritdoc */ glob(patterns: ReadonlyArray<string>): Promise<string[]>; /** @inheritdoc */ globSync(patterns: ReadonlyArray<string>): string[]; /** @inheritdoc */ isCaseSensitive(): boolean;}
/** Nominal type to denote a file path that has been standardized. */export type StandardizedFilePath = string & { _standardizedFilePathBrand: undefined;};
export interface DirEntry { path: StandardizedFilePath; isFile: boolean; isDirectory: boolean; isSymlink: boolean;}
export interface TransactionalFileSystemOptions { fileSystem: FileSystemHost; skipLoadingLibFiles: boolean | undefined; libFolderPath: string | undefined;}
/** * FileSystemHost wrapper that allows transactionally queuing operations to the file system. */export declare class TransactionalFileSystem { #private; /** * Constructor. * @param fileSystem - File system host to commit the operations to. */ constructor(options: TransactionalFileSystemOptions); queueFileDelete(filePath: StandardizedFilePath): void; removeFileDelete(filePath: StandardizedFilePath): void; queueMkdir(dirPath: StandardizedFilePath): void; queueDirectoryDelete(dirPath: StandardizedFilePath): void; queueMoveDirectory(srcPath: StandardizedFilePath, destPath: StandardizedFilePath): void; queueCopyDirectory(srcPath: StandardizedFilePath, destPath: StandardizedFilePath): void; flush(): Promise<void>; flushSync(): void; saveForDirectory(dirPath: StandardizedFilePath): Promise<void>; saveForDirectorySync(dirPath: StandardizedFilePath): void; moveFileImmediately(oldFilePath: StandardizedFilePath, newFilePath: StandardizedFilePath, fileText: string): Promise<void>; moveFileImmediatelySync(oldFilePath: StandardizedFilePath, newFilePath: StandardizedFilePath, fileText: string): void; deleteFileImmediately(filePath: StandardizedFilePath): Promise<void>; deleteFileImmediatelySync(filePath: StandardizedFilePath): void; copyDirectoryImmediately(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): Promise<void>; copyDirectoryImmediatelySync(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): void; moveDirectoryImmediately(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): Promise<void>; moveDirectoryImmediatelySync(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): void; deleteDirectoryImmediately(dirPath: StandardizedFilePath): Promise<void>; /** Recreates a directory on the underlying file system asynchronously. */ clearDirectoryImmediately(dirPath: StandardizedFilePath): Promise<void>; /** Recreates a directory on the underlying file system synchronously. */ clearDirectoryImmediatelySync(dirPath: StandardizedFilePath): void; deleteDirectoryImmediatelySync(dirPath: StandardizedFilePath): void; fileExists(filePath: StandardizedFilePath): boolean | Promise<boolean>; fileExistsSync(filePath: StandardizedFilePath): boolean; directoryExistsSync(dirPath: StandardizedFilePath): boolean; readFileIfExistsSync(filePath: StandardizedFilePath, encoding: string | undefined): string | undefined; readFileSync(filePath: StandardizedFilePath, encoding: string | undefined): string; readFileIfExists(filePath: StandardizedFilePath, encoding: string | undefined): Promise<string | undefined>; readFile(filePath: StandardizedFilePath, encoding: string | undefined): Promise<string>; readDirSync(dirPath: StandardizedFilePath): DirEntry[]; glob(patterns: ReadonlyArray<string>): Promise<StandardizedFilePath[]>; globSync(patterns: ReadonlyArray<string>): Generator<StandardizedFilePath, void, unknown>; getFileSystem(): FileSystemHost; getCurrentDirectory(): StandardizedFilePath; getDirectories(dirPath: StandardizedFilePath): StandardizedFilePath[]; realpathSync(path: StandardizedFilePath): StandardizedFilePath; getStandardizedAbsolutePath(fileOrDirPath: string, relativeBase?: string): StandardizedFilePath; readFileOrNotExists(filePath: StandardizedFilePath, encoding: string): false | Promise<string | false>; readFileOrNotExistsSync(filePath: StandardizedFilePath, encoding: string): string | false; writeFile(filePath: StandardizedFilePath, fileText: string): Promise<void>; writeFileSync(filePath: StandardizedFilePath, fileText: string): void;}
/** Gets the TypeScript lib files (.d.ts files). */export declare function getLibFiles(): { fileName: string; text: string;}[];
export declare function getLibFolderPath(options: { libFolderPath?: string; skipLoadingLibFiles?: boolean;}): string;
/** The folder to use to "store" the in memory lib files. */export declare const libFolderInMemoryPath: StandardizedFilePath;
/** * Gets the enum name for the specified syntax kind. * @param kind - Syntax kind. */export declare function getSyntaxKindName(kind: ts.SyntaxKind): string;
/** * Holds the compiler options. */export declare class CompilerOptionsContainer extends SettingsContainer<ts.CompilerOptions> { constructor(defaultSettings?: ts.CompilerOptions); /** * Sets one or all of the compiler options. * * WARNING: Setting the compiler options will cause a complete reparse of all the source files. * @param settings - Compiler options to set. */ set(settings: Partial<ts.CompilerOptions>): void; /** * Gets the encoding from the compiler options or returns utf-8. */ getEncoding(): string;}
export declare abstract class SettingsContainer<T extends object> { #private; protected _settings: T; /** * Constructor. * @param defaultSettings - The settings to use by default. */ constructor(defaultSettings: T); /** * Resets the settings to the default. */ reset(): void; /** * Gets a copy of the settings as an object. */ get(): T; /** * Sets one or all of the settings. * @param settings - Settings to set. */ set(settings: Partial<T>): void; /** * Subscribe to modifications in the settings container. * @param action - Action to execute when the settings change. */ onModified(action: () => void): void;}
export declare const runtime: Runtime;
export interface Runtime { fs: RuntimeFileSystem; path: RuntimePath; getEnvVar(name: string): string | undefined; getEndOfLine(): string; getPathMatchesPattern(path: string, pattern: string): boolean;}
export interface RuntimeDirEntry { name: string; isFile: boolean; isDirectory: boolean; isSymlink: boolean;}
export interface RuntimeFileInfo { isFile(): boolean; isDirectory(): boolean;}
export interface RuntimeFileSystem { /** Gets if this file system is case sensitive. */ isCaseSensitive(): boolean; /** Asynchronously deletes the specified file or directory. */ delete(path: string): Promise<void>; /** Synchronously deletes the specified file or directory */ deleteSync(path: string): void; /** Reads all the child directories and files. */ readDirSync(dirPath: string): RuntimeDirEntry[]; /** Asynchronously reads a file at the specified path. */ readFile(filePath: string, encoding?: string): Promise<string>; /** Synchronously reads a file at the specified path. */ readFileSync(filePath: string, encoding?: string): string; /** Asynchronously writes a file to the file system. */ writeFile(filePath: string, fileText: string): Promise<void>; /** Synchronously writes a file to the file system. */ writeFileSync(filePath: string, fileText: string): void; /** Asynchronously creates a directory at the specified path. */ mkdir(dirPath: string): Promise<void>; /** Synchronously creates a directory at the specified path. */ mkdirSync(dirPath: string): void; /** Asynchronously moves a file or directory. */ move(srcPath: string, destPath: string): Promise<void>; /** Synchronously moves a file or directory. */ moveSync(srcPath: string, destPath: string): void; /** Asynchronously copies a file or directory. */ copy(srcPath: string, destPath: string): Promise<void>; /** Synchronously copies a file or directory. */ copySync(srcPath: string, destPath: string): void; /** Asynchronously gets the path's stat information. */ stat(path: string): Promise<RuntimeFileInfo | undefined>; /** Synchronously gets the path's stat information. */ statSync(path: string): RuntimeFileInfo | undefined; /** See https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options */ realpathSync(path: string): string; /** Gets the current directory of the environment. */ getCurrentDirectory(): string; /** Uses pattern matching to find files or directories. */ glob(patterns: ReadonlyArray<string>): Promise<string[]>; /** Synchronously uses pattern matching to find files or directories. */ globSync(patterns: ReadonlyArray<string>): string[];}
export interface RuntimePath { /** Joins the paths. */ join(...paths: string[]): string; /** Normalizes the provided path. */ normalize(path: string): string; /** Returns the relative path from `from` to `to`. */ relative(from: string, to: string): string;}
export declare function matchFiles(this: any, path: string, extensions: ReadonlyArray<string>, excludes: ReadonlyArray<string>, includes: ReadonlyArray<string>, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string, directoryExists: (path: string) => boolean): string[];
export declare function getFileMatcherPatterns(this: any, path: string, excludes: ReadonlyArray<string>, includes: ReadonlyArray<string>, useCaseSensitiveFileNames: boolean, currentDirectory: string): FileMatcherPatterns;
export declare function getEmitModuleResolutionKind(this: any, compilerOptions: ts.CompilerOptions): any;
export interface FileMatcherPatterns { /** One pattern for each "include" spec. */ includeFilePatterns: ReadonlyArray<string>; /** One pattern matching one of any of the "include" specs. */ includeFilePattern: string; includeDirectoryPattern: string; excludePattern: string; basePaths: ReadonlyArray<string>;}
export interface FileSystemEntries { readonly files: ReadonlyArray<string>; readonly directories: ReadonlyArray<string>;}
export declare class ArrayUtils { private constructor(); static isReadonlyArray<T>(a: unknown): a is ReadonlyArray<T>; static isNullOrEmpty<T>(a: ReadonlyArray<T> | undefined): a is undefined; static getUniqueItems<T>(a: ReadonlyArray<T>): T[]; static removeFirst<T>(a: T[], item: T): boolean; static removeAll<T>(a: T[], isMatch: (item: T) => boolean): T[]; static toIterator<T>(items: ReadonlyArray<T>): Generator<T, void, unknown>; static sortByProperty<T>(items: T[], getProp: (item: T) => string | number): T[]; static groupBy<T>(items: ReadonlyArray<T>, getGroup: (item: T) => string | number): T[][]; static binaryInsertWithOverwrite<T>(items: T[], newItem: T, comparer: Comparer<T>): void; static binarySearch<T>(items: ReadonlyArray<T>, storedComparer: StoredComparer<T>): number; static containsSubArray<T>(items: ReadonlyArray<T>, subArray: ReadonlyArray<T>): boolean;}
/** * Deep clones an object not maintaining references. * @remarks If this has a circular reference it will go forever so be careful. */export declare function deepClone<T extends object>(objToClone: T): T;
/** * Event container subscription type */export type EventContainerSubscription<EventArgType> = (arg: EventArgType) => void;
/** * Event container for event subscriptions. */export declare class EventContainer<EventArgType = undefined> { #private; /** * Subscribe to an event being fired. * @param subscription - Subscription. */ subscribe(subscription: EventContainerSubscription<EventArgType>): void; /** * Unsubscribe to an event being fired. * @param subscription - Subscription. */ unsubscribe(subscription: EventContainerSubscription<EventArgType>): void; /** * Fire an event. */ fire(arg: EventArgType): void;}
export declare class IterableUtils { static find<T>(items: IterableIterator<T>, condition: (item: T) => boolean): T | undefined;}
export declare function nameof<TObject>(obj: TObject, key: keyof TObject): string;
export declare function nameof<TObject>(key: keyof TObject): string;
export declare class ObjectUtils { private constructor(); static clone<T>(obj: T): T;}
export declare class StringUtils { private constructor(); static isWhitespaceCharCode(charCode: number | undefined): boolean; static isSpaces(text: string): boolean; static hasBom(text: string): boolean; static stripBom(text: string): string; static stripQuotes(text: string): string; static isQuoted(text: string): boolean; static isNullOrWhitespace(str: string | undefined): str is undefined; static isNullOrEmpty(str: string | undefined): str is undefined; static isWhitespace(text: string | undefined): boolean; static startsWithNewLine(str: string | undefined): boolean; static endsWithNewLine(str: string | undefined): boolean; static insertAtLastNonWhitespace(str: string, insertText: string): string; static getLineNumberAtPos(str: string, pos: number): number; static getLengthFromLineStartAtPos(str: string, pos: number): number; static getLineStartFromPos(str: string, pos: number): number; static getLineEndFromPos(str: string, pos: number): number; static escapeForWithinString(str: string, quoteKind: "\"" | "'"): string; /** * Escapes all the occurrences of the char in the string. */ static escapeChar(str: string, char: string): string; static removeIndentation(str: string, opts: { isInStringAtPos: (pos: number) => boolean; indentSizeInSpaces: number; }): string; static indent(str: string, times: number, options: { indentText: string; indentSizeInSpaces: number; isInStringAtPos: (pos: number) => boolean; }): string;}// @deno-types="./typescript.d.ts"
import { CompilerOptions, DiagnosticCategory, EditorSettings, EmitHint, LanguageVariant, ModuleKind, ModuleResolutionKind, NewLineKind, NodeFlags, ObjectFlags, ScriptKind, ScriptTarget, SymbolFlags, SyntaxKind, TypeFlags, TypeFormatFlags } from "./typescript.js";export { ts, CompilerOptions, DiagnosticCategory, EditorSettings, EmitHint, LanguageVariant, ModuleKind, ModuleResolutionKind, NewLineKind, NodeFlags, ObjectFlags, ScriptKind, ScriptTarget, SymbolFlags, SyntaxKind, TypeFlags, TypeFormatFlags };
ts_morph
Version Info
2 months ago
