chore: wip

Author: chrisbbreuer

src/generator.ts

@@ -135,7 +135,7 @@ export async function processFile(
   }
 
   // Process declarations to generate DTS
-  const dtsContent = processDeclarations(declarations, context)
+  const dtsContent = processDeclarations(declarations, context, config.keepComments)
 
   return dtsContent
 }

src/processor.ts

@@ -4,8 +4,8 @@ import type { Declaration, ProcessingContext } from './types'
 /**
  * Format comments for DTS output
  */
-function formatComments(comments: string[] | undefined): string {
-  if (!comments || comments.length === 0) {
+function formatComments(comments: string[] | undefined, keepComments: boolean = true): string {
+  if (!keepComments || !comments || comments.length === 0) {
     return ''
   }
 
@@ -148,6 +148,7 @@ function extractAllImportedItems(importText: string): string[] {
 export function processDeclarations(
   declarations: Declaration[],
   context: ProcessingContext,
+  keepComments: boolean = true,
 ): string {
   const output: string[] = []
 
@@ -471,25 +472,25 @@ export function processDeclarations(
     let processed = ''
     switch (decl.kind) {
       case 'function':
-        processed = processFunctionDeclaration(decl)
+        processed = processFunctionDeclaration(decl, keepComments)
         break
       case 'variable':
-        processed = processVariableDeclaration(decl)
+        processed = processVariableDeclaration(decl, keepComments)
         break
       case 'interface':
-        processed = processInterfaceDeclaration(decl)
+        processed = processInterfaceDeclaration(decl, keepComments)
         break
       case 'type':
-        processed = processTypeDeclaration(decl)
+        processed = processTypeDeclaration(decl, keepComments)
         break
       case 'class':
-        processed = processClassDeclaration(decl)
+        processed = processClassDeclaration(decl, keepComments)
         break
       case 'enum':
-        processed = processEnumDeclaration(decl)
+        processed = processEnumDeclaration(decl, keepComments)
         break
       case 'module':
-        processed = processModuleDeclaration(decl)
+        processed = processModuleDeclaration(decl, keepComments)
         break
     }
 
@@ -517,9 +518,9 @@ export function processDeclarations(
 /**
  * Process function declaration to DTS format
  */
-export function processFunctionDeclaration(decl: Declaration): string {
+export function processFunctionDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   // The extractor already provides the correct DTS signature, just return it
   return comments + decl.text
@@ -557,9 +558,9 @@ function isGenericType(typeAnnotation: string): boolean {
 /**
  * Process variable declaration to DTS format
  */
-export function processVariableDeclaration(decl: Declaration): string {
+export function processVariableDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   let result = ''
 
@@ -614,9 +615,9 @@ export function processVariableDeclaration(decl: Declaration): string {
 /**
  * Process interface declaration to DTS format
  */
-export function processInterfaceDeclaration(decl: Declaration): string {
+export function processInterfaceDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   let result = ''
 
@@ -656,9 +657,9 @@ export function processInterfaceDeclaration(decl: Declaration): string {
 /**
  * Process type alias declaration to DTS format
  */
-export function processTypeDeclaration(decl: Declaration): string {
+export function processTypeDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   // For type exports like export type { Foo }
   if (decl.text.includes('{') && decl.text.includes('}') && decl.text.includes('from')) {
@@ -699,9 +700,9 @@ export function processTypeDeclaration(decl: Declaration): string {
 /**
  * Process class declaration to DTS format
  */
-export function processClassDeclaration(decl: Declaration): string {
+export function processClassDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   // The extractor already provides the correct DTS signature, just return it
   return comments + decl.text
@@ -710,9 +711,9 @@ export function processClassDeclaration(decl: Declaration): string {
 /**
  * Process enum declaration to DTS format
  */
-export function processEnumDeclaration(decl: Declaration): string {
+export function processEnumDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   let result = ''
 
@@ -775,9 +776,9 @@ export function processExportDeclaration(decl: Declaration): string {
 /**
  * Process module/namespace declaration to DTS format
  */
-export function processModuleDeclaration(decl: Declaration): string {
+export function processModuleDeclaration(decl: Declaration, keepComments: boolean = true): string {
   // Add comments if present
-  const comments = formatComments(decl.leadingComments)
+  const comments = formatComments(decl.leadingComments, keepComments)
 
   // Check if this is an ambient module (quoted name)
   const isAmbientModule = decl.source || (decl.name.startsWith('"') || decl.name.startsWith('\'') || decl.name.startsWith('`'))

test/fixtures/output/edge-cases.d.ts

@@ -1,24 +1,33 @@
+// Function with complex overloads
 export declare function complexOverload(value: string): string;
 export declare function complexOverload(value: number): number;
 export declare function complexOverload(value: boolean): boolean;
 export declare function complexOverload<T extends object>(value: T): T;
 export declare function complexOverload(value: any): any;
+// Async generator function
 export declare function asyncGenerator<T>(items: T[]): AsyncGenerator<T, void, unknown>;
+// Test edge cases for type inference
+// BigInt literals
 export declare const bigIntLiteral: 123n;
 export declare const bigIntExpression: bigint;
+// Symbol types
 export declare const symbolUnique: symbol;
 export declare const symbolFor: symbol;
+// Template literals
 export declare const templateSimple: `Hello World`;
 export declare const templateWithExpression: `Count: ${42}`;
 export declare const templateTagged: string;
+// Promise types
 export declare const promiseResolved: Promise<42>;
 export declare const promiseRejected: Promise<never>;
 export declare const promiseAll: Promise<[1, 'two']>;
+// Date and built-in types
 export declare const dateInstance: Date;
 export declare const mapInstance: Map<any, any>;
 export declare const setInstance: Set<any>;
 export declare const regexInstance: RegExp;
 export declare const errorInstance: Error;
+// Complex nested structures
 export declare const deeplyNested: {
   level1: {
   level2: {
@@ -29,23 +38,30 @@ export declare const deeplyNested: {
 }
 }
 };
+// Mixed type arrays
 export declare const mixedTypeArray: readonly ['string', 123, true, null, undefined, {
   key: 'value'
 }, readonly [1, 2, 3], (() => unknown), Date, Promise<'async'>];
+// Type with conditional and infer
 export type ExtractPromise<T> = T extends Promise<infer U> ? U : never
 export type ExtractArray<T> = T extends (infer U)[] ? U : never
+// Mapped type with template literal
 export type Getters<T> = {
   [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
 }
+// Discriminated union
 export type Result<T, E = Error> = | { success: true; data: T; error?: never }
   | { success: false; data?: never; error: E }
+// Recursive type with constraints
 export type DeepReadonly<T> = T extends any[] ? DeepReadonlyArray<T[number]> :
   T extends object ? DeepReadonlyObject<T> :
   T
 declare type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>
 declare type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
 }
+// Class with decorators (as comments for now)
+// @sealed
 export declare class DecoratedClass {
   name: string;
   oldMethod(): void;

test/fixtures/output/example/0004.d.ts

@@ -1,3 +1,8 @@
+/**
+ * DtsGenerationConfig
+ *
+ * This is the configuration object for the DTS generation process.
+ */
 export declare interface DtsGenerationConfig {
   cwd: string
   root: string
@@ -8,6 +13,9 @@ export declare interface DtsGenerationConfig {
   tsconfigPath: string
   verbose: boolean
 }
+/**
+ * Regular expression patterns used throughout the module
+ */
 export declare interface RegexPatterns {
   typeImport: RegExp
   regularImport: RegExp
@@ -79,19 +87,28 @@ export declare interface MethodSignature {
   params: string
   returnType: string
 }
+/**
+ * Represents property type information with support for nested structures
+ */
 export declare interface PropertyInfo {
   key: string
   value: string
   type: string
   nested?: PropertyInfo[]
   method?: MethodSignature
 }
+/**
+ * Import statement metadata and tracking
+ */
 export declare interface ImportInfo {
   kind: 'type' | 'value' | 'mixed'
   usedTypes: Set<string>
   usedValues: Set<string>
   source: string
 }
+/**
+ * Function signature components
+ */
 export declare interface FunctionSignature {
   name: string
   params: string
@@ -102,5 +119,15 @@ export declare interface ProcessedMethod {
   name: string
   signature: string
 }
+/**
+ * DtsGenerationOption
+ *
+ * This is the configuration object for the DTS generation process.
+ */
 export type DtsGenerationOption = Partial<DtsGenerationConfig>
+/**
+ * DtsGenerationOptions
+ *
+ * This is the configuration object for the DTS generation process.
+ */
 export type DtsGenerationOptions = DtsGenerationOption | DtsGenerationOption[]

test/fixtures/output/example/0005.d.ts

@@ -1,6 +1,21 @@
 import type { ProcessingState } from './types';
+/**
+ * Extracts types from a TypeScript file and generates corresponding .d.ts content
+ * @param filePath - Path to source TypeScript file
+ */
 export declare function extract(filePath: string): Promise<string>;
+/**
+ * Processes TypeScript source code and generates declaration types
+ * @param sourceCode - TypeScript source code
+ */
 export declare function extractDtsTypes(sourceCode: string): string;
+/**
+ * Check if a given type string represents a function type
+ */
 export declare function isFunctionType(type: string): boolean;
+/**
+ * Check if a declaration is complete by examining its content
+ * @param content - Content to check, either as a string or array of lines
+ */
 export declare function isDeclarationComplete(content: string | string[]): boolean;
 export declare function processSpecificDeclaration(declarationWithoutComments: string, fullDeclaration: string, state: ProcessingState): void;

test/fixtures/output/example/0007.d.ts

@@ -1,5 +1,9 @@
 import forge, { pki, tls } from 'node-forge';
 import type { CAOptions, CertificateOptions, GenerateCertReturn, TlsOption } from './types';
+/**
+ * Generate a random serial number for the Certificate
+ * @returns The serial number for the Certificate
+ */
 export declare function generateRandomSerial(verbose?: boolean): string;
 export declare function calculateValidityDates(options: {
   validityDays?: number
@@ -9,8 +13,21 @@ export declare function calculateValidityDates(options: {
 }): { notBefore: Date, notAfter: Date };
 export declare function createRootCA(options?: CAOptions): Promise<GenerateCertReturn>;
 export declare function generateCertificate(options: CertificateOptions): Promise<GenerateCertReturn>;
+/**
+ * Add a certificate to the system trust store and save the certificate to a file
+ * @param cert
+ * @param caCert
+ * @param options
+ * @returns The path to the stored certificate
+ */
 export declare function addCertToSystemTrustStoreAndSaveCert(cert: Cert, caCert: string, options?: TlsOption): Promise<string>;
 export declare function storeCertificate(cert: Cert, options?: TlsOption): string;
+/**
+ * Store the CA Certificate
+ * @param caCert - The CA Certificate
+ * @param options - The options for storing the CA Certificate
+ * @returns The path to the CA Certificate
+ */
 export declare function storeCACertificate(caCert: string, options?: TlsOption): string;
 export declare interface Cert {
   certificate: string

test/fixtures/output/example/0008.d.ts

@@ -1,10 +1,43 @@
 import { pki } from 'node-forge';
 import type { CertDetails } from './types';
+/**
+ * Checks if a certificate is valid for a given domain.
+ * @param certPemOrPath - The certificate in PEM format or the path to the certificate file.
+ * @param domain - The domain to check.
+ * @returns {boolean} - True if the certificate is valid for the domain, false otherwise.
+ */
 export declare function isCertValidForDomain(certPemOrPath: string, domain: string): boolean;
+/**
+ * Reads a certificate from a file.
+ * @param certPath - Path to the certificate file.
+ * @returns {string} - The certificate content.
+ */
 export declare function readCertFromFile(certPath: string): string;
+/**
+ * Parses and extracts details from a certificate.
+ * @param certPemOrPath - The certificate in PEM format or the path to the certificate file.
+ * @returns {CertDetails} - An object containing certificate details.
+ */
 export declare function parseCertDetails(certPemOrPath: string): CertDetails;
+/**
+ * Checks if a certificate is expired.
+ * @param certPemOrPath - The certificate in PEM format or the path to the certificate file.
+ * @returns {boolean} - True if the certificate is expired, false otherwise.
+ */
 export declare function isCertExpired(certPemOrPath: string): boolean;
+/**
+ * Gets a certificate from a PEM string or a path to a certificate file.
+ * @param certPemOrPath - The certificate in PEM format or the path to the certificate file.
+ * @returns {pki.Certificate} - The certificate object.
+ */
 export declare function getCertificateFromCertPemOrPath(certPemOrPath: string): pki.Certificate;
+/**
+ * Lists all certificates in a directory.
+ * By default, it returns the certificates stored in their default locations on each operating system.
+ * If no certificates are found in the default paths, it checks the fallback path.
+ * @param dirPath - Path to the directory. If not provided, the default directory for the OS will be used.
+ * @returns {string[]} - An array of certificate file paths.
+ */
 export declare function listCertsInDirectory(dirPath?: string): string[];
 export declare function makeNumberPositive(hexString: string): string;
 export declare function findFoldersWithFile(rootDir: string, fileName: string): string[];

test/fixtures/output/example/0009.d.ts

@@ -1,4 +1,23 @@
 import type { Config } from './types';
+/**
+ * Load Config
+ *
+ * @param {object} options - The configuration options.
+ * @param {string} options.name - The name of the configuration file.
+ * @param {string} [options.cwd] - The current working directory.
+ * @param {string} [options.endpoint] - The API endpoint to fetch config from in browser environments.
+ * @param {string} [options.headers] - The headers to send with the request in browser environments.
+ * @param {T} options.defaultConfig - The default configuration.
+ * @returns {Promise<T>} The merged configuration.
+ * @example ```ts
+ * // Merges arrays if both configs are arrays, otherwise does object deep merge
+ * await loadConfig({
+ *   name: 'example',
+ *   endpoint: '/api/my-custom-config/endpoint',
+ *   defaultConfig: [{ foo: 'bar' }]
+ * })
+ * ```
+ */
 export declare function loadConfig<T>({
   name,
   cwd,