@artel/artc 0.6.25191

package/build/chunk-QRBDQKYM.js

@@ -0,0 +1,94 @@
+import {
+  Analyzer,
+  CompilationLoader,
+  DefaultNamesOfDirectoriesToIgnore,
+  Diagnostic,
+  DiagnosticCollector,
+  DiagnosticData,
+  Emitter,
+  SourcePackageDependencyGraph,
+  WellKnownDeclarationsLoadError,
+  __async,
+  createTsInteropInputsForCompilation
+} from "./chunk-O2JKESUU.js";
+
+// source/executor/Compiler.ts
+var Compiler = class {
+  static loadCompilation(projectUri, sourcesProvider, tsLibrariesProvider, diagnostics, workspaceUri, standardPackagesUri, cancellationToken) {
+    return __async(this, null, function* () {
+      const config = {
+        treatRootAsPackageIfConfigIsMissing: true,
+        standardPackagesUri
+      };
+      const { loadResult } = yield CompilationLoader.loadUsingSourcesProvider(
+        projectUri,
+        sourcesProvider,
+        config,
+        diagnostics,
+        workspaceUri,
+        DefaultNamesOfDirectoriesToIgnore,
+        cancellationToken
+      );
+      return loadResult.compilation;
+    });
+  }
+  static createAnalyzer(compilation, tsLibrariesProvider, diagnostics, _cancellationToken) {
+    return __async(this, null, function* () {
+      const tsInteropInputs = createTsInteropInputsForCompilation(compilation, tsLibrariesProvider);
+      try {
+        return new Analyzer(compilation, tsInteropInputs);
+      } catch (e) {
+        if (!(e instanceof WellKnownDeclarationsLoadError)) {
+          throw e;
+        }
+        diagnostics?.addDiagnostic(e.diagnostic);
+        return void 0;
+      }
+    });
+  }
+  static analyze(analyzer, diagnostics, cancellationToken) {
+    return __async(this, null, function* () {
+      let hasErrorsPreventingCompilation = false;
+      const sourcePackageGraph = new SourcePackageDependencyGraph(analyzer);
+      const packages = Array.from(sourcePackageGraph.enumeratePackages(0 /* JavaScript */));
+      for (const pkg of packages) {
+        for (const sourceFile of pkg.sourceFiles) {
+          const fileDiagnostics = yield new DiagnosticCollector(analyzer, sourceFile, cancellationToken).collect();
+          for (const diagnostic of fileDiagnostics) {
+            diagnostics?.addDiagnostic(diagnostic);
+            hasErrorsPreventingCompilation ||= pkg.kind === "program" && fileDiagnostics.some((d) => d.data.kind === 0 /* Error */);
+          }
+        }
+      }
+      return !hasErrorsPreventingCompilation;
+    });
+  }
+  static emit(analyzer, outputUri, outputAcceptor, _diagnostics, emitOptions, cancellationToken) {
+    return __async(this, null, function* () {
+      if (analyzer.compilation.mainPackage === void 0) {
+        _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
+          140 /* ProgramWithoutMainPackageCanNotBeCompiled */
+        ), void 0));
+        return void 0;
+      }
+      yield Emitter.emitToFileSystem(analyzer, outputUri, outputAcceptor, emitOptions, cancellationToken);
+      const launchUri = outputUri.append(Emitter.LaunchFileName);
+      return launchUri;
+    });
+  }
+  static emitToString(analyzer, _diagnostics, emitOptions, cancellationToken) {
+    return __async(this, null, function* () {
+      if (analyzer.compilation.mainPackage === void 0) {
+        _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
+          140 /* ProgramWithoutMainPackageCanNotBeCompiled */
+        ), void 0));
+        return "";
+      }
+      return yield Emitter.emitToString(analyzer, emitOptions, cancellationToken);
+    });
+  }
+};
+
+export {
+  Compiler
+};

package/build/types/Cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+declare const _default: Promise<void>;
+export default _default;

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

