@artel/artc 0.6.25191

package/build/types/emitter/IntrinsicEntities.d.ts

@@ -0,0 +1,118 @@
+import * as tags from '../analysis/Tags.js';
+import { Tag } from '../analysis/Tags.js';
+import { Name } from '../common/index.js';
+import type { EntityOwningGetter, EntityOwningSetter } from '../entities/index.js';
+import { ConstructorEntity, Entity, EntityHidingLevel, EntityKind, GetterEntity, GetterEntityDefinition, IndexerEntity, LocalVariableEntity, PackageEntity, PackageMethodEntity, ParameterVariableEntity, ParameterVariableEntityContainer, SetterEntity, SetterEntityDefinition, SpecialVariableEntityInfo, TypeEntityWithMembers, TypeMemberEntityContainer, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, VariableEntityDefinition } from '../entities/index.js';
+import * as types from '../types/index.js';
+export declare class EmitterIntrinsicTypeVariableEntity implements TypeVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _container;
+    private readonly _isStatic;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "type";
+    constructor(_name: Name, _type: types.Type, _container: TypeMemberEntityContainer, _isStatic: boolean);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isConsistent(): boolean;
+    isObservable(): boolean;
+}
+export declare class EmitterIntrinsicParameterVariableEntity implements ParameterVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _container;
+    private readonly _isOptional;
+    private readonly _isVariadic;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    constructor(_name: Name, _type: types.Type, _container: ParameterVariableEntityContainer, _isOptional: boolean, _isVariadic: boolean);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export declare class EmitterIntrinsicLocalVariableEntity implements LocalVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _isConstant;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    constructor(_name: Name, _type: types.Type, _isConstant: boolean);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): Entity;
+}
+export declare class UnfinishedEmitterIntrinsicPackageMethodEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): PackageMethodEntity;
+    constructor(name: Name, typeParameters: readonly TypeParameterEntity[], returnType: types.Type, isAsync: boolean, containingPackage: PackageEntity);
+    finish(parameters: readonly ParameterVariableEntity[]): PackageMethodEntity;
+}
+export declare class UnfinishedEmitterIntrinsicTypeMethodEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): TypeMethodEntity;
+    constructor(name: Name, typeParameters: readonly TypeParameterEntity[], returnType: types.Type, isAsync: boolean, container: TypeMemberEntityContainer, isStatic: boolean, isModifyingOwningPlainObject: boolean);
+    finish(parameters: readonly ParameterVariableEntity[]): TypeMethodEntity;
+}
+export declare class EmitterIntrinsicGetterEntity implements GetterEntity {
+    private readonly _isModifyingOwningPlainObject;
+    private readonly _containingEntity;
+    readonly kind = EntityKind.Getter;
+    constructor(_isModifyingOwningPlainObject: boolean, _containingEntity: EntityOwningGetter);
+    getReturnType(): types.Type;
+    getDefinition(): GetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningGetter;
+    getTags(): readonly tags.Tag[];
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class EmitterIntrinsicSetterEntity implements SetterEntity {
+    private readonly _isModifyingOwningPlainObject;
+    private readonly _containingEntity;
+    readonly kind = EntityKind.Setter;
+    constructor(_isModifyingOwningPlainObject: boolean, _containingEntity: EntityOwningSetter);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    getTags(): readonly tags.Tag[];
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class UnfinishedEmitterIntrinsicConstructorEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): ConstructorEntity;
+    constructor(containingEntity: TypeEntityWithMembers);
+    finish(parameters: readonly ParameterVariableEntity[]): ConstructorEntity;
+}
+export declare class UnfinishedEmitterIntrinsicIndexerEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): IndexerEntity;
+    constructor(type: types.Type, container: TypeMemberEntityContainer, isStatic: boolean, getter: GetterEntity | undefined, setter: SetterEntity | undefined);
+    finish(parameters: readonly ParameterVariableEntity[]): IndexerEntity;
+}

package/build/types/emitter/IrBuilder.d.ts

