@nestia/factory 12.0.0-dev.20260520.1

package/src/factory/declarations/createFunctionDeclaration.ts

@@ -0,0 +1,33 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createFunctionDeclaration(
+  modifiers: readonly Node[] | undefined,
+  asteriskToken: Node | undefined,
+  name: string | Node | undefined,
+  typeParameters: readonly Node[] | undefined,
+  parameters: readonly Node[] = [],
+  type: Node | undefined,
+  body: Node | undefined,
+): Node {
+  return createNode(SyntaxKind.FunctionDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    asteriskToken,
+    name: name === undefined ? undefined : asName(name),
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+    body,
+    typeArguments: undefined,
+    jsDoc: undefined,
+    locals: undefined,
+    nextContainer: undefined,
+    endFlowNode: undefined,
+    returnFlowNode: undefined,
+  });
+}

package/src/factory/declarations/createMethodDeclaration.ts

@@ -0,0 +1,35 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createMethodDeclaration(
+  modifiers: readonly Node[] | undefined,
+  asteriskToken: Node | undefined,
+  name: string | Node,
+  questionToken: Node | undefined,
+  typeParameters: readonly Node[] | undefined,
+  parameters: readonly Node[],
+  type: Node | undefined,
+  body: Node | undefined,
+): Node {
+  return createNode(SyntaxKind.MethodDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    asteriskToken,
+    name: asName(name),
+    questionToken,
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+    body,
+    typeArguments: undefined,
+    jsDoc: undefined,
+    locals: undefined,
+    nextContainer: undefined,
+    endFlowNode: undefined,
+    returnFlowNode: undefined,
+  });
+}

package/src/factory/declarations/createParameterDeclaration.ts

@@ -0,0 +1,24 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createParameterDeclaration(
+  modifiers: readonly Node[] | undefined,
+  dotDotDotToken: Node | undefined,
+  name: string | Node,
+  questionToken?: Node,
+  type?: Node,
+  initializer?: Node,
+): Node {
+  return createNode(SyntaxKind.Parameter, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    dotDotDotToken,
+    name: asName(name),
+    questionToken,
+    type,
+    initializer,
+    jsDoc: undefined,
+  });
+}

package/src/factory/declarations/createTypeAliasDeclaration.ts

@@ -0,0 +1,24 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createTypeAliasDeclaration(
+  modifiers: readonly Node[] | undefined,
+  name: string | Node,
+  typeParameters: readonly Node[] | undefined,
+  type: Node,
+): Node {
+  return createNode(SyntaxKind.TypeAliasDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    name: asName(name),
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    type,
+    jsDoc: undefined,
+    locals: undefined,
+    nextContainer: undefined,
+  });
+}

package/src/factory/declarations/createVariableDeclaration.ts

@@ -0,0 +1,18 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createVariableDeclaration(
+  name: string | Node,
+  exclamationToken?: Node,
+  type?: Node,
+  initializer?: Node,
+): Node {
+  return createNode(SyntaxKind.VariableDeclaration, {
+    name: asName(name),
+    exclamationToken,
+    type,
+    initializer,
+  });
+}

package/src/factory/declarations/createVariableDeclarationList.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createVariableDeclarationList(
+  declarations: readonly Node[],
+  flags = 0,
+): Node {
+  return createNode(SyntaxKind.VariableDeclarationList, {
+    flags,
+    declarations: createNodeArray(declarations),
+  });
+}

package/src/factory/declarations/createVariableStatement.ts

@@ -0,0 +1,15 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createVariableStatement(
+  modifiers: readonly Node[] | undefined,
+  declarationList: Node,
+): Node {
+  return createNode(SyntaxKind.VariableStatement, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    declarationList,
+    jsDoc: undefined,
+  });
+}

package/src/factory/declarations/updateClassDeclaration.ts

@@ -0,0 +1,25 @@
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function updateClassDeclaration(
+  original: Node,
+  modifiers: readonly Node[] | undefined,
+  name: string | Node | undefined,
+  typeParameters: readonly Node[] | undefined,
+  heritageClauses: readonly Node[] | undefined,
+  members: readonly Node[],
+): Node {
+  return {
+    ...original,
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    name: name === undefined ? undefined : asName(name),
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    heritageClauses: heritageClauses
+      ? createNodeArray(heritageClauses)
+      : undefined,
+    members: createNodeArray(members),
+  };
+}

package/src/factory/declarations/updateMethodDeclaration.ts

