or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-management.mdcli-commands.mdindex.mdinitialization.mdutilities.md
tile.json

index.mddocs/

gts (Google TypeScript Style)

gts is Google's opinionated TypeScript style guide, formatter, and linter that provides zero-configuration setup for TypeScript projects. It integrates ESLint and Prettier to enforce consistent code style with automatic formatting, linting, and code fixing capabilities through both CLI commands and programmatic APIs.

Package Information

  • Package Name: gts
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install gts

Core Imports

For ESLint configuration:

const gtsConfig = require("gts");

For programmatic API (requires direct module imports):

import { run, Options, Logger, VerbFilesFunction } from "gts/build/src/cli";
import { init } from "gts/build/src/init";
import { clean } from "gts/build/src/clean";
import { addScripts, addDependencies, installDefaultTemplate } from "gts/build/src/init";
import { getTSConfig, isYarnUsed, getPkgManagerCommand, readJsonp } from "gts/build/src/util";

Basic Usage

CLI Usage

# Initialize gts in a TypeScript project
gts init

# Lint TypeScript files
gts lint

# Fix formatting and linting issues
gts fix

# Clean build artifacts
gts clean

Programmatic Usage

import { init } from "gts/build/src/init";
import { Options } from "gts/build/src/cli";

const options: Options = {
  dryRun: false,
  gtsRootDir: "/path/to/gts",
  targetRootDir: process.cwd(),
  yes: false,
  no: false,
  logger: console,
};

// Initialize gts programmatically
await init(options);

Architecture

gts is built around several key components:

  • CLI Interface: Main command-line tool providing init, lint, fix, and clean commands
  • ESLint Configuration: Pre-configured ESLint setup with TypeScript and Prettier integration
  • Project Initialization: Automated setup of package.json scripts, dependencies, and configuration files
  • Template System: Default TypeScript template with intentional style issues for demonstration
  • Utility Functions: Helper functions for package management, TypeScript configuration, and file operations

Capabilities

CLI Commands

Main command-line interface providing TypeScript project initialization, linting, fixing, and cleanup operations.

function run(verb: string, files: string[]): Promise<boolean>;

interface Options {
  dryRun: boolean;
  gtsRootDir: string;
  targetRootDir: string;
  yes: boolean;
  no: boolean;
  logger: Logger;
  yarn?: boolean;
}

interface Logger {
  log: (...args: Array<{}>) => void;
  error: (...args: Array<{}>) => void;
  dir: (obj: {}, options?: {}) => void;
}

CLI Commands

Project Initialization

Project setup functionality for adding gts configuration, scripts, and dependencies to TypeScript projects.

function init(options: Options): Promise<boolean>;

function addScripts(
  packageJson: PackageJSON,
  options: Options
): Promise<boolean>;

function addDependencies(
  packageJson: PackageJSON,
  options: Options
): Promise<boolean>;

Project Initialization

Build Management

Build artifact management and cleanup functionality.

function clean(options: Options): Promise<boolean>;

Build Management

Utility Functions

Helper functions for configuration management, package detection, and file operations.

function getTSConfig(
  rootDir: string,
  customReadFilep?: ReadFileP
): Promise<ConfigFile>;

function isYarnUsed(existsSync?: Function): boolean;

function getPkgManagerCommand(isYarnUsed?: boolean): string;

Utility Functions

Core Types

interface Options {
  dryRun: boolean;
  gtsRootDir: string;
  targetRootDir: string;
  yes: boolean;
  no: boolean;
  logger: Logger;
  yarn?: boolean;
}

interface Logger {
  log: (...args: Array<{}>) => void;
  error: (...args: Array<{}>) => void;
  dir: (obj: {}, options?: {}) => void;
}

interface ConfigFile {
  files?: string[];
  compilerOptions?: {};
  include?: string[];
  exclude?: string[];
  extends?: string[];
}

interface DefaultPackage {
  gts: string;
  typescript: string;
  '@types/node': string;
}

type VerbFilesFunction = (
  options: Options,
  files: string[],
  fix?: boolean
) => Promise<boolean>;

interface ReadFileP {
  (path: string, encoding: string): Promise<string>;
}

interface Bag<T> {
  [script: string]: T;
}

type PackageJSON = {
  name?: string;
  version?: string;
  description?: string;
  main?: string;
  types?: string;
  files?: string[];
  license?: string;
  keywords?: string[];
  scripts?: { [key: string]: string };
  devDependencies?: { [key: string]: string };
  dependencies?: { [key: string]: string };
  engines?: { [key: string]: string };
  [key: string]: any;
}