@nestia/factory 12.0.0-dev.20260520.1

package/src/factory/index.ts

@@ -0,0 +1,86 @@
+export { createArrayBindingPattern } from "./bindings/createArrayBindingPattern";
+export { createBindingElement } from "./bindings/createBindingElement";
+export { createClassDeclaration } from "./declarations/createClassDeclaration";
+export { createFunctionDeclaration } from "./declarations/createFunctionDeclaration";
+export { createMethodDeclaration } from "./declarations/createMethodDeclaration";
+export { createParameterDeclaration } from "./declarations/createParameterDeclaration";
+export { createTypeAliasDeclaration } from "./declarations/createTypeAliasDeclaration";
+export { createVariableDeclaration } from "./declarations/createVariableDeclaration";
+export { createVariableDeclarationList } from "./declarations/createVariableDeclarationList";
+export { createVariableStatement } from "./declarations/createVariableStatement";
+export { updateClassDeclaration } from "./declarations/updateClassDeclaration";
+export { updateMethodDeclaration } from "./declarations/updateMethodDeclaration";
+export { createArrayLiteralExpression } from "./expressions/createArrayLiteralExpression";
+export { createArrowFunction } from "./expressions/createArrowFunction";
+export { createAsExpression } from "./expressions/createAsExpression";
+export { createAwaitExpression } from "./expressions/createAwaitExpression";
+export { createBinaryExpression } from "./expressions/createBinaryExpression";
+export { createCallChain } from "./expressions/createCallChain";
+export { createCallExpression } from "./expressions/createCallExpression";
+export { createConditionalExpression } from "./expressions/createConditionalExpression";
+export { createElementAccessChain } from "./expressions/createElementAccessChain";
+export { createElementAccessExpression } from "./expressions/createElementAccessExpression";
+export { createLogicalNot } from "./expressions/createLogicalNot";
+export { createNewExpression } from "./expressions/createNewExpression";
+export { createObjectLiteralExpression } from "./expressions/createObjectLiteralExpression";
+export { createPrefixMinus } from "./expressions/createPrefixMinus";
+export { createPrefixUnaryExpression } from "./expressions/createPrefixUnaryExpression";
+export { createPropertyAccessChain } from "./expressions/createPropertyAccessChain";
+export { createPropertyAccessExpression } from "./expressions/createPropertyAccessExpression";
+export { createPropertyAssignment } from "./expressions/createPropertyAssignment";
+export { createShorthandPropertyAssignment } from "./expressions/createShorthandPropertyAssignment";
+export { createSpreadAssignment } from "./expressions/createSpreadAssignment";
+export { createStrictEquality } from "./expressions/createStrictEquality";
+export { createBigIntLiteral } from "./literals/createBigIntLiteral";
+export { createFalse } from "./literals/createFalse";
+export { createIdentifier } from "./literals/createIdentifier";
+export { createNull } from "./literals/createNull";
+export { createNumericLiteral } from "./literals/createNumericLiteral";
+export { createStringLiteral } from "./literals/createStringLiteral";
+export { createTrue } from "./literals/createTrue";
+export { createExportDeclaration } from "./modules/createExportDeclaration";
+export { createImportClause } from "./modules/createImportClause";
+export { createImportDeclaration } from "./modules/createImportDeclaration";
+export { createImportSpecifier } from "./modules/createImportSpecifier";
+export { createModuleBlock } from "./modules/createModuleBlock";
+export { createModuleDeclaration } from "./modules/createModuleDeclaration";
+export { createNamedImports } from "./modules/createNamedImports";
+export { createNamespaceExport } from "./modules/createNamespaceExport";
+export { createNamespaceImport } from "./modules/createNamespaceImport";
+export { createQualifiedName } from "./names/createQualifiedName";
+export { createSourceFile } from "./source-files/createSourceFile";
+export { updateSourceFile } from "./source-files/updateSourceFile";
+export { createBlock } from "./statements/createBlock";
+export { createCatchClause } from "./statements/createCatchClause";
+export { createContinueStatement } from "./statements/createContinueStatement";
+export { createExpressionStatement } from "./statements/createExpressionStatement";
+export { createForOfStatement } from "./statements/createForOfStatement";
+export { createIfStatement } from "./statements/createIfStatement";
+export { createReturnStatement } from "./statements/createReturnStatement";
+export { createThrowStatement } from "./statements/createThrowStatement";
+export { createTryStatement } from "./statements/createTryStatement";
+export { createTemplateExpression } from "./templates/createTemplateExpression";
+export { createTemplateHead } from "./templates/createTemplateHead";
+export { createTemplateMiddle } from "./templates/createTemplateMiddle";
+export { createTemplateSpan } from "./templates/createTemplateSpan";
+export { createTemplateTail } from "./templates/createTemplateTail";
+export { createDecorator } from "./tokens/createDecorator";
+export { createModifier } from "./tokens/createModifier";
+export { createToken } from "./tokens/createToken";
+export { createArrayTypeNode } from "./types/createArrayTypeNode";
+export { createFunctionTypeNode } from "./types/createFunctionTypeNode";
+export { createIndexSignature } from "./types/createIndexSignature";
+export { createIntersectionTypeNode } from "./types/createIntersectionTypeNode";
+export { createKeywordTypeNode } from "./types/createKeywordTypeNode";
+export { createLiteralTypeNode } from "./types/createLiteralTypeNode";
+export { createOptionalTypeNode } from "./types/createOptionalTypeNode";
+export { createParenthesizedType } from "./types/createParenthesizedType";
+export { createPropertySignature } from "./types/createPropertySignature";
+export { createRestTypeNode } from "./types/createRestTypeNode";
+export { createTemplateLiteralType } from "./types/createTemplateLiteralType";
+export { createTemplateLiteralTypeSpan } from "./types/createTemplateLiteralTypeSpan";
+export { createTupleTypeNode } from "./types/createTupleTypeNode";
+export { createTypeLiteralNode } from "./types/createTypeLiteralNode";
+export { createTypeQueryNode } from "./types/createTypeQueryNode";
+export { createTypeReferenceNode } from "./types/createTypeReferenceNode";
+export { createUnionTypeNode } from "./types/createUnionTypeNode";

