TypeScript Projects

/**
 * TypeScript project with build toolchain, testing, and development tools
 * Extends NodeProject with TypeScript compilation and type checking
 */
class TypeScriptProject extends NodeProject {
  constructor(options: TypeScriptProjectOptions);
  
  /** Source directory for TypeScript files (default: "src") */
  readonly srcdir: string;
  /** Compiled output directory (default: "lib") */
  readonly libdir: string;
  /** Test directory (default: "test") */
  readonly testdir: string;
  /** Main TypeScript configuration file */
  readonly tsconfig?: TypescriptConfig;
  /** Development TypeScript configuration */
  readonly tsconfigDev: TypescriptConfig;
  /** ESLint TypeScript configuration file */
  readonly tsconfigEslint?: TypescriptConfig;
  /** ESLint configuration for TypeScript */
  readonly eslint?: Eslint;
  /** Watch task for development */
  readonly watchTask: Task;
  /** Documentation generation enabled */
  readonly docgen?: boolean;
  /** Documentation output directory */
  readonly docsDirectory: string;
}

interface TypeScriptProjectOptions extends NodeProjectOptions {
  /** Source directory (default: "src") */
  srcdir?: string;
  /** Compiled output directory (default: "lib") */
  libdir?: string;
  /** Test directory (default: "test") */
  testdir?: string;
  /** TypeScript compiler options */
  tsconfig?: TypescriptConfigOptions;
  /** Development TypeScript compiler options */
  tsconfigDev?: TypescriptConfigOptions;
  /** The name of the development tsconfig.json file (default: "tsconfig.dev.json") */
  tsconfigDevFile?: string;
  /** Disable TypeScript compilation */
  disableTsconfig?: boolean;
  /** Do not generate a tsconfig.dev.json file */
  disableTsconfigDev?: boolean;
  /** TypeScript version to use (default: "latest") */
  typescriptVersion?: string;
  /** Enable TypeScript ESLint (default: true) */
  eslint?: boolean;
  /** ESLint configuration options */
  eslintOptions?: EslintOptions;
  /** Enable documentation generation with typedoc */
  docgen?: boolean;
  /** Documentation output directory (default: "docs") */
  docsDirectory?: string;
  /** Sample code generation (default: true) */
  sampleCode?: boolean;
  /** The .d.ts file that includes the type declarations for this module */
  entrypointTypes?: string;
  /** Use TypeScript for your projenrc file (.projenrc.ts) */
  projenrcTs?: boolean;
  /** Options for .projenrc.ts */
  projenrcTsOptions?: ProjenrcTsOptions;
  /** Options for ts-jest */
  tsJestOptions?: TsJestOptions;
}

import { TypeScriptProject } from "projen";

const project = new TypeScriptProject({
  name: "my-typescript-lib",
  defaultReleaseBranch: "main",
  
  // Author information
  author: "Jane Developer",
  authorEmail: "jane@example.com",
  repository: "https://github.com/user/my-typescript-lib.git",
  
  // TypeScript configuration
  srcdir: "src",
  testdir: "test",
  libdir: "lib",
  
  // Dependencies
  deps: ["axios", "lodash"],
  devDeps: ["@types/node", "@types/lodash"],
  peerDeps: ["react"],
  
  // Tooling
  eslint: true,
  prettier: true,
  jest: true,
  
  // Documentation
  docgen: true,
  
  // Sample files
  sampleCode: true,
});

project.synth();

/**
 * Manages TypeScript configuration files (tsconfig.json)
 */
class TypescriptConfig extends Component {
  constructor(project: Project, options?: TypescriptConfigOptions);
  
  /** TypeScript compiler options */
  readonly compilerOptions: any;
  /** Files to include in compilation */
  readonly include?: string[];
  /** Files to exclude from compilation */
  readonly exclude?: string[];
  
  /** Add include pattern */
  addInclude(pattern: string): void;
  /** Add exclude pattern */
  addExclude(pattern: string): void;
}

interface TypescriptConfigOptions {
  /** TypeScript compiler options */
  compilerOptions?: any;
  /** Files to include */
  include?: string[];
  /** Files to exclude */
  exclude?: string[];
  /** Extend from another tsconfig */
  extends?: string;
}

