typia 9.7.0 → 9.7.2

package/src/transformers/ImportTransformer.ts

@@ -26,7 +26,8 @@ export namespace ImportTransformer {
     );
     const to: string = from.replace(props.top, props.to);
 
-    return ts.visitEachChild(
+    // First pass: transform relative imports
+    let transformedFile = ts.visitEachChild(
       props.file,
       (node) =>
         transform_node({
@@ -37,6 +38,11 @@ export namespace ImportTransformer {
         }),
       props.context,
     );
+
+    // Second pass: remove unused typia imports
+    transformedFile = removeUnusedTypiaImports(transformedFile);
+
+    return transformedFile;
   };
 
   const transform_node = (props: {
@@ -79,3 +85,169 @@ const get_directory_path = (file: string): string => {
   split.pop();
   return path.resolve(split.join(path.sep));
 };
+
+/** Remove unused typia imports that are only used in transformable calls */
+const removeUnusedTypiaImports = (file: ts.SourceFile): ts.SourceFile => {
+  // Find typia imports and collect all identifiers
+  interface ImportMetadata {
+    declaration: ts.ImportDeclaration;
+    default: boolean;
+  }
+  const imports: Map<string, ImportMetadata> = new Map();
+  for (const stmt of file.statements) {
+    if (
+      ts.isImportDeclaration(stmt) === false ||
+      ts.isStringLiteral(stmt.moduleSpecifier) === false ||
+      stmt.moduleSpecifier.text !== "typia" ||
+      stmt.importClause === undefined
+    )
+      continue;
+
+    // Track default import (import typia from 'typia')
+    if (stmt.importClause.name)
+      imports.set(stmt.importClause.name.text, {
+        declaration: stmt,
+        default: true,
+      });
+
+    // Track named imports (import { tags } from 'typia') - keep these
+    if (
+      stmt.importClause.namedBindings &&
+      ts.isNamedImports(stmt.importClause.namedBindings)
+    )
+      for (const element of stmt.importClause.namedBindings.elements)
+        imports.set(element.name.text, {
+          declaration: stmt,
+          default: false,
+        });
+  }
+  if (imports.size === 0) return file; // No typia imports to check
+
+  // Find usage of typia identifiers that are NOT transformable calls
+  const nonTransformableUsage = new Set<string>();
+  const checkUsage = (node: ts.Node) => {
+    if (ts.isIdentifier(node) && imports.has(node.text)) {
+      const identifier: string = node.text;
+      // Check if this identifier is being used as part of a property access
+      if (
+        node.parent &&
+        ts.isPropertyAccessExpression(node.parent) &&
+        node.parent.expression === node
+      ) {
+        // This is typia.something - check if it's a transformable call pattern
+        if (!isLikelyTransformableCall(node.parent))
+          nonTransformableUsage.add(identifier);
+      } else
+        // Direct usage of the typia identifier (not as property access)
+        // This is definitely non-transformable usage
+        nonTransformableUsage.add(identifier);
+    }
+    ts.forEachChild(node, checkUsage);
+  };
+
+  // Check all statements except import declarations
+  for (const stmt of file.statements)
+    if (
+      !ts.isImportDeclaration(stmt) ||
+      !ts.isStringLiteral(stmt.moduleSpecifier) ||
+      stmt.moduleSpecifier.text !== "typia"
+    )
+      checkUsage(stmt);
+
+  // Update import statements
+  const newStatements: ts.Statement[] = file.statements
+    .map((stmt) => {
+      if (
+        ts.isImportDeclaration(stmt) &&
+        ts.isStringLiteral(stmt.moduleSpecifier) &&
+        stmt.moduleSpecifier.text === "typia" &&
+        stmt.importClause
+      ) {
+        const newImportClause = filterTypiaImportClause(
+          stmt.importClause,
+          nonTransformableUsage,
+        );
+        if (newImportClause)
+          return ts.factory.createImportDeclaration(
+            stmt.modifiers,
+            newImportClause,
+            stmt.moduleSpecifier,
+            stmt.attributes,
+          );
+        return null; // Skip adding the import if all imports are unused
+      }
+      return stmt;
+    })
+    .filter((stmt) => stmt !== null);
+  return ts.factory.updateSourceFile(
+    file,
+    newStatements,
+    file.isDeclarationFile,
+    file.referencedFiles,
+    file.typeReferenceDirectives,
+    file.hasNoDefaultLib,
+    file.libReferenceDirectives,
+  );
+};
+
+/**
+ * Check if a property access expression looks like a transformable typia call
+ * This uses heuristics to detect patterns like typia.xxx(),
+ * typia.namespace.xxx()
+ */
+const isLikelyTransformableCall = (
+  node: ts.PropertyAccessExpression,
+): boolean => {
+  // Check if this is eventually part of a call expression
+  let current: ts.Node = node;
+
+  // Walk up the chain to find if this leads to a call expression
+  // Handle patterns like: typia.xxx(), typia.namespace.xxx()
+  while (ts.isPropertyAccessExpression(current)) {
+    current = current.parent;
+  }
+
+  // If the final result is a call expression, this is likely transformable
+  if (
+    ts.isCallExpression(current) &&
+    (current.expression === node ||
+      (ts.isPropertyAccessExpression(current.expression) &&
+        isTypiaPropertyChain(current.expression)))
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+/** Check if a property access expression is part of a typia.xxx.yyy chain */
+const isTypiaPropertyChain = (node: ts.PropertyAccessExpression): boolean => {
+  let current: ts.Expression = node;
+
+  while (ts.isPropertyAccessExpression(current)) {
+    current = current.expression;
+  }
+
+  return ts.isIdentifier(current) && current.text === "typia";
+};
+
+/** Filter import clause to remove unused default imports */
+const filterTypiaImportClause = (
+  importClause: ts.ImportClause,
+  usedImports: Set<string>,
+): ts.ImportClause | undefined => {
+  const hasDefaultImport =
+    importClause.name && usedImports.has(importClause.name.text);
+  const namedBindings = importClause.namedBindings; // Always keep named bindings like { tags }
+
+  // Return undefined if no imports are used
+  if (!hasDefaultImport && !namedBindings) {
+    return undefined;
+  }
+
+  return ts.factory.createImportClause(
+    importClause.isTypeOnly,
+    hasDefaultImport ? importClause.name : undefined,
+    namedBindings,
+  );
+};

package/src/transformers/NoTransformConfigurationError.ts

@@ -1,6 +1,4 @@
-/**
- * @internal
- */
+/** @internal */
 export function NoTransformConfigurationError(name: string): never {
   throw new Error(
     [

package/src/transformers/features/llm/LlmApplicationTransformer.ts

@@ -61,9 +61,7 @@ export namespace LlmApplicationTransformer {
     );
   };
 
-  /**
-   * @internal
-   */
+  /** @internal */
   export const decompose = (
     method: string,
     props: ITransformProps,

package/src/typings/Equal.ts

@@ -1,16 +1,16 @@
 /**
  * Compare the equivalence of the two types X and Y.
  *
- * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
+ * The two types X and Y refer to any type that can be expressed in the
+ * TypeScript, such as the union type and the object type.
  *
+ * @author Kyungsu Kang - https://github.com/kakasoo
  * @template X One of the types to compare
  * @template Y One of the types to compare
  *
- * ```ts
- * type Answer = Equal<1 | 2, 1 | 2>; // true
- * ```
- *
- * @author Kyungsu Kang - https://github.com/kakasoo
+ *   ```ts
+ *   type Answer = Equal<1 | 2, 1 | 2>; // true
+ *   ```
  */
 export type Equal<X, Y> =
   (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2