Projects sharing features with Ts Migrate

This project is a suite of abstract syntax tree transformation tools designed to automate the migration of source code to newer versions of React. It provides a set of scripts that programmatically modify code structures to replace deprecated APIs and component patterns with modern equivalents. The toolkit specializes in converting class components into functional components using arrow functions and prop destructuring. It also includes utilities for modernizing JSX syntax, updating deprecated lifecycle methods to stable versions, and migrating legacy string-based references to callback refs.

OpenRewrite is an automated refactoring engine and source-to-source migration framework. It uses a lossless semantic tree parser to represent source code as type-aware trees that preserve original whitespace and formatting, enabling precise and deterministic modifications. The project utilizes a declarative refactoring pipeline where sequences of transformations are defined in YAML to resolve breaking changes and technical debt. It features type-aware pattern matching and cross-language model mapping to apply similar refactoring patterns across different programming languages. The framework

This project is an AST-based code optimizer and compressor for modern ECMAScript, JSX, and TypeScript source code. It functions as a JavaScript minifier that uses the Babel toolchain to reduce file size by removing unnecessary characters and whitespace while preserving program logic. The tool is distinguished by its ability to process experimental language proposals and transform modern syntax into browser-compatible versions. It provides specialized handling for React JSX transpilation and strips type annotations from TypeScript files to produce compressed production assets. The system cove

unplugin-auto-import is a build-time import automation plugin and AST-based code transformer. It analyzes source code to identify missing identifiers and automatically injects the required import statements during the bundling process. The project functions as a cross-bundler build plugin, providing a unified abstraction layer that ensures consistent behavior across Vite, Webpack, and Rollup. It utilizes a pattern-based module resolver to scan local directories via glob patterns and employs a TypeScript declaration generator to maintain type definition files for IDE autocompletion. Its capab

Recast is a JavaScript AST parser and printer designed for automated code refactoring. It converts source code into abstract syntax trees that can be modified and then printed back into source code. The project focuses on formatting-preserving transformations, storing original whitespace and indentation metadata within syntax tree nodes to reconstruct code without losing its original layout. It also generates character-level source maps to maintain precise correspondences between original input and transformed output. The toolkit includes utilities for syntax tree manipulation using a visito

ts-morph is a TypeScript AST manipulation library and a high-level wrapper for the TypeScript compiler API. It provides a programmatic interface for analyzing, modifying, and generating TypeScript source code, serving as a tool for automated code refactoring and source code generation. The library simplifies the process of navigating and inspecting project structures by offering an object-oriented abstraction over the underlying compiler API. It allows for the programmatic transformation of existing codebases to automate structural updates and bulk code migrations. Its capabilities cover sta

This is a collection of official extensions for the Rollup bundling process. These plugins serve as module transformers, resolution managers, and bundle optimizers designed to modify how JavaScript modules are processed, resolved, and optimized. The suite provides specialized capabilities for modern web transpilation, converting TypeScript, JSX, Flow, and GraphQL into compatible JavaScript. It distinguishes itself through extensive non-JavaScript asset integration, allowing the import of JSON, YAML, CSV, and image files as JavaScript modules or data URIs, and providing support for bundling We

The Concise TypeScript Book: A Concise Guide to Effective Development in TypeScript. Free and Open Source.

gpt-migrate is an automated code migration tool that uses large language models to translate source code and project structures between different programming languages. It functions as an automated code translator that converts codebases across frameworks while mapping compatible third-party dependencies. The system includes a containerized code validator to ensure functional parity by executing unit tests within isolated environments. It also operates as an automated debugging agent that analyzes execution logs and edits source files to resolve bugs in the translated code. The tool covers c

Sucrase is a high-speed transpilation tool that compiles modern JavaScript, TypeScript, JSX, and Flow to standard JavaScript for modern runtimes. It operates as a fast alternative to Babel, using a single-pass scanner and tokenizer that strips type annotations and applies only requested syntax transforms without building an AST or performing type checking. The tool differentiates itself through a zero-type-checking pipeline that omits type checking entirely, relying on the assumption that input code is already valid for the target runtime. It uses scanner-based tokenization and single-pass co

GoGoCode is an AST-based code transformation toolkit that enables developers to query, match, and rewrite JavaScript source code using jQuery-style selectors and wildcard patterns. At its core, it provides a programmatic code refactoring library that manipulates parsed AST nodes, allowing precise structural modifications without worrying about formatting differences. The toolkit also functions as a JavaScript AST query engine, finding code patterns through snippet-based matching with wildcards that capture unknown or variable-length fragments. What distinguishes GoGoCode is its callback-drive

ZIO is a functional effect system for the JVM that models asynchronous and concurrent programs as pure, composable values with typed error handling and dependency injection. Its core identity is built on fiber-based concurrency, where lightweight, non-blocking fibers execute millions of concurrent tasks with structured lifecycle management, and a dual-channel error model that separates expected business failures from unexpected system defects at compile time. The system provides effect-typed dependency injection through a layer-based dependency graph, pull-based reactive stream processing with

Include What You Use is a C++ include optimizer and header dependency analyzer. It identifies unused or missing header includes in source files to reduce project bloat and improve compilation performance. The tool performs static analysis using a Clang-based abstract syntax tree to map symbol usage and track preprocessor effects across different build configurations. It can automatically rewrite source files by inserting or deleting preprocessor directives based on the calculated dependency graph. The system integrates with compilation databases to determine the exact compiler flags used for

