@artel/artc 0.6.25280 → 0.6.25282

package/build/types/analysis/ObjectExpressionMeaning.d.ts

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -10,19 +10,14 @@ import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: tree.ObjectExpression);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.ObjectExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveOwnConstructorAccess;
     private resolveContextAccess;
     private invalidContextDiagnostic;
     private findContainingConstructor;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionResult;
-}
 export type Meaning = Meaning_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
 declare class Meaning_ownConstructorAccess {
     /**

package/build/types/analysis/{PackageMemberNameConflictsValidator.d.ts → PackageMemberConflictsValidator.d.ts}

@@ -1,23 +1,27 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageEntityMembers } from '../entities/PackageMembers.js';
-import { ProgramPackage } from '../project/SourcePackage.js';
+import { PackageEntityMembers } from '../entities/index.js';
+import { ProgramOrTextTranslationPackage } from '../project/SourcePackage.js';
 import { Analyzer } from './Analyzer.js';
-export declare class PackageMemberNameConflictsValidator {
+export declare class PackageMemberConflictsValidator {
     private readonly analyzer;
     private readonly members;
     private readonly diagnostics;
     constructor(analyzer: Analyzer, members: PackageEntityMembers);
     validate(): readonly Diagnostic[];
+    private validateNameConflicts;
+    private validateTextConflicts;
     private validateFunctionNameConflicts;
     private validateTypeNameConflicts;
     private createAndAddNameConflictDiagnosticsForAllEntities;
+    private createAndAddTextConflictDiagnosticsForAllEntities;
     private shouldReportConflictWithMemberBasedOnHiding;
     private reportNameConflictDiagnostic;
+    private reportTextConflictDiagnostic;
     private getDiagnosticLocation;
 }
 export declare class SourcePackageMemberConflictsValidator {
     private readonly analyzer;
     private readonly package_;
-    constructor(analyzer: Analyzer, package_: ProgramPackage);
+    constructor(analyzer: Analyzer, package_: ProgramOrTextTranslationPackage);
     validate(): readonly Diagnostic[];
 }

package/build/types/analysis/ResolvedTextTranslationPackage.d.ts

@@ -0,0 +1,9 @@
+import { PackageEntity } from '../entities/index.js';
+import { TextTranslationPackage } from '../project/index.js';
+export declare class ResolvedTextTranslationPackage {
+    readonly sourcePackage: TextTranslationPackage;
+    readonly entity: PackageEntity;
+    readonly targetPackage: PackageEntity;
+    constructor(sourcePackage: TextTranslationPackage, entity: PackageEntity, targetPackage: PackageEntity);
+    isPrimary(): boolean;
+}

package/build/types/analysis/SourceFileAnalyzer.d.ts

@@ -83,4 +83,5 @@ export declare class SourceFileAnalyzer {
     private addDiagnostic;
     private addDiagnostics;
     private addDiagnosticsLocatedInAnalyzedFile;
+    private sortAndRemoveDuplicateDiagnosticsInPlace;
 }

package/build/types/analysis/SourcePackageDependencyGraph.d.ts

@@ -23,6 +23,10 @@ export interface SourcePackageDependencyGraphNode {
      * Информация о подключаемых пакетах.
      */
     readonly links: readonly SourcePackageDependencyGraphLink[];
+    /**
+     * Пакеты перевода текстов на разные языки, для которых подключаемый пакет является целевым (источником текстов).
+     */
+    readonly textTranslationPackages: readonly SourcePackageDependencyGraphNode[];
 }
 export interface SourcePackageDependencyGraphLink {
     /**

package/build/types/analysis/SubstitutedFunction.d.ts

@@ -20,6 +20,7 @@ export declare class SubstitutedFunction_entity implements ISubstitutedFunction
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale?: boolean): boolean;
 }
 export declare class SubstitutedFunction_typeMember implements ISubstitutedFunction {
     readonly method: types.Method;
@@ -37,6 +38,7 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale?: boolean): boolean;
 }
 interface ISubstitutedFunction {
     getEntity(): NamedFunctionEntity;
@@ -47,5 +49,6 @@ interface ISubstitutedFunction {
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale: boolean): boolean;
 }
 export {};

package/build/types/analysis/TagMeaning.d.ts

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -9,9 +9,10 @@ import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private readonly semanticContext_;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: Tag);
+    constructor(analyzer: Analyzer, node: Tag, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): ResolutionResult;
     private resolveNameInScope;
     private resolveNameInPackage;
@@ -21,9 +22,8 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics?: readonly Diagnostic[];
     readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[];
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics?: (readonly Diagnostic[]) | Diagnostic, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {

package/build/types/analysis/UserDefinableBinaryOperatorResolver.d.ts

@@ -1,4 +1,4 @@
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -26,7 +26,8 @@ export declare class UserDefinableBinaryOperatorResolver {
     private readonly right;
     private readonly operatorKind;
     private readonly operatorNodeForDiagnostic;
-    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, operatorNodeForDiagnostic: tree.Node);
-    resolve(): WithDiagnostics<types.Operator>;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, operatorNodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Operator | undefined;
     private chooseSuitableOperators;
 }

package/build/types/analysis/UserDefinableUnaryOperatorResolver.d.ts

@@ -1,4 +1,4 @@
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
@@ -16,7 +16,8 @@ import { Analyzer } from './index.js';
 export declare class UserDefinableUnaryOperatorResolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private get operatorKind();
-    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression);
-    resolve(): WithDiagnostics<types.Operator>;
+    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Operator | undefined;
 }

package/build/types/analysis/Utils.d.ts

@@ -15,6 +15,7 @@ export declare function findTag(tagTypeEntity: TypeEntity, tags: readonly Tag[])
 export declare function findTag(tagFunctionEntity: FunctionEntity, tags: readonly Tag[]): TagFunction | undefined;
 export declare function findTag(tagEntity: TypeEntity | FunctionEntity, tags: readonly Tag[]): TagType | TagFunction | undefined;
 export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;
+export declare function flattenPackageImportDirectiveList(list: tree.PackageImportDirectiveList): Iterable<tree.PackageImport>;
 export declare function flattenPackageMemberDeclarationList(list: tree.PackageMemberDeclarationList): Iterable<Exclude<tree.PackageMemberDeclaration, tree.PackageMemberGroupDeclaration>>;
 export declare function flattenTypeMemberDeclarationList(list: tree.TypeMemberDeclarationList): Iterable<Exclude<tree.TypeMemberDeclaration, tree.TypeMemberGroupDeclaration>>;
 export declare function isComputedVariableEntity(entity: VariableEntity): boolean;

package/build/types/analysis/semantic-context/SemanticContextBase.d.ts

@@ -37,7 +37,7 @@ export declare abstract class SemanticContextBase {
     getOperators(noInstanceMembers?: boolean): readonly types.Operator[];
     getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean): readonly types.Operator[];
     getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
-    getPrimaryTextTranslationEntityByTextKey(key: TextKey): TextTranslationEntity | undefined;
+    getTextTranslationEntityByTextKey(key: TextKey): readonly TextTranslationEntity[];
     private semanticContexts;
     private getSourceFileContext;
 }

package/build/types/analysis/semantic-context/SourceFileSemanticContext.d.ts

@@ -1,4 +1,5 @@
 import { Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import { PackageEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
 import { SourceFile } from '../../project/SourceFile.js';
@@ -15,14 +16,16 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     protected asContext: SemanticContext;
     private readonly analyzer;
     private readonly sourceFile;
-    private readonly sourceFileMembers;
     private readonly containingPackageMemberLookup;
     private readonly importedPackageMemberLookups;
+    private readonly packageAliases;
+    private readonly packageAliasesByNameKey_;
     private readonly packageNameSegments;
-    private readonly packageNameSegmentsByKey_;
+    private readonly packageNameSegmentsByNameKey_;
     private readonly diagnosticArgumentFactory;
     private readonly primaryTextTranslationPackage_;
-    private get packageNameSegmentsByKey();
+    private get packageAliasesByNameKey();
+    private get packageNameSegmentsByNameKey();
     private get primaryTextTranslationPackage();
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getContainingSubprogram(): SubprogramInfo | undefined;
@@ -37,7 +40,8 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
     getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
     getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
-    getPrimaryTextTranslationEntityByTextKey(key: TextKey): TextTranslationEntity | undefined;
+    getTextTranslationEntityByTextKey(key: TextKey): readonly TextTranslationEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;
     private convertPackageMemberToTypeOrContainerWithTypes;

package/build/types/api/Api.d.ts

@@ -6,21 +6,20 @@ export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/Autot
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
-export * from '../analysis/SourceFileAnalyzer.js';
 export * from '../analysis/FindModifier.js';
-export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
+export type { Meaning as IdentifierExpressionMeaning } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
-export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
+export type { Meaning as MemberAccessExpressionMeaning } from '../analysis/MemberAccessExpressionMeaning.js';
 export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
 export * from '../analysis/PackageMemberLookup.js';
 export * as semanticContext from '../analysis/semantic-context/index.js';
-export * from '../analysis/SourceFileMembers.js';
+export * from '../analysis/SourceFileAnalyzer.js';
 export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';
-export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Tag.js';
+export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Translation.js';
 export * from '../analysis/TypeMemberLookup.js';
 export * from '../analysis/Utils.js';

package/build/types/common/ArrayUtils.d.ts

@@ -4,12 +4,14 @@ export declare class ArrayUtils {
      *
      * Работает быстрее, чем `array.splice(index, 1)`, и не выделяет память для массива удалённых элементов.
      */
-    static removeElement<T>(array: T[], index: number): void;
+    static removeElement<T>(array: T[], index: number, count?: number): void;
     static pushElementIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, element: T): boolean;
     static pushElementsIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, elements: readonly T[]): void;
     static count<T>(array: readonly T[], cb: (v: T) => boolean): number;
     static compareWithEqualsIgnoringOrder<T extends WithEqualsMethod<T>>(array1: readonly T[], array2: readonly T[]): boolean;
     static compareWithComparatorIgnoringOrder<T1, T2>(array1: readonly T1[], array2: readonly T2[], comparator: (e1: T1, e2: T2) => boolean): boolean;
