@git.zone/tsbuild

Documentation for @git.zone/tsbuild

readme.md for @git.zone/tsbuild

A powerful, modern TypeScript build tool with smart defaults, full tsconfig.json support, automatic output directory management, and cross-module import path rewriting.

Issue Reporting and Security

For reporting bugs, issues, or security vulnerabilities, please visit community.foss.global/. This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a code.foss.global/ account to submit Pull Requests directly.

Install

# Using pnpm (recommended)
pnpm install @git.zone/tsbuild --save-dev

# Using npm
npm install @git.zone/tsbuild --save-dev

Why tsbuild?

Feature Description
Smart tsconfig.json Integration Respects all your compiler options with intelligent merging
Protected Defaults Critical build settings are safeguarded while staying flexible
Zero Config Works perfectly without tsconfig.json
Glob Pattern Support Compile multiple directories with a single command
Dependency-Aware Automatically orders compilation based on module dependencies
Type Checking Validate code without emitting files
Clean Builds Automatically clears output directories before compilation
Auto-Unpack Flattens nested output directories automatically
Import Path Rewriting Rewrites cross-module imports to point at compiled output
CI/CD Ready JSON output mode and proper exit codes
Modern Defaults ESNext, NodeNext modules, decorators out of the box

Quick Start

CLI Usage

Compile your TypeScript project:

npx tsbuild

Compiles ./ts/**/*.ts to ./dist_ts/

Custom directories:

npx tsbuild custom src utils

Compiles:

Auto-discover and compile in dependency order:

npx tsbuild tsfolders

Finds all ts_* folders and compiles them respecting dependencies.

Programmatic Usage

Basic compilation:

import { TsCompiler } from '@git.zone/tsbuild';

const compiler = new TsCompiler();
await compiler.compileFilesOrThrow([
  './src/index.ts',
  './src/utils.ts'
], { outDir: './dist' });

Production-ready with error tracking (recommended):

import { TsCompiler } from '@git.zone/tsbuild';

const compiler = new TsCompiler();
const result = await compiler.compileFiles([
  './src/index.ts',
  './src/utils.ts'
], { outDir: './dist' });

if (result.errorSummary.totalErrors > 0) {
  console.error(`Compilation failed with ${result.errorSummary.totalErrors} errors`);
  process.exit(1);
}

console.log(`Compiled ${result.emittedFiles.length} files successfully!`);

Glob pattern compilation:

import { TsCompiler } from '@git.zone/tsbuild';

const compiler = new TsCompiler();
await compiler.compileGlob({
  './ts/**/*.ts': './dist_ts',
  './ts_web/**/*.ts': './dist_web'
});

CLI Commands

1. Default Build

npx tsbuild [options]

Compiles all TypeScript files from ./ts/ to ./dist_ts/

Options:

Flag Description
--skiplibcheck Skip type checking of declaration files
--confirmskiplibcheck Skip lib check with extended warning (5s pause)
--disallowimplicitany Disallow implicit any types
--commonjs Use CommonJS instead of ESNext modules
--json Output results as JSON (for CI/CD)
--quiet Suppress console output

Examples:

# Standard build
npx tsbuild

# Build with JSON output for CI
npx tsbuild --json --quiet

# CommonJS build
npx tsbuild --commonjs

# Strict mode
npx tsbuild --disallowimplicitany

2. Custom Directories

npx tsbuild custom <dir1> <dir2> ... [options]

Compile specific directories to their corresponding dist_ folders.

# Compile src and utils
npx tsbuild custom src utils
# Creates: ./dist_src/ and ./dist_utils/

# Multiple directories with options
npx tsbuild custom api models services --commonjs

3. TSFolders (Dependency-Aware)

npx tsbuild tsfolders [options]

Automatically discovers and compiles all ts_* folders in dependency order:

  1. Prioritizes ts_interfaces first (if no tspublish.json)
  2. Prioritizes ts_shared second (if no tspublish.json)
  3. Reads tspublish.json in each folder for order property
  4. Compiles in correct sequence

Example output:

