@ttsc/factory 0.15.6

package/src/factory/types/createMethodSignature.ts

@@ -0,0 +1,40 @@
+import type {
+  MethodSignature,
+  ModifierLike,
+  ParameterDeclaration,
+  PropertyName,
+  Token,
+  TypeNode,
+  TypeParameterDeclaration,
+} from "../../ast";
+import { asPropertyName } from "../internal/asPropertyName";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link MethodSignature}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The type.
+ * @returns The created {@link MethodSignature}.
+ */
+export const createMethodSignature = (
+  modifiers: readonly ModifierLike[] | undefined,
+  name: string | PropertyName,
+  questionToken: Token | undefined,
+  typeParameters: readonly TypeParameterDeclaration[] | undefined,
+  parameters: readonly ParameterDeclaration[],
+  type: TypeNode | undefined,
+): MethodSignature =>
+  make("MethodSignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    typeParameters,
+    parameters,
+    type,
+  });

package/src/factory/types/createNamedTupleMember.ts

@@ -0,0 +1,26 @@
+import type { Identifier, NamedTupleMember, Token, TypeNode } from "../../ast";
+import { asName } from "../internal/asName";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link NamedTupleMember}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param dotDotDotToken The dotDotDotToken.
+ * @param name The name.
+ * @param questionToken The questionToken.
+ * @param type The type.
+ * @returns The created node.
+ */
+export const createNamedTupleMember = (
+  dotDotDotToken: Token | undefined,
+  name: string | Identifier,
+  questionToken: Token | undefined,
+  type: TypeNode,
+): NamedTupleMember =>
+  make("NamedTupleMember", {
+    dotDotDotToken,
+    name: asName(name),
+    questionToken,
+    type,
+  });

package/src/factory/types/createOptionalTypeNode.ts

@@ -0,0 +1,12 @@
+import type { OptionalTypeNode, TypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link OptionalTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The type.
+ * @returns The created node.
+ */
+export const createOptionalTypeNode = (type: TypeNode): OptionalTypeNode =>
+  make("OptionalTypeNode", { type });

package/src/factory/types/createParenthesizedType.ts

@@ -0,0 +1,13 @@
+import type { ParenthesizedTypeNode, TypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link ParenthesizedTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The type.
+ * @returns The created {@link ParenthesizedTypeNode}.
+ */
+export const createParenthesizedType = (
+  type: TypeNode,
+): ParenthesizedTypeNode => make("ParenthesizedTypeNode", { type });

package/src/factory/types/createPropertySignature.ts

@@ -0,0 +1,32 @@
+import type {
+  ModifierLike,
+  PropertyName,
+  PropertySignature,
+  Token,
+  TypeNode,
+} from "../../ast";
+import { asPropertyName } from "../internal/asPropertyName";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link PropertySignature}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param type The type.
+ * @returns The created {@link PropertySignature}.
+ */
+export const createPropertySignature = (
+  modifiers: readonly ModifierLike[] | undefined,
+  name: string | PropertyName,
+  questionToken: Token | undefined,
+  type: TypeNode | undefined,
+): PropertySignature =>
+  make("PropertySignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    type,
+  });

package/src/factory/types/createRestTypeNode.ts

@@ -0,0 +1,12 @@
+import type { RestTypeNode, TypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link RestTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The type.
+ * @returns The created node.
+ */
+export const createRestTypeNode = (type: TypeNode): RestTypeNode =>
+  make("RestTypeNode", { type });

package/src/factory/types/createTemplateLiteralType.ts

@@ -0,0 +1,20 @@
+import type {
+  TemplateHead,
+  TemplateLiteralTypeNode,
+  TemplateLiteralTypeSpan,
+} from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TemplateLiteralType}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param head The head.
+ * @param templateSpans The templateSpans.
+ * @returns The created node.
+ */
+export const createTemplateLiteralType = (
+  head: TemplateHead,
+  templateSpans: readonly TemplateLiteralTypeSpan[],
+): TemplateLiteralTypeNode =>
+  make("TemplateLiteralType", { head, templateSpans });

package/src/factory/types/createTemplateLiteralTypeSpan.ts

@@ -0,0 +1,21 @@
+import type {
+  TemplateLiteralTypeSpan,
+  TemplateMiddle,
+  TemplateTail,
+  TypeNode,
+} from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TemplateLiteralTypeSpan}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The type.
+ * @param literal The literal.
+ * @returns The created node.
+ */
+export const createTemplateLiteralTypeSpan = (
+  type: TypeNode,
+  literal: TemplateMiddle | TemplateTail,
+): TemplateLiteralTypeSpan =>
+  make("TemplateLiteralTypeSpan", { type, literal });

