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

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

jiti

Name: tessl/npm-jiti
Author: tessl

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>;