import { TypeScriptProject } from "projen";

const project = new TypeScriptProject({
  name: "advanced-ts-project",
  tsconfig: {
    compilerOptions: {
      target: "ES2020",
      module: "commonjs",
      lib: ["ES2020", "DOM"],
      strict: true,
      esModuleInterop: true,
      skipLibCheck: true,
      forceConsistentCasingInFileNames: true,
    },
    include: ["src/**/*"],
    exclude: ["node_modules", "lib"],
  },
  tsconfigDev: {
    compilerOptions: {
      noEmit: true,
    },
    include: ["src/**/*", "test/**/*"],
  },
});

/**
 * TypeScript projenrc configuration file
 * Provides type-safe project configuration
 */
class ProjenrcTs extends Component {
  constructor(project: TypeScriptProject, options?: ProjenrcOptions);
}

interface ProjenrcOptions {
  /** Filename for the projenrc file (default: ".projenrc.ts") */
  filename?: string;
  /** Use ts-node for execution (default: true) */
  tsNode?: boolean;
}

// .projenrc.ts
import { TypeScriptProject } from "projen";

const project = new TypeScriptProject({
  name: "my-project",
  defaultReleaseBranch: "main",
  
  // Full TypeScript IntelliSense support
  deps: ["axios"],
  devDeps: ["@types/node"],
  
  // Type-safe configuration
  tsconfig: {
    compilerOptions: {
      target: "ES2020",
      strict: true,
    },
  },
});

// Custom configuration with full type checking
project.addTask("custom-task", {
  description: "Custom build step",
  exec: "echo 'Custom task executed'",
});

project.synth();

/**
 * TypeDoc documentation generation for TypeScript projects
 */
class TypedocDocgen extends Component {
  constructor(project: TypeScriptProject, options?: TypedocOptions);
}

interface TypedocOptions {
  /** Entry point for documentation */
  entryPoint?: string;
  /** Output directory (default: "docs") */
  out?: string;
  /** Include private members */
  includePrivate?: boolean;
  /** TypeDoc theme */
  theme?: string;
  /** Additional TypeDoc options */
  options?: any;
}

import { TypeScriptProject } from "projen";

const project = new TypeScriptProject({
  name: "documented-project",
  
  // Enable documentation generation
  docgen: true,
  typedocOptions: {
    entryPoint: "src/index.ts",
    out: "api-docs",
    theme: "default",
    includePrivate: false,
  },
});

// Documentation will be generated in the "api-docs" directory
// Available via npm run docgen

/**
 * TypeScript application project (for applications vs libraries)
 */
class TypeScriptAppProject extends TypeScriptProject {
  constructor(options: TypeScriptAppProjectOptions);
}

interface TypeScriptAppProjectOptions extends TypeScriptProjectOptions {
  /** Application entry point */
  entrypoint?: string;
  /** Enable bundling with esbuild */
  bundle?: boolean;
  /** Bundling options */
  bundlerOptions?: BundlerOptions;
}

import { TypeScriptAppProject } from "projen";

const app = new TypeScriptAppProject({
  name: "my-typescript-app",
  defaultReleaseBranch: "main",
  
  // Application-specific settings
  entrypoint: "src/main.ts",
  bundle: true,
  
  // Runtime dependencies
  deps: [
    "express",
    "cors",
  ],
  
  // Development dependencies
  devDeps: [
    "@types/express",
    "@types/cors",
    "@types/node",
  ],
});

// Add application-specific tasks
app.addTask("start", {
  description: "Start the application",
  exec: "node lib/main.js",
});

app.addTask("dev", {
  description: "Start in development mode",
  exec: "ts-node src/main.ts",
});

interface BundlerOptions {
  /** Bundler to use (esbuild, webpack) */
  bundler?: "esbuild" | "webpack";
  /** Bundle format */
  format?: "cjs" | "esm";
  /** External dependencies */
  externals?: string[];
  /** Target environment */
  target?: string;
}

interface EslintOptions {
  /** ESLint configuration directories */
  dirs?: string[];
  /** File extensions to lint */
  fileExtensions?: string[];
  /** Ignore patterns */
  ignorePatterns?: string[];
  /** Additional ESLint rules */
  rules?: Record<string, any>;
}