package/src/factory/types/createThisTypeNode.ts

@@ -0,0 +1,10 @@
+import type { ThisTypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link ThisTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created node.
+ */
+export const createThisTypeNode = (): ThisTypeNode => make("ThisTypeNode", {});

package/src/factory/types/createTupleTypeNode.ts

@@ -0,0 +1,13 @@
+import type { TupleTypeNode, TypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TupleTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The elements.
+ * @returns The created {@link TupleTypeNode}.
+ */
+export const createTupleTypeNode = (
+  elements: readonly TypeNode[],
+): TupleTypeNode => make("TupleTypeNode", { elements });

package/src/factory/types/createTypeLiteralNode.ts

@@ -0,0 +1,13 @@
+import type { TypeElement, TypeLiteralNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TypeLiteralNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param members The members.
+ * @returns The created {@link TypeLiteralNode}.
+ */
+export const createTypeLiteralNode = (
+  members: readonly TypeElement[] = [],
+): TypeLiteralNode => make("TypeLiteralNode", { members });

package/src/factory/types/createTypeOperatorNode.ts

@@ -0,0 +1,16 @@
+import type { TypeNode, TypeOperatorNode } from "../../ast";
+import { SyntaxKind } from "../../syntax";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TypeOperatorNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operator The operator token.
+ * @param type The type.
+ * @returns The created {@link TypeOperatorNode}.
+ */
+export const createTypeOperatorNode = (
+  operator: SyntaxKind,
+  type: TypeNode,
+): TypeOperatorNode => make("TypeOperatorNode", { operator, type });

package/src/factory/types/createTypeParameterDeclaration.ts

@@ -0,0 +1,31 @@
+import type {
+  Identifier,
+  ModifierLike,
+  TypeNode,
+  TypeParameterDeclaration,
+} from "../../ast";
+import { asName } from "../internal/asName";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TypeParameterDeclaration}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param constraint The `extends` constraint, if any.
+ * @param defaultType The default type, if any.
+ * @returns The created {@link TypeParameterDeclaration}.
+ */
+export const createTypeParameterDeclaration = (
+  modifiers: readonly ModifierLike[] | undefined,
+  name: string | Identifier,
+  constraint?: TypeNode,
+  defaultType?: TypeNode,
+): TypeParameterDeclaration =>
+  make("TypeParameterDeclaration", {
+    modifiers,
+    name: asName(name),
+    constraint,
+    default: defaultType,
+  });

package/src/factory/types/createTypePredicateNode.ts

@@ -0,0 +1,32 @@
+import type {
+  Identifier,
+  ThisTypeNode,
+  Token,
+  TypeNode,
+  TypePredicateNode,
+} from "../../ast";
+import { make } from "../internal/make";
+import { createIdentifier } from "../names/createIdentifier";
+
+/**
+ * Create a {@link TypePredicateNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param assertsModifier The assertsModifier.
+ * @param parameterName The parameterName.
+ * @param type The type.
+ * @returns The created node.
+ */
+export const createTypePredicateNode = (
+  assertsModifier: Token | undefined,
+  parameterName: string | Identifier | ThisTypeNode,
+  type: TypeNode | undefined,
+): TypePredicateNode =>
+  make("TypePredicateNode", {
+    assertsModifier,
+    parameterName:
+      typeof parameterName === "string"
+        ? createIdentifier(parameterName)
+        : parameterName,
+    type,
+  });

package/src/factory/types/createTypeQueryNode.ts

@@ -0,0 +1,12 @@
+import type { EntityName, TypeQueryNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TypeQueryNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param exprName The queried entity name.
+ * @returns The created {@link TypeQueryNode}.
+ */
+export const createTypeQueryNode = (exprName: EntityName): TypeQueryNode =>
+  make("TypeQueryNode", { exprName });

package/src/factory/types/createTypeReferenceNode.ts

@@ -0,0 +1,20 @@
+import type { EntityName, TypeNode, TypeReferenceNode } from "../../ast";
+import { asEntityName } from "../internal/asEntityName";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link TypeReferenceNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param typeName The referenced type name.
+ * @param typeArguments The generic type arguments, if any.
+ * @returns The created {@link TypeReferenceNode}.
+ */
+export const createTypeReferenceNode = (
+  typeName: string | EntityName,
+  typeArguments?: readonly TypeNode[],
+): TypeReferenceNode =>
+  make("TypeReferenceNode", {
+    typeName: asEntityName(typeName),
+    typeArguments,
+  });

package/src/factory/types/createUnionTypeNode.ts

@@ -0,0 +1,13 @@
+import type { TypeNode, UnionTypeNode } from "../../ast";
+import { make } from "../internal/make";
+
+/**
+ * Create a {@link UnionTypeNode}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param types The constituent types.
+ * @returns The created {@link UnionTypeNode}.
+ */
+export const createUnionTypeNode = (
+  types: readonly TypeNode[],
+): UnionTypeNode => make("UnionTypeNode", { types });

package/src/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Hand-written, dependency-free re-implementation of the legacy TypeScript AST
+ * factory (`ts.factory`) and printer (`ts.Printer`).
+ *
+ * ```typescript
+ * import factory, { SyntaxKind, TsPrinter } from "@ttsc/factory";
+ * ```
+ *
+ * - `factory` — the node factory namespace (also the default export).
+ * - {@link TsPrinter} — renders factory nodes to TypeScript source text.
+ * - {@link SyntaxKind} / {@link NodeFlags} — token & flag enums.
+ * - Outline AST types (`Expression`, `Statement`, `TypeNode`, ...).
+ *
+ * No `typescript` module is imported anywhere; the logic is implemented
+ * directly, so this keeps working in the TypeScript-Go (tsgo) era.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export * as factory from "./factory/index";
+export { SyntaxKind, NodeFlags, tokenToString } from "./syntax";
+export { TsPrinter } from "./TsPrinter";
+export type { TsPrinterOptions } from "./TsPrinter";
+export type * from "./ast";
+
+import * as factory from "./factory/index";
+
+/** Outline of the legacy `ts.NodeFactory`. */
+export type NodeFactory = typeof factory;
+
+export default factory;

package/src/internal/doc.ts

@@ -0,0 +1,195 @@
+/**
+ * Internal Wadler/Prettier-style pretty-printing engine.
+ *
+ * {@link TsPrinter} builds a {@link Doc} (an intermediate representation) per
+ * node instead of concatenating strings, then {@link printDocToString} lays it
+ * out against a print width: each {@link group} prints flat when it fits on the
+ * current line and breaks otherwise — the same algorithm Prettier uses.
+ *
+ * This module is internal; it is not part of the public `@ttsc/factory` API.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type Doc =
+  | string
+  | { type: "concat"; parts: Doc[] }
+  | { type: "line" }
+  | { type: "softline" }
+  | { type: "hardline" }
+  | { type: "indent"; doc: Doc }
+  | { type: "group"; doc: Doc; break: boolean }
+  | { type: "ifBreak"; broken: Doc; flat: Doc };
+
+/** Concatenate documents. */
+export const concat = (parts: Doc[]): Doc => ({ type: "concat", parts });
+/** A group: printed flat when it fits, broken otherwise. */
+export const group = (doc: Doc, shouldBreak: boolean = false): Doc => ({
+  type: "group",
+  doc,
+  break: shouldBreak,
+});
+/** Increase indentation of the inner document by one level. */
+export const indent = (doc: Doc): Doc => ({ type: "indent", doc });
+/** A space when flat, a newline when broken. */
+export const line: Doc = { type: "line" };
+/** Nothing when flat, a newline when broken. */
+export const softline: Doc = { type: "softline" };
+/** Always a newline; forces every enclosing group to break. */
+export const hardline: Doc = { type: "hardline" };
+/** Print `broken` when the enclosing group breaks, `flat` otherwise. */
+export const ifBreak = (broken: Doc, flat: Doc = ""): Doc => ({
+  type: "ifBreak",
+  broken,
+  flat,
+});
+/** Interleave `items` with `separator`. */
+export const join = (separator: Doc, items: Doc[]): Doc => {
+  const parts: Doc[] = [];
+  items.forEach((item, i) => {
+    if (i !== 0) parts.push(separator);
+    parts.push(item);
+  });
+  return concat(parts);
+};
+
+const MODE_BREAK = 1;
+const MODE_FLAT = 2;
+type Cmd = [number, number, Doc];
+
+/** Mark every group that (transitively) contains a hardline as broken. */
+const propagateBreaks = (doc: Doc): boolean => {
+  if (typeof doc === "string") return false;
+  switch (doc.type) {
+    case "concat": {
+      let broke = false;
+      for (const part of doc.parts) broke = propagateBreaks(part) || broke;
+      return broke;
+    }
+    case "indent":
+      return propagateBreaks(doc.doc);
+    case "group": {
+      const broke = propagateBreaks(doc.doc);
+      doc.break = doc.break || broke;
+      return doc.break;
+    }
+    case "ifBreak":
+      propagateBreaks(doc.broken);
+      propagateBreaks(doc.flat);
+      return false;
+    case "hardline":
+      return true;
+    default:
+      return false;
+  }
+};
+
+/** Does `next` (followed by `rest`) fit flat within `remaining` columns? */
+const fits = (next: Cmd, rest: readonly Cmd[], remaining: number): boolean => {
+  let width = remaining;
+  const cmds: Cmd[] = [next];
+  let restIndex = rest.length;
+  while (width >= 0) {
+    if (cmds.length === 0) {
+      if (restIndex === 0) return true;
+      cmds.push(rest[--restIndex]!);
+      continue;
+    }
+    const [ind, mode, doc] = cmds.pop()!;
+    if (typeof doc === "string") {
+      width -= doc.length;
+      continue;
+    }
+    switch (doc.type) {
+      case "concat":
+        for (let i = doc.parts.length - 1; i >= 0; i--)
+          cmds.push([ind, mode, doc.parts[i]!]);
+        break;
+      case "indent":
+        cmds.push([ind + 1, mode, doc.doc]);
+        break;
+      case "group":
+        cmds.push([ind, doc.break ? MODE_BREAK : mode, doc.doc]);
+        break;
+      case "ifBreak":
+        cmds.push([ind, mode, mode === MODE_BREAK ? doc.broken : doc.flat]);
+        break;
+      case "line":
+        if (mode === MODE_FLAT) width -= 1;
+        else return true;
+        break;
+      case "softline":
+        if (mode !== MODE_FLAT) return true;
+        break;
+      case "hardline":
+        return true;
+    }
+  }
+  return false;
+};
+
+/** Options for {@link printDocToString}. */
+export interface PrintDocOptions {
+  printWidth: number;
+  newLine: string;
+  indent: string;
+}
+
+/** Lay a {@link Doc} out into source text. */
+export const printDocToString = (
+  doc: Doc,
+  options: PrintDocOptions,
+): string => {
+  propagateBreaks(doc);
+  const { printWidth, newLine, indent: tab } = options;
+  const out: string[] = [];
+  let pos = 0;
+  const cmds: Cmd[] = [[0, MODE_BREAK, doc]];
+  const newlineTo = (ind: number): void => {
+    if (out.length)
+      out[out.length - 1] = out[out.length - 1]!.replace(/[ \t]+$/, "");
+    out.push(newLine + tab.repeat(ind));
+    pos = tab.length * ind;
+  };
+  while (cmds.length) {
+    const [ind, mode, d] = cmds.pop()!;
+    if (typeof d === "string") {
+      out.push(d);
+      pos += d.length;
+      continue;
+    }
+    switch (d.type) {
+      case "concat":
+        for (let i = d.parts.length - 1; i >= 0; i--)
+          cmds.push([ind, mode, d.parts[i]!]);
+        break;
+      case "indent":
+        cmds.push([ind + 1, mode, d.doc]);
+        break;
+      case "group":
+        if (mode === MODE_FLAT && !d.break) cmds.push([ind, MODE_FLAT, d.doc]);
+        else if (
+          !d.break &&
+          fits([ind, MODE_FLAT, d.doc], cmds, printWidth - pos)
+        )
+          cmds.push([ind, MODE_FLAT, d.doc]);
+        else cmds.push([ind, MODE_BREAK, d.doc]);
+        break;
+      case "ifBreak":
+        cmds.push([ind, mode, mode === MODE_BREAK ? d.broken : d.flat]);
+        break;
+      case "line":
+        if (mode === MODE_FLAT) {
+          out.push(" ");
+          pos += 1;
+        } else newlineTo(ind);
+        break;
+      case "softline":
+        if (mode !== MODE_FLAT) newlineTo(ind);
+        break;
+      case "hardline":
+        newlineTo(ind);
+        break;
+    }
+  }
+  return out.join("");
+};

package/src/syntax/NodeFlags.ts

@@ -0,0 +1,12 @@
+/**
+ * Flags for {@link factory.createVariableDeclarationList}.
+ *
+ * Outline of the relevant subset of the legacy `ts.NodeFlags`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export enum NodeFlags {
+  None = 0,
+  Let = 1,
+  Const = 2,
+}