@ttsc/factory 0.19.2 → 0.20.0

package/src/ast/expressions/Expression.ts

@@ -1,3 +1,6 @@
+import type { JsxElement } from "../jsx/JsxElement";
+import type { JsxFragment } from "../jsx/JsxFragment";
+import type { JsxSelfClosingElement } from "../jsx/JsxSelfClosingElement";
 import type { Identifier } from "../names/Identifier";
 import type { Token } from "../names/Token";
 import type { ArrayLiteralExpression } from "./ArrayLiteralExpression";
@@ -24,6 +27,7 @@ import type { NumericLiteral } from "./NumericLiteral";
 import type { ObjectLiteralExpression } from "./ObjectLiteralExpression";
 import type { OmittedExpression } from "./OmittedExpression";
 import type { ParenthesizedExpression } from "./ParenthesizedExpression";
+import type { PartiallyEmittedExpression } from "./PartiallyEmittedExpression";
 import type { PostfixUnaryExpression } from "./PostfixUnaryExpression";
 import type { PrefixUnaryExpression } from "./PrefixUnaryExpression";
 import type { PropertyAccessChain } from "./PropertyAccessChain";
@@ -61,6 +65,9 @@ export type Expression =
   | ElementAccessExpression
   | FunctionExpression
   | Identifier
+  | JsxElement
+  | JsxFragment
+  | JsxSelfClosingElement
   | MetaProperty
   | NewExpression
   | NoSubstitutionTemplateLiteral
@@ -70,6 +77,7 @@ export type Expression =
   | ObjectLiteralExpression
   | OmittedExpression
   | ParenthesizedExpression
+  | PartiallyEmittedExpression
   | PostfixUnaryExpression
   | PrefixUnaryExpression
   | PropertyAccessChain

package/src/ast/imports/ImportClause.ts

@@ -1,3 +1,4 @@
+import type { SyntaxKind } from "../../syntax";
 import type { Identifier } from "../names/Identifier";
 import type { NamedImports } from "./NamedImports";
 import type { NamespaceImport } from "./NamespaceImport";
