PluginBench
Skill
Pass
Audit score 90

ts-library

onmax/nuxt-skills

Author TypeScript libraries with dual CJS/ESM, type-safe APIs, and modern build tooling.

What is ts-library?

Comprehensive patterns for building high-quality TypeScript npm packages, covering project setup, package.json exports, build configuration (tsdown/unbuild), API design, advanced types, testing, and release workflows. Use when creating new libraries, configuring dual module formats, or setting up CI/CD pipelines.

  • Configure package.json exports for dual CJS/ESM output
  • Set up tsconfig and build tools (tsdown, unbuild)
  • Design type-safe APIs using builder, factory, and plugin patterns
  • Write advanced TypeScript types with proper inference
  • Configure vitest for library testing
  • Set up release workflows and CI/CD pipelines

How to install ts-library

npx skills add https://github.com/onmax/nuxt-skills --skill ts-library
Prerequisites
  • Node.js and pnpm/npm installed
  • Basic TypeScript knowledge
  • Understanding of CommonJS vs ESM modules
Claude Code
Cursor
Windsurf
Cline

How to use ts-library

  1. 1.Load project-setup.md to initialize your library structure
  2. 2.Configure package.json with proper exports and dual format support
  3. 3.Set up tsdown.config.ts or unbuild configuration for your build
  4. 4.Create tsconfig.json with moduleResolution: 'Bundler'
  5. 5.Add vitest configuration and write tests
  6. 6.Configure release workflow via references/release.md
  7. 7.Run pnpm build && pnpm pack --dry-run to verify output includes .mjs, .cjs, and .d.ts files

Use cases

Good for
  • Starting a new TypeScript library from scratch
  • Configuring dual CommonJS/ESM outputs for existing packages
  • Setting up build tooling and tsconfig for library development
  • Designing public APIs with type-safe patterns
  • Implementing advanced TypeScript type patterns
Who it's for
  • Library authors
  • npm package maintainers
  • TypeScript developers building reusable modules
  • Teams setting up monorepo library structures

ts-library FAQ

When should I use tsdown vs unbuild?

Use tsdown for most TypeScript libraries—it's simpler and faster. Use unbuild for complex cases with multiple entry points, custom transforms, or non-TypeScript assets.

How do I support both CommonJS and ESM consumers?

Set "type": "module" in package.json, configure tsdown with format: ['esm', 'cjs'], and define both import and require in package.json exports.

What does moduleResolution: 'Bundler' do?

It enables modern TypeScript resolution for bundlers, allowing proper tree-shaking and ESM-first development while maintaining backward compatibility.

How do I make my library tree-shakeable?

Use lazy getters, set "sideEffects": false in package.json, avoid top-level side effects, and structure exports to allow dead-code elimination.

Should I include dist/ in version control?

No—add dist/ to .gitignore and let CI build and publish. Include only source files in the repository.

Full instructions (SKILL.md)

Source of truth, from onmax/nuxt-skills.


name: ts-library description: Use when authoring TypeScript libraries or npm packages - covers project setup, package.json exports, build tooling (tsdown/unbuild), API design patterns, type inference tricks, testing, and publishing to npm. Use when bundling, configuring dual CJS/ESM output, or setting up release workflows. license: MIT

TypeScript Library Development

Patterns for authoring high-quality TypeScript libraries, extracted from studying unocss, shiki, unplugin, vite, vitest, vueuse, zod, trpc, drizzle-orm, and more.

When to Use

  • Starting a new TypeScript library (single or monorepo)
  • Setting up package.json exports for dual CJS/ESM
  • Configuring tsconfig for library development
  • Choosing build tools (tsdown, unbuild)
  • Designing type-safe APIs (builder, factory, plugin patterns)
  • Writing advanced TypeScript types
  • Setting up vitest for library testing
  • Configuring release workflow and CI

For Nuxt module development: use nuxt-modules skill

Quick Reference

Working on...Load file
New project setupreferences/project-setup.md
Package exportsreferences/package-exports.md
tsconfig optionsreferences/typescript-config.md
Build configurationreferences/build-tooling.md
ESLint configreferences/eslint-config.md
API design patternsreferences/api-design.md
Type inference tricksreferences/type-patterns.md
Testing setupreferences/testing.md
Release workflowreferences/release.md
CI/CD setupreferences/ci-workflows.md

Loading Files

Consider loading these reference files based on your task:

DO NOT load all files at once. Load only what's relevant to your current task.

New Library Workflow

  1. Create project structure → load references/project-setup.md
  2. Configure package.json exports → load references/package-exports.md
  3. Set up build with tsdown → load references/build-tooling.md
  4. Verify build: pnpm build && pnpm pack --dry-run — check output includes .mjs, .cjs, .d.ts
  5. Add tests → load references/testing.md
  6. Configure release → load references/release.md

Quick Start

// package.json (minimal)
{
  "name": "my-lib",
  "type": "module",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.cjs"
    }
  },
  "main": "./dist/index.cjs",
  "module": "./dist/index.mjs",
  "types": "./dist/index.d.ts",
  "files": ["dist"]
}
// tsdown.config.ts
import { defineConfig } from 'tsdown'

export default defineConfig({
  entry: ['src/index.ts'],
  format: ['esm', 'cjs'],
  dts: true,
})

Key Principles

  • ESM-first: "type": "module" with .mjs outputs
  • Dual format: always support both CJS and ESM consumers
  • moduleResolution: "Bundler" for modern TypeScript
  • tsdown for most builds, unbuild for complex cases
  • Smart defaults: detect environment, don't force config
  • Tree-shakeable: lazy getters, proper sideEffects: false

Token efficiency: Main skill ~300 tokens, each reference ~800-1200 tokens