package/src/factory/literals/createBigIntLiteral.ts

@@ -0,0 +1,8 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createBigIntLiteral(value: string | number | bigint): Node {
+  const text: string = String(value).replace(/n$/i, "");
+  return createNode(SyntaxKind.BigIntLiteral, { text, transformFlags: 32 });
+}

package/src/factory/literals/createFalse.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+
+export function createFalse(): Node {
+  return createToken(SyntaxKind.FalseKeyword);
+}

package/src/factory/literals/createIdentifier.ts

@@ -0,0 +1,12 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createIdentifier(text: string): Node {
+  return createNode(SyntaxKind.Identifier, {
+    escapedText: text,
+    text,
+    jsDoc: undefined,
+    flowNode: undefined,
+  });
+}

package/src/factory/literals/createNull.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+
+export function createNull(): Node {
+  return createToken(SyntaxKind.NullKeyword);
+}

package/src/factory/literals/createNumericLiteral.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createNumericLiteral(value: string | number): Node {
+  return createNode(SyntaxKind.NumericLiteral, {
+    text: String(value),
+    numericLiteralFlags: 0,
+  });
+}

package/src/factory/literals/createStringLiteral.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createStringLiteral(
+  text: string,
+  isSingleQuote?: boolean,
+): Node {
+  return createNode(SyntaxKind.StringLiteral, {
+    text,
+    singleQuote: isSingleQuote,
+    hasExtendedUnicodeEscape: undefined,
+  });
+}

package/src/factory/literals/createTrue.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createToken } from "../tokens/createToken";
+
+export function createTrue(): Node {
+  return createToken(SyntaxKind.TrueKeyword);
+}

package/src/factory/modules/createExportDeclaration.ts

@@ -0,0 +1,26 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asModuleSpecifier } from "../../utils/asModuleSpecifier";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createExportDeclaration(
+  modifiers: readonly Node[] | undefined,
+  isTypeOnly: boolean,
+  exportClause: Node | undefined,
+  moduleSpecifier?: string | Node,
+  attributes?: Node,
+): Node {
+  return createNode(SyntaxKind.ExportDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    isTypeOnly,
+    exportClause,
+    moduleSpecifier:
+      moduleSpecifier === undefined
+        ? undefined
+        : asModuleSpecifier(moduleSpecifier),
+    assertClause: undefined,
+    attributes,
+    jsDoc: undefined,
+  });
+}

package/src/factory/modules/createImportClause.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createImportClause(
+  isTypeOnly: boolean,
+  name: string | Node | undefined,
+  namedBindings?: Node,
+): Node {
+  return createNode(SyntaxKind.ImportClause, {
+    isTypeOnly,
+    name: name === undefined ? undefined : asName(name),
+    namedBindings,
+  });
+}

