jiti

What is jiti?

The jiti npm package is a runtime TypeScript and ES Module (ESM) loader that allows you to import TypeScript files, ESM, or JSON modules dynamically in a Node.js environment without the need for prior compilation. It is designed to be a zero-config, drop-in replacement for dynamic imports and require calls, providing just-in-time transpilation of code.

What are jiti's main functionalities?

Dynamic Import of TypeScript Files

This feature allows you to dynamically import TypeScript files at runtime. The jiti function is called with the current filename to create a context, and then it is used to import a TypeScript module, which is transpiled just-in-time.

const jiti = require('jiti')(__filename)
const myModule = jiti('./my-module.ts')

Dynamic Import of ESM

With this feature, jiti can dynamically import ES Module files. The 'esmResolve' option enables proper resolution of ESM modules, allowing them to be loaded at runtime without prior compilation.

const jiti = require('jiti')(__filename, { esmResolve: true })
const myESMModule = jiti('./my-esm-module.mjs')

Dynamic Import of JSON Modules

This feature enables the dynamic import of JSON modules. By using jiti, you can load JSON files at runtime, which can be useful for configuration files or other data that needs to be imported into your application.

const jiti = require('jiti')(__filename)
const config = jiti('./config.json')

Other packages similar to jiti

esbuild-register

esbuild-register is a package that uses the esbuild bundler to transpile TypeScript and modern JavaScript on the fly for Node.js. It is similar to jiti in that it allows just-in-time transpilation, but it leverages the fast esbuild compiler.

ts-node

ts-node is a TypeScript execution engine and REPL for Node.js. It provides on-the-fly transpilation of TypeScript into JavaScript, allowing developers to execute TypeScript directly without pre-compilation. ts-node is widely used and has more configuration options compared to jiti.

babel-register

babel-register is a Babel hook that transpiles files on the fly when they are required. It is similar to jiti in providing just-in-time transpilation, but it uses Babel, which has a wide range of plugins and is highly configurable.

README

jiti

Runtime typescript and ESM support for Node.js (CommonJS)

Features

• Seamless typescript and ESM syntax support
• Seamless interoperability between ESM and CommonJS
• Synchronous API to replace require
• Super slim and zero dependency
• Smart syntax detection to avoid extra transforms
• CommonJS cache integration
• Filesystem transpile hard cache
• V8 compile cache

Usage

Programmatic

const jiti = require('jiti')(__filename)

jiti('./path/to/file.ts')

You can also pass options as second argument:

const jiti = require('jiti')(__filename, { debug: true })

CLI

jiti index.ts
# or npx jiti index.ts

Register require hook

node -r jiti/register index.ts

Alternatively, you can register jiti as a require hook programmatically:

const jiti = require('jiti')()
const unregister = jiti.register()

Options

debug

• Type: Boolean
• Default: false
• Environment Variable: JITI_DEBUG

Enable debug to see which files are transpiled

cache

• Type: Boolean | String
• Default: true
• Environment Vriable: JITI_CACHE

Use transpile cache

If set to true will use node_modules/.cache/jiti (if exists) or {TMP_DIR}/node-jiti

transform

• Type: Function
• Default: Babel (lazy loaded)

Transform function. See src/babel for more details

Development

• Clone Repo
• Run yarn
• Run yarn build
• Run yarn dev
• Run yarn jiti ./test/path/to/file.ts

License

MIT. Made with 💖