TypeScript Folder Compilation Plan (5 folders)
  1. ts_interfaces
  2. ts_shared
  3. ts_core
  4. ts_utils
  5. ts_modules

4. Emit Check

npx tsbuild emitcheck <file_or_pattern> [more...] [options]

Validates TypeScript files can be compiled without actually emitting them.

# Check specific files
npx tsbuild emitcheck src/main.ts src/utils.ts

# Check with glob patterns
npx tsbuild emitcheck "src/**/*.ts" "test/**/*.ts"

Exit codes:

5. Type Check

npx tsbuild check [pattern] [more...] [options]

Performs type checking without emitting files.

With arguments: Check specified files/patterns

npx tsbuild check "ts/**/*.ts"
npx tsbuild check "src/**/*.ts" "test/**/*.ts"

Without arguments: Two-phase default check

  1. Phase 1: Type check ts/**/* (strict, includes .d.ts)
  2. Phase 2: Type check test/**/* (relaxed, skipLibCheck: true)
npx tsbuild check
# Running default type checking sequence...
# Checking ts/**/* files...
# Checking test/**/* files with --skiplibcheck...
# All default type checks passed!

API Reference

TsCompiler Class

The main class for TypeScript compilation.

import { TsCompiler } from '@git.zone/tsbuild';

const compiler = new TsCompiler(cwd?: string, argvArg?: any);

Constructor Parameters:

compileFiles(fileNames, customOptions?, taskInfo?)

Compile files with error tracking. Returns result instead of throwing.

const result = await compiler.compileFiles(
  ['./src/index.ts', './src/utils.ts'],
  { outDir: './dist' }
);

console.log(`Emitted: ${result.emittedFiles.length} files`);
console.log(`Errors: ${result.errorSummary.totalErrors}`);

Returns: Promise<ICompileResult>

interface ICompileResult {
  emittedFiles: string[];
  errorSummary: IErrorSummary;
}

interface IErrorSummary {
  errorsByFile: Record<string, Diagnostic[]>;
  generalErrors: Diagnostic[];
  totalErrors: number;
  totalFiles: number;
}

compileFilesOrThrow(fileNames, customOptions?)

Compile files and throw on error. For simple scripts.

try {
  const emittedFiles = await compiler.compileFilesOrThrow(
    ['./src/index.ts'],
    { outDir: './dist' }
  );
  console.log('Compiled:', emittedFiles);
} catch (error) {
  console.error('Compilation failed!');
  process.exit(1);
}

Returns: Promise<string[]> - Array of emitted file paths

compileGlob(globPatterns, customOptions?)

Compile multiple glob patterns to different destinations. Automatically clears output directories before compilation, unpacks nested output, and rewrites cross-module import paths.

const result = await compiler.compileGlob({
  './ts/**/*.ts': './dist_ts',
  './ts_web/**/*.ts': './dist_web',
  './ts_node/**/*.ts': './dist_node'
});

Returns: Promise<ICompileResult>

checkTypes(fileNames, customOptions?)

Type check files without emitting. Fast validation.

const success = await compiler.checkTypes(['./src/**/*.ts']);

if (!success) {
  console.error('Type errors found!');
  process.exit(1);
}

Returns: Promise<boolean> - true if no errors

checkEmit(fileNames, customOptions?)

Validate files can be emitted without actually emitting.

const canEmit = await compiler.checkEmit(['./src/index.ts']);

if (!canEmit) {
  console.error('Cannot emit these files!');
}

Returns: Promise<boolean> - true if can emit

createOptions(customOptions?)

Get merged compiler options (useful for debugging).

const options = compiler.createOptions({ strict: true });
console.log(options); // Shows merged options

Supporting Classes

TsConfig

TypeScript configuration management.

import { TsConfig } from '@git.zone/tsbuild';

const config = new TsConfig(process.cwd());
const options = config.merge({ target: 'ES2022' }, argvArg);

TsPublishConfig

Reads tspublish.json for module configuration.

import { TsPublishConfig } from '@git.zone/tsbuild';

const pubConfig = new TsPublishConfig('./ts_core');
console.log(pubConfig.shouldUnpack); // true/false
console.log(pubConfig.order);        // number or undefined

