@goast/typescript 0.6.3-beta.1 → 0.7.1

package/src/src/ast/nodes/constructor-parameter.ts

@@ -0,0 +1,70 @@
+import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+
+import type { TsAccessModifier } from '../common.js';
+import { writeTsNode } from '../utils/write-ts-nodes.js';
+import { writeTsParameters } from '../utils/write-ts-parameters.js';
+import { tsDecorator } from './decorator.js';
+import { TsParameter } from './parameter.js';
+
+type Injects = 'modifiers';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsParameter<TBuilder, TInjects | Injects>,
+  {
+    accessModifier?: Nullable<TsAccessModifier>;
+    readonly?: Nullable<boolean>;
+  }
+>;
+
+export class TsConstructorParameter<TBuilder extends SourceBuilder, TInjects extends string = never>
+  extends TsParameter<
+    TBuilder,
+    TInjects | Injects
+  > {
+  public accessModifier: TsAccessModifier | null;
+  public readonly: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.accessModifier = options.accessModifier ?? null;
+    this.readonly = options.readonly ?? false;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append(this.inject.beforeDecorators);
+    tsDecorator.write(builder, this.decorators);
+    builder.append(this.inject.afterDecorators);
+
+    builder.append(this.inject.beforeModifiers);
+    if (this.accessModifier) builder.append(this.accessModifier, ' ');
+    if (this.readonly) builder.append('readonly ');
+    builder.append(this.inject.afterModifiers);
+
+    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+    if (this.optional) builder.append('?');
+
+    if (this.type) {
+      builder.append(': ');
+      builder.append(this.inject.beforeType);
+      writeTsNode(builder, this.type);
+      builder.append(this.inject.afterType);
+    }
+
+    if (this.default) {
+      builder.append(' = ');
+      builder.append(this.inject.beforeDefault);
+      writeTsNode(builder, this.default);
+      builder.append(this.inject.afterDefault);
+    }
+  }
+}
+
+const createConstructorParameter = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
+): TsConstructorParameter<TBuilder> => new TsConstructorParameter<TBuilder>({ ...options, name });
+
+export const tsConstructorParameter: typeof createConstructorParameter & { write: typeof writeTsParameters } = Object
+  .assign(createConstructorParameter, {
+    write: writeTsParameters,
+  });

package/src/src/ast/nodes/constructor.ts

@@ -0,0 +1,77 @@
+import {
+  type AppendValue,
+  type AstNodeOptions,
+  type BasicAppendValue,
+  notNullish,
+  type Nullable,
+  type SourceBuilder,
+} from '@goast/core';
+
+import { TsNode } from '../node.js';
+import { writeTsNodes } from '../utils/write-ts-nodes.js';
+import type { TsConstructorParameter } from './constructor-parameter.js';
+import { type TsDecorator, tsDecorator } from './decorator.js';
+import { type TsDoc, tsDoc } from './doc.js';
+import { tsParameter } from './parameter.js';
+
+type Injects = 'params' | 'doc' | 'decorators' | 'body';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsConstructorParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+  }
+>;
+
+export class TsConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public doc: TsDoc<TBuilder> | null;
+  public decorators: TsDecorator<TBuilder>[];
+  public parameters: (TsConstructorParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+  public body: AppendValue<TBuilder> | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.doc = options.doc ?? null;
+    this.decorators = options.decorators?.filter(notNullish) ?? [];
+    this.parameters = options.parameters?.filter(notNullish) ?? [];
+    this.body = options.body ?? null;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append(this.inject.beforeDoc);
+    tsDoc.get(this.doc, { parameters: this.parameters })?.write(builder);
+    builder.append(this.inject.afterDoc);
+
+    builder.append(this.inject.beforeDecorators);
+    tsDecorator.write(builder, this.decorators, { multiline: true });
+    builder.append(this.inject.afterDecorators);
+
+    builder.append('constructor');
+    builder.append(this.inject.beforeParams);
+    tsParameter.write(builder, this.parameters);
+    builder.append(this.inject.afterParams);
+    builder.append(' ');
+
+    builder.append(this.inject.beforeBody);
+    builder.parenthesize('{}', this.body, { multiline: !!this.body });
+    builder.append(this.inject.afterBody);
+
+    builder.appendLine();
+  }
+}
+
+const createConstructor = <TBuilder extends SourceBuilder>(options?: Options<TBuilder>): TsConstructor<TBuilder> =>
+  new TsConstructor<TBuilder>(options ?? {});
+
+export const tsConstructor: typeof createConstructor & { write: typeof writeTsNodes } = Object.assign(
+  createConstructor,
+  {
+    write: writeTsNodes,
+  },
+);