package/src/factory/modules/createImportDeclaration.ts

@@ -0,0 +1,21 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asModuleSpecifier } from "../../utils/asModuleSpecifier";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createImportDeclaration(
+  modifiers: readonly Node[] | undefined,
+  importClause: Node | undefined,
+  moduleSpecifier: string | Node,
+  attributes?: Node,
+): Node {
+  return createNode(SyntaxKind.ImportDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    importClause,
+    moduleSpecifier: asModuleSpecifier(moduleSpecifier),
+    assertClause: undefined,
+    attributes,
+    jsDoc: undefined,
+  });
+}

package/src/factory/modules/createImportSpecifier.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createImportSpecifier(
+  isTypeOnly: boolean,
+  propertyName: string | Node | undefined,
+  name: string | Node,
+): Node {
+  return createNode(SyntaxKind.ImportSpecifier, {
+    isTypeOnly,
+    propertyName: propertyName === undefined ? undefined : asName(propertyName),
+    name: asName(name),
+  });
+}

package/src/factory/modules/createModuleBlock.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createModuleBlock(statements: readonly Node[] = []): Node {
+  return createNode(SyntaxKind.ModuleBlock, {
+    statements: createNodeArray(statements),
+  });
+}

package/src/factory/modules/createModuleDeclaration.ts

@@ -0,0 +1,23 @@
+import { NodeFlags } from "../../constants/NodeFlags";
+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 createModuleDeclaration(
+  modifiers: readonly Node[] | undefined,
+  name: string | Node,
+  body?: Node,
+  flags = 0,
+): Node {
+  return createNode(SyntaxKind.ModuleDeclaration, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    name: asName(name),
+    body,
+    flags: NodeFlags.Synthesized | flags,
+    jsDoc: undefined,
+    locals: undefined,
+    nextContainer: undefined,
+  });
+}

package/src/factory/modules/createNamedImports.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createNamedImports(elements: readonly Node[]): Node {
+  return createNode(SyntaxKind.NamedImports, {
+    elements: createNodeArray(elements),
+  });
+}

package/src/factory/modules/createNamespaceExport.ts

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

package/src/factory/modules/createNamespaceImport.ts

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

package/src/factory/names/createQualifiedName.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 createQualifiedName(
+  left: string | Node,
+  right: string | Node,
+): Node {
+  return createNode(SyntaxKind.QualifiedName, {
+    left: asName(left),
+    right: asName(right),
+  });
+}

package/src/factory/source-files/createSourceFile.ts

@@ -0,0 +1,52 @@
+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 createSourceFile(
+  statements: readonly Node[],
+  endOfFileToken?: Node,
+  flags = 0,
+): Node {
+  return createNode(SyntaxKind.SourceFile, {
+    flags,
+    statements: createNodeArray(statements),
+    endOfFileToken: endOfFileToken ?? createToken(SyntaxKind.EndOfFileToken),
+    text: "",
+    fileName: "",
+    path: "",
+    languageVersion: 99,
+    languageVariant: 0,
+    scriptKind: 3,
+    isDeclarationFile: false,
+    hasNoDefaultLib: false,
+    locals: undefined,
+    nextContainer: undefined,
+    endFlowNode: undefined,
+    nodeCount: 0,
+    identifierCount: 0,
+    symbolCount: 0,
+    parseDiagnostics: [],
+    bindDiagnostics: [],
+    bindSuggestionDiagnostics: undefined,
+    lineMap: undefined,
+    externalModuleIndicator: undefined,
+    setExternalModuleIndicator: undefined,
+    pragmas: new Map(),
+    checkJsDirective: undefined,
+    referencedFiles: [],
+    typeReferenceDirectives: [],
+    libReferenceDirectives: [],
+    amdDependencies: [],
+    commentDirectives: undefined,
+    identifiers: new Map(),
+    packageJsonLocations: undefined,
+    packageJsonScope: undefined,
+    imports: [],
+    moduleAugmentations: [],
+    ambientModuleNames: [],
+    classifiableNames: undefined,
+    impliedNodeFormat: undefined,
+  });
+}

package/src/factory/source-files/updateSourceFile.ts

@@ -0,0 +1,9 @@
+import type { Node } from "../../structures/Node";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function updateSourceFile(
+  file: Node,
+  statements: readonly Node[],
+): Node {
+  return { ...file, statements: createNodeArray(statements) };
+}