TsUnpacker

Flattens nested TypeScript output directories.

import { TsUnpacker } from '@git.zone/tsbuild';

const unpacker = new TsUnpacker('ts_core', './dist_ts_core');
await unpacker.unpack();

TsPathRewriter

Rewrites cross-module import paths in compiled output files. When TypeScript compiles files that import from sibling directories (e.g., ../ts_shared/helper.js), TsPathRewriter rewrites those paths to reference the compiled output directories (../dist_ts_shared/helper.js).

import { TsPathRewriter } from '@git.zone/tsbuild';

// Auto-detect all ts_* folders in the project
const rewriter = await TsPathRewriter.fromProjectDirectory(process.cwd());
const filesModified = await rewriter.rewriteDirectory('./dist_ts_core');

// Or from explicit glob patterns
const rewriter2 = TsPathRewriter.fromGlobPatterns({
  './ts_core/**/*.ts': './dist_ts_core',
  './ts_shared/**/*.ts': './dist_ts_shared',
});

FsHelpers

Static filesystem utilities.

import { FsHelpers } from '@git.zone/tsbuild';

const files = await FsHelpers.listFilesWithGlob('./', 'ts/**/*.ts');
const exists = await FsHelpers.fileExists('./tsconfig.json');
const dirExists = await FsHelpers.directoryExists('./ts');

TsBuildCli

CLI command handler. Used internally by the CLI.

import { TsBuildCli, runCli } from '@git.zone/tsbuild';

// Run the CLI
runCli();

// Or with custom working directory
const cli = new TsBuildCli('/path/to/project');
cli.run();

Configuration

tsconfig.json Support

tsbuild fully supports all compiler options from tsconfig.json. Your project configuration is respected and intelligently merged.

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "verbatimModuleSyntax": true
  }
}

Configuration Priority (5 Levels)

When multiple configuration sources exist, they merge in this order (later overrides earlier):

Priority Source Description
1 Default Options tsbuild's sensible defaults
2 tsconfig.json All options from your tsconfig.json (if present)
3 Protected Defaults Critical options for build integrity
4 Programmatic Options Options passed to API functions
5 CLI Flags Command-line arguments (highest priority)

Protected Options

These options cannot be overridden by tsconfig.json alone (but can be overridden programmatically or via CLI):

Option Value Reason
outDir 'dist_ts/' Required for automatic path transformations
noEmitOnError true Prevents broken builds from being emitted
declaration true Ensures .d.ts files for library consumers
inlineSourceMap true Consistent debugging experience

Default Compiler Options

When no tsconfig.json exists:

{
  declaration: true,              // Generate .d.ts files
  inlineSourceMap: true,          // Debug-friendly
  noEmitOnError: true,            // Fail-fast on errors
  outDir: 'dist_ts/',             // Output directory
  module: 'NodeNext',             // Modern Node.js modules
  target: 'ESNext',               // Latest JavaScript
  moduleResolution: 'NodeNext',
  noImplicitAny: false,           // Flexible for quick development
  esModuleInterop: true,          // CJS/ESM interop
  verbatimModuleSyntax: true      // Explicit imports/exports
}

Path Transformation

tsbuild automatically transforms path mappings:

tsconfig.json:

{
  "compilerOptions": {
    "paths": {
      "@models/*": ["./ts_models/*"]
    }
  }
}

Automatic transformation:

./ts_models/* -> ./dist_ts_models/*

Features

Clean Builds

Output directories are automatically cleared before compilation:

Clearing output directory: ./dist_ts
Compiling 14 files from ./ts/**/*.ts

This ensures no stale files remain from previous builds.

Import Path Rewriting

When working with multi-module projects (multiple ts_* folders), TypeScript compiles import paths relative to source directories. After compilation and unpacking, these paths would be wrong because the directory structure changes.

tsbuild automatically detects all ts_* folders in the project and rewrites import paths in the compiled output:

# Source code
import { helper } from '../ts_shared/helper.js';

# Compiled output (after rewriting)
import { helper } from '../dist_ts_shared/helper.js';