@@ -0,0 +1,29 @@
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function updateMethodDeclaration(
+  original: Node,
+  modifiers: readonly Node[] | undefined,
+  asteriskToken: Node | undefined,
+  name: string | Node,
+  questionToken: Node | undefined,
+  typeParameters: readonly Node[] | undefined,
+  parameters: readonly Node[],
+  type: Node | undefined,
+  body: Node | undefined,
+): Node {
+  return {
+    ...original,
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    asteriskToken,
+    name: asName(name),
+    questionToken,
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+    body,
+  };
+}

package/src/factory/expressions/createArrayLiteralExpression.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createArrayLiteralExpression(
+  elements: readonly Node[] = [],
+  multiLine?: boolean,
+): Node {
+  return createNode(SyntaxKind.ArrayLiteralExpression, {
+    elements: createNodeArray(elements),
+    multiLine: !!multiLine,
+  });
+}

package/src/factory/expressions/createArrowFunction.ts

@@ -0,0 +1,32 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+import { createToken } from "../tokens/createToken";
+
+export function createArrowFunction(
+  modifiers: readonly Node[] | undefined,
+  typeParameters: readonly Node[] | undefined,
+  parameters: readonly Node[],
+  type: Node | undefined,
+  equalsGreaterThanToken: Node | undefined,
+  body: Node,
+): Node {
+  return createNode(SyntaxKind.ArrowFunction, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+    equalsGreaterThanToken:
+      equalsGreaterThanToken ?? createToken(SyntaxKind.EqualsGreaterThanToken),
+    body,
+    typeArguments: undefined,
+    jsDoc: undefined,
+    locals: undefined,
+    nextContainer: undefined,
+    endFlowNode: undefined,
+    returnFlowNode: undefined,
+  });
+}

package/src/factory/expressions/createAsExpression.ts

@@ -0,0 +1,11 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createAsExpression(expression: Node, type: Node): Node {
+  return createNode(SyntaxKind.AsExpression, {
+    expression,
+    type,
+    transformFlags: 1,
+  });
+}

package/src/factory/expressions/createAwaitExpression.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createAwaitExpression(expression: Node): Node {
+  return createNode(SyntaxKind.AwaitExpression, {
+    expression,
+    transformFlags: 32,
+  });
+}

package/src/factory/expressions/createBinaryExpression.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asToken } from "../../utils/asToken";
+import { createNode } from "../../utils/createNode";
+
+export function createBinaryExpression(
+  left: Node,
+  operator: Node | number,
+  right: Node,
+): Node {
+  return createNode(SyntaxKind.BinaryExpression, {
+    left,
+    operatorToken: asToken(operator),
+    right,
+  });
+}

package/src/factory/expressions/createCallChain.ts

@@ -0,0 +1,20 @@
+import { NodeFlags } from "../../constants/NodeFlags";
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+import { createCallExpression } from "./createCallExpression";
+
+export function createCallChain(
+  expression: Node,
+  questionDotToken?: Node,
+  typeArguments?: readonly Node[],
+  args?: readonly Node[],
+): Node {
+  return {
+    ...createCallExpression(expression, typeArguments, args),
+    flags: NodeFlags.Synthesized | NodeFlags.OptionalChain,
+    questionDotToken:
+      questionDotToken ?? createToken(SyntaxKind.QuestionDotToken),
+    transformFlags: 32,
+  };
+}

package/src/factory/expressions/createCallExpression.ts

@@ -0,0 +1,17 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createCallExpression(
+  expression: Node,
+  typeArguments?: readonly Node[],
+  args?: readonly Node[],
+): Node {
+  return createNode(SyntaxKind.CallExpression, {
+    expression,
+    questionDotToken: undefined,
+    typeArguments: typeArguments ? createNodeArray(typeArguments) : undefined,
+    arguments: createNodeArray(args),
+  });
+}

package/src/factory/expressions/createConditionalExpression.ts

@@ -0,0 +1,20 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createToken } from "../tokens/createToken";
+
+export function createConditionalExpression(
+  condition: Node,
+  questionToken: Node | undefined,
+  whenTrue: Node,
+  colonToken: Node | undefined,
+  whenFalse: Node,
+): Node {
+  return createNode(SyntaxKind.ConditionalExpression, {
+    condition,
+    questionToken: questionToken ?? createToken(SyntaxKind.QuestionToken),
+    whenTrue,
+    colonToken: colonToken ?? createToken(SyntaxKind.ColonToken),
+    whenFalse,
+  });
+}

package/src/factory/expressions/createElementAccessChain.ts

