tsnite 0.1.2 → 0.1.5

package/README.md

@@ -5,63 +5,163 @@
 [![prettier](https://img.shields.io/badge/Prettier-de9954?logo=prettier&logoColor=ffffff)](https://img.shields.io/badge/Prettier-de9954?logo=prettier&logoColor=ffffff)
 [![github license](https://img.shields.io/github/license/luas10c/tsnite)](https://img.shields.io/github/license/luas10c/tsnite)
 
-```
-TypeScript at full throttle—fast, safe, unstoppable. 🚀
+TypeScript runner for Node.js with watch mode, `tsconfig` path alias support, and extensionless TypeScript import resolution.
+
+## Install
+
+```bash
+npm install --save-dev tsnite
 ```
 
-`tsnite` is a tool that accelerates TypeScript project development, offering a streamlined build and run experience. Ideal for developers seeking productivity without compromising security and performance.
+## Usage
 
-### 🚀 Installation
+Run a TypeScript entry file:
 
-To add `tsnite` to your project as a development dependency, run:
+```bash
+npx tsnite src/index.ts
+```
+
+Run in watch mode:
 
 ```bash
-npm install tsnite -D
+npx tsnite watch src/index.ts
 ```
 
-Or, if you're using Yarn:
+Pass extra Node.js arguments after the entry file:
 
 ```bash
-yarn add --dev tsnite
+npx tsnite src/index.ts --env-file=.env
+```
+
+Use in `package.json`:
+
+```json
+{
+  "scripts": {
+    "dev": "tsnite src/index.ts",
+    "dev:watch": "tsnite watch src/index.ts"
+  }
+}
 ```
 
-### ⚡ Features
+## Features
 
-- **Decorators** first-class support for TypeScript decorators.
-- **Simple integration** with existing projects.
-- **ESM Support** native support for modern JavaScript modules.
-- **Automatic `tsconfig.json` loading** – respects your project configuration.
+- Run `.ts`, `.tsx`, `.mts`, and `.cts` files directly in Node.js
+- Watch mode with automatic restart
+- Reads the current project's `tsconfig.json`
+- Resolves `compilerOptions.paths`
+- Resolves extensionless TypeScript imports
+- ESM-friendly runtime
+- Decorator support in transpilation
 
-### 🛠️ How to use
+## Import Resolution
 
-With `tsnite` installed, you can use it directly in your terminal to run TypeScript files without needing to compile them first.
+`tsnite` resolves TypeScript files without requiring explicit extensions.
 
-### Run a TypeScript file
+These imports work:
+
+```ts
+import './server'
+import './components/App'
+```
+
+It will try these TypeScript candidates:
+
+- `./server.ts`
+- `./server.tsx`
+- `./server.mts`
+- `./server.cts`
+- `./server/index.ts`
+- `./server/index.tsx`
+- `./server/index.mts`
+- `./server/index.cts`
+
+Explicit JavaScript imports such as `.js`, `.mjs`, and `.cjs` are delegated to Node.js.
+
+## `tsconfig` Paths
+
+`tsnite` supports `compilerOptions.paths` aliases.
+
+```json
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "#/*": ["src/*"]
+    }
+  }
+}
+```
+
+Then this works without an extension:
+
+```ts
+import { getMetadata } from '#/common/metadata'
+```
+
+If `baseUrl` is not defined, `tsnite` uses the project root by default.
+
+## Watch Mode
+
+Customize watched paths and extensions:
 
 ```bash
-npx tsnite path/to/file.ts
+npx tsnite watch --include src --exclude dist,coverage,uploads --ext ts,tsx,js,jsx,json src/index.ts
 ```
 
-This will execute the specified TypeScript file, allowing you to quickly test and run scripts during development.
+Options:
+
+- `--include <paths>` comma-separated paths to watch
+- `--exclude <paths>` comma-separated paths to ignore
+- `--ext <extensions>` comma-separated file extensions to watch
+- `--source-root <path>` base path used by the watcher
+
+Defaults:
+
+- include: `.`
+- exclude: `node_modules,.git,dist,build,coverage`
+- ext: `ts,tsx,js,jsx,json`
+- source root: `.`
 
-## 💡 Tips & Best Practices
+## Example
 
-- **Use with `package.json` scripts** – integrate `tsnite` into `npm` or `yarn` scripts for a smoother workflow.
-  Example:
-  ```json
-  {
-    "scripts": {
-      //...
-      "dev": "tsnite watch --include src --exclude uploads --ext js,ts,json src/index.ts"
+`tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "module": "es2022",
+    "moduleResolution": "bundler",
+    "baseUrl": ".",
+    "paths": {
+      "#/*": ["src/*"]
     }
   }
-  ```
+}
+```
+
+`src/index.ts`
+
+```ts
+import { startServer } from '#/server/start'
+
+await startServer()
+```
+
+Run it:
+
+```bash
+npx tsnite src/index.ts
+```
 
-## 📚 More information
+## Notes
 
-Check the official npm page for details, examples, and updates:
-[https://www.npmjs.com/package/tsnite](https://www.npmjs.com/package/tsnite)
+- `tsnite` is focused on development-time execution
+- the current project's `tsconfig.json` is used
+- watch mode clears cached resolution and transpilation state before restart
 
-#
+## Links
 
-Enjoy developing TypeScript at full throttle!
+- npm: <https://www.npmjs.com/package/tsnite>
+- repository: <https://github.com/luas10c/tsnite>

package/dist/cache.js

@@ -1,13 +1,13 @@
 import { createHash } from 'node:crypto';
 import { mkdir, rm, stat } from 'node:fs/promises';
-import path from 'node:path';
+import { join, resolve } from 'node:path';
 export const resolveCache = new Map();
 const statCache = new Map();
 function getTranspileCacheDir() {
-    return path.join(process.cwd(), 'node_modules', '.cache', 'tsnite');
+    return join(import.meta.dirname, '..', 'node_modules', '.cache', 'tsnite');
 }
 function getTSConfigPath() {
-    return path.join(process.cwd(), 'tsconfig.json');
+    return join(import.meta.dirname, '..', 'tsconfig.json');
 }
 function hash(value) {
     return createHash('sha1').update(value).digest('hex');
@@ -34,7 +34,7 @@ export function invalidateStatCache(filePath) {
     statCache.delete(filePath);
 }
 export function getTranspileCacheFile(filePath) {
-    return path.join(getTranspileCacheDir(), `${hash(filePath)}.json`);
+    return join(getTranspileCacheDir(), `${hash(filePath)}.json`);
 }
 export async function ensureTranspileCacheDir() {
     await mkdir(getTranspileCacheDir(), { recursive: true });
@@ -43,7 +43,7 @@ export async function clearTranspileCache() {
     await rm(getTranspileCacheDir(), { recursive: true, force: true });
 }
 export function isTSConfigPath(filePath) {
-    return path.resolve(filePath) === getTSConfigPath();
+    return resolve(filePath) === getTSConfigPath();
 }
 export async function invalidateFileCaches(filePath) {
     invalidateStatCache(filePath);

package/dist/cli.js

@@ -38,7 +38,8 @@ process.on('SIGTERM', function () {
     cleanup('SIGTERM');
 });
 function spawn(entry, nodeArgs) {
-    const child = fork(join(process.cwd(), entry), {
+    const entryPath = isAbsolute(entry) ? entry : resolve(process.cwd(), entry);
+    const child = fork(entryPath, {
         stdio: 'inherit',
         execArgv: [
             '--enable-source-maps',
@@ -130,6 +131,7 @@ function createWatchConfig(options) {
     };
 }
 async function handler(entry, options, nodeArgs, isWatch) {
+    const runtimeEntry = isAbsolute(entry) ? entry : resolve(process.cwd(), entry);
     async function restart(reason) {
         process.stdout.write('\x1Bc');
         if (reason) {
@@ -154,14 +156,14 @@ async function handler(entry, options, nodeArgs, isWatch) {
             }
         }
         clearResolveCache();
-        spawn(entry, nodeArgs);
+        spawn(runtimeEntry, nodeArgs);
     }
     const restartDebounced = debounce(restart, WATCH_DEBOUNCE_MS);
     process.stdout.write('\x1Bc');
     if (isWatch) {
         console.log(yellow('Watching for changes...'));
     }
-    spawn(entry, nodeArgs);
+    spawn(runtimeEntry, nodeArgs);
     if (!isWatch)
         return;
     const { ignored, paths } = createWatchConfig(options);

package/dist/loader.js

@@ -4,7 +4,7 @@ import { readFile, stat, writeFile } from 'node:fs/promises';
 import { extname, join, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { parse } from './parse.js';
-import { clearTranspileCache, ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
+import { ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
 const tsconfigCache = { paths: null, baseUrl: null };
 const transpileCache = new Map();
 const MAX_TRANSPILE_CACHE_ENTRIES = 256;
@@ -16,6 +16,57 @@ function isTypeScriptSpecifier(specifier) {
     const extension = extname(specifier);
     return extension === '' || hasTypeScriptExtension(extension);
 }
+function getTypeScriptTryFiles(basePath) {
+    return [
+        basePath,
+        ...TS_EXTENSIONS.map((extension) => basePath + extension),
+        ...TS_EXTENSIONS.map((extension) => join(basePath, 'index' + extension))
+    ];
+}
+async function resolveTypeScriptFile(basePath) {
+    for (const file of getTypeScriptTryFiles(basePath)) {
+        if (await existsWithCache(file)) {
+            return file;
+        }
+    }
+    return null;
+}
+function matchPathPattern(specifier, pattern) {
+    const starIndex = pattern.indexOf('*');
+    if (starIndex === -1) {
+        return specifier === pattern ? [] : null;
+    }
+    const prefix = pattern.slice(0, starIndex);
+    const suffix = pattern.slice(starIndex + 1);
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) {
+        return null;
+    }
+    return [specifier.slice(prefix.length, specifier.length - suffix.length)];
+}
+function applyPathMapping(target, matches) {
+    let mapped = target;
+    for (const match of matches) {
+        mapped = mapped.replace('*', match);
+    }
+    return mapped;
+}
+async function resolveTsConfigPath(specifier, paths, baseUrl) {
+    if (!paths || !baseUrl || !isTypeScriptSpecifier(specifier)) {
+        return null;
+    }
+    for (const [pattern, targets] of Object.entries(paths)) {
+        const matches = matchPathPattern(specifier, pattern);
+        if (!matches)
+            continue;
+        for (const target of targets) {
+            const mappedTarget = applyPathMapping(target, matches);
+            const resolved = await resolveTypeScriptFile(join(baseUrl, mappedTarget));
+            if (resolved)
+                return resolved;
+        }
+    }
+    return null;
+}
 function hash(value) {
     return createHash('sha1').update(value).digest('hex');
 }
@@ -76,24 +127,33 @@ async function loadTSConfig() {
         return tsconfigCache;
     }
     try {
-        const data = await readFile(join(import.meta.dirname, '..', 'tsconfig.json'), 'utf-8');
+        const data = await readFile(join(process.cwd(), 'tsconfig.json'), 'utf-8');
         const { compilerOptions } = parse(data);
         const paths = compilerOptions?.paths ?? null;
         const baseUrl = compilerOptions?.baseUrl;
         tsconfigCache.paths = paths || null;
         tsconfigCache.baseUrl =
-            baseUrl ?
-                join(import.meta.dirname, '..', baseUrl)
-                : join(import.meta.dirname, '..');
+            baseUrl ? join(process.cwd(), baseUrl) : process.cwd();
         return tsconfigCache;
     }
     catch {
         tsconfigCache.paths = null;
-        tsconfigCache.baseUrl = join(import.meta.dirname, '..');
+        tsconfigCache.baseUrl = process.cwd();
         return tsconfigCache;
     }
 }
 export async function resolve(specifier, ctx, next) {
+    const { paths, baseUrl } = await loadTSConfig();
+    const resolvedTsConfigPath = await resolveTsConfigPath(specifier, paths, baseUrl);
+    if (resolvedTsConfigPath) {
+        const url = pathToFileURL(resolvedTsConfigPath).href;
+        resolveCache.set(`${ctx.parentURL}::${specifier}`, url);
+        return {
+            url,
+            format: 'module',
+            shortCircuit: true
+        };
+    }
     if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
         return next(specifier, ctx);
     }
@@ -153,7 +213,10 @@ export async function load(url, ctx, next) {
     const { paths, baseUrl } = await loadTSConfig();
     const filename = fileURLToPath(url);
     const fileStats = await stat(filename);
-    const configHash = hash(JSON.stringify({ baseUrl: baseUrl || process.cwd(), paths: paths ?? {} }));
+    const configHash = hash(JSON.stringify({
+        baseUrl: baseUrl || process.cwd(),
+        paths: paths ?? {}
+    }));
     const cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, configHash);
     if (cachedCode !== null) {
         return { format: 'module', source: cachedCode, shortCircuit: true };
@@ -198,12 +261,3 @@ export async function load(url, ctx, next) {
     });
     return { format: 'module', source: code, shortCircuit: true };
 }
-export async function resetLoaderState(options) {
-    tsconfigCache.paths = null;
-    tsconfigCache.baseUrl = null;
-    transpileCache.clear();
-    resolveCache.clear();
-    if (!options?.preserveTranspileCache) {
-        await clearTranspileCache();
-    }
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "keywords": [
     "cli",
     "esm",