Remark is a markdown processor that parses markdown text into a structured JSON abstract syntax tree for programmatic analysis and transformation. It functions as a markdown AST parser and processor, utilizing a plugin framework to manage extensible syntax and transformation rules. The project enables custom markdown syntax extensions and content transformation through a plugin system, allowing for the addition of non-standard markup and metadata. It also includes a markdown linter to identify style inconsistencies and ensure adherence to writing standards. The toolset covers markdown docume

This project is a collection of curated guidelines and manuals for writing clean, idiomatic, and maintainable code in Scala. It serves as a comprehensive guide for Scala coding standards, functional programming design, and enterprise software architecture. The repository provides specific strategies for concurrency management, including patterns for actors, futures, and thread pools to ensure thread safety. It also contains a performance optimization manual focused on reducing memory allocations and managing garbage collection pressure to improve runtime efficiency. The guides cover a broad

SVGR is a tool that transforms static SVG files into reusable React components for direct rendering within user interface trees. It functions as an AST-based code transformer and build-time asset pipeline, parsing SVG XML into an abstract syntax tree to modify elements before generating JavaScript source code. The project integrates an external optimization engine to strip redundant metadata and minify attributes, ensuring vector images are flexible and easy to style. It uses recursive tree traversal to apply these transformations to all nested graphic elements and employs attribute mapping t

Rebound is an automated error resolver and exception handling extension that maps runtime exceptions to external community knowledge bases. It functions as a search automation tool designed to surface community-driven error resolutions directly in the terminal when a software exception is thrown. The tool specifically integrates with Stack Overflow to automatically fetch relevant discussion threads and solutions during a program crash. It reduces manual searching by retrieving these community answers without requiring the developer to leave the command line interface. The system covers autom

Naive UI Admin is a Vue 3 admin dashboard framework built with TypeScript, Vite, and the Naive UI component library. It provides a pre-built backend management interface with reusable components, dynamic menus, and a component-level permission system that restricts UI elements down to individual components using directive-based checks and role-based access control. The framework enforces compile-time type safety across the entire codebase to reduce runtime errors and improve maintainability. The project distinguishes itself through a permission system that controls feature and UI element visi

Arrow is a functional programming library for Kotlin that provides tools for implementing data-oriented programming patterns. It serves as a framework for typed error handling, a concurrency toolkit, and a library for the manipulation of immutable data. The project distinguishes itself through specialized capabilities for managing application failures using explicit types instead of exceptions and implementing resilience patterns such as circuit breakers and retry policies for distributed services. It also provides optics to update and query deeply nested immutable data structures without man

Utopia is a development platform for building React components through a visual interface that synchronizes changes directly with underlying source code. It functions as an AST-based code editor and a visual component editor, using abstract syntax tree manipulation to update files while preserving the original formatting and structure. The project features an in-browser module bundler that compiles and executes JavaScript modules directly within the browser to provide immediate feedback without server-side build steps. It also includes a pull request preview tool for inspecting and validating

gpt-migrate is an automated system that uses large language models to translate source code between different programming languages and frameworks. It serves as a tool for language migration and code refactoring, transforming codebases while maintaining the original project structure. The project employs a containerized execution loop to run migrated code in isolated environments. It captures runtime stack traces and logs to automatically identify and fix errors through an iterative refinement cycle, modifying files until the application functions. To ensure functional parity, the system syn

Linaria is a zero-runtime CSS-in-JS library and static CSS generator. It evaluates JavaScript expressions at build time to extract styles from tagged template literals into standalone, static CSS files, removing the need for a runtime style injection engine. The library distinguishes itself by mapping component props to CSS custom properties, enabling dynamic styling and runtime property updates without regenerating stylesheets. It utilizes a build-time evaluation engine to resolve interpolations and a hashing system to generate scoped class names that prevent style collisions. The project c

This project is a collection of official toolsets and server implementations designed for the parsing, formatting, and semantic analysis of the Go programming language. It includes a language server that provides real-time code intelligence and automated editing capabilities to editors via the Language Server Protocol. The toolset provides a suite of utilities for source code formatting and static analysis. This includes automated standardization of code layout, import organization, and the generation of string representation methods for enumerated types. The project covers broad static anal

AST Explorer is a web-based tool for parsing source code into abstract syntax trees and visualizing the resulting tree structure. It serves as a code inspector and transformation playground, allowing users to explore the structural representation of various programming languages through an interactive browser interface. The tool provides a transformation environment where users can apply modification rules to parsed trees to test code modification logic. It features bidirectional mapping that highlights matching tree nodes and source text simultaneously as the cursor moves across the editor.

Prepack is a build-time code evaluator and JavaScript bundle optimizer. It functions as a static analysis compiler that pre-evaluates static code and precalculates function results and global assignments during the build phase to accelerate startup times and reduce bundle size. The project specifically targets JSX optimization by processing syntax and node serialization to improve user interface rendering efficiency. It utilizes a partial evaluation engine and static execution analysis to replace runtime computations with precalculated constants. The tool covers a range of capabilities inclu

ansible-lint is a static code analysis tool and linter designed to identify syntax errors and best practice violations within Ansible playbooks and roles. It functions as a quality gate for automation pipelines, scanning configuration files and scripts without executing the code to ensure reliability and consistency. The project distinguishes itself by acting as an automated code formatter that can correct identified linting issues and reformat files to meet community standards. It also serves as a dependency manager, automatically detecting and installing required roles and collections from