This works for ES module imports, dynamic import() calls, and CommonJS require() statements. The rewriting happens automatically as part of compileGlob().

Monorepo Support with tspublish

tsbuild is designed to work seamlessly with @git.zone/tspublish for monorepo workflows. This enables building and publishing multiple packages from a single repository.

Directory Structure

my-project/
  ts/                    # Main package source
  ts_interfaces/         # Shared interfaces (order: 1)
  ts_shared/             # Shared utilities (order: 2)
  ts_core/               # Core logic (order: 3)
  ts_web/                # Web-specific code (order: 4)
  ts_node/               # Node-specific code (order: 5)

Each ts_* folder can contain its own tspublish.json to configure compilation and publishing behavior.

tspublish.json Configuration

Create a tspublish.json in each ts_* folder:

{
  "name": "@myorg/core",
  "order": 3,
  "unpack": true,
  "dependencies": ["ts_interfaces", "ts_shared"]
}
Option Type Default Description
name string -- Package name for publishing
order number Infinity Build sequence (lower builds first)
unpack boolean true Flatten nested output directories
dependencies string[] -- Monorepo dependencies to bundle

Build Order

The tsfolders command respects the order property:

npx tsbuild tsfolders

Default ordering (without tspublish.json):

  1. ts_interfaces - always first (shared types)
  2. ts_shared - always second (shared utilities)
  3. Other folders sorted by order property
  4. Folders without order are built last

Auto-Unpack

When TypeScript compiles files that import from sibling directories, it creates nested output:

dist_ts_core/
  ts_core/        <-- nested output
  ts_shared/      <-- pulled-in dependency

tsbuild automatically flattens this to:

dist_ts_core/
  index.js        <-- flat, clean structure

This is especially important for monorepos where packages import from each other.

Control via tspublish.json:

{
  "unpack": true
}

What gets unpacked:

Decorator Support

tsbuild supports both TC39 standard decorators (recommended) and legacy experimental decorators.

TC39 Standard Decorators (Preferred)

We strongly recommend using TC39 standard decorators for all new code. They are the official JavaScript standard and provide better semantics:

// TC39 standard decorator
function log(target: any, context: ClassMethodDecoratorContext) {
  return function (...args: any[]) {
    console.log(`Calling ${String(context.name)}`);
    return target.apply(this, args);
  };
}

class UserService {
  @log
  getUser(id: string) {
    return { id, name: 'John' };
  }
}

Legacy Decorators (Backwards Compatibility)

For existing projects using frameworks that still require experimental decorators:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

Structured Logging

tsbuild uses a 4-level visual hierarchy for console output, making it easy to follow compilation progress:

All output uses ANSI color codes for terminal readability. Use --quiet to suppress output or --json for machine-readable format.

CI/CD Integration

GitHub Actions

name: Build
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'

      - run: npm install
      - run: npx tsbuild

JSON Output

npx tsbuild --json --quiet

{
  "success": true,
  "totals": {
    "errors": 0,
    "filesWithErrors": 0,
    "tasks": 1
  },
  "errorsByFile": {}
}

Package.json Scripts

{
  "scripts": {
    "build": "tsbuild",
    "build:prod": "tsbuild --disallowimplicitany",
    "typecheck": "tsbuild check",
    "pretest": "tsbuild emitcheck 'test/**/*.ts'"
  }
}

Troubleshooting

Common Issues

"Cannot find module" errors in compiled output

Make sure path mappings are configured in tsconfig.json. tsbuild automatically transforms them.

Decorator errors

Ensure your tsconfig.json has:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

Slow compilation

Use --skiplibcheck to skip declaration file checking:

npx tsbuild --skiplibcheck

Only use this if you trust your dependencies' type definitions.

This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the LICENSE file.

Please note: The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.

Trademarks

This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.

Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.

Company Information

Task Venture Capital GmbH Registered at District Court Bremen HRB 35230 HB, Germany

By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

changelog.md for @git.zone/tsbuild

2026-03-24 - 4.4.0 - feat(config)

add smartconfig metadata and update TypeScript build configuration docs

2026-03-06 - 4.3.0 - feat(mod_logger)

