@ttsc/factory 0.15.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# @ttsc/factory
+
+[![NPM Version](https://img.shields.io/npm/v/@ttsc/factory.svg)](https://www.npmjs.com/package/@ttsc/factory) [![NPM Downloads](https://img.shields.io/npm/dm/@ttsc/factory.svg)](https://www.npmjs.com/package/@ttsc/factory) [![GitHub License](https://img.shields.io/github/license/samchon/ttsc.svg)](https://github.com/samchon/ttsc/blob/master/LICENSE) [![Build Status](https://github.com/samchon/ttsc/workflows/build/badge.svg)](https://github.com/samchon/ttsc/actions?query=workflow%3Abuild)
+
+Hand-written, dependency-free TypeScript **AST factory** and **printer** for source code generation.
+
+```bash
+npm install @ttsc/factory
+```
+
+```typescript
+import factory, { TsPrinter } from "@ttsc/factory";
+
+const node = factory.createCallExpression(
+  factory.createPropertyAccessExpression(
+    factory.createIdentifier("console"),
+    factory.createIdentifier("log"),
+  ),
+  undefined,
+  [factory.createStringLiteral("hello world")],
+);
+
+const printer = new TsPrinter();
+console.log(printer.print(node));
+// console.log("hello world")
+```
+
+## Why?
+
+The legacy (`<= 6.x`, JavaScript based) TypeScript compiler exposes a node factory and a printer through its JavaScript API:
+
+```typescript
+import ts from "typescript";
+
+const node = ts.factory.createStringLiteral("hello");
+const text = ts.createPrinter().printNode(/* ... */);
+```
+
+Once a project migrates its tool-chain to the **TypeScript-Go** (tsgo, `>= 7.x`) native compiler, that JavaScript `ts.factory` / `ts.Printer` API is gone — so AST based code generation built on top of it breaks.
+
+`@ttsc/factory` keeps that capability alive **without importing `typescript` at all**. The factory and printer are re-implemented directly, so the package has **zero dependencies** and works no matter which compiler builds the rest of your project.
+
+## API
+
+| Export | Description |
+| --- | --- |
+| `factory` (default export) | The node factory; `createXxx` mirror the legacy signatures. |
+| `TsPrinter` | Renders factory nodes to TypeScript source text. |
+| `SyntaxKind`, `NodeFlags` | Outline token & flag enums. |
+| Outline AST types | `Expression`, `Statement`, `TypeNode`, `Node`, ... |
+
+### `factory`
+
+`createXxx` methods mirror the legacy `ts.factory` names and parameter order, and return concrete, fully typed _outline_ AST nodes (each with a `kind` discriminant).
+
+```typescript
+import factory, { SyntaxKind } from "@ttsc/factory";
+
+factory.createKeywordTypeNode(SyntaxKind.StringKeyword); // string
+```
+
+### `TsPrinter`
+
+A **width-aware** printer implemented directly (not a wrapper over `ts.Printer`). Like Prettier, it keeps lists on one line when they fit within `printWidth` and breaks them — with trailing commas — when they don't.
+
+```typescript
+const printer = new TsPrinter({
+  printWidth: 80, // default 80
+  indent: "  ", //   default two spaces
+  newLine: "\n", //  default LineFeed
+});
+
+printer.print(node); // print one node (or a SourceFile)
+printer.printNodes([a, b, c]); // print many nodes, joined by new lines
+printer.printFile(undefined, st); // compose & print a whole source file
+```
+
+```typescript
+// fits on one line → inline
+factory.createCallExpression(id("foo"), undefined, [a, b]); // foo(a, b)
+
+// exceeds printWidth → breaks
+// foo(
+//   argumentOne,
+//   argumentTwo,
+//   argumentThree,
+// )
+```
+
+## Coverage
+
+The factory and printer cover the constructs most used for code generation: identifiers, literals, the common expressions, types (keyword / reference / union / intersection / array / tuple / type-literal / function / operator / ...), statements, classes & interfaces, enums, functions & arrow functions, and import / export declarations. Coverage is easy to extend — add the node under `src/ast/`, a builder under `src/factory/`, and a `case` to the printer.
+
+## License
+
+MIT © [Jeongho Nam](https://github.com/samchon)

package/lib/TsPrinter.d.ts

@@ -0,0 +1,67 @@
+import type { Node, SourceFile, Statement } from "./ast";
+/** Options for {@link TsPrinter}. */
+export interface TsPrinterOptions {
+    /** Maximum line width before groups break. Defaults to `80`. */
+    printWidth?: number;
+    /** Indentation unit. Defaults to two spaces. */
+    indent?: string;
+    /** New line sequence. Defaults to `"\n"` (LineFeed). */
+    newLine?: string;
+}
+/**
+ * Printer turning {@link factory} produced AST nodes into TypeScript source
+ * text.
+ *
+ * The printer is a width-aware pretty-printer: it builds a Prettier-style
+ * document for the {@link Node} discriminated union and lays it out against
+ * {@link TsPrinterOptions.printWidth}. Lists (arguments, parameters, generic
+ * arguments, array / object members, ...) print on one line when they fit and
+ * break onto indented lines — with trailing commas — when they do not. Every
+ * `node.kind` narrows to its concrete type, so the walk is fully type-checked;
+ * no `typescript` module is involved.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   import factory, { TsPrinter } from "@ttsc/factory";
+ *
+ *   const printer = new TsPrinter({ printWidth: 80, indent: "  " });
+ *   printer.print(factory.createStringLiteral("hello")); // "hello"
+ *   ```;
+ */
+export declare class TsPrinter {
+    private readonly printWidth_;
+    private readonly indent_;
+    private readonly newLine_;
+    constructor(options?: TsPrinterOptions);
+    /** Print a single node (or a whole {@link SourceFile}) into source text. */
+    print(node: Node): string;
+    /** Print multiple nodes, joining them with new lines. */
+    printNodes(nodes: readonly Node[]): string;
+    /**
+     * Print an entire source file.
+     *
+     * @param sourceFile A {@link SourceFile}. When omitted, one is composed from
+     *   the given `statements`.
+     * @param statements Statements to compose a source file from when no
+     *   `sourceFile` is provided.
+     */
+    printFile(sourceFile?: SourceFile, statements?: readonly Statement[]): string;
+    private layout;
+    /** Comma-separated, width-aware delimited list (`(...)`, `[...]`, `<...>`). */
+    private delim;
+    /** Semicolon-separated member block (`{ a; b }`), e.g. interfaces. */
+    private memberBlock;
+    /** Always-broken statement block (`{ ... }`). */
+    private statementBlock;
+    private typeArguments;
+    private params;
+    private modifiers;
+    private heritage;
+    private optType;
+    private optBody;
+    private emit;
+    /** Width-aware `|` / `&` type list with leading-operator breaks. */
+    private binaryType;
+    private unsupported;
+}