@@ -0,0 +1,53 @@
+import { Name } from '../common/index.js';
+import { MethodEntity, ParameterVariableEntity, TypeParameterEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { SubstitutedMethod } from './SubstitutedMethod.js';
+export type AccessedMethod = AccessedMethod_entity | AccessedMethod_typeMember | AccessedMethod_substitutedMethod;
+export declare class AccessedMethod_entity implements IAccessedMethod {
+    readonly value: MethodEntity;
+    readonly kind = "entity";
+    constructor(value: MethodEntity);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly AccessedMethodValueParameter[];
+    getReturnType(): types.Type;
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(analyzer: Analyzer): types.MethodType;
+}
+export declare class AccessedMethod_typeMember implements IAccessedMethod {
+    readonly value: types.Method;
+    readonly kind = "type-member";
+    constructor(value: types.Method);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly AccessedMethodValueParameter[];
+    getReturnType(): types.Type;
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(_analyzer: Analyzer): types.MethodType;
+}
+export declare class AccessedMethod_substitutedMethod implements IAccessedMethod {
+    readonly value: SubstitutedMethod;
+    readonly kind = "substituted-method";
+    constructor(value: SubstitutedMethod);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly AccessedMethodValueParameter[];
+    getReturnType(): types.Type;
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(_analyzer: Analyzer): types.MethodType;
+}
+export declare class AccessedMethodValueParameter {
+    readonly entity: ParameterVariableEntity;
+    readonly type: types.Type;
+    constructor(entity: ParameterVariableEntity, type: types.Type);
+}
+interface IAccessedMethod {
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly AccessedMethodValueParameter[];
+    getReturnType(): types.Type;
+    getEntity(): MethodEntity;
+    getName(): Name;
+    getSignatureType(analyzer: Analyzer): types.MethodType;
+}
+export {};

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

@@ -0,0 +1,191 @@
+import { Name, PackageLocale } from '../common/index.js';
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { PackageEntity } from '../entities/PackageEntity.js';
+import { NamedMember, NamedPackageMemberEntity } from '../entities/PackageMembers.js';
+import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
+import { PackageVariableEntity, ParameterVariableEntity, TypeVariableEntity } from '../entities/VariableEntity.js';
+import { VariantEntity } from '../entities/VariantEntity.js';
+import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageTypeEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeMethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { PackageName, TranslationPackage } from '../project/index.js';
+import * as tree from '../tree/index.js';
+import { Analyzer } from './Analyzer.js';
+import { LocalizedName } from './Localization.js';
+import { NamedEntity } from './LocalizationContext.js';
+export declare class AnalyzedTranslationPackage {
+    private readonly _analyzer;
+    private readonly _package;
+    private readonly _translatedPackage;
+    private readonly _members;
+    private readonly _translatedTypeEntityMembers;
+    private readonly _translatedVariants;
+    private readonly _methodSignatureTranslations;
+    private readonly _methodTypeSignatureTranslations;
+    private readonly _constructorSignatureTranslations;
+    private readonly _indexerSignatureTranslations;
+    private readonly _translatedTypeHeaders;
+    constructor(_analyzer: Analyzer, _package: TranslationPackage, _translatedPackage: PackageEntity);
+    getTranslatedPackage(): PackageEntity;
+    getDefinition(): TranslationPackage;
+    getTranslatedName(): PackageName;
+    getTranslationLocale(): PackageLocale;
+    getMembers(): TranslatedPackageMembers;
+    getTypeEntityMembers(typeEntity: PackageTypeEntity): TranslatedTypeEntityMembers | undefined;
+    getVariants(typeEntity: PackageVariantTypeEntity): TranslatedVariants | undefined;
+    getPackageVariableTranslationTarget(node: tree.PackageVariableTranslation): GetSingleTranslationTargetResult<PackageVariableEntity>;
+    getPackageMethodTranslationTargets(node: tree.PackageMethodTranslation): GetMultipleTranslationTargetsResult<PackageMethodEntity>;
+    getMethodTypeTranslationTarget(node: tree.MethodTypeTranslation): GetSingleTranslationTargetResult<PackageMethodTypeEntity>;
+    getTypeTranslationTarget(node: tree.TypeTranslation): GetSingleTranslationTargetResult<PackageTypeEntity>;
+    getTypeVariableOrVariantTranslationTarget(node: tree.TypeVariableOrVariantTranslation): GetSingleTranslationTargetResult<TypeVariableEntity | VariantEntity>;
+    getTypeMethodTranslationTargets(node: tree.TypeMethodTranslation): GetMultipleTranslationTargetsResult<TypeMethodEntity>;
+    getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
+    getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
+    getMethodSignature(entity: MethodEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getPackageMethodSignature(entity: PackageMethodEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getTypeMethodSignature(entity: TypeMethodEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getMethodTypeSignature(entity: MethodTypeEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getConstructorSignature(entity: ConstructorEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getDestructorSignature(entity: DestructorEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getIndexerSignature(entity: IndexerEntity): LocalizedSubprogramSignature.Translated | undefined;
+    getTypeHeader(entity: TypeEntityWithHeaderLocalization): LocalizedTypeHeader.Translated | undefined;
+    getEntityName(entity: NamedEntity): Name | undefined;
+    private createPackageMembers;
+    private createTypeEntityMembers;
+    private createVariants;
+    private createTranslatedSubprogramSignatureFromPackageMethodTranslation;
+    private createTranslatedSubprogramSignatureFromTypeMethodTranslation;
+    private createTranslatedSubprogramSignatureFromMethodTypeAlias;
+    private createTranslatedSubprogramSignatureFromConstructorAlias;
+    private createTranslatedSubprogramSignatureFromIndexerAlias;
+    private createTranslatedTypeSignature;
+    private enumerateTranslationsDeclarations;
+    private findTypeTranslation;
+}
+export declare class TranslatedPackageMembers {
+    private readonly _namedMembers;
+    private readonly _membersByUniversalName;
+    private readonly _nameByEntity;
+    private get membersByUniversalName();
+    private get nameByEntity();
+    constructor(_namedMembers: readonly TranslatedNamedPackageMember[]);
+    getNamedMembers(): readonly TranslatedNamedPackageMember[];
+    getNamedMembersByName(name: Name): readonly TranslatedNamedPackageMember[];
+    getMemberName(entity: NamedPackageMemberEntity): Name | undefined;
+}
+export declare class TranslatedNamedPackageMember {
+    readonly value: NamedMember;
+    readonly name: LocalizedName.Translated;
+    constructor(value: NamedMember, name: LocalizedName.Translated);
+}
+export declare class TranslatedTypeEntityMembers {
+    private readonly _namedMembers;
+    readonly translationPackage: AnalyzedTranslationPackage;
+    private readonly _membersByUniversalName;
+    private readonly _nameByEntity;
+    private get membersByUniversalName();
+    private get nameByEntity();
+    constructor(_namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
+    getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
+    getNamedMembersByName(name: Name): readonly TranslatedNamedTypeEntityMember[];
+    getMemberName(entity: NamedTypeMemberEntity): Name | undefined;
+}
+export declare class TranslatedNamedTypeEntityMember {
+    readonly value: NamedTypeMemberEntity;
+    readonly name: LocalizedName.Translated;
+    constructor(value: NamedTypeMemberEntity, name: LocalizedName.Translated);
+}
+export declare class TranslatedVariants {
+    private readonly _variants;
+    readonly translationPackage: AnalyzedTranslationPackage;
+    private readonly _variantsByUniversalName;
+    private readonly _nameByEntity;
+    private get variantsByUniversalName();
+    private get nameByEntity();
+    constructor(_variants: readonly TranslatedVariant[], translationPackage: AnalyzedTranslationPackage);
+    get(): readonly TranslatedVariant[];
+    getByName(name: Name): readonly TranslatedVariant[];
+    getName(entity: VariantEntity): Name | undefined;
+}
+export declare class TranslatedVariant {
+    readonly value: VariantEntity;
+    readonly name: LocalizedName.Translated;
+    constructor(value: VariantEntity, name: LocalizedName.Translated);
+}
+export type LocalizedSubprogramSignature = LocalizedSubprogramSignature.Original | LocalizedSubprogramSignature.Translated;
+export declare namespace LocalizedSubprogramSignature {
+    export class Original implements ILocalizedSubprogramSignature {
+        readonly typeParameters: readonly Name[];
+        readonly valueParameters: readonly Name[];
+        readonly locale: PackageLocale;
+        readonly kind = "original";
+        constructor(typeParameters: readonly Name[], valueParameters: readonly Name[], locale: PackageLocale);
+        getTypeParameterNames(): readonly LocalizedName[];
+        getValueParameterNames(): readonly LocalizedName[];
+    }
+    export class Translated implements ILocalizedSubprogramSignature {
+        readonly typeParameters: readonly TranslatedTypeParameter[];
+        readonly valueParameters: readonly TranslatedValueParameter[];
+        readonly kind = "translated";
+        constructor(typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
+        getTypeParameterNames(): readonly LocalizedName[];
+        getValueParameterNames(): readonly LocalizedName[];
+        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
+        getValueParameterName(entity: ParameterVariableEntity): Name | undefined;
+    }
+    interface ILocalizedSubprogramSignature {
+        getTypeParameterNames(): readonly LocalizedName[];
+        getValueParameterNames(): readonly LocalizedName[];
+    }
+    export {};
+}
+export declare class TranslatedTypeParameter {
+    readonly value: TypeParameterEntity;
+    readonly name: LocalizedName.Translated;
+    constructor(value: TypeParameterEntity, name: LocalizedName.Translated);
+}
+export declare class TranslatedValueParameter {
+    readonly value: ParameterVariableEntity;
+    readonly name: LocalizedName.Translated;
+    constructor(value: ParameterVariableEntity, name: LocalizedName.Translated);
+}
+export type LocalizedTypeHeader = LocalizedTypeHeader.Original | LocalizedTypeHeader.Translated;
+export declare namespace LocalizedTypeHeader {
+    export class Original implements ILocalizedTypeHeader {
+        readonly typeParameters: readonly Name[];
+        readonly locale: PackageLocale;
+        readonly kind = "original";
+        constructor(typeParameters: readonly Name[], locale: PackageLocale);
+        getTypeParameterNames(): readonly LocalizedName[];
+    }
+    export class Translated implements ILocalizedTypeHeader {
+        readonly typeParameters: readonly TranslatedTypeParameter[];
+        readonly kind = "translated";
+        constructor(typeParameters: readonly TranslatedTypeParameter[]);
+        getTypeParameterNames(): readonly LocalizedName[];
+        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
+    }
+    interface ILocalizedTypeHeader {
+        getTypeParameterNames(): readonly LocalizedName[];
+    }
+    export {};
+}
+export type TypeEntityWithHeaderLocalization = StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
+export declare class GetSingleTranslationTargetResult<T> {
+    readonly target: T | undefined;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly isValid: boolean;
+    get validTarget(): T | undefined;
+    constructor(target: T | undefined, diagnostics: readonly Diagnostic[], isValid: boolean);
+    static valid<T>(target: T): GetSingleTranslationTargetResult<T>;
+    static invalid<T>(diagnostics: readonly Diagnostic[]): GetSingleTranslationTargetResult<T>;
+}
+export declare class GetMultipleTranslationTargetsResult<T> {
+    readonly targets: readonly T[];
+    readonly diagnostics: readonly Diagnostic[];
+    readonly isAmbiguous: boolean;
+    readonly isValid: boolean;
+    get validUnambiguousTargets(): readonly T[];
+    constructor(targets: readonly T[], diagnostics: readonly Diagnostic[], isAmbiguous: boolean, isValid: boolean);
+    static valid<T>(targets: readonly T[]): GetMultipleTranslationTargetsResult<T>;
+    static invalid<T>(diagnostics: readonly Diagnostic[]): GetMultipleTranslationTargetsResult<T>;
+    static invalid<T>(diagnostics: readonly Diagnostic[], targets: readonly T[], isAmbiguous: boolean): GetMultipleTranslationTargetsResult<T>;
+}