add centralized TsBuildLogger and replace ad-hoc console output with structured, colored logging

2026-03-05 - 4.2.6 - fix(meta)

no changes

2026-03-05 - 4.2.5 - fix(compiler)

yield to the event loop after TypeScript emit to allow pending microtasks and I/O to settle before reading or modifying the output directory

2026-03-05 - 4.2.4 - fix(fshelpers)

remove outdated comment about using synchronous rm to avoid XFS metadata corruption

2026-03-05 - 4.2.3 - fix(compiler)

defer unpacking until after all compilations and remove diagnostic filesystem syncs to avoid XFS metadata visibility issues

2026-03-05 - 4.2.2 - fix(compiler)

force global filesystem sync to flush XFS delayed logging and add diagnostics comparing Node's readdirSync with system ls to detect directory entry inconsistencies

2026-03-05 - 4.2.1 - fix(compiler)

use TypeScript sys hooks instead of fs monkeypatching to detect writes/deletes in previous output directories

2026-03-05 - 4.2.0 - feat(mod_compiler)

add diagnostic interception of fs operations to detect and report unexpected file system changes in previously compiled output directories during compilation

2026-03-05 - 4.1.26 - fix(compiler)

fsync output directories after unpack to avoid XFS delayed logging causing corrupt or invisible directory entries during subsequent TypeScript emits

2026-03-05 - 4.1.25 - fix(mod_unpack)

flush directory metadata on XFS before reading and use readdirSync-based iteration to avoid missing entries when unpacking

2026-03-05 - 4.1.24 - fix(mod_unpack)

iterate directories with opendirSync/readSync to avoid missing entries on XFS and ensure directory handles are closed

2026-03-05 - 4.1.23 - fix(mod_unpack)

handle partial readdirSync results when moving nested directory entries and add diagnostic log

2026-03-05 - 4.1.22 - fix(mod_compiler)

improve logging of successful output directories to include a sorted list of entries and use a shortened relative path

2026-03-05 - 4.1.21 - fix(compiler)

log emitted files written outside expected destination directory for diagnostics

2026-03-05 - 4.1.20 - fix(mod_compiler)

add diagnostic snapshots for output directories around clear and compile steps

2026-03-05 - 4.1.19 - fix(mod_fs)

use synchronous rm to avoid XFS metadata corruption when removing directories

2026-03-05 - 4.1.18 - fix(mod_compiler)

add diagnostic logging of output directory states after compilation and after import-path rewriting to aid debugging

2026-03-05 - 4.1.17 - fix(tsunpacker)

use synchronous fs operations in tsunpacker to avoid readdir race conditions

2026-03-05 - 4.1.16 - fix(mod_unpack)

handle partial readdir results from signal-interrupted getdents64 when unpacking to ensure sibling removal and nested moves complete

2026-03-05 - 4.1.15 - fix(mod_unpack)

flatten nested output directory without temporary rename steps to avoid race conditions

2026-03-05 - 4.1.14 - fix(fs)

replace execSync and fsync workarounds with atomic async FsHelpers operations to avoid XFS races and shell dependencies

2026-03-05 - 4.1.13 - fix(mod_unpack)

Use child_process.execSync (mv/rm) to perform unpack atomically, replacing async fs operations and logs to avoid ENOENT/partial directory listings on XFS

2026-03-05 - 4.1.12 - fix(mod_compiler)

replace runtime require calls with top-level imports and use execSync/path.join for filesystem sync and traversal

2026-03-05 - 4.1.11 - fix(mod_compiler)

flush directory entries before unpack to avoid XFS delayed-log causing partial readdir results

2026-03-05 - 4.1.10 - fix(unpack)

use atomic renames to flatten nested output and make unpacking more reliable

2026-03-05 - 4.1.9 - fix(fs)

improve filesystem helpers: use sync rename for reliability on certain filesystems; retry rmdir with delays and avoid recursive rm; bump @push.rocks/smartfs to ^1.3.2

2026-03-05 - 4.1.8 - fix(unpack)

catch unpack errors and add verbose unpack logging

2026-03-05 - 4.1.7 - fix(fs/compiler/unpack)

