@artel/artc 0.6.25191

package/build/types/services/signature-help/SignatureWithValueParameters.d.ts

@@ -0,0 +1,114 @@
+import { Localization, WithLocalization } from '../../analysis/Localization.js';
+import { SubstitutedMethod } from '../../analysis/SubstitutedMethod.js';
+import { Analyzer } from '../../analysis/index.js';
+import { Name } from '../../common/index.js';
+import { MethodEntity, ParameterVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+export declare class ValueArgumentFactory {
+    private static createValueArgumentFromCallArgument;
+    private static createValueArgumentFromIndexerArgument;
+    static createValueArgumentsOfCallExpression(node: tree.CallExpression): ValueArgument[];
+    static createValueArgumentsOfAutotypeCallExpression(node: tree.AutotypeCallExpression): ValueArgument[];
+    static createValueArgumentsOfIndexedAccessExpression(node: tree.IndexedAccessExpression): ValueArgument[];
+    static createValueArgumentsOfTag(node: tree.Tag): ValueArgument[];
+    private static createValueArgumentsFromListElement;
+}
+export declare class SignatureForNode {
+    static getSignaturesForNode(analyzer: Analyzer, node: NodeWithValueArguments): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForCallExpression(analyzer: Analyzer, node: tree.CallExpression): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForAutotypeCallExpression(analyzer: Analyzer, node: tree.AutotypeCallExpression): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForIndexedAccessExpression(analyzer: Analyzer, node: tree.IndexedAccessExpression): SignaturesWithSingleSuitable | undefined;
+    static getSignaturesForTag(analyzer: Analyzer, node: tree.Tag): SignaturesWithSingleSuitable | undefined;
+}
+export declare class SimplifiedArgumentToParameterMatcher {
+    static match(analyzer: Analyzer, arguments_: readonly ValueArgument[], signature: Signature): SimplifiedArgumentToParameterMatchResult;
+}
+export declare class SimplifiedArgumentToParameterMatchResult {
+    readonly arguments: readonly ValueArgument[];
+    readonly parameterByArgumentIndex: ReadonlyArray<ValueParameter | undefined>;
+    private readonly _parameterByArgument;
+    get parameterByArgument(): ReadonlyMap<ValueArgument, ValueParameter>;
+    constructor(arguments_: readonly ValueArgument[], parameterByArgumentIndex: ReadonlyArray<ValueParameter | undefined>);
+}
+export declare class SimplifiedOverloadResolver {
+    static isSuitableSignature(analyzer: Analyzer, matchedSignature: MatchedSignature, valueArguments: readonly ValueArgument[]): boolean;
+    static getMostSuitableSignatureIndex(analyzer: Analyzer, matchedSignatures: readonly MatchedSignature[], valueArguments: readonly ValueArgument[]): number;
+}
+export type NodeWithValueArguments = tree.CallExpression | tree.AutotypeCallExpression | tree.IndexedAccessExpression | tree.Tag;
+export declare class ValueArgument {
+    readonly name: string | undefined;
+    readonly expression: tree.Expression | undefined;
+    constructor(name: string | undefined, expression: tree.Expression | undefined);
+}
+export declare class SignaturesWithSingleSuitable {
+    readonly values: readonly Signature[];
+    readonly suitableSignatureIndex: number | undefined;
+    constructor(values: readonly Signature[], suitableSignatureIndex: number | undefined);
+}
+export declare class MatchedSignature {
+    readonly value: Signature;
+    readonly matchResult: SimplifiedArgumentToParameterMatchResult;
+    constructor(value: Signature, matchResult: SimplifiedArgumentToParameterMatchResult);
+}
+export type Signature = MethodEntitySignature | TypeMethodSignature | SubstitutedMethodSignature | MethodTypeSignature | ConstructorSignature | IndexerSignature;
+export declare class MethodEntitySignature implements ISignature {
+    readonly kind = "method-entity";
+    readonly method: WithLocalization<MethodEntity>;
+    private readonly _valueParameters;
+    constructor(method: WithLocalization<MethodEntity>);
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class TypeMethodSignature implements ISignature {
+    readonly kind = "type-method";
+    readonly method: WithLocalization<types.Method>;
+    private readonly _valueParameters;
+    constructor(method: WithLocalization<types.Method>);
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class SubstitutedMethodSignature implements ISignature {
+    readonly kind = "substituted-method";
+    readonly method: WithLocalization<SubstitutedMethod>;
+    private readonly _valueParameters;
+    constructor(method: WithLocalization<SubstitutedMethod>);
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class MethodTypeSignature implements ISignature {
+    readonly kind = "method-type";
+    readonly methodType: types.MethodType;
+    private readonly _valueParameters;
+    constructor(methodType: types.MethodType);
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class ConstructorSignature implements ISignature {
+    readonly kind = "constructor";
+    readonly constructor_: WithLocalization<types.Constructor>;
+    private readonly _valueParameters;
+    constructor(constructor_: WithLocalization<types.Constructor>);
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class IndexerSignature implements ISignature {
+    readonly kind = "indexer";
+    readonly indexer: WithLocalization<types.Indexer>;
+    private readonly _valueParameters;
+    constructor(indexer: WithLocalization<types.Indexer>);
+    getValueParameters(): readonly ValueParameter[];
+}
+interface ISignature {
+    getValueParameters(): readonly ValueParameter[];
+}
+export type ValueParameter = UniversalValueParameter;
+export declare class UniversalValueParameter implements IValueParameter {
+    readonly name: Name;
+    readonly type: types.Type;
+    readonly entity: ParameterVariableEntity;
+    readonly localization: Localization;
+    constructor(name: Name, type: types.Type, entity: ParameterVariableEntity, localization: Localization);
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IValueParameter {
+    getName(): Name;
+    getType(): types.Type;
+}
+export {};

package/build/types/services/signature-help/TypeParameterSignatureHelpProvider.d.ts

@@ -0,0 +1,20 @@
+import { Analyzer } from '../../analysis/index.js';
+import { SourceFile } from '../../project/index.js';
+import { SignatureHelp } from './SignatureHelpService.js';
+export declare class TypeParameterSignatureHelpProvider {
+    private readonly _signatureContext;
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _offset;
+    private get signatureContext();
+    constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
+    provideSignatureHelp(): SignatureHelp | undefined;
+    private getNodeWithTypeArgumentsInfoAtOffset;
+    private getArgumentIndex;
+    private countArguments;
+    private getSignaturesForNode;
+    private getSignaturesForNamedTypeSpecifier;
+    private getSignaturesForGenericSpecializationExpression;
+    private getSignatureForSubstitutedMethod;
+    private getSignatureForNamedType;
+}

package/build/types/services/signature-help/ValueParametersSignatureHelpProvider.d.ts

@@ -0,0 +1,15 @@
+import { Analyzer } from '../../analysis/index.js';
+import { SourceFile } from '../../project/index.js';
+import { SignatureHelp } from './SignatureHelpService.js';
+export declare class ValueParametersSignatureHelpProvider {
+    private readonly _signatureContext;
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _offset;
+    private get signatureContext();
+    constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
+    provideSignatureHelp(): SignatureHelp | undefined;
+    private getNodeWithValueArgumentsInfoAtOffset;
+    private getArgumentIndexInList;
+    private getSignatureDisplayParts;
+}

package/build/types/services/signature-help/utils.d.ts

@@ -0,0 +1,9 @@
+import { SignatureInfo } from './SignatureHelpService.js';
+export declare class SignatureDisplayParts {
+    readonly prefix: string;
+    readonly parameters: readonly string[];
+    readonly parameterSeparator: string;
+    readonly postfix: string;
+    constructor(prefix: string, parameters: readonly string[], parameterSeparator: string, postfix: string);
+}
+export declare function convertSignatureDisplayPartsToSignatureInfo(displayParts: SignatureDisplayParts, activeParameterIndex: number): SignatureInfo;

package/build/types/services/source-generation/EntityToSyntax.d.ts

@@ -0,0 +1,47 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { LocalizationContext } from '../../analysis/LocalizationContext.js';
+import { PackageEntity } from '../../entities/PackageEntity.js';
+import * as tree from '../../tree/green/index.js';
+export declare class EntityToSyntax {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _localizationContext;
+    constructor(analyzer: Analyzer, entity: PackageEntity, localizationContext: LocalizationContext | undefined);
+    convert(): tree.SourceFile;
+    private convertPackage;
+    private convertNamedPackageMember;
+    private convertPackageVariable;
+    private convertPackageMethod;
+    private convertPackageStructuredType;
+    private convertPackageAliasType;
+    private convertPackageVariantType;
+    private convertPackageMethodType;
+    private convertTypeEntityMembers;
+    private convertTypeVariable;
+    private convertTypeMethod;
+    private convertTypeConstructor;
+    private convertTypeDestructor;
+    private convertTypeIndexer;
+    private convertVariants;
+    private convertVariant;
+    private createStructuredTypeDeclarationBody;
+    private createAliasTypeDeclarationBody;
+    private createVariantTypeDeclarationBody;
+    private createMethodTypeDeclarationBody;
+    private convertTypeParameters;
+    private convertTypeParameter;
+    private convertValueParameters;
+    private convertValueParameter;
+    private createHidingModifier;
+    private convertTags;
+    private getEntityName;
+    private convertType;
+    private convertStructuredType;
+    private convertVariantType;
+    private convertMethodType;
+    private convertAliasType;
+    private convertParameterType;
+    private convertUnionType;
+    private convertUnresolvedType;
+    private createNamedTypeSpecifier;
+}

package/build/types/services/source-generation/SourceGenerationService.d.ts

@@ -0,0 +1,22 @@
+import { ObservableObject } from 'reactronic';
+import { Analyzer, TsInteropInputs } from '../../analysis/Analyzer.js';
+import { LocalizationContext } from '../../analysis/LocalizationContext.js';
+import { Entity } from '../../entities/index.js';
+import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
+import { SourceLocation } from '../Types.js';
+import { CompilationController, ReadonlyClientTrackedSourceFiles } from '../workspace/index.js';
+export declare class SourceGenerationService extends ObservableObject {
+    private readonly _trackedSourceFiles;
+    private readonly _tsLibrariesProvider;
+    private readonly _configurationPackagesTsInteropInputs;
+    private readonly _generatedPackageStates;
+    get compilationControllers(): readonly CompilationController[];
+    constructor(_trackedSourceFiles: ReadonlyClientTrackedSourceFiles, _tsLibrariesProvider: TypeScriptLibrariesProvider, _configurationPackagesTsInteropInputs: TsInteropInputs);
+    getDefinitionInGeneratedCode(analyzer: Analyzer, entity: Entity, localizationContext: LocalizationContext | undefined): Promise<SourceLocation[] | undefined>;
+    entityDefinitionRequiresSourceGeneration(entity: Entity): boolean;
+    protected onOpenedSourceFilesChanged(): void;
+    private getOrGeneratePackageSource;
+    private createGeneratedPackageConfiguration;
+    private checkIfEntityOfKindIsPresentInGeneratedCode;
+    private setDeleteGeneratedPackageTimeout;
+}

package/build/types/services/workspace/ClientTrackedSourceFiles.d.ts

@@ -0,0 +1,41 @@
+import { ObservableMap, ObservableObject } from 'reactronic';
+import { Uri } from '../../common/index.js';
+export declare class ClientTrackedSourceFiles extends ObservableObject implements ReadonlyClientTrackedSourceFiles {
+    readonly items: ObservableMap<string, ClientTrackedSourceFile>;
+    get unsaved(): Map<string, ClientTrackedSourceFile>;
+    track(uri: Uri, text: string, version: number): ClientTrackedSourceFile | undefined;
+    update(uri: Uri, text: string, version: number): ClientTrackedSourceFile | undefined;
+    update(uri: Uri, applyEdits: (text: string) => string, version: number): ClientTrackedSourceFile | undefined;
+    update(uri: Uri, textOrEditor: string | ((text: string) => string), version: number): ClientTrackedSourceFile | undefined;
+    save(uri: Uri): void;
+    close(uri: Uri): void;
+    createItemsSnapshot(): Map<string, ClientTrackedSourceFileSnapshot>;
+    dispose(): void;
+}
+export interface ReadonlyClientTrackedSourceFiles {
+    readonly items: ObservableMap<string, ReadonlyClientTrackedSourceFile>;
+    readonly unsaved: Map<string, ReadonlyClientTrackedSourceFile>;
+    createItemsSnapshot(): Map<string, ClientTrackedSourceFileSnapshot>;
+}
+export declare class ClientTrackedSourceFile extends ObservableObject {
+    readonly uri: Uri;
+    text: string;
+    version: number;
+    isSaved: boolean;
+    constructor(uri: Uri, text: string, version: number, isSaved: boolean);
+    createSnapshot(): ClientTrackedSourceFileSnapshot;
+    dispose(): void;
+}
+export interface ReadonlyClientTrackedSourceFile {
+    readonly uri: Uri;
+    readonly text: string;
+    readonly version: number;
+    readonly isSaved: boolean;
+}
+export declare class ClientTrackedSourceFileSnapshot {
+    readonly uri: Uri;
+    readonly text: string;
+    readonly version: number;
+    readonly isSaved: boolean;
+    constructor(uri: Uri, text: string, version: number, isSaved: boolean);
+}

package/build/types/services/workspace/CompilationController.d.ts

@@ -0,0 +1,108 @@
+import { Indicator, ObservableObject } from 'reactronic';
+import { Analyzer, TsInteropInputs } from '../../analysis/index.js';
+import { CancellationToken, Uri } from '../../common/index.js';
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { ConvertedConfiguration, ProgramPackageConfiguration, SourceFile, fsTree } from '../../project/index.js';
+import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
+import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
+export declare class CompilationController extends ObservableObject {
+    readonly mainCompilationReloadIndicator: Indicator;
+    readonly configurationControllersUpdateIndictor: Indicator;
+    private readonly _mainAnalyzerChangedIndicator;
+    private readonly _fileSystemTree;
+    readonly config: CompilationControllerConfig;
+    isConfigurationsProcessingEnabled: boolean;
+    isDiagnosticsCollectionInBackgroundEnabled: boolean;
+    private readonly _rootDirectory;
+    private _configurationControllerByPackageUri;
+    private _mainCompilationState?;
+    private _previousCompilationLoadResult;
+    private _sourceFilesForWhichDiagnosticsWereReported;
+    private readonly _checkedConfigurationVersionByPackageUri;
+    private _packageConfigurationsVersion;
+    private _packageConfigurationsVersionDuringCompilationLoad;
+    private _tsInteropInputs;
+    private _tsProgramLoaderInputs;
+    private _state;
+    private _builtInSystemPackagesConfigurations;
+    private _configurationsOfPackagesOutsideProject;
+    get uri(): Uri;
+    get mainCompilationState(): ReadonlyCompilationState | undefined;
+    get configurationControllerByPackageUri(): ReadonlyMap<string, ConfigurationController>;
+    get state(): CompilationControllerState;
+    constructor(config: CompilationControllerConfig);
+    waitFullyLoaded(): Promise<void>;
+    getStateOfCompilationContainingItemAtUri(uri: Uri): Promise<ReadonlyCompilationState | undefined>;
+    notifyReportedSourceFileDiagnostics(uri: Uri, compilationVersion: number): void;
+    isLastReportedSourceFileDiagnosticsUpToDate(uri: Uri, compilationVersion: number): boolean;
+    reportDiagnosticsCollectedInBackground(sourceFile: SourceFile, trackedVersion: number | undefined, diagnostics: readonly Diagnostic[], compilationVersion: number): Promise<void>;
+    dispose(): void;
+    private reloadMainCompilation;
+    private updateTsInteropInputs;
+    private updateState;
+    private updateConfigurationControllers;
+    private onConfigurationsUpdated;
+    private onMainAnalyzerChanged;
+    private collectDiagnosticsInBackground;
+    private onRawPackageConfigurationsUpdated;
+    private createConfigurationProvider;
+    private findConfigurationDirectories;
+}
+export interface CompilationControllerConfig {
+    readonly rootDirectory: fsTree.Directory;
+    readonly fileSystemTree: fsTree.ReadonlyFileSystemTree;
+    readonly tsLibrariesProvider: TypeScriptLibrariesProvider;
+    readonly configurationPackagesTsInteropInputs: TsInteropInputs;
+    readonly trackedSourceFiles: ReadonlyClientTrackedSourceFiles;
+    readonly diagnosticsCollectedInBackgroundHandler?: DiagnosticsCollectedInBackgroundHandler;
+    readonly rawPackageConfigurationsChangedHandler?: RawPackageConfigurationsChangedHandler;
+    readonly mainPackageConfigurationIfMissing?: ProgramPackageConfiguration;
+    readonly getTreatRootAsPackageIfConfigIsMissing?: () => boolean;
+    readonly standardPackagesUri?: Uri;
+}
+export declare enum CompilationControllerState {
+    Created = 0,
+    ProcessingInitialPackageConfigs = 1,
+    ProcessedPackageConfigsWithErrors = 2,
+    LoadedMainCompilation = 3
+}
+export type DiagnosticsCollectedInBackgroundHandler = (sourceFile: SourceFile, trackedVersion: number | undefined, diagnostics: readonly Diagnostic[], compilationVersion: number, controller: CompilationController) => Promise<void>;
+export type RawPackageConfigurationsChangedHandler = (configurations: readonly ChangedPackageConfiguration[]) => Promise<void>;
+export declare class ChangedPackageConfiguration {
+    readonly packageUri: Uri;
+    readonly hasError: boolean;
+    constructor(packageUri: Uri, hasError: boolean);
+}
+export declare class ReadonlyCompilationState {
+    readonly analyzer: Analyzer;
+    readonly version: number;
+    private _diagnosticsCollectionSummaryByUri;
+    constructor(analyzer: Analyzer, version: number);
+    collectSourceFileDiagnosticsWithHighPriority(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<readonly Diagnostic[]>;
+    collectSourceFileDiagnosticsWithLowPriority(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<readonly Diagnostic[]>;
+    getDiagnosticsCollectionSummary(sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<DiagnosticsCollectionSummary>;
+    private collectSourceFileDiagnostics;
+    private createDiagnosticsCollectionSummary;
+}
+export declare class DiagnosticsCollectionSummary {
+    readonly hasErrors: boolean;
+    constructor(hasErrors: boolean);
+}
+declare class ConfigurationController extends ObservableObject {
+    readonly packageUri: Uri;
+    readonly processingIndicator: Indicator;
+    readonly rootDirectory: fsTree.Directory;
+    private readonly _mainCompilationController;
+    private _jsonConfigurationFile;
+    private _convertedJsonConfigurationFileVersion;
+    private _convertedConfiguration;
+    private _convertedConfigurationVersion;
+    get convertedConfiguration(): ConvertedConfiguration | undefined;
+    get convertedConfigurationVersion(): number;
+    get hasConvertedConfiguration(): boolean;
+    constructor(rootDirectory: fsTree.Directory, packageUri: Uri, mainCompilationController: CompilationController);
+    dispose(): void;
+    protected updateJsonConfigurationFile(): void;
+    protected processConfiguration(): Promise<void>;
+}
+export {};

package/build/types/services/workspace/FileSystemTreeProviderBasedOnWatchedFileSystem.d.ts

@@ -0,0 +1,61 @@
+import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { CancellationToken, Uri } from '../../common/index.js';
+import * as fsTree from '../../project/FileSystemTree.js';
+import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
+import { FileSystemTreeProvider } from './WorkspaceFiles.js';
+import type { WorkspaceFileSystem } from './WorkspaceFileSystem.js';
+export declare class FileSystemTreeProviderBasedOnWatchedFileSystem extends ObservableObject implements FileSystemTreeProvider {
+    readonly fileSystemTree: fsTree.FileSystemTree;
+    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    private readonly _fileSystem;
+    private readonly _notificationsPublisher;
+    private readonly _listener;
+    private _workspaceFolderUris;
+    private _trackedSourceFiles;
+    private _lastCheckedWorkspaceFolderUris;
+    /**
+     * Очередь используется для обработки запросов, изменяющих дерево файловой системы.
+     * Очередь позволяет избежать конкурентного редактирования, а также сохранить порядок обработки.
+     */
+    private readonly _taskQueue;
+    private readonly _namesOfDirectoriesToIgnore;
+    private readonly _lastCheckedTrackedSourceFileInfoVersionByUri;
+    private readonly _loadedDirectoryUris;
+    constructor(fileSystem: WorkspaceFileSystem, notificationsPublisher: FileSystemUpdateNotificationsPublisher, namesOfDirectoriesToIgnore?: string[]);
+    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    waitLoaded(cancellationToken: CancellationToken): Promise<void>;
+    dispose(): void;
+    protected onTrackedSourceFilesUpdated(): void;
+    protected onWorkspaceFolderUrisUpdated(): void;
+    protected updateLoadedWorkspaceFolders(): void;
+    private onFileSystemUpdated;
+    private addWorkspaceFoldersWorker;
+    private removeWorkspaceFoldersWorker;
+    private deleteDirectoryContentsPreservingGivingDirectories;
+    private onFileSystemTreeUpdatedWorker;
+    private stopTrackingSourceFile;
+    private uriBelongsToWorkspace;
+    private createFileSystemTreeUpdateFromUpdateNotification;
+    private updateFileSystemTree;
+    private isUpdateRelatedToIgnoredDirectory;
+    private loadDirectoryFromFileSystemRecursively;
+    private loadNodeModulesPackagesFromFileSystemRecursively;
+    private deleteFileSystemTreeDirectory;
+}
+export type FileSystemUpdateNotificationsListener = (notifications: readonly FileSystemUpdateNotification[]) => void;
+export interface FileSystemUpdateNotificationsPublisher {
+    addListener(listener: FileSystemUpdateNotificationsListener): void;
+    removeListener(listener: FileSystemUpdateNotificationsListener): void;
+}
+export declare class SimpleFileSystemUpdateNotificationsPublisher implements FileSystemUpdateNotificationsPublisher {
+    private readonly _listeners;
+    publish(notifications: readonly FileSystemUpdateNotification[]): void;
+    addListener(listener: FileSystemUpdateNotificationsListener): void;
+    removeListener(listener: FileSystemUpdateNotificationsListener): void;
+}
+export type FileSystemUpdateNotificationKind = 'created' | 'updated' | 'deleted';
+export declare class FileSystemUpdateNotification {
+    readonly uri: Uri;
+    readonly kind: FileSystemUpdateNotificationKind;
+    constructor(uri: Uri, kind: FileSystemUpdateNotificationKind);
+}

package/build/types/services/workspace/ManuallyUpdatedFileSystemTreeProvider.d.ts

@@ -0,0 +1,21 @@
+import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { CancellationToken } from '../../common/CancellationToken.js';
+import { Uri } from '../../common/Uri.js';
+import * as fsTree from '../../project/FileSystemTree.js';
+import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
+import { FileSystemTreeProvider } from './WorkspaceFiles.js';
+export declare class ManuallyUpdatedFileSystemTreeProvider extends ObservableObject implements FileSystemTreeProvider {
+    readonly fileSystemTree: fsTree.FileSystemTree;
+    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    private _workspaceFolderUris;
+    private _trackedSourceFiles;
+    private readonly _lastCheckedTrackedSourceFileInfoByUri;
+    private readonly _manuallyCreatedSourceFileTextByUri;
+    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    waitLoaded(_cancellationToken: CancellationToken): Promise<void>;
+    dispose(): void;
+    createOrUpdateSourceFile(uri: Uri, text: string): void;
+    deleteSourceFile(uri: Uri): void;
+    protected onTrackedSourceFilesUpdated(): void;
+    protected updateLoadedWorkspaceFolderByUri(): void;
+}

package/build/types/services/workspace/Workspace.d.ts

@@ -0,0 +1,59 @@
+import { ObservableMap, ObservableObject } from 'reactronic';
+import { Analyzer, TsInteropInputs } from '../../analysis/index.js';
+import { CancellationToken, Uri } from '../../common/index.js';
+import * as fsTree from '../../project/FileSystemTree.js';
+import { SourceFile, SourcePackage } from '../../project/index.js';
+import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
+import { ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
+import { CompilationController, DiagnosticsCollectedInBackgroundHandler, RawPackageConfigurationsChangedHandler } from './CompilationController.js';
+import { FileSystemTreeProvider } from './WorkspaceFiles.js';
+export declare class Workspace extends ObservableObject {
+    isReadyToAcceptWorkspaceDiagnostics: boolean;
+    private readonly _config;
+    private readonly _compilationControllers;
+    private readonly _controllersWithOpenedFiles;
+    private _atLeastOneFileOfCompilationHasBeenOpened;
+    private readonly _files;
+    get compilationControllers(): readonly CompilationController[];
+    get trackedSourceFiles(): ReadonlyClientTrackedSourceFiles;
+    get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;
+    get workspaceFolderUris(): readonly Uri[];
+    private get compilationControllerByUri();
+    get configurationPackagesTsInteropInputs(): TsInteropInputs;
+    private constructor();
+    static create(config: WorkspaceConfig): Promise<Workspace>;
+    addWorkspaceFolders(uris: readonly Uri[]): void;
+    removeWorkspaceFolders(uris: readonly Uri[]): void;
+    notifyOpenedTextDocument(uri: Uri, text: string, version: number): void;
+    notifyUpdatedTextDocument(uri: Uri, text: string, version: number): void;
+    notifyUpdatedTextDocument(uri: Uri, applyEdit: (text: string) => string, version: number): void;
+    notifyUpdatedTextDocument(uri: Uri, textOrEditor: string | ((text: string) => string), version: number): void;
+    notifySavedTextDocument(uri: Uri): void;
+    notifyClosedTextDocument(uri: Uri): void;
+    waitLoadedAndGetWorkspaceElementInfo(uri: Uri, cancellationToken: CancellationToken): Promise<WorkspaceElementInfo | undefined>;
+    dispose(): void;
+    protected updateCompilationControllers(): void;
+    protected processControllersWithUnprocessedConfigs(): Promise<void>;
+    protected updateIsDiagnosticsCollectionInBackgroundEnabled(): void;
+    protected updateControllersWithOpenedFiles(): Promise<void>;
+    private deleteCompilationController;
+    private createCompilationController;
+    private getControllerToLoad;
+    private isCompilationControllerStateWithProcessedConfigs;
+    private waitForControllerToFullyLoad;
+}
+export interface WorkspaceElementInfo {
+    compilationController: CompilationController;
+    analyzer: Analyzer;
+    package?: SourcePackage;
+    sourceFile?: SourceFile;
+}
+export interface WorkspaceConfig {
+    readonly fileSystemTreeProvider: FileSystemTreeProvider;
+    readonly tsLibrariesProvider: TypeScriptLibrariesProvider;
+    readonly diagnosticsCollectedInBackgroundHandler?: DiagnosticsCollectedInBackgroundHandler;
+    readonly rawPackageConfigurationsChangedHandler?: RawPackageConfigurationsChangedHandler;
+    readonly initiallyOpenedFileUris?: readonly Uri[];
+    readonly namesOfDirectoriesToIgnore?: readonly string[];
+    readonly standardPackagesUri?: Uri;
+}

package/build/types/services/workspace/WorkspaceFileSystem.d.ts

@@ -0,0 +1,5 @@
+import { Uri } from '../../common/index.js';
+import { DirectoryEntry, SourcesProvider } from '../../project/index.js';
+export interface WorkspaceFileSystem extends SourcesProvider {
+    readEntry(uri: Uri): Promise<DirectoryEntry | undefined>;
+}

package/build/types/services/workspace/WorkspaceFiles.d.ts

@@ -0,0 +1,35 @@
+import { ObservableArray, ObservableMap, ObservableObject } from 'reactronic';
+import { CancellationToken, Uri } from '../../common/index.js';
+import * as fsTree from '../../project/FileSystemTree.js';
+import { ClientTrackedSourceFiles, ReadonlyClientTrackedSourceFiles } from './ClientTrackedSourceFiles.js';
+export declare class WorkspaceFiles extends ObservableObject {
+    readonly trackedSourceFiles: ClientTrackedSourceFiles;
+    readonly workspaceFolderUris: ObservableArray<Uri>;
+    readonly workspaceFolderWithArtelProjectByUri: ObservableMap<string, fsTree.Directory>;
+    private readonly _fileSystemTreeProvider;
+    get fileSystemTree(): fsTree.ReadonlyFileSystemTree;
+    get isMissingConfigurationDirectoryAllowed(): boolean;
+    get loadedWorkspaceFolderByUri(): ObservableMap<string, fsTree.Directory>;
+    constructor(fileSystemTreeProvider: FileSystemTreeProvider);
+    addWorkspaceFolders(uris: readonly Uri[]): void;
+    removeWorkspaceFolders(uris: readonly Uri[]): void;
+    trackSourceFile(uri: Uri, text: string, version: number): void;
+    updateTrackedSourceFile(uri: Uri, text: string, version: number): void;
+    updateTrackedSourceFile(uri: Uri, applyEdit: (text: string) => string, version: number): void;
+    updateTrackedSourceFile(uri: Uri, textOrEditor: string | ((text: string) => string), version: number): void;
+    notifyTrackedSourceFileSaved(uri: Uri): void;
+    stopTrackingSourceFile(uri: Uri): void;
+    waitLoaded(cancellationToken: CancellationToken): Promise<void>;
+    dispose(): void;
+    protected updateWorkspaceFolderWithArtelProjectByUri(): void;
+}
+export interface FileSystemTreeProvider {
+    readonly fileSystemTree: fsTree.ReadonlyFileSystemTree;
+    readonly loadedWorkspaceFolderByUri: ObservableMap<string, fsTree.Directory>;
+    /**
+     * Должен быть вызван до вызова всех остальных методов.
+     */
+    initialize(workspaceFolderUris: ObservableArray<Uri>, trackedSourceFiles: ReadonlyClientTrackedSourceFiles): void;
+    waitLoaded(cancellationToken: CancellationToken): Promise<void>;
+    dispose(): void;
+}

package/build/types/services/workspace/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ClientTrackedSourceFiles.js';
+export * from './CompilationController.js';
+export * from './FileSystemTreeProviderBasedOnWatchedFileSystem.js';
+export * from './ManuallyUpdatedFileSystemTreeProvider.js';
+export * from './Workspace.js';
+export * from './WorkspaceFiles.js';
+export * from './WorkspaceFileSystem.js';

package/build/types/tree/KeywordKind.d.ts

@@ -0,0 +1,64 @@
+export declare enum KeywordKind {
+    Unknown = 0,
+    Let = 1,
+    Autotype = 2,
+    Aspect = 3,
+    Object = 4,
+    PlainObject = 5,
+    Variant = 6,
+    Run = 7,
+    From = 8,
+    Else = 9,
+    ElseIf = 10,
+    Operation = 11,
+    If = 12,
+    Is = 13,
+    Return = 14,
+    Type = 15,
+    Import = 16,
+    Error = 17,
+    Finally = 18,
+    And = 19,
+    Or = 20,
+    Xor = 21,
+    While = 22,
+    Loop = 23,
+    RepeatWhile = 24,
+    Yield = 25,
+    When = 26,
+    OnCreate = 27,
+    OnError = 28,
+    BreakLoop = 29,
+    ContinueLoop = 30,
+    For = 31,
+    Const = 32,
+    Hidden = 33,
+    Observable = 34,
+    Consistent = 35,
+    Abstract = 36,
+    Redefinable = 37,
+    Redefined = 38,
+    Transactional = 39,
+    Unobservable = 40,
+    Async = 41,
+    Static = 42,
+    As = 43,
+    Not = 44,
+    Switch = 45,
+    Case = 46,
+    Await = 47,
+    Dispose = 48,
+    OnDispose = 49,
+    InFamily = 50,
+    InFile = 51,
+    InPackage = 52,
+    InType = 53,
+    Yes = 54,
+    No = 55,
+    Reference = 56,
+    Translations = 57,
+    Base = 58,
+    None = 59,
+    Get = 60,
+    Set = 61
+}