+    static compareWithEquals<T extends WithEqualsMethod<T>>(array1: readonly T[], array2: readonly T[]): boolean;
+    static compareWithComparator<T1, T2>(array1: readonly T1[], array2: readonly T2[], comparator: (e1: T1, e2: T2) => boolean): boolean;
 }
 export type WithEqualsMethod<T> = {
     equals(t: T): boolean;

package/build/types/common/Displayable.d.ts

@@ -1,13 +1,13 @@
 export interface Displayable {
     getDisplayText(): string;
 }
+export type DisplayableOrPrimitive = Displayable | string | number | boolean;
+export declare namespace DisplayableOrPrimitive {
+    function getDisplayText(value: DisplayableOrPrimitive): string;
+}
 export declare class DisplayableArray implements Displayable {
     private readonly array;
     private readonly separator;
     constructor(array: readonly DisplayableOrPrimitive[], separator: string);
     getDisplayText(): string;
 }
-export type DisplayableOrPrimitive = Displayable | string | number | boolean;
-export declare namespace DisplayableOrPrimitive {
-    function getDisplayText(value: DisplayableOrPrimitive): string;
-}

package/build/types/common/FormatString.d.ts

@@ -3,4 +3,4 @@ import { DisplayableOrPrimitive } from './Displayable.js';
  * @example
  * "Сообщение: {0} Экранирование: \{0}", ["Привет!"] -> "Сообщение: Привет! Экранирование: {0}"
  */
-export declare function formatString(text: string, ...formatArguments: readonly DisplayableOrPrimitive[]): string;
+export declare function formatString(text: string, formatArguments?: readonly DisplayableOrPrimitive[]): string;

package/build/types/common/index.d.ts

@@ -6,9 +6,12 @@ export * from './CancellationToken.js';
 export * from './Constants.js';
 export * from './Debug.js';
 export * from './Displayable.js';
+export * from './ErrorHandlingStrategy.js';
 export * from './FormatString.js';
+export * from './HelperPhrases.js';
 export * from './Interner.js';
 export * from './JavaScriptIdentifier.js';
+export * from './L10nConfig.js';
 export * from './Lazy.js';
 export * from './LocalizationHelper.js';
 export * from './Logger.js';