package/src/factory/statements/createBlock.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 createBlock(
+  statements: readonly Node[] = [],
+  multiLine?: boolean,
+): Node {
+  return createNode(SyntaxKind.Block, {
+    statements: createNodeArray(statements),
+    multiLine: !!multiLine,
+  });
+}

package/src/factory/statements/createCatchClause.ts

@@ -0,0 +1,17 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createVariableDeclaration } from "../declarations/createVariableDeclaration";
+
+export function createCatchClause(
+  variableDeclaration: string | Node | undefined,
+  block: Node,
+): Node {
+  return createNode(SyntaxKind.CatchClause, {
+    variableDeclaration:
+      typeof variableDeclaration === "string"
+        ? createVariableDeclaration(variableDeclaration)
+        : variableDeclaration,
+    block,
+  });
+}

package/src/factory/statements/createContinueStatement.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createContinueStatement(label?: string | Node): Node {
+  return createNode(SyntaxKind.ContinueStatement, {
+    label: label === undefined ? undefined : asName(label),
+  });
+}

package/src/factory/statements/createExpressionStatement.ts

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

package/src/factory/statements/createForOfStatement.ts

@@ -0,0 +1,17 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createForOfStatement(
+  awaitModifier: Node | undefined,
+  initializer: Node,
+  expression: Node,
+  statement: Node,
+): Node {
+  return createNode(SyntaxKind.ForOfStatement, {
+    awaitModifier,
+    initializer,
+    expression,
+    statement,
+  });
+}

package/src/factory/statements/createIfStatement.ts

@@ -0,0 +1,15 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createIfStatement(
+  expression: Node,
+  thenStatement: Node,
+  elseStatement?: Node,
+): Node {
+  return createNode(SyntaxKind.IfStatement, {
+    expression,
+    thenStatement,
+    elseStatement,
+  });
+}

package/src/factory/statements/createReturnStatement.ts

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

package/src/factory/statements/createThrowStatement.ts

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

package/src/factory/statements/createTryStatement.ts

@@ -0,0 +1,15 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createTryStatement(
+  tryBlock: Node,
+  catchClause?: Node,
+  finallyBlock?: Node,
+): Node {
+  return createNode(SyntaxKind.TryStatement, {
+    tryBlock,
+    catchClause,
+    finallyBlock,
+  });
+}

package/src/factory/templates/createTemplateExpression.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 createTemplateExpression(
+  head: Node,
+  templateSpans: readonly Node[],
+): Node {
+  return createNode(SyntaxKind.TemplateExpression, {
+    head,
+    templateSpans: createNodeArray(templateSpans),
+  });
+}

package/src/factory/templates/createTemplateHead.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createTemplateHead(text: string, rawText = text): Node {
+  return createNode(SyntaxKind.TemplateHead, { text, rawText });
+}

package/src/factory/templates/createTemplateMiddle.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createTemplateMiddle(text: string, rawText = text): Node {
+  return createNode(SyntaxKind.TemplateMiddle, { text, rawText });
+}

package/src/factory/templates/createTemplateSpan.ts

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

package/src/factory/templates/createTemplateTail.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createTemplateTail(text: string, rawText = text): Node {
+  return createNode(SyntaxKind.TemplateTail, { text, rawText });
+}

package/src/factory/tokens/createDecorator.ts

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

package/src/factory/tokens/createModifier.ts

@@ -0,0 +1,6 @@
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createModifier(kind: number): Node {
+  return createNode(kind);
+}

package/src/factory/tokens/createToken.ts

@@ -0,0 +1,6 @@
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createToken(kind: number): Node {
+  return createNode(kind);
+}

package/src/factory/types/createArrayTypeNode.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createParenthesizedType } from "./createParenthesizedType";
+
+export function createArrayTypeNode(elementType: Node): Node {
+  return createNode(SyntaxKind.ArrayType, {
+    elementType:
+      elementType.kind === SyntaxKind.UnionType ||
+      elementType.kind === SyntaxKind.IntersectionType
+        ? createParenthesizedType(elementType)
+        : elementType,
+  });
+}

package/src/factory/types/createFunctionTypeNode.ts

@@ -0,0 +1,18 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createFunctionTypeNode(
+  typeParameters: readonly Node[] | undefined,
+  parameters: readonly Node[],
+  type: Node,
+): Node {
+  return createNode(SyntaxKind.FunctionType, {
+    typeParameters: typeParameters
+      ? createNodeArray(typeParameters)
+      : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+  });
+}