@@ -13,8 +14,15 @@ export interface ImportClause {
   /** Discriminant tag; always `"ImportClause"`. */
   kind: "ImportClause";
 
-  /** Whether this is a type-only import/export. */
-  isTypeOnly: boolean;
+  /**
+   * The keyword between `import` and the bindings, when there is one.
+   *
+   * `TypeKeyword` is the type-only import; `DeferKeyword` is `import defer`.
+   * Upstream calls the pair `ImportPhaseModifierSyntaxKind`, and this field
+   * replaced a `isTypeOnly: boolean` that could not express the second phase at
+   * all.
+   */
+  phaseModifier?: SyntaxKind.TypeKeyword | SyntaxKind.DeferKeyword;
 
   /** The name. */
   name?: Identifier;

package/src/ast/jsdoc/JSDocImportTag.ts

@@ -1,4 +1,5 @@
 import type { Expression } from "../expressions/Expression";
+import type { ImportAttributes } from "../imports/ImportAttributes";
 import type { ImportClause } from "../imports/ImportClause";
 import type { Identifier } from "../names/Identifier";
 import type { JSDocComment } from "./JSDocComment";
@@ -23,6 +24,9 @@ export interface JSDocImportTag {
   /** The module specifier. */
   moduleSpecifier: Expression;
 
+  /** The `with { … }` import attributes, if any. */
+  attributes?: ImportAttributes;
+
   /** The trailing comment, if any. */
   comment?: string | readonly JSDocComment[];
 }

package/src/ast/types/ImportTypeNode.ts

@@ -1,3 +1,4 @@
+import type { ImportAttributes } from "../imports/ImportAttributes";
 import type { EntityName } from "../names/EntityName";
 import type { TypeNode } from "./TypeNode";
 
@@ -15,6 +16,9 @@ export interface ImportTypeNode {
   /** Argument. */
   argument: TypeNode;
 
+  /** The `with { … }` import attributes, if any. */
+  attributes?: ImportAttributes;
+
   /** Qualifier. */
   qualifier?: EntityName;
 

package/src/factory/expressions/createComma.ts

@@ -7,9 +7,9 @@ import { createBinaryExpression } from "./createBinaryExpression";
  * which evaluates both operands and yields the right one.
  *
  * Shorthand for {@link createBinaryExpression} with the `CommaToken` operator.
- * The printer treats the comma like any other binary operator and surrounds it
- * with a single space on each side, so the output has a space before the
- * comma.
+ * The comma attaches to the operand before it, the way every other producer
+ * writes it — {@link createCommaListExpression}, the legacy printer, and
+ * Prettier all emit `a, b`.
  *
  * Given operands `a` and `b`, the printer emits:
  *

package/src/factory/imports/createImportClause.ts

@@ -4,6 +4,7 @@ import type {
   NamedImports,
   NamespaceImport,
 } from "../../ast";
+import { SyntaxKind } from "../../syntax";
 import { make } from "../internal/make";
 
 /**
@@ -13,7 +14,12 @@ import { make } from "../internal/make";
  * The `name` is the default-import binding, if any. The `namedBindings` slot
  * holds either a {@link NamedImports} brace group or a {@link NamespaceImport}. A
  * default binding and named bindings can appear together, joined by a comma.
- * Set `isTypeOnly` to prefix the clause with `type`.
+ *
+ * The `phaseModifier` is the keyword between `import` and the bindings:
+ * `SyntaxKind.TypeKeyword` for a type-only import, `SyntaxKind.DeferKeyword`
+ * for `import defer`. Upstream calls the pair `ImportPhaseModifierSyntaxKind`
+ * and takes it in this position; this factory took a boolean here, which read a
+ * modern first argument as `isTypeOnly` and could not express `defer` at all.
  *
  * Given a default binding `Def` plus named import `a`, this prints:
  *
@@ -22,13 +28,13 @@ import { make } from "../internal/make";
  * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @param isTypeOnly Whether this is a type-only import/export.
+ * @param phaseModifier The `type` or `defer` keyword, if any.
  * @param name The name.
  * @param namedBindings The named or namespace bindings, if any.
  * @returns The created {@link ImportClause}.
  */
 export const createImportClause = (
-  isTypeOnly: boolean,
-  name: Identifier | undefined,
-  namedBindings: NamedImports | NamespaceImport | undefined,
-): ImportClause => make("ImportClause", { isTypeOnly, name, namedBindings });
+  phaseModifier?: SyntaxKind.TypeKeyword | SyntaxKind.DeferKeyword,
+  name?: Identifier,
+  namedBindings?: NamedImports | NamespaceImport,
+): ImportClause => make("ImportClause", { phaseModifier, name, namedBindings });

package/src/factory/jsdoc/createJSDocImportTag.ts

@@ -1,6 +1,7 @@
 import type {
   Expression,
   Identifier,
+  ImportAttributes,
   ImportClause,
   JSDocComment,
   JSDocImportTag,
@@ -27,6 +28,7 @@ import { createIdentifier } from "../names/createIdentifier";
  * @param tagName The tag name; defaults to `import`.
  * @param importClause The import clause, if any.
  * @param moduleSpecifier The module specifier.
+ * @param attributes The `with { … }` import attributes, if any.
  * @param comment The trailing comment, if any.
  * @returns The created {@link JSDocImportTag}.
  */
@@ -34,11 +36,13 @@ export const createJSDocImportTag = (
   tagName: Identifier | undefined,
   importClause: ImportClause | undefined,
   moduleSpecifier: Expression,
-  comment?: string | readonly JSDocComment[],
+  attributes?: ImportAttributes,
+  comment?: readonly JSDocComment[],
 ): JSDocImportTag =>
   make("JSDocImportTag", {
     tagName: tagName ?? createIdentifier("import"),
     importClause,
     moduleSpecifier,
+    attributes,
     comment,
   });

package/src/factory/types/createImportTypeNode.ts

@@ -1,9 +1,20 @@
-import type { EntityName, ImportTypeNode, TypeNode } from "../../ast";
+import type {
+  EntityName,
+  ImportAttributes,
+  ImportTypeNode,
+  TypeNode,
+} from "../../ast";
 import { make } from "../internal/make";
 
 /**
  * Create an {@link ImportTypeNode}: an `import("module").Qualifier<Args>` type.
  *
+ * The parameter order is upstream's: `isTypeOf` first, then the module
+ * specifier, then the `with { … }` attributes, then the qualifier and type
+ * arguments. This factory used to put `isTypeOf` last and omit `attributes`
+ * entirely, so a caller ported from `ts.factory` bound every argument to the
+ * wrong slot.
+ *
  * The `argument` is the module specifier inside `import(...)`. A `qualifier`
  * adds a `.Member` access, and type arguments add `<...>`. When `isTypeOf` is
  * true the whole thing is prefixed with `typeof ` to query a value's type.
@@ -23,9 +34,16 @@ import { make } from "../internal/make";
  * @returns The created {@link ImportTypeNode}.
  */
 export const createImportTypeNode = (
+  isTypeOf: boolean | undefined,
   argument: TypeNode,
+  attributes?: ImportAttributes,
   qualifier?: EntityName,
   typeArguments?: readonly TypeNode[],
-  isTypeOf: boolean = false,
 ): ImportTypeNode =>
-  make("ImportTypeNode", { argument, qualifier, typeArguments, isTypeOf });
+  make("ImportTypeNode", {
+    argument,
+    attributes,
+    qualifier,
+    typeArguments,
+    isTypeOf: isTypeOf === true,
+  });

package/src/internal/doc.ts

@@ -12,6 +12,7 @@
  */
 export type Doc =
   | string
+  | { type: "raw"; text: string }
   | { type: "concat"; parts: Doc[] }
   | { type: "line" }
   | { type: "softline" }
@@ -22,6 +23,16 @@ export type Doc =
 
 /** Concatenate documents. */
 export const concat = (parts: Doc[]): Doc => ({ type: "concat", parts });
+/**
+ * Literal text whose trailing whitespace is content, not layout.
+ *
+ * {@link printDocToString} strips spaces and tabs from the end of a line before
+ * writing a newline, which is right for generated code and wrong for the one
+ * node emitted as unquoted source text, `JsxText`: a trimmed trailing space
+ * there deletes a JSX separator and changes what the component renders. Text
+ * emitted through this node is never trimmed.
+ */
+export const raw = (text: string): Doc => ({ type: "raw", text });
 /** A group: printed flat when it fits, broken otherwise. */
 export const group = (doc: Doc, shouldBreak: boolean = false): Doc => ({
   type: "group",
@@ -100,6 +111,9 @@ const fits = (next: Cmd, rest: readonly Cmd[], remaining: number): boolean => {
       continue;
     }
     switch (doc.type) {
+      case "raw":
+        width -= doc.text.length;
+        break;
       case "concat":
         for (let i = doc.parts.length - 1; i >= 0; i--)
           cmds.push([ind, mode, doc.parts[i]!]);
@@ -143,21 +157,34 @@ export const printDocToString = (
   const { printWidth, newLine, indent: tab } = options;
   const out: string[] = [];
   let pos = 0;
+  // whether the tail of `out` is raw text, whose trailing whitespace is content
+  let rawTail = false;
   const cmds: Cmd[] = [[0, MODE_BREAK, doc]];
   const newlineTo = (ind: number): void => {
-    if (out.length)
+    if (out.length && !rawTail)
       out[out.length - 1] = out[out.length - 1]!.replace(/[ \t]+$/, "");
     out.push(newLine + tab.repeat(ind));
     pos = tab.length * ind;
+    rawTail = false;
   };
   while (cmds.length) {
     const [ind, mode, d] = cmds.pop()!;
     if (typeof d === "string") {
-      out.push(d);
-      pos += d.length;
+      // an empty string contributes nothing but would become the tail that
+      // `newlineTo` trims, hiding the real end of the line behind it
+      if (d.length !== 0) {
+        out.push(d);
+        pos += d.length;
+        rawTail = false;
+      }
       continue;
     }
     switch (d.type) {
+      case "raw":
+        out.push(d.text);
+        pos += d.text.length;
+        rawTail = true;
+        break;
       case "concat":
         for (let i = d.parts.length - 1; i >= 0; i--)
           cmds.push([ind, mode, d.parts[i]!]);

package/src/syntax/NodeFlags.ts

@@ -4,10 +4,12 @@
  *
  * An outline of the relevant subset of the legacy `ts.NodeFlags`. Each member's
  * value is the keyword it implies (`Let = "let"`, `Const = "const"`), so the
- * printer reads it directly. `Namespace` is accepted for API parity — the
- * printer renders the `module` / `namespace` keyword from the module name kind,
- * not from this flag. A string-valued enum (deliberately not `const enum`, so
- * consumers compiled with `isolatedModules` can still reference its members).
+ * printer reads it directly. `Namespace` selects the keyword a module
+ * declaration with an identifier name prints: with the flag it is `namespace
+ * A`, without it `module A`. A string-literal name is always `module "…"`, so
+ * the flag says nothing there. A string-valued enum (deliberately not `const
+ * enum`, so consumers compiled with `isolatedModules` can still reference its
+ * members).
  *
  * @author Jeongho Nam - https://github.com/samchon
  */

package/src/syntax/SyntaxKind.ts

@@ -28,6 +28,13 @@ export enum SyntaxKind {
   FalseKeyword = "false",
   ThisKeyword = "this",
 
+  // import phase modifiers — the two keywords that may precede an import
+  // clause's bindings. Upstream types them as
+  // `ImportPhaseModifierSyntaxKind = TypeKeyword | DeferKeyword`, and
+  // `createImportClause` takes one where this factory used to take a boolean.
+  TypeKeyword = "type",
+  DeferKeyword = "defer",
+
   // modifiers
   ExportKeyword = "export",
   DefaultKeyword = "default",