@@ -0,0 +1,19 @@
+import { NodeFlags } from "../../constants/NodeFlags";
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+import { createElementAccessExpression } from "./createElementAccessExpression";
+
+export function createElementAccessChain(
+  expression: Node,
+  questionDotToken: Node | undefined,
+  argumentExpression: Node,
+): Node {
+  return {
+    ...createElementAccessExpression(expression, argumentExpression),
+    flags: NodeFlags.Synthesized | NodeFlags.OptionalChain,
+    questionDotToken:
+      questionDotToken ?? createToken(SyntaxKind.QuestionDotToken),
+    transformFlags: 32,
+  };
+}

package/src/factory/expressions/createElementAccessExpression.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createElementAccessExpression(
+  expression: Node,
+  argumentExpression: Node,
+): Node {
+  return createNode(SyntaxKind.ElementAccessExpression, {
+    expression,
+    questionDotToken: undefined,
+    argumentExpression,
+    jsDoc: undefined,
+    flowNode: undefined,
+  });
+}

package/src/factory/expressions/createLogicalNot.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createPrefixUnaryExpression } from "./createPrefixUnaryExpression";
+
+export function createLogicalNot(operand: Node): Node {
+  return createPrefixUnaryExpression(SyntaxKind.ExclamationToken, operand);
+}

package/src/factory/expressions/createNewExpression.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createNewExpression(
+  expression: Node,
+  typeArguments?: readonly Node[],
+  args?: readonly Node[],
+): Node {
+  return createNode(SyntaxKind.NewExpression, {
+    expression,
+    typeArguments: typeArguments ? createNodeArray(typeArguments) : undefined,
+    arguments: args ? createNodeArray(args) : undefined,
+  });
+}

package/src/factory/expressions/createObjectLiteralExpression.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createObjectLiteralExpression(
+  properties: readonly Node[] = [],
+  multiLine?: boolean,
+): Node {
+  return createNode(SyntaxKind.ObjectLiteralExpression, {
+    properties: createNodeArray(properties),
+    multiLine: !!multiLine,
+  });
+}

package/src/factory/expressions/createPrefixMinus.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createPrefixUnaryExpression } from "./createPrefixUnaryExpression";
+
+export function createPrefixMinus(operand: Node): Node {
+  return createPrefixUnaryExpression(SyntaxKind.MinusToken, operand);
+}

package/src/factory/expressions/createPrefixUnaryExpression.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createPrefixUnaryExpression(
+  operator: number,
+  operand: Node,
+): Node {
+  return createNode(SyntaxKind.PrefixUnaryExpression, { operator, operand });
+}

package/src/factory/expressions/createPropertyAccessChain.ts

@@ -0,0 +1,19 @@
+import { NodeFlags } from "../../constants/NodeFlags";
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+import { createPropertyAccessExpression } from "./createPropertyAccessExpression";
+
+export function createPropertyAccessChain(
+  expression: Node,
+  questionDotToken: Node | undefined,
+  name: string | Node,
+): Node {
+  return {
+    ...createPropertyAccessExpression(expression, name),
+    flags: NodeFlags.Synthesized | NodeFlags.OptionalChain,
+    questionDotToken:
+      questionDotToken ?? createToken(SyntaxKind.QuestionDotToken),
+    transformFlags: 32,
+  };
+}

package/src/factory/expressions/createPropertyAccessExpression.ts

@@ -0,0 +1,17 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createPropertyAccessExpression(
+  expression: Node,
+  name: string | Node,
+): Node {
+  return createNode(SyntaxKind.PropertyAccessExpression, {
+    expression,
+    questionDotToken: undefined,
+    name: asName(name),
+    jsDoc: undefined,
+    flowNode: undefined,
+  });
+}

package/src/factory/expressions/createPropertyAssignment.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createPropertyAssignment(
+  name: string | Node,
+  initializer: Node,
+): Node {
+  return createNode(SyntaxKind.PropertyAssignment, {
+    name: asName(name),
+    initializer,
+  });
+}

package/src/factory/expressions/createShorthandPropertyAssignment.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createShorthandPropertyAssignment(
+  name: string | Node,
+  objectAssignmentInitializer?: Node,
+): Node {
+  return createNode(SyntaxKind.ShorthandPropertyAssignment, {
+    name: asName(name),
+    objectAssignmentInitializer,
+  });
+}

package/src/factory/expressions/createSpreadAssignment.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createSpreadAssignment(expression: Node): Node {
+  return createNode(SyntaxKind.SpreadAssignment, { expression });
+}

package/src/factory/expressions/createStrictEquality.ts

@@ -0,0 +1,11 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createBinaryExpression } from "./createBinaryExpression";
+
+export function createStrictEquality(left: Node, right: Node): Node {
+  return createBinaryExpression(
+    left,
+    SyntaxKind.EqualsEqualsEqualsToken,
+    right,
+  );
+}