tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/factory.d.ts

@@ -0,0 +1,147 @@
+import { ArrowFunction, DeleteExpression, SyntheticReferenceExpression, BinaryExpression, ElementAccessExpression, FunctionExpression, ModifierFlags, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, type Node, NodeFlags, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SourceFile, StringLiteral, SyntaxList, Token, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression } from '../ast.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import { TokenFlags } from '../types.js';
+import type { EmitContext } from './emit-context.js';
+import { GeneratedIdentifierFlags } from './emit-flags.js';
+import { NodeFactoryBase } from './factory-base.js';
+import { OuterExpressionKinds } from '../transformers/utilities.js';
+/**
+ * The node factory of an emit context. The context is the factory (`EmitContext` extends it), so the two are one
+ * object: a factory and a context that pointed at each other made every context a reference cycle.
+ */
+export declare abstract class NodeFactory extends NodeFactoryBase {
+    /** The emit context this factory belongs to: the factory itself. */
+    abstract get context(): EmitContext;
+    protected finishUpdate(updated: Node, original: Node): boolean;
+    /** Flags a node built with its constructor as synthesized. */
+    created<T extends Node>(node: T): T;
+    /** A shallow copy of `node` with the same range and flags, its original set to `node`. */
+    cloneNode<T extends Node>(node: T, copy: T): T;
+    cloneIdentifier(node: Identifier): Identifier;
+    createNodeList(nodes: Node[]): NodeList;
+    createModifierList(nodes: Node[]): ModifierList;
+    /** A copy of `list` with other nodes, keeping its range. */
+    updateNodeList(list: NodeList, nodes: Node[]): NodeList;
+    createToken(kind: SyntaxKind): Token;
+    createIdentifier(text: string): Identifier;
+    createKeywordExpression(kind: SyntaxKind): KeywordExpression;
+    createStringLiteral(text: string, tokenFlags: TokenFlags): StringLiteral;
+    createNumericLiteral(text: string): NumericLiteral;
+    /** A string literal printed from the text of another node, e.g. an identifier. */
+    createStringLiteralFromNode(textSource: Node): StringLiteral;
+    createSyntaxList(children: Node[]): SyntaxList;
+    createParenthesizedExpression(expression: Node): ParenthesizedExpression;
+    createPropertyAccessExpression(expression: Node, name: Node): PropertyAccessExpression;
+    createCallExpression(expression: Node, args: Node[]): CallExpression;
+    createBinaryExpression(left: Node, operator: SyntaxKind, right: Node): BinaryExpression;
+    createAssignment(left: Node, right: Node): BinaryExpression;
+    createStrictEquality(left: Node, right: Node): BinaryExpression;
+    createConditionalExpression(condition: Node, whenTrue: Node, whenFalse: Node): ConditionalExpression;
+    createVoidZero(): VoidExpression;
+    /** `typeof value === "tag"` */
+    createTypeCheck(value: Node, tag: string): BinaryExpression;
+    createBlock(statements: Node[], multiLine: boolean): Block;
+    createExpressionStatement(expression: Node): ExpressionStatement;
+    createReturnStatement(expression: Node | undefined): ReturnStatement;
+    createIfStatement(expression: Node, thenStatement: Node, elseStatement: Node | undefined): IfStatement;
+    createVariableDeclaration(name: Node, exclamationToken: Token | undefined, type: Node | undefined, initializer: Node | undefined): VariableDeclaration;
+    createVariableDeclarationList(declarations: NodeList, flags: NodeFlags): VariableDeclarationList;
+    createVariableStatement(modifiers: ModifierList | undefined, list: VariableDeclarationList): VariableStatement;
+    createElementAccessExpression(expression: Node, argument: Node): ElementAccessExpression;
+    createCommaExpression(left: Node, right: Node): BinaryExpression;
+    createLogicalOr(left: Node, right: Node): BinaryExpression;
+    createPrefixUnaryExpression(operator: SyntaxKind, operand: Node): PrefixUnaryExpression;
+    createTrue(): KeywordExpression;
+    createObjectLiteral(properties: Node[], multiLine: boolean): ObjectLiteralExpression;
+    createPropertyAssignment(name: Node, initializer: Node): PropertyAssignment;
+    createParameter(name: Node): ParameterDeclaration;
+    createFunctionExpression(parameters: Node[], body: Block): FunctionExpression;
+    createArrowFunction(parameters: Node[], body: Node): ArrowFunction;
+    /** The expressions joined with commas, or undefined if there are none. */
+    inlineExpressions(expressions: Node[]): Node | undefined;
+    /** `a.b.c` as a property access chain, from the qualified name `a.b.c`. */
+    createExpressionFromEntityName(node: Node): Node;
+    private getName;
+    /** A name referring to the declaration in its own scope, never prefixed with its export. */
+    getLocalName(node: Node, options: NameOptions): Identifier;
+    /** A name referring to the declaration that is prefixed with its export when it has one. */
+    getExportName(node: Node, options: NameOptions): Identifier;
+    getDeclarationName(node: Node, options: NameOptions): Identifier;
+    /** `ns.name` */
+    getNamespaceMemberName(namespace: Identifier, name: Identifier, options: NameOptions): PropertyAccessExpression;
+    /** `ns.name` for an exported declaration in a namespace, else its export name. */
+    getExternalModuleOrNamespaceExportName(namespace: Identifier | undefined, node: Node, options: NameOptions): Node;
+    /** A copy of a source file with other statements. */
+    updateSourceFile(node: SourceFile, statements: NodeList, endOfFileToken: Token): SourceFile;
+    private createGeneratedIdentifier;
+    /** A temporary variable such as `_a`; add it to an environment with `addVariableDeclaration`. */
+    createTempVariable(flags: GeneratedIdentifierFlags): Identifier;
+    createLoopVariable(flags: GeneratedIdentifierFlags): Identifier;
+    createUniqueName(text: string, flags: GeneratedIdentifierFlags): Identifier;
+    createGeneratedNameForNode(node: Node, flags: GeneratedIdentifierFlags, prefix: string, suffix: string): Identifier;
+    /** A private name such as `#x_accessor_storage`, unique within its class and based on `node`. */
+    createGeneratedPrivateNameForNode(node: Node, prefix: string, suffix: string): PrivateIdentifier;
+    /** The name of an unscoped emit helper such as `__decorate`. */
+    createUnscopedHelperName(name: string): Identifier;
+    /** `__importDefault(expression)` */
+    createImportDefaultHelper(expression: Node): CallExpression;
+    /** `__importStar(expression)` */
+    createImportStarHelper(expression: Node): CallExpression;
+    /** `__exportStar(moduleExpression, exportsExpression)` */
+    createExportStarHelper(moduleExpression: Node, exportsExpression: Node): CallExpression;
+    /** `__rewriteRelativeImportExtension(argument)`, with `true` to keep `.jsx`. */
+    createRewriteRelativeImportExtensionsHelper(argument: Node, preserveJsx: boolean): CallExpression;
+    isCallToHelper(node: Node, helperName: string): boolean;
+    /** `__makeTemplateObject(cooked, raw)` */
+    createTemplateObjectHelper(cooked: Node, raw: Node): CallExpression;
+    createThisExpression(): KeywordExpression;
+    createDeleteExpression(expression: Node): DeleteExpression;
+    createSyntheticReferenceExpression(expression: Node, thisArg: Node): SyntheticReferenceExpression;
+    /** `object.method(...args)`, keeping an optional call chain `object` optional. */
+    createMethodCall(object: Node, method: string, args: Node[]): CallExpression;
+    /** `Global.method(...args)`, such as `Math.pow(a, b)`. */
+    createGlobalMethodCall(global: string, method: string, args: Node[]): CallExpression;
+    /** `target.call(thisArg, ...args)` */
+    createFunctionCallCall(target: Node, thisArg: Node, args: Node[]): CallExpression;
+    /** `left !== null && right !== void 0`, or with `invert`, `left === null || right === void 0`. */
+    createNotNullCondition(left: Node, right: Node, invert: boolean): BinaryExpression;
+    /** `inner` wrapped again in the outer expressions of `kinds` that wrapped what it replaces in `outer`. */
+    restoreOuterExpressions(outer: Node | undefined, inner: Node, kinds: OuterExpressionKinds): Node;
+    /** A synthesized parenthesized expression without ranges, which the printer recreates as needed. */
+    private isIgnorableParen;
+    private updateOuterExpression;
+    /** A unique name based on `text`, with `suffix` added when the name is made unique. */
+    createUniqueNameWithSuffix(text: string, flags: GeneratedIdentifierFlags, suffix: string): Identifier;
+    /** The modifiers for `flags`, in canonical order. */
+    createModifiersFromFlags(flags: ModifierFlags): ModifierList;
+    /** `target.bind(thisArg, ...args)` */
+    createFunctionBindCall(target: Node, thisArg: Node, args: Node[]): CallExpression;
+    /** `Object.defineProperty(target, name, descriptor)` */
+    createObjectDefinePropertyCall(target: Node, name: Node, descriptor: Node): CallExpression;
+    /** `Reflect.get(target, propertyKey, receiver)` */
+    createReflectGetCall(target: Node, propertyKey: Node, receiver: Node): CallExpression;
+    /** `Reflect.set(target, propertyKey, value, receiver)` */
+    createReflectSetCall(target: Node, propertyKey: Node, value: Node, receiver: Node): CallExpression;
+    /** `(() => { ...statements })()` */
+    createImmediatelyInvokedArrowFunction(statements: Node[]): CallExpression;
+    /** `({ set value(parameter) { expression; } }).value`, a destructuring target running `expression`. */
+    createAssignmentTargetWrapper(parameter: Identifier, expression: Node): PropertyAccessExpression;
+    /** `__classPrivateFieldGet(receiver, state, kind, f)`; `kind` is `"f"`, `"m"` or `"a"`. */
+    createClassPrivateFieldGetHelper(receiver: Node, state: Node, kind: string, f: Node | undefined): CallExpression;
+    /** `__classPrivateFieldSet(receiver, state, value, kind, f)` */
+    createClassPrivateFieldSetHelper(receiver: Node, state: Node, value: Node, kind: string, f: Node | undefined): CallExpression;
+    /** `__classPrivateFieldIn(state, receiver)` */
+    createClassPrivateFieldInHelper(state: Node, receiver: Node): CallExpression;
+    /** `__addDisposableResource(env, value, async)` */
+    createAddDisposableResourceHelper(env: Node, value: Node, async: boolean): CallExpression;
+    /** `__disposeResources(env)` */
+    createDisposeResourcesHelper(env: Node): CallExpression;
+}
+/** Options for declaration names. */
+export declare const enum NameOptions {
+    None = 0,
+    AllowComments = 1,
+    AllowSourceMaps = 2,
+    /** Use the declaration's own name, not one assigned to it. */
+    IgnoreAssignedName = 4
+}