tsnite 0.1.0 → 0.1.1

package/dist/cache.js

@@ -1,17 +1,61 @@
-import { stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { mkdir, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
 export const resolveCache = new Map();
 const statCache = new Map();
+function getTranspileCacheDir() {
+    return path.join(process.cwd(), 'node_modules', '.cache', 'tsnite');
+}
+function getTSConfigPath() {
+    return path.join(process.cwd(), 'tsconfig.json');
+}
+function hash(value) {
+    return createHash('sha1').update(value).digest('hex');
+}
 export async function existsWithCache(filePath) {
     const cached = statCache.get(filePath);
     if (cached)
         return cached.exists;
     try {
         const stats = await stat(filePath);
-        statCache.set(filePath, { exists: true, mtime: stats.mtimeMs });
-        return true;
+        const exists = stats.isFile();
+        statCache.set(filePath, { exists, mtime: stats.mtimeMs });
+        return exists;
     }
     catch {
         statCache.set(filePath, { exists: false });
         return false;
     }
 }
+export function clearResolveCache() {
+    resolveCache.clear();
+}
+export function invalidateStatCache(filePath) {
+    statCache.delete(filePath);
+}
+export function getTranspileCacheFile(filePath) {
+    return path.join(getTranspileCacheDir(), `${hash(filePath)}.json`);
+}
+export async function ensureTranspileCacheDir() {
+    await mkdir(getTranspileCacheDir(), { recursive: true });
+}
+export async function clearTranspileCache() {
+    await rm(getTranspileCacheDir(), { recursive: true, force: true });
+}
+export function isTSConfigPath(filePath) {
+    return path.resolve(filePath) === getTSConfigPath();
+}
+export async function invalidateFileCaches(filePath) {
+    invalidateStatCache(filePath);
+    clearResolveCache();
+    if (isTSConfigPath(filePath)) {
+        await clearTranspileCache();
+        return;
+    }
+    try {
+        await rm(getTranspileCacheFile(filePath), { force: true });
+    }
+    catch {
+        // Ignore cache eviction failures during watch restarts.
+    }
+}

package/dist/cli.js

@@ -1,24 +1,29 @@
 #!/usr/bin/env node
 import { program } from 'commander';
-import { extname, join, relative } from 'node:path';
+import { extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { fork } from 'node:child_process';
 import { watch } from 'chokidar';
 import { name, description, version } from './metadata.js';
+import { clearResolveCache, invalidateFileCaches } from './cache.js';
+import { debounce, yellow } from './util.js';
 const DEFAULT_INCLUDE_PATHS = ['.'];
 const DEFAULT_EXCLUDE_PATHS = ['dist', 'build', 'coverage'];
 const DEFAULT_WATCH_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'json'];
 const INTERNAL_IGNORED_PATHS = ['node_modules', '.git'];
-const pids = new Set();
+const WATCH_DEBOUNCE_MS = 100;
+const CHILD_EXIT_TIMEOUT_MS = 300;
+const children = new Set();
 program
     .name(name)
     .description(description)
     .version(version, '-v, --version', 'Output the current version')
     .showSuggestionAfterError();
-function cleanup() {
-    for (const pid of pids.values()) {
+function cleanup(signal) {
+    process.stdout.write(`${yellow(`Received ${signal}. Stopping watcher and child processes...`)}\n`);
+    for (const child of children.values()) {
         try {
-            process.kill(pid, 'SIGTERM');
+            child.kill('SIGTERM');
         }
         catch {
             //
@@ -26,10 +31,14 @@ function cleanup() {
     }
     process.exit(0);
 }
-process.on('SIGINT', cleanup);
-process.on('SIGTERM', cleanup);
+process.on('SIGINT', function () {
+    cleanup('SIGINT');
+});
+process.on('SIGTERM', function () {
+    cleanup('SIGTERM');
+});
 function spawn(entry, nodeArgs) {
-    const { pid } = fork(join(process.cwd(), entry), {
+    const child = fork(join(process.cwd(), entry), {
         stdio: 'inherit',
         execArgv: [
             '--enable-source-maps',
@@ -39,8 +48,25 @@ function spawn(entry, nodeArgs) {
             ...nodeArgs
         ]
     });
-    if (pid)
-        pids.add(pid);
+    children.add(child);
+    child.once('exit', function () {
+        children.delete(child);
+    });
+}
+async function waitForChildExit(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return true;
+    return await new Promise(function (resolve) {
+        const timeout = setTimeout(function () {
+            child.off('exit', handleExit);
+            resolve(false);
+        }, CHILD_EXIT_TIMEOUT_MS);
+        function handleExit() {
+            clearTimeout(timeout);
+            resolve(true);
+        }
+        child.once('exit', handleExit);
+    });
 }
 function normalizePath(value) {
     return value
@@ -51,11 +77,25 @@ function normalizePath(value) {
 function normalizeExt(value) {
     return value.trim().replace(/^\./, '').toLowerCase();
 }
+function hasIgnoredSegment(filePath, ignoredSegments) {
+    let start = 0;
+    for (let index = 0; index <= filePath.length; index++) {
+        if (index !== filePath.length && filePath[index] !== '/')
+            continue;
+        if (ignoredSegments.has(filePath.slice(start, index)))
+            return true;
+        start = index + 1;
+    }
+    return false;
+}
 function createWatchConfig(options) {
     const includePaths = options.include.map((value) => join(options.sourceRoot, value));
     const excludePaths = options.exclude.map(normalizePath).filter(Boolean);
-    const excludeSet = new Set(excludePaths);
+    const excludedExactPaths = new Set(excludePaths);
+    const excludedSegments = new Set(excludePaths.filter((value) => !value.includes('/')));
+    const excludedPrefixes = excludePaths.map((value) => value + '/');
     const allowedExts = new Set(options.ext.map(normalizeExt).filter(Boolean));
+    const internalIgnoredSegments = new Set(INTERNAL_IGNORED_PATHS);
     function toRelativeFromRoot(sourceRoot, filePath) {
         const rel = normalizePath(relative(sourceRoot, filePath));
         return rel === '' ? '.' : rel;
@@ -66,14 +106,16 @@ function createWatchConfig(options) {
             return true;
         if (rel === '.')
             return false;
-        const segments = rel.split('/');
-        if (segments.some((segment) => INTERNAL_IGNORED_PATHS.includes(segment)))
+        if (hasIgnoredSegment(rel, internalIgnoredSegments))
             return true;
-        if (segments.some((segment) => excludeSet.has(segment)))
+        if (hasIgnoredSegment(rel, excludedSegments))
             return true;
-        const isExcludedByPath = excludePaths.some((excluded) => rel === excluded || rel.startsWith(excluded + '/'));
-        if (isExcludedByPath)
+        if (excludedExactPaths.has(rel))
             return true;
+        for (const excludedPrefix of excludedPrefixes) {
+            if (rel.startsWith(excludedPrefix))
+                return true;
+        }
         if (!stats || stats.isDirectory())
             return false;
         const extension = extname(rel).slice(1).toLowerCase();
@@ -88,7 +130,37 @@ function createWatchConfig(options) {
     };
 }
 async function handler(entry, options, nodeArgs, isWatch) {
+    async function restart(reason) {
+        process.stdout.write('\x1Bc');
+        if (reason) {
+            console.log(yellow(reason));
+        }
+        for (const child of children.values()) {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                continue;
+            }
+            const exited = await waitForChildExit(child);
+            if (exited)
+                continue;
+            console.log(yellow(`${reason ?? 'Restart requested.'} Process hasn't exited. Killing process...`));
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                //
+            }
+        }
+        clearResolveCache();
+        spawn(entry, nodeArgs);
+    }
+    const restartDebounced = debounce(restart, WATCH_DEBOUNCE_MS);
     process.stdout.write('\x1Bc');
+    if (isWatch) {
+        console.log(yellow('Watching for changes...'));
+    }
     spawn(entry, nodeArgs);
     if (!isWatch)
         return;
@@ -98,18 +170,14 @@ async function handler(entry, options, nodeArgs, isWatch) {
         ignoreInitial: true,
         ignored
     });
-    watcher.on('change', async function () {
-        process.stdout.write('\x1Bc');
-        for (const pid of pids.values()) {
-            try {
-                process.kill(pid);
-            }
-            catch {
-                //
-            }
+    watcher.on('all', async function (eventName, changedPath) {
+        if (eventName !== 'change' &&
+            eventName !== 'add' &&
+            eventName !== 'unlink') {
+            return;
         }
-        pids.clear();
-        spawn(entry, nodeArgs);
+        await invalidateFileCaches(isAbsolute(changedPath) ? changedPath : (resolve(process.cwd(), changedPath)));
+        restartDebounced(`Change detected (${eventName}): ${changedPath}`);
     });
 }
 function parseCsv(value) {

package/dist/loader.js

@@ -1,19 +1,81 @@
 import { transformFile } from '@swc/core';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { parse } from './parse.js';
-import { resolveCache, existsWithCache } from './cache.js';
+import { clearTranspileCache, ensureTranspileCacheDir, existsWithCache, getTranspileCacheFile, resolveCache } from './cache.js';
 const tsconfigCache = { paths: null, baseUrl: null };
+const transpileCache = new Map();
+const MAX_TRANSPILE_CACHE_ENTRIES = 256;
+const TS_SOURCE_RE = /\.(cts|mts|tsx|ts)$/;
+function hash(value) {
+    return createHash('sha1').update(value).digest('hex');
+}
+function getMemoryCachedTranspile(filename, mtimeMs, size, configHash) {
+    const memoryCached = transpileCache.get(filename);
+    if (!memoryCached ||
+        memoryCached.mtimeMs !== mtimeMs ||
+        memoryCached.size !== size ||
+        memoryCached.configHash !== configHash) {
+        return null;
+    }
+    transpileCache.delete(filename);
+    transpileCache.set(filename, memoryCached);
+    return memoryCached.code;
+}
+function setMemoryCachedTranspile(filename, entry) {
+    if (transpileCache.has(filename)) {
+        transpileCache.delete(filename);
+    }
+    transpileCache.set(filename, entry);
+    if (transpileCache.size <= MAX_TRANSPILE_CACHE_ENTRIES)
+        return;
+    const oldestKey = transpileCache.keys().next().value;
+    if (oldestKey)
+        transpileCache.delete(oldestKey);
+}
+async function readCachedTranspile(filename, mtimeMs, size, configHash) {
+    const memoryCached = getMemoryCachedTranspile(filename, mtimeMs, size, configHash);
+    if (memoryCached !== null)
+        return memoryCached;
+    try {
+        const raw = await readFile(getTranspileCacheFile(filename), 'utf8');
+        const diskCached = JSON.parse(raw);
+        if (diskCached.mtimeMs !== mtimeMs ||
+            diskCached.size !== size ||
+            diskCached.configHash !== configHash) {
+            return null;
+        }
+        setMemoryCachedTranspile(filename, diskCached);
+        return diskCached.code;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCachedTranspile(filename, entry) {
+    setMemoryCachedTranspile(filename, entry);
+    try {
+        await ensureTranspileCacheDir();
+        await writeFile(getTranspileCacheFile(filename), JSON.stringify(entry));
+    }
+    catch {
+        // Ignore cache write failures and continue with fresh output.
+    }
+}
 async function loadTSConfig() {
     if (tsconfigCache.paths !== null && tsconfigCache.baseUrl !== null) {
         return tsconfigCache;
     }
     try {
         const data = await readFile(path.join(process.cwd(), 'tsconfig.json'), 'utf-8');
-        const { compilerOptions: { paths, baseUrl } } = parse(data);
+        const { compilerOptions } = parse(data);
+        const paths = compilerOptions?.paths ?? null;
+        const baseUrl = compilerOptions?.baseUrl;
         tsconfigCache.paths = paths || null;
-        tsconfigCache.baseUrl = path.join(process.cwd(), baseUrl) || process.cwd();
+        tsconfigCache.baseUrl =
+            baseUrl ? path.resolve(process.cwd(), baseUrl) : process.cwd();
         return tsconfigCache;
     }
     catch {
@@ -28,7 +90,10 @@ export async function resolve(specifier, ctx, next) {
     }
     const cacheKey = `${ctx.parentURL}::${specifier}`;
     const cached = resolveCache.get(cacheKey);
-    if (cached) {
+    if (cached !== undefined) {
+        if (cached === null) {
+            return next(specifier, ctx);
+        }
         return {
             url: cached,
             format: 'module',
@@ -42,12 +107,18 @@ export async function resolve(specifier, ctx, next) {
         basePath,
         basePath + '.ts',
         basePath + '.tsx',
+        basePath + '.mts',
+        basePath + '.cts',
         basePath + '.js',
         basePath + '.mjs',
+        basePath + '.cjs',
         path.join(basePath, 'index.ts'),
         path.join(basePath, 'index.tsx'),
+        path.join(basePath, 'index.mts'),
+        path.join(basePath, 'index.cts'),
         path.join(basePath, 'index.js'),
-        path.join(basePath, 'index.mjs')
+        path.join(basePath, 'index.mjs'),
+        path.join(basePath, 'index.cjs')
     ];
     for (const file of tryFiles) {
         if (await existsWithCache(file)) {
@@ -60,14 +131,21 @@ export async function resolve(specifier, ctx, next) {
             };
         }
     }
+    resolveCache.set(cacheKey, null);
     return next(specifier, ctx);
 }
 export async function load(url, ctx, next) {
-    if (!url.startsWith('file://') || !url.endsWith('.ts')) {
+    if (!url.startsWith('file://') || !TS_SOURCE_RE.test(url)) {
         return next(url, ctx);
     }
     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 cachedCode = await readCachedTranspile(filename, fileStats.mtimeMs, fileStats.size, configHash);
+    if (cachedCode !== null) {
+        return { format: 'module', source: cachedCode, shortCircuit: true };
+    }
     const { code } = await transformFile(filename, {
         filename,
         jsc: {
@@ -100,5 +178,20 @@ export async function load(url, ctx, next) {
         },
         sourceMaps: 'inline'
     });
+    await writeCachedTranspile(filename, {
+        code,
+        mtimeMs: fileStats.mtimeMs,
+        size: fileStats.size,
+        configHash
+    });
     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/dist/util.js

@@ -0,0 +1,14 @@
+export function debounce(callback, waitMs) {
+    let timer;
+    return function (...args) {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => callback(...args), waitMs);
+    };
+}
+function color(code, value) {
+    return `\u001B[${code}m${value}\u001B[0m`;
+}
+export function yellow(value) {
+    return color(33, value);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "keywords": [
     "cli",
     "esm",
@@ -32,30 +32,29 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@swc/core": "^1.15.18",
+    "@swc/core": "^1.15.24",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.4.3",
-    "@commitlint/config-conventional": "^20.4.3",
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
     "@eslint/js": "^10.0.1",
     "@jest/globals": "^30.3.0",
     "@swc/jest": "^0.2.39",
-    "eslint": "^10.0.3",
-    "eslint-plugin-jest": "^29.15.0",
+    "eslint": "^10.2.0",
+    "eslint-plugin-jest": "^29.15.2",
     "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.4.0",
+    "globals": "^17.5.0",
     "husky": "^9.1.7",
     "jest": "^30.3.0",
     "jest-environment-node": "^30.3.0",
-    "jest-mock-extended": "^4.0.0",
-    "lint-staged": "^16.3.3",
-    "prettier": "^3.8.1",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.2",
     "rimraf": "^6.1.3",
     "tsc-alias": "^1.8.16",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.0"
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1"
   },
   "engines": {
     "node": "^20.9.0 || ^22.11.0 || ^24.11.0"