@@ -0,0 +1,108 @@
+import { Analyzer } from '../analysis/index.js';
+import { DeclarationsUsageCountResult } from '../analysis/DeclarationsUsageCounter.js';
+import { SourceFile } from '../project/index.js';
+import * as ir from './ir/index.js';
+export declare class IrBuilder {
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _config;
+    private readonly _typesCreatedFromAnonymousTypes;
+    private _id;
+    private _currentLoopLabel;
+    constructor(analyzer: Analyzer, sourceFile: SourceFile, config: IrBuilderConfig);
+    buildIR(): ir.SourceFile;
+    private buildSourceFile;
+    private buildPackageMemberDeclarationList;
+    private buildPackageConstructorDeclaration;
+    private buildStatementBlock;
+    private buildRunStatementClause;
+    private buildStatement;
+    private buildAssignmentStatement;
+    private buildContinueLoopStatement;
+    private buildBreakLoopStatement;
+    private buildPackageEntryPointDeclaration;
+    private buildPackageMethodDeclaration;
+    private buildPackageStructuredTypeDeclaration;
+    private buildPackageAliasTypeDeclaration;
+    private buildPackageVariableDeclaration;
+    private buildComputedPackageVariable;
+    private buildBackingPackageVariable;
+    private buildPackageVariantTypeDeclaration;
+    private buildVariantDeclaration;
+    private buildTypeExtensionDeclaration;
+    private buildTypeMemberList;
+    private buildTypeConstructorDeclaration;
+    private createDefaultStructuredTypeConstructor;
+    private buildTypeDestructorDeclaration;
+    private buildTypeIndexerDeclaration;
+    private buildTypeDereferenceOperatorDeclaration;
+    private buildTypeMethodDeclaration;
+    private buildTypeVariableDeclaration;
+    private buildComputedTypeVariable;
+    private buildBackingTypeVariable;
+    private buildDisposeStatement;
+    private buildRunStatement;
+    private buildEmptyStatement;
+    private buildErrorStatement;
+    private buildExpressionStatement;
+    private buildForStatement;
+    private buildIfStatement;
+    private buildElseIfClausesRecursively;
+    private buildNestedMethodDeclarationStatement;
+    private buildParameterList;
+    private buildLocalVariableDeclarationStatement;
+    private buildUnobservableStatement;
+    private buildLoopStatement;
+    private buildReturnStatement;
+    private buildSwitchStatement;
+    private isDefaultSwitchStatementCaseClause;
+    private buildTransactionalStatement;
+    private buildWhileStatement;
+    private buildYieldStatement;
+    private buildExpression;
+    private getImplicitConversionKind;
+    private expressionCanBeImplicitlyConverted;
+    private buildArrayLiteral;
+    private buildAssertionExpression;
+    private buildAssumptionExpression;
+    private buildAsExpression;
+    private buildBinaryExpression;
+    private buildMethodBlockLiteral;
+    private buildCallExpression;
+    private buildAutotypeCallExpression;
+    private buildIndexedAccessExpression;
+    private buildIsExpression;
+    private buildUnobservableExpression;
+    private buildNotExpression;
+    private buildMethodLiteral;
+    private buildParenthesizedExpression;
+    private buildPrefixUnaryExpression;
+    private buildPropertyAccessExpression;
+    private buildReferenceExpression;
+    private buildWhenTernaryExpression;
+    private buildTextTemplateLiteral;
+    private buildTokenExpression;
+    private buildKeywordExpression;
+    private buildObjectExpression;
+    private buildBaseExpression;
+    private buildTransactionalExpression;
+    private buildDereferenceExpression;
+    private buildGenericSpecializationExpression;
+    private buildDefaultMatchExpression;
+    private buildIdentifierExpression;
+    private getEntityFromType;
+    private buildCallArgumentList;
+    private buildAndSaveTypeIfIsAnonymousTypeSpecifier;
+    private buildAndSaveAnonymousTypeDeclaration;
+    private buildAnonymousStructuredTypeDeclaration;
+    private buildAnonymousVariantTypeDeclaration;
+    private getUnderlyingTypeKind;
+    private expressionIsCallee;
+    private preserveVariableOrUndefinedIfUnused;
+    private generateLoopLabel;
+    private getSourceLocation;
+}
+export interface IrBuilderConfig {
+    declarationsUsageCountResult: DeclarationsUsageCountResult;
+    declarationsOfPackageSourceFilesUsageCountResults: readonly DeclarationsUsageCountResult[];
+}