robustify directory removal and remove noisy diagnostic logging

2026-03-05 - 4.1.6 - fix(mod_compiler)

add diagnostic logging to report dist_ts and output directory contents after each compilation task and after import-path rewriting

2026-03-05 - 4.1.5 - fix(diagnostics)

add diagnostic logging around compilation and unpack to aid troubleshooting

2026-03-05 - 4.1.4 - fix(deps)

bump @git.zone/tspublish dependency to ^1.11.2

2026-03-04 - 4.1.3 - fix(deps)

bump dependencies: @push.rocks/smartcli, @push.rocks/smartlog, @git.zone/tstest, and @types/node to their newer versions

2026-01-04 - 4.1.0 - feat(docs)

update README with improved docs and monorepo/tspublish guidance; namespace and extend npmextra.json with release registries; bump several dependencies

2025-12-14 - 4.0.2 - fix(TsCompiler)

Clear output directories before compilation to ensure clean builds and avoid stale files

2025-12-13 - 3.1.3 - fix(npmextra)

Align npmextra.json package name with package.json (@git.zone/tsbuild)

2025-11-28 - 3.1.2 - fix(TsBuild)

Set default TypeScript target to ESNext

2025-11-27 - 3.1.1 - fix(compiler)

Update default TypeScript target to ES2024

2025-11-17 - 3.1.0 - feat(tsbuild.classes)

Update default TypeScript lib to lib.esnext.d.ts

2025-11-17 - 3.0.0 - BREAKING CHANGE(TsBuild)

Stop forcing emitDecoratorMetadata in protected compiler defaults

2025-11-17 - 2.7.3 - fix(tsbuild.classes)

Remove duplicate emitDecoratorMetadata from default compiler options and centralize it in protected defaults

2025-11-17 - 2.7.2 - fix(compilerOptions)

Remove experimentalDecorators and useDefineForClassFields from default TypeScript compiler options

2025-11-02 - 2.7.1 - fix(readme)

Update documentation: expand README with usage, CLI and API examples; add readme.hints.md project memory

2025-11-02 - 2.7.0 - feat(tsbuild)

Add tsconfig.json support and safer compiler option merging; protect critical options; apply path and enum transforms; bump dependencies.

2025-08-29 - 2.6.8 - fix(tsbuild)

Avoid process.exit in library, add confirmskiplibcheck flag, improve CLI exit handling and JSON/quiet modes, update test script

2025-08-18 - 2.6.7 - fix(tspublish)

Bump @git.zone/tspublish dependency to ^1.10.3

2025-08-18 - 2.6.6 - fix(dependencies)

Update dependency @git.zone/tspublish to ^1.10.2

2025-08-18 - 2.6.5 - fix(dependencies)

Bump dependencies and add pnpm-workspace configuration

2025-05-24 - 2.6.4 - fix(dependencies)

Add .npmrc and update dependency versions for smartfile and tstest

2025-05-21 - 2.6.3 - fix(tsbuild)

minor maintenance updates and documentation improvements

2025-05-21 - 2.6.2 - fix(npm configuration)

Remove .npmrc file to default npm registry behavior

2025-05-21 - 2.6.1 - fix(tsbuild.classes)

Improve error diagnostics handling by removing legacy helper and integrating more robust error summaries in the compilation process

2025-05-21 - 2.6.0 - feat(tsbuild)

Improve task logging and update dependencies

2025-05-21 - 2.5.2 - fix(tsbuild)

Improve diagnostic error handling and summary reporting for TypeScript compilation by refactoring diagnostic processing and adding pre-emit error checks.

2025-05-15 - 2.5.1 - fix(commitinfo)

Update commit information and metadata to synchronize release data

2025-05-15 - 2.5.0 - feat(cli)

Enhance type checking in CLI by adding default file pattern handling

2025-05-15 - 2.4.1 - fix(cli)

Improve TS folder compilation order display in CLI

2025-05-15 - 2.4.0 - feat(cli)

Add new 'check' command for type checking and update compiler options handling

2025-03-20 - 2.3.2 - fix(compileGlobStringObject)

Fix duplicate file outputs in glob pattern processing

