CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-jiti

Runtime TypeScript and ESM support for Node.js with seamless interoperability between ESM and CommonJS.

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

jiti

jiti provides seamless runtime TypeScript and ESM support for Node.js with zero configuration. It enables importing TypeScript files directly in Node.js applications without a build step, offering both asynchronous and synchronous APIs for maximum compatibility between ESM and CommonJS modules.

Package Information

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

Core Imports

import { createJiti } from "jiti";
// or default import (deprecated)
import createJiti from "jiti";

For CommonJS:

const { createJiti } = require("jiti");
// or default import (deprecated)
const createJiti = require("jiti");

Basic Usage

import { createJiti } from "jiti";

// Create a jiti instance
const jiti = createJiti(import.meta.url);

// Import TypeScript files asynchronously (recommended)
const config = await jiti.import("./config.ts");
const utils = await jiti.import("./utils.ts", { default: true }); // Get default export

// Resolve module paths with ESM conditions
const resolved = jiti.esmResolve("./some-module");

For CommonJS (deprecated but supported):

const { createJiti } = require("jiti");

const jiti = createJiti(__filename);

// Synchronous import (deprecated)
const config = jiti("./config.ts");

Architecture

jiti is built around several key components:

  • Instance Creation: createJiti() creates configured instances with custom options
  • Async Import API: Modern import() style API for loading modules with TypeScript support
  • Transform Engine: Babel-based transformation for TypeScript, JSX, and ESM syntax
  • Cache System: Filesystem and memory caching for optimal performance
  • Resolution System: Smart module resolution with alias support and ESM/CommonJS interoperability
  • ESM Loader: Global Node.js loader registration for automatic TypeScript support
  • Native Mode: Lightweight mode using runtime import.meta.resolve and dynamic import()

Capabilities

Instance Creation and Configuration

Core jiti instance creation with comprehensive configuration options for caching, transformation, and module handling.

function createJiti(id: string, userOptions?: JitiOptions): Jiti;

interface JitiOptions {
  fsCache?: boolean | string;
  rebuildFsCache?: boolean;
  moduleCache?: boolean;
  debug?: boolean;
  sourceMaps?: boolean;
  interopDefault?: boolean;
  extensions?: string[];
  alias?: Record<string, string>;
  nativeModules?: string[];
  transformModules?: string[];
  jsx?: boolean | JSXOptions;
  tryNative?: boolean;
}

Instance Creation and Configuration

Module Import and Resolution

Modern asynchronous module importing with TypeScript support and advanced resolution capabilities.

interface Jiti {
  import<T>(
    id: string,
    opts?: JitiResolveOptions & { default?: true }
  ): Promise<T>;
  
  esmResolve(id: string, opts?: JitiResolveOptions): string;
}

interface JitiResolveOptions {
  conditions?: string[];
  parentURL?: string | URL;
  try?: boolean;
}

Module Import and Resolution

Source Code Transformation

Babel-based source code transformation for TypeScript, JSX, and ESM syntax with comprehensive options.

interface Jiti {
  transform(opts: TransformOptions): string;
  evalModule(source: string, options?: EvalModuleOptions): unknown;
}

interface TransformOptions {
  source: string;
  filename?: string;
  ts?: boolean;
  retainLines?: boolean;
  interopDefault?: boolean;
  async?: boolean;
  jsx?: boolean | JSXOptions;
  babel?: Record<string, any>;
}

interface TransformResult {
  code: string;
  error?: any;
}

Source Code Transformation

Global Registration and ESM Loader

Global ESM loader registration and native runtime mode for seamless TypeScript support across Node.js applications.

// Import for global registration
import "jiti/register";

// Native mode with limited API
import { createJiti } from "jiti/native";

Global Registration and ESM Loader

CLI Tool

Command-line interface for directly executing TypeScript files with full jiti transformation support.

# CLI usage
jiti <path> [...arguments]

CLI Tool

Legacy API (Deprecated)

interface Jiti extends NodeRequire {
  // Deprecated synchronous import
  (id: string): any;
  
  // Deprecated CommonJS resolution
  resolve: {
    (id: string, options?: { paths?: string[] }): string;
    paths(request: string): string[] | null;
  };
  
  // Deprecated CommonJS properties
  cache: ModuleCache;
  extensions: Record<string, Function>;
  main: NodeModule | undefined;
}

Note: Synchronous APIs are deprecated. Use await jiti.import() instead of jiti() for better compatibility.

Types

interface JSXOptions {
  throwIfNamespace?: boolean;
  runtime?: "classic" | "automatic";
  importSource?: string;
  pragma?: string;
  pragmaFrag?: string;
  useBuiltIns?: boolean;
  useSpread?: boolean;
}

interface EvalModuleOptions {
  id?: string;
  filename?: string;
  ext?: string;
  cache?: ModuleCache;
  async?: boolean;
  forceTranspile?: boolean;
}

interface NodeModule {
  isPreloading: boolean;
  exports: any;
  require: NodeRequire;
  id: string;
  filename: string;
  loaded: boolean;
  parent: NodeModule | null | undefined;
  children: NodeModule[];
  path: string;
  paths: string[];
}

type ModuleCache = Record<string, NodeModule>;
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/jiti@2.5.x
Publish Source
CLI
Badge
tessl/npm-jiti badge