package/build/types/emitter/IrToJs.d.ts

@@ -0,0 +1,113 @@
+import * as js from '@babel/types';
+import { DebugStack } from './DebugStack.js';
+import { EntityNameProvider } from './EntityNameProviders.js';
+import * as ir from './ir/index.js';
+export interface IrToJsConfig {
+    /**
+     * static:  import { MyType } from 'my-lib'
+     *
+     * dynamic: const { MyType } = await import('my-lib')
+     */
+    readonly importMode: ImportEmitMode;
+    readonly runtimeEntityNames: EntityNameProvider;
+    readonly attachSourceLocation?: boolean;
+}
+export type ImportEmitMode = ImportEmitMode.Static | ImportEmitMode.Dynamic;
+export declare namespace ImportEmitMode {
+    interface Static {
+        readonly kind: 'static';
+    }
+    interface Dynamic {
+        readonly kind: 'dynamic';
+        readonly isCustomImportSynchronous: boolean;
+        readonly emitOnlyCustomImport: boolean;
+    }
+}
+export declare class IrToJs {
+    private readonly _config;
+    static readonly customImportFunctionName = "_artelImport";
+    protected readonly _debugStack: DebugStack;
+    constructor(_config: IrToJsConfig);
+    convert(sourceFile: ir.SourceFile): js.File;
+    private convertSourceFile;
+    private convertPackageMemberDeclaration;
+    private convertEsModuleImportDirectiveStatement;
+    private convertCjsModuleImportDirectiveStatement;
+    private convertStaticEsModuleImportDirective;
+    private convertDynamicEsModuleImportDirective;
+    private convertStaticCjsModuleImportDirective;
+    private convertDynamicCjsModuleImportDirective;
+    private createDynamicImport;
+    private convertJsNamespaceDestructuringStatement;
+    private convertPackageMethodDeclaration;
+    private convertValueParameters;
+    private convertPackageTypeDeclaration;
+    private convertPropertyDeclaration;
+    private convertPackageVariableDeclaration;
+    private convertPackageVariantTypeDeclaration;
+    private convertNumericVariants;
+    private convertNonNumericVariants;
+    private convertBlockStatement;
+    private convertExpression;
+    private convertBooleanLiteral;
+    private convertBinaryExpression;
+    private convertCallExpression;
+    private convertCharLiteral;
+    private convertNoneLiteral;
+    private convertHelperMethodCallExpression;
+    private convertNotExpression;
+    private convertIntegerLiteral;
+    private convertNumericLiteral;
+    private convertMethodLiteral;
+    private convertJsFunctionLiteral;
+    private convertJsTypeOfExpression;
+    private convertJsInstanceOfExpression;
+    private convertJsIdentifierExpression;
+    private convertPrefixUnaryExpression;
+    private convertTextLiteral;
+    private convertTextTemplateLiteral;
+    private convertTernaryExpression;
+    private convertThisExpression;
+    private convertBaseExpression;
+    private convertBinaryExpressionOperator;
+    private convertPrefixUnaryExpressionOperator;
+    private convertArrayLiteral;
+    private convertTypeAccessExpression;
+    private convertVariableAccessExpression;
+    private convertMethodAccessExpression;
+    private convertVariantAccessExpression;
+    private convertInstanceVariableAccessExpression;
+    private convertTypeMethodAccessExpression;
+    private convertConstructorCallExpression;
+    private convertCallArguments;
+    private convertInlineJsExpression;
+    private convertAssignmentExpression;
+    private convertCommaExpression;
+    private convertJsIndexedAccessExpression;
+    private convertJsObjectLiteral;
+    private convertJsPropertyAccessExpression;
+    private convertStatements;
+    private convertStatement;
+    private convertAssignmentStatement;
+    private convertBreakLoopStatement;
+    private convertContinueLoopStatement;
+    private convertEmptyStatement;
+    private convertErrorStatement;
+    private convertExpressionStatement;
+    private convertForStatement;
+    private convertIfStatement;
+    private convertNestedMethodDeclarationStatement;
+    private convertLocalVariableDeclarationStatement;
+    private convertLoopStatement;
+    private convertReturnStatement;
+    private convertSwitchStatement;
+    private convertWhileStatement;
+    private convertYieldStatement;
+    private convertTryCatchFinallyStatement;
+    private convertAssignmentOperator;
+    private convertTypeConstructorDeclaration;
+    private convertTypeMethodDeclaration;
+    private convertTypeVariableDeclaration;
+    private addNodeLocation;
+    private convertArrayWithErrorBoundary;
+}

package/build/types/emitter/JavaScriptName.d.ts

@@ -0,0 +1 @@
+export declare function convertToCompliantJavaScriptName(name: string): string;

package/build/types/emitter/PackageMemberDeclarationTransformationResult.d.ts

@@ -0,0 +1,17 @@
+import { PackageMemberDeclaration } from './ir/index.js';
+export declare const enum Kind {
+    Preserve = 0,
+    Replace = 1,
+    Remove = 2
+}
+export type PackageMemberDeclarationTransformationResult = {
+    kind: Kind.Preserve;
+} | {
+    kind: Kind.Replace;
+    declarations: readonly PackageMemberDeclaration[];
+} | {
+    kind: Kind.Remove;
+};
+export declare function preserve(): PackageMemberDeclarationTransformationResult;
+export declare function replace(declarations: readonly PackageMemberDeclaration[]): PackageMemberDeclarationTransformationResult;
+export declare function remove(): PackageMemberDeclarationTransformationResult;

package/build/types/emitter/SimpleTransformationResult.d.ts

@@ -0,0 +1,14 @@
+import { TransformationContinuationAction } from './TransformationContinuationAction.js';
+export declare enum Kind {
+    Preserve = 0,
+    Replace = 1
+}
+export type Type<T> = {
+    kind: Kind.Preserve;
+    action: TransformationContinuationAction;
+} | {
+    kind: Kind.Replace;
+    node: T;
+};
+export declare function preserve<T>(action?: TransformationContinuationAction): Type<T>;
+export declare function replace<T>(node: T): Type<T>;

package/build/types/emitter/StatementTransformationResult.d.ts

@@ -0,0 +1,16 @@
+import { VariableEntity } from '../entities/index.js';
+import { Statement } from './ir/index.js';
+export declare const enum Kind {
+    Preserve = 0,
+    Replace = 1,
+    ReplaceAndAddLocalVariables = 2
+}
+export type Type = {
+    kind: Kind.Preserve;
+} | {
+    kind: Kind.Replace;
+    statement: Statement;
+    hoistedLocalVariables?: readonly VariableEntity[];
+};
+export declare function preserve(): Type;
+export declare function replace(statement: Statement, hoistedLocalVariables?: readonly VariableEntity[]): Type;

package/build/types/emitter/StructuredTypeMemberDeclarationTransformationResult.d.ts

@@ -0,0 +1,13 @@
+import { TypeMemberDeclaration } from './ir/index.js';
+export declare enum Kind {
+    Preserve = 0,
+    Replace = 1
+}
+export type Type = {
+    kind: Kind.Preserve;
+} | {
+    kind: Kind.Replace;
+    declarations: readonly TypeMemberDeclaration[];
+};
+export declare function preserve(): Type;
+export declare function replace(declarations: readonly TypeMemberDeclaration[]): Type;

package/build/types/emitter/TransformationContinuationAction.d.ts

@@ -0,0 +1,4 @@
+export declare const enum TransformationContinuationAction {
+    Continue = 0,
+    DoNotTransformChildren = 1
+}