2025-03-20 - 2.3.1 - fix(compiler)

Refactor compiler implementation with consolidated TsBuild class and improved diagnostics handling

2025-03-20 - 2.3.0 - feat(cli)

Add emitcheck command to validate TS file emission without generating output

2025-03-17 - 2.2.7 - fix(compiler)

Improve diagnostic checking and error handling in the TypeScript compiler integration

2025-03-04 - 2.2.6 - fix(package)

Fix repository URL in package.json

2025-03-04 - 2.2.5 - fix(package.json)

Update repository URLs in package metadata.

2025-03-04 - 2.2.4 - fix(core)

Fix compiler logic to remove duplicate compiled files and improve glob pattern handling.

2025-03-04 - 2.2.3 - fix(exports)

Fixed duplicate file compilation in compileGlobStringObject

2025-01-28 - 2.2.2 - fix(ci)

Remove GitLab CI configuration

2025-01-28 - 2.2.1 - fix(core)

Update dependencies to improve stability and performance.

2024-11-05 - 2.2.0 - feat(cli)

Enhance CLI for TypeScript folder compilation ordering based on rank and predefined rules.

2024-10-27 - 2.1.85 - fix(compiler)

Improve path handling in compiler options

2024-07-22 - 2.1.84 - fix(cli)

Fixed transpilation order issue in tsfolders command

2024-07-21 - 2.1.83 - fix(cli)

Ensure 'ts_shared' folder is compiled first if present

2024-06-24 - 2.1.82 - fix(core)

Minor improvements and optimizations in core TypeScript compiler integration.

2024-06-24 - 2.1.81 - fix(dependencies)

Update dependencies to latest versions

2024-05-17 - 2.1.80 - core

Fix multiple core issues.

2024-05-17 - 2.1.76 to 2.1.79 - core

Routine core updates and fixes.

2024-05-14 - 2.1.74 to 2.1.75 - core

General core maintenance updates.

2024-05-10 - 2.1.72 to 2.1.73 - core

Minor core updates.

2024-01-08 - 2.1.70 to 2.1.71 - core

Core functionality enhancements.

2023-08-26 - 2.1.66 to 2.1.69 - core

Regular core updates and fixes.

2023-06-03 - 2.1.65 - core

Core maintenance update.

2022-08-03 - 2.1.63 to 2.1.64 - core

Minor core updates and fixes.

2022-05-25 - 2.1.61 to 2.1.62 - core

Routine core updates.

2022-03-24 - 2.1.60 - core

Core functionality update.

2022-03-18 - 2.1.57 to 2.1.59 - core

Minor core updates and enhancements.

2022-03-15 - 2.1.50 to 2.1.56 - core

Several core bug fixes.

2022-03-14 - 2.1.49 - core

Core update.

2022-03-12 - 2.1.43 to 2.1.48 - core

General core maintenance updates.

2022-03-11 - 2.1.33 to 2.1.42 - core

Core functionality enhancements and fixes.

2022-03-11 - 2.1.29 to 2.1.32 - core

Routine core updates.

2022-01-19 - 2.1.28 to 2.1.29 - core

Core bug fixes.

2021-10-06 - 2.1.27 - core

Minor core update.

2021-09-08 - 2.1.26 - core

Core update.

2021-08-17 - 2.1.25 - core

Core bug fixes.

2020-08-11 - 2.1.24 - core

Routine core update.

2020-05-14 - 2.1.23 - core

General core updates.

2020-03-13 - 2.1.20 to 2.1.22 - core

Minor core updates.

2020-03-09 - 2.1.19 - core

Maintenance core update.

2019-08-26 - 2.1.16 to 2.1.17 - core

Routine minor core updates.

2019-01-27 - 2.1.6 - custom directory compilation

Now picking up TypeScript files correctly.

2018-12-05 - 2.1.0 to 2.1.1 - core

Minor core updates.

2018-12-05 - 2.0.22 - cli options

Now support --web for web compilations targeting Google Chrome.

2018-07-25 - 2.0.15 to 2.0.19 - various

Multiple fixes across core, dependency, and compiler modules.