tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/class-fields.d.ts

@@ -0,0 +1,206 @@
+import { type Node } from '../ast.js';
+import type { CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+declare const enum VisitMode {
+    Modifier = 0,
+    Discarded = 1,
+    HeritageClause = 2,
+    AssignmentTarget = 3,
+    ClassElement = 4,
+    AccessorFieldResult = 5,
+    ArrayAssignmentElement = 6,
+    ObjectAssignmentElement = 7,
+    Substitution = 8
+}
+export declare class ClassFieldsTransformer extends Transformer {
+    readonly options: CompilerOptions;
+    readonly facts: SyntaxFacts;
+    readonly resolver: EmitResolver;
+    private readonly legacyDecorators;
+    private readonly useDefineForClassFields;
+    private readonly shouldTransformInitializersUsingSet;
+    private readonly shouldTransformInitializersUsingDefine;
+    private readonly shouldTransformInitializers;
+    private readonly shouldTransformPrivateElementsOrClassStaticBlocks;
+    private readonly shouldTransformAutoAccessors;
+    /** Static initializers move out of the class body, so their `this` and `super` must name the class. */
+    private readonly shouldTransformThisInStaticInitializers;
+    private shouldTransformPrivateStaticElementsInFile;
+    /** Computed name expressions from elided names, to inline at the next execution site. */
+    private pendingExpressions;
+    /** Statements to emit after the current variable statement, for decorated classes. */
+    private pendingStatements;
+    private lexicalEnvironment;
+    private currentClassContainer;
+    private currentClassElement;
+    /** Class declarations to aliases replacing references to the class in its static initializers. */
+    private readonly classAliases;
+    private readonly enclosingClassDeclarations;
+    private inIterationStatement;
+    /** Computed property names evaluate in the scope outside the class. */
+    private insideComputedPropertyName;
+    private parentNode;
+    private currentNode;
+    private readonly modifierMode;
+    private readonly discarded;
+    private readonly heritageMode;
+    private readonly assignmentTargetMode;
+    private readonly classElementMode;
+    private readonly accessorResultMode;
+    private readonly arrayElementMode;
+    private readonly objectElementMode;
+    private readonly substitutionMode;
+    /** Anonymous classes that named evaluation must name here. */
+    private readonly classesNeedingNames;
+    constructor(context: EmitContext, options: CompilerOptions, facts: SyntaxFacts, resolver: EmitResolver);
+    visitInMode(mode: VisitMode, node: Node): Node | undefined;
+    /** Whether an auto-accessor, a `#x in` check or a private access needs WeakMaps and WeakSets. */
+    private requiresBlockScopedVar;
+    /** Whether a class expression's temporary is block scoped: it's in a loop and has an instance field with a computed name. */
+    private classExpressionNeedsBlockScopedTemp;
+    private addHoisted;
+    private visitSourceFile;
+    private visitModifier;
+    /** Substitutes class aliases in subtrees with nothing else to transform, leaving property names alone. */
+    private visitForSubstitution;
+    visit(node: Node): Node | undefined;
+    private visitWorker;
+    private visitInIteration;
+    /** Visits the children of a function-like class member with it as the current class element. */
+    private visitInClassElement;
+    /**
+     * Functions get their own `this`, unless synthesized from a static member of the current class,
+     * as the ES decorators transform does for static private auto-accessors.
+     */
+    private visitFunctionExpressionOrDeclaration;
+    private visitDiscardedValue;
+    private visitHeritageClause;
+    private visitClassElement;
+    private visitPropertyName;
+    /** Visits the field and accessors an auto-accessor became. */
+    private visitAccessorFieldResult;
+    /** A reference to a class from its static initializers, replaced with the class alias. */
+    private visitIdentifier;
+    private mostOriginalIdentifier;
+    /** An undeclared private name becomes an empty identifier, except as a statement such as `#;`. */
+    private visitPrivateIdentifier;
+    /** `#x in obj` */
+    private transformPrivateIdentifierInInExpression;
+    /** An anonymous class whose static members move out of its body, so it can't name itself. */
+    isAnonymousClassNeedingAssignedName(node: Node): boolean;
+    private hasTransformableStatics;
+    /** `node`, naming an anonymous class whose static members move out of its body. */
+    private transformNamedEvaluationIfNeeded;
+    private visitVariableStatement;
+    private visitExportAssignment;
+    private injectPendingExpressions;
+    /** Visits a computed name's expression in the lexical environment outside the class. */
+    private visitInOuterEnvironment;
+    private visitComputedPropertyName;
+    private shouldTransformClassElementToWeakMap;
+    private shouldAlwaysTransformPrivateStaticElements;
+    private hasTransformPrivateStaticElementsFlag;
+    /** A private method or accessor becomes a hoisted function; the member is removed. */
+    private visitMethodOrAccessorDeclaration;
+    private getHoistedFunctionName;
+    /** `this` in a static initializer of the current class: its classThis or constructor alias. */
+    private tryGetClassThis;
+    private tryGetClassThisNoContainer;
+    /** `accessor x = 1` becomes `#x_accessor_storage = 1`, `get x()` and `set x(value)`. */
+    private transformAutoAccessor;
+    private transformPrivateFieldInitializer;
+    private transformPublicFieldInitializer;
+    private transformFieldInitializer;
+    private shouldTransformAutoAccessorsInCurrentClass;
+    private currentClassFacts;
+    private visitPropertyDeclaration;
+    private createPrivateIdentifierAccess;
+    private createPrivateIdentifierAccessHelper;
+    /** `super.x` in a static initializer, with the class and its base available. */
+    private staticSuperData;
+    private visitPropertyAccessExpression;
+    private visitPropertyAccessExpressionForSubstitution;
+    private visitElementAccessExpression;
+    private visitPreOrPostfixUnaryExpression;
+    private withRange;
+    /** `(_a = expression, ++_a)`, or `(_a = expression, result = _a++, _a)` for postfix operators. */
+    private expandIncrementOrDecrement;
+    private visitForStatement;
+    private visitExpressionStatement;
+    private createCopiableReceiver;
+    /** A copy of `node` sharing its children, which keep generated names. */
+    private shallowClone;
+    private visitCallExpression;
+    private visitTaggedTemplateExpression;
+    /** A static block as an expression to evaluate after the class: an arrow function called in place. */
+    private transformClassStaticBlockDeclaration;
+    private visitBinaryExpression;
+    /** `super.x = 1` becomes `(Reflect.set(_baseTemp, "x", _a = 1, _classTemp), _a)`. */
+    private transformSuperPropertyAssignment;
+    private createPrivateIdentifierAssignment;
+    /**
+     * Whether the body or initializer of `member` refers to the class `classNode` by name, which then
+     * needs an alias once the member's code moves out of the class.
+     */
+    private memberContainsConstructorReference;
+    private classContainsConstructorReference;
+    private getClassFacts;
+    private visitExpressionWithTypeArgumentsInHeritageClause;
+    /** Visits a class in a new class lexical environment. */
+    private visitClassLike;
+    private visitClassDeclarationInEnvironment;
+    private createClassTemp;
+    private visitClassExpressionInEnvironment;
+    /** `this` in a static initializer, or a computed name, of a class whose code moves out of its body. */
+    private visitThisExpression;
+    private transformClassMembers;
+    private createBrandCheckWeakSetForPrivateMethods;
+    private transformConstructor;
+    private transformConstructorBodyWorker;
+    private skipParameterPropertyAssignments;
+    private transformConstructorBody;
+    private addPropertyOrClassStaticBlockStatements;
+    private transformStaticBlockInElement;
+    private transformPropertyOrClassStaticBlock;
+    private generateInitializedPropertyExpressionsOrClassStaticBlock;
+    private transformProperty;
+    private transformPropertyWorker;
+    private createMemberAccessForPropertyName;
+    /** `_C_instances.add(this)` brands instances for private methods and accessors. */
+    private addInstanceMethodStatements;
+    private visitInvalidSuperProperty;
+    /**
+     * A visited computed name: an assignment caching its value when it's needed again (`shouldHoist`),
+     * the expression when it has effects, or undefined when it's unused or safe to repeat.
+     */
+    private getPropertyNameExpressionIfNeeded;
+    private getClassData;
+    private getPrivateEnvironment;
+    /** The brand check of a static member: the class, or its classThis. */
+    private staticBrandCheck;
+    private addPrivateIdentifierPropertyDeclarationToEnvironment;
+    private addPrivateIdentifierToEnvironment;
+    private setPrivateIdentifier;
+    private getPrivateIdentifier;
+    /** A hoisted variable such as `_C_x`, prefixed with the class name when it has one. */
+    private createHoistedVariableForClass;
+    private createHoistedVariableForPrivateName;
+    /** What a private name declared in this or an enclosing class transforms to. */
+    private accessPrivateIdentifier;
+    private isReservedPrivateName;
+    /** `obj.#x` as a destructuring target: `({ set value(_a) { __classPrivateFieldSet(obj, ...); } }).value`. */
+    private wrapPrivateIdentifierForDestructuringTarget;
+    private visitDestructuringAssignmentTarget;
+    private visitAssignmentElement;
+    private visitArrayAssignmentElement;
+    private visitObjectAssignmentElement;
+    /** Private names and static `super` in destructuring targets, as `[{ set value(x) { ... } }.value] = ...`. */
+    private visitAssignmentPattern;
+    private createAccessorPropertyGetRedirector;
+    private createAccessorPropertySetRedirector;
+    private createCallBinding;
+}
+export {};