package/src/src/ast/nodes/decorator.ts

@@ -0,0 +1,76 @@
+import {
+  type AppendValue,
+  type AstNodeOptions,
+  type BasicAppendValue,
+  notNullish,
+  type Nullable,
+  type Prettify,
+  type SingleOrMultiple,
+  type SourceBuilder,
+  toArray,
+} from '@goast/core';
+
+import { TsNode } from '../node.js';
+import { writeTsNode } from '../utils/write-ts-nodes.js';
+import { type TsArgument, tsArgument } from './argument.js';
+import type { TsReference } from './reference.js';
+import type { TsValue } from './types.js';
+
+type Injects = 'function' | 'arguments';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    function: TsReference<TBuilder> | BasicAppendValue<TBuilder>;
+    arguments?: Nullable<Nullable<TsArgument<TBuilder> | TsValue<TBuilder>>[]>;
+  }
+>;
+
+export class TsDecorator<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public function: TsReference<TBuilder> | BasicAppendValue<TBuilder>;
+  public arguments: (TsArgument<TBuilder> | TsValue<TBuilder>)[] | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.function = options.function;
+    this.arguments = options.arguments?.filter(notNullish) ?? null;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append('@');
+    builder.append(this.inject.beforeFunction);
+    writeTsNode(builder, this.function);
+    builder.append(this.inject.afterFunction);
+
+    if (this.arguments) {
+      builder.append(this.inject.beforeArguments);
+      tsArgument.write(builder, this.arguments);
+      builder.append(this.inject.afterArguments);
+    }
+  }
+}
+
+const createDecorator = <TBuilder extends SourceBuilder>(
+  fn: Options<TBuilder>['function'],
+  args?: Options<TBuilder>['arguments'],
+  options?: Prettify<Omit<Options<TBuilder>, 'function' | 'arguments'>>,
+): TsDecorator<TBuilder> => new TsDecorator<TBuilder>({ ...options, function: fn, arguments: args });
+
+const writeDecorators = <TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<TsDecorator<TBuilder> | AppendValue<TBuilder>>>,
+  options?: { multiline?: boolean },
+): void => {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  builder.forEach(filteredNodes, (b, d) => {
+    writeTsNode(b, d);
+    b.append(options?.multiline ? '\n' : ' ');
+  });
+};
+
+export const tsDecorator: typeof createDecorator & { write: typeof writeDecorators } = Object.assign(createDecorator, {
+  write: writeDecorators,
+});

package/src/src/ast/nodes/doc-tag.ts

@@ -0,0 +1,291 @@
+import {
+  type AstNodeOptions,
+  type BasicAppendValue,
+  basicAppendValueGroup,
+  notNullish,
+  type Nullable,
+  type ParametersWithOverloads,
+  type Prettify,
+  type SourceBuilder,
+  type StringSuggestions,
+} from '@goast/core';
+
+import { isTypeScriptAppendValue } from '../../file-builder.js';
+import { TsNode } from '../node.js';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+import type { TsType } from './types.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    tag: string;
+    type?: Nullable<TsType<TBuilder>>;
+    text?: Nullable<BasicAppendValue<TBuilder>>;
+  }
+>;
+
+export class TsDocTag<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public tag: string;
+  public type: TsType<TBuilder> | null;
+  public text: BasicAppendValue<TBuilder> | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.tag = options.tag;
+    this.type = options.type ?? null;
+    this.text = options.text ?? null;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append('@', this.tag);
+
+    if (this.type) {
+      builder.append(' ');
+      builder.parenthesize('{}', (b) => writeTsNode(b, this.type));
+    }
+
+    if (this.text) {
+      builder.append(' ', this.text);
+    }
+  }
+}
+
+type _TsDocTagOpt<TBuilder extends SourceBuilder> = Prettify<Omit<Options<TBuilder>, 'tag'>>;
+
+type _TsDocTagArgsMap<TBuilder extends SourceBuilder> =
+  & {
+    access(
+      access: StringSuggestions<'package' | 'private' | 'protected' | 'public'>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    author(authorName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    author(
+      authorName: BasicAppendValue<TBuilder>,
+      emailAddress: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    borrows(
+      thatNamepath: BasicAppendValue<TBuilder>,
+      thisNamepath: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    params(
+      paramName: BasicAppendValue<TBuilder>,
+      paramDescription: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    example(
+      caption: BasicAppendValue<TBuilder>,
+      code: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    example(code: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    exports(
+      moduleName: BasicAppendValue<TBuilder>,
+      exportName: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    kind(
+      kindName: StringSuggestions<
+        | 'class'
+        | 'constant'
+        | 'event'
+        | 'external'
+        | 'file'
+        | 'function'
+        | 'member'
+        | 'mixin'
+        | 'module'
+        | 'namespace'
+        | 'typedef'
+      >,
+      options?: _TsDocTagOpt<TBuilder>,
+    ): never;
+    license(identifier: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    listens(eventName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    mixes(otherObjectPath: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    mixin(mixinName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    requires(moduleName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    variation(variationNumber: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+  }
+  & {
+    [K in 'virtual' | 'abstract']: (options?: _TsDocTagOpt<TBuilder>) => never;
+  }
+  & {
+    [K in 'alias' | 'augments' | 'callback' | 'extends' | 'lends' | 'name' | 'see' | 'this']: (
+      namePath: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ) => never;
+  }
+  & {
+    [
+      K in
+        | 'async'
+        | 'generator'
+        | 'global'
+        | 'hideconstructor'
+        | 'ignore'
+        | 'inheritdoc'
+        | 'inner'
+        | 'instance'
+        | 'override'
+        | 'static'
+        | 'enum'
+        | 'package'
+        | 'private'
+        | 'protected'
+        | 'implements'
+        | 'type'
+    ]: (options?: _TsDocTagOpt<TBuilder>) => never;
+  }
+  & {
+    [
+      K in
+        | 'class'
+        | 'constructor'
+        | 'const'
+        | 'function'
+        | 'func'
+        | 'method'
+        | 'constant'
+        | 'member'
+        | 'constructs'
+        | 'interface'
+        | 'var'
+        | 'yield'
+        | 'yields'
+        | 'module'
+        | 'namespace'
+        | 'typedef'
+    ]: {
+      (name: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+      (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+  }
+  & {
+    [
+      K in
+        | 'return'
+        | 'returns'
+        | 'throws'
+        | 'exception'
+        | 'classdesc'
+        | 'copyright'
+        | 'deprecated'
+        | 'desc'
+        | 'description'
+        | 'file'
+        | 'fileoverview'
+        | 'overview'
+        | 'public'
+        | 'readonly'
+        | 'since'
+        | 'summary'
+        | 'todo'
+        | 'tutorial'
+        | 'version'
+    ]: {
+      (description: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+      (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+  }
+  & {
+    [K in 'default' | 'defaultvalue']: {
+      (value: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+      (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+  }
+  & {
+    [K in 'event' | 'fires']: (
+      className: BasicAppendValue<TBuilder>,
+      eventName: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ) => never;
+  }
+  & {
+    [K in 'external' | 'host']: (nameOfExternal: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>) => never;
+  }
+  & {
+    [K in 'memberof' | 'memberof!']: (
+      parentNamepath: BasicAppendValue<TBuilder>,
+      options?: _TsDocTagOpt<TBuilder>,
+    ) => never;
+  }
+  & {
+    [K in 'param' | 'arg' | 'argument' | 'prop' | 'property' | 'template']: {
+      (
+        name: BasicAppendValue<TBuilder>,
+        description: BasicAppendValue<TBuilder>,
+        options?: _TsDocTagOpt<TBuilder>,
+      ): never;
+      (name: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    };
+  };
+
+type _TsDocTagArgs<
+  TTagName extends StringSuggestions<keyof _TsDocTagArgsMap<TBuilder>>,
+  TBuilder extends SourceBuilder,
+> = TTagName extends keyof _TsDocTagArgsMap<TBuilder>
+  // deno-lint-ignore no-explicit-any
+  ? _TsDocTagArgsMap<TBuilder>[TTagName] extends (...args: any[]) => any
+    ? ParametersWithOverloads<_TsDocTagArgsMap<TBuilder>[TTagName]>
+  : never
+  : [options?: _TsDocTagOpt<TBuilder>];
+
+function createDocTag<
+  TTagName extends StringSuggestions<keyof _TsDocTagArgsMap<TBuilder>>,
+  TBuilder extends SourceBuilder,
+>(
+  tag: TTagName,
+  ...args: _TsDocTagArgs<TTagName, TBuilder>
+): TsDocTag<TBuilder>;
+// deno-lint-ignore no-explicit-any
+function createDocTag<TBuilder extends SourceBuilder>(tag: string, ...args: any[]): TsDocTag<TBuilder> {
+  let opt: _TsDocTagOpt<TBuilder> = {};
+  if (args.length > 0) {
+    const lastArg = args[args.length - 1];
+    if (!isTypeScriptAppendValue(lastArg) && !!lastArg) {
+      opt = args.pop() as _TsDocTagOpt<TBuilder>;
+    }
+  }
+
+  let params = args as BasicAppendValue<TBuilder>[];
+
+  if (tag === 'author' && params.length === 2) {
+    params[1] = `<${params[1]}>`;
+  }
+
+  if (tag === 'borrows') {
+    params.splice(1, 0, 'as');
+  }
+
+  if (tag === 'example') {
+    if (typeof params[0] === 'string') {
+      params[0] = `<caption>${params[0]}</caption>`;
+    }
+    if (params[1] && isTypeScriptAppendValue(params[1])) {
+      params.splice(1, 0, '\n');
+    }
+  }
+
+  if ((tag === 'event' || tag === 'fires') && typeof params[0] === 'string' && typeof params[1] === 'string') {
+    params.splice(0, 2, `${params[0]}#${params[1]}`);
+  }
+
+  params = [...params, opt.text].filter(notNullish);
+  return new TsDocTag({
+    tag,
+    type: opt.type,
+    text: params.length > 0 ? basicAppendValueGroup<TBuilder>(params, ' ') : null,
+    inject: opt.inject,
+  });
+}
+
+export const tsDocTag: typeof createDocTag & { write: typeof writeTsNodes } = Object.assign(createDocTag, {
+  write: writeTsNodes,
+});

package/src/src/ast/nodes/doc.ts

@@ -0,0 +1,102 @@
+import {
+  type AstNodeOptions,
+  type BasicAppendValue,
+  createOverwriteProxy,
+  getIsInstanceOf,
+  notNullish,
+  type Nullable,
+  type SourceBuilder,
+} from '@goast/core';
+
+import { TsNode } from '../node.js';
+import { writeTsNodes } from '../utils/write-ts-nodes.js';
+import { type TsDocTag, tsDocTag } from './doc-tag.js';
+import { TsGenericParameter } from './generic-parameter.js';
+import { TsParameter } from './parameter.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    tags?: Nullable<Nullable<TsDocTag<TBuilder>>[]>;
+  }
+>;
+
+export class TsDoc<TBuilder extends SourceBuilder, TInjects extends string = never>
+  extends TsNode<TBuilder, TInjects | Injects> {
+  public description: BasicAppendValue<TBuilder> | null;
+  public tags: TsDocTag<TBuilder>[];
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.description = options.description ?? null;
+    this.tags = options.tags?.filter(notNullish) ?? [];
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (!this.description && this.tags.length === 0) {
+      return;
+    }
+
+    builder
+      .ensureCurrentLineEmpty()
+      .parenthesize(
+        ['/**', ' */'],
+        (b) =>
+          b.appendWithLinePrefix(' * ', (b) => {
+            if (this.description) {
+              b.append(this.description);
+            }
+
+            if (this.tags.length > 0) {
+              b.ensurePreviousLineEmpty();
+              tsDocTag.write(b, this.tags, { separator: '\n' });
+            }
+          }),
+        { multiline: true, indent: false },
+      )
+      .appendLine();
+  }
+}
+
+const createDoc = <TBuilder extends SourceBuilder>(options?: Options<TBuilder>): TsDoc<TBuilder> =>
+  new TsDoc<TBuilder>(options ?? {});
+
+function getDoc<TBuilder extends SourceBuilder>(
+  baseDoc: TsDoc<TBuilder> | null,
+  options: {
+    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+  },
+): TsDoc<TBuilder> | null {
+  const paramsWithDesc = options.parameters
+    ?.filter(getIsInstanceOf(TsParameter<TBuilder>))
+    .filter((x): x is TsParameter<TBuilder> & { description: NonNullable<unknown> } => !!x.description) ?? [];
+  const genericsWithDesc = options.generics
+    ?.filter(getIsInstanceOf(TsGenericParameter<TBuilder>))
+    .filter((x): x is TsGenericParameter<TBuilder> & { description: NonNullable<unknown> } => !!x.description) ?? [];
+  if (paramsWithDesc.length === 0 && genericsWithDesc.length === 0) {
+    return baseDoc;
+  }
+  const doc = baseDoc ? createOverwriteProxy(baseDoc) : createDoc<TBuilder>();
+  const paramTags = paramsWithDesc.map<TsDocTag<TBuilder>>((p) => tsDocTag('param', p.name, p.description));
+  const genericTags = genericsWithDesc.map<TsDocTag<TBuilder>>((p) => tsDocTag('template', p.name, p.description));
+  doc.tags.splice(0, 0, ...genericTags, ...paramTags);
+  return doc;
+}
+
+function isDocEmpty(doc: Nullable<TsDoc<SourceBuilder>>): boolean {
+  return !doc || (!doc.description && doc.tags.length === 0);
+}
+
+export const tsDoc: typeof createDoc & {
+  write: typeof writeTsNodes;
+  get: typeof getDoc;
+  isEmpty: typeof isDocEmpty;
+} = Object.assign(createDoc, {
+  write: writeTsNodes,
+  get: getDoc,
+  isEmpty: isDocEmpty,
+});

package/src/src/ast/nodes/enum-value.ts

@@ -0,0 +1,72 @@
+import type {
+  AppendValue,
+  AstNodeOptions,
+  BasicAppendValue,
+  Nullable,
+  Prettify,
+  SingleOrMultiple,
+  SourceBuilder,
+} from '@goast/core';
+
+import { TsNode } from '../node.js';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+import type { TsDoc } from './doc.js';
+import type { TsString } from './string.js';
+
+type Injects = 'doc' | 'name' | 'value';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof TsNode<TBuilder, TInjects | Injects>,
+  {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    name: string;
+    value?: Nullable<TsString<TBuilder> | BasicAppendValue<TBuilder>>;
+  }
+>;
+
+export class TsEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public doc: TsDoc<TBuilder> | null;
+  public name: string;
+  public value: TsString<TBuilder> | BasicAppendValue<TBuilder> | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options.name;
+    this.doc = options.doc ?? null;
+    this.value = options.value ?? null;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append(this.inject.beforeDoc);
+    this.doc?.write(builder);
+    builder.append(this.inject.afterDoc);
+
+    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+
+    if (this.value) {
+      builder.append(' = ');
+      builder.append(this.inject.beforeValue);
+      writeTsNode(builder, this.value);
+      builder.append(this.inject.afterValue);
+    }
+  }
+}
+
+const createEnumValue = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
+): TsEnumValue<TBuilder> => new TsEnumValue<TBuilder>({ ...options, name });
+
+const writeEnumValues = <TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<TsEnumValue<TBuilder> | AppendValue<TBuilder>>>,
+): void => {
+  writeTsNodes(builder, nodes, { separator: ',\n' });
+};
+
+export const tsEnumValue: typeof createEnumValue & { write: typeof writeEnumValues } = Object.assign(createEnumValue, {
+  write: writeEnumValues,
+});