tsnite 0.0.18 → 0.0.20

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2025
+Copyright (c) 2026
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -52,7 +52,7 @@ This will execute the specified TypeScript file, allowing you to quickly test an
   {
     "scripts": {
       //...
-      "dev": "tsnite --watch --include-assets src/index.ts"
+      "dev": "tsnite watch --include src --exclude uploads --ext js,ts,json src/index.ts"
     }
   }
   ```

package/dist/cli.js

@@ -1,22 +1,19 @@
 #!/usr/bin/env node
 import { program } from 'commander';
-import { join } from 'node:path';
+import { extname, join, resolve, relative } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { fork } from 'node:child_process';
 import { watch } from 'chokidar';
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.dirname);
-const { name, description, version } = require(join(import.meta.dirname, '..', 'package.json'));
+import { name, description, version } from './metadata.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();
 program
     .name(name)
     .description(description)
     .version(version, '-v, --version', 'Output the current version')
-    .option('--source-root <string>', 'Source Root', '.')
-    .option('--watch', 'Enables watch mode', false)
-    .option('--include-assets', 'Include static files in the build', false)
-    .argument('<string>', 'Entrypoint file')
-    .argument('[args...]', 'Specify the Node.js command and any additional arguments')
     .showSuggestionAfterError();
 function cleanup() {
     for (const pid of pids.values()) {
@@ -24,17 +21,14 @@ function cleanup() {
             process.kill(pid, 'SIGTERM');
         }
         catch {
-            // processo já morreu
+            //
         }
     }
     process.exit(0);
 }
 process.on('SIGINT', cleanup);
 process.on('SIGTERM', cleanup);
-async function handler() {
-    const options = program.opts();
-    const [entry, nodeArgs] = program.processedArgs;
-    process.stdout.write('\x1Bc');
+function spawn(entry, nodeArgs) {
     const { pid } = fork(join(process.cwd(), entry), {
         stdio: 'inherit',
         execArgv: [
@@ -46,12 +40,68 @@ async function handler() {
         ]
     });
     pids.add(pid);
-    if (!options.watch)
+}
+function normalizePath(value) {
+    return value
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .replace(/\/+$/, '');
+}
+function normalizeExt(value) {
+    return value.trim().replace(/^\./, '').toLowerCase();
+}
+function createWatchConfig(options) {
+    const sourceRoot = resolve(process.cwd(), options.sourceRoot);
+    const includePaths = options.include.map((value) => resolve(sourceRoot, value));
+    const excludePaths = options.exclude.map(normalizePath).filter(Boolean);
+    const excludeSet = new Set(excludePaths);
+    const allowedExts = new Set(options.ext.map(normalizeExt).filter(Boolean));
+    function ignored(filePath, stats) {
+        const rel = normalizePath(relative(sourceRoot, filePath));
+        // fora do sourceRoot
+        if (rel.startsWith('../')) {
+            return true;
+        }
+        // raiz do sourceRoot
+        if (rel === '') {
+            return false;
+        }
+        const segments = rel.split('/');
+        // ignora por nome de pasta/arquivo em qualquer nível
+        if (segments.some((segment) => excludeSet.has(segment))) {
+            return true;
+        }
+        // ignora por caminho relativo completo
+        if (excludePaths.some((excluded) => rel === excluded || rel.startsWith(excluded + '/'))) {
+            return true;
+        }
+        // nunca filtra diretório por extensão
+        if (stats?.isDirectory()) {
+            return false;
+        }
+        const extension = extname(rel).slice(1).toLowerCase();
+        // se tiver lista de extensões, ignora arquivo fora dela
+        if (allowedExts.size > 0 && !allowedExts.has(extension)) {
+            return true;
+        }
+        return false;
+    }
+    return {
+        sourceRoot,
+        paths: includePaths,
+        ignored
+    };
+}
+async function handler(entry, options, nodeArgs, isWatch) {
+    process.stdout.write('\x1Bc');
+    spawn(entry, nodeArgs);
+    if (!isWatch)
         return;
-    const watcher = watch('.', {
+    const { ignored, paths } = createWatchConfig(options);
+    const watcher = watch(paths, {
         atomic: true,
         ignoreInitial: true,
-        ignored: [/.+\.(?:test|spec)\.ts$/i]
+        ignored
     });
     watcher.on('change', async function () {
         process.stdout.write('\x1Bc');
@@ -63,18 +113,36 @@ async function handler() {
                 //
             }
         }
-        const { pid } = fork(join(process.cwd(), entry), {
-            stdio: 'inherit',
-            execArgv: [
-                '--enable-source-maps',
-                '--no-experimental-strip-types',
-                '--import',
-                pathToFileURL(join(import.meta.dirname, 'register.js')).href,
-                ...nodeArgs
-            ]
-        });
-        pids.add(pid);
+        spawn(entry, nodeArgs);
     });
 }
-program.action(handler);
-program.parse(process.argv);
+function parseCsv(value) {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+program
+    .argument('<string>', 'Entrypoint file')
+    .argument('[nodeArgs...]', 'Specify the Node.js command and any additional arguments')
+    .action(async function (entry, nodeArgs, options) {
+    await handler(entry, options, nodeArgs, false);
+});
+program
+    .command('watch')
+    .option('--include <string>', 'Paths to be watched', parseCsv, DEFAULT_INCLUDE_PATHS)
+    .option('--exclude <string>', 'Paths to be ignored by watched', parseCsv, [
+    ...INTERNAL_IGNORED_PATHS,
+    ...DEFAULT_EXCLUDE_PATHS
+])
+    .option('--ext <string>', 'Extensions to be watched', parseCsv, DEFAULT_WATCH_EXTENSIONS)
+    .option('--source-root <string>', 'Source root to be watched', '.')
+    .argument('<string>', 'Entrypoint file')
+    .argument('[nodeArgs...]', 'Specify the Node.js command and any additional arguments')
+    .action(async function (entry, nodeArgs, options) {
+    await handler(entry, options, nodeArgs, true);
+});
+await program.parseAsync(process.argv).catch(function (err) {
+    console.error(err);
+    process.exit(1);
+});

package/dist/loader.js

@@ -1,8 +1,8 @@
 import { transformFile } from '@swc/core';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readFile } from 'node:fs/promises';
-import json5 from 'json5';
 import path from 'node:path';
+import { parse } from './parse.js';
 import { resolveCache, existsWithCache } from './cache.js';
 const tsconfigCache = { paths: null, baseUrl: null };
 async function loadTSConfig() {
@@ -11,9 +11,9 @@ async function loadTSConfig() {
     }
     try {
         const data = await readFile(path.join(process.cwd(), 'tsconfig.json'), 'utf-8');
-        const { compilerOptions: { paths, baseUrl } } = json5.parse(data);
+        const { compilerOptions: { paths, baseUrl } } = parse(data);
         tsconfigCache.paths = paths || null;
-        tsconfigCache.baseUrl = baseUrl || process.cwd();
+        tsconfigCache.baseUrl = path.join(process.cwd(), baseUrl) || process.cwd();
         return tsconfigCache;
     }
     catch {

package/dist/metadata.js

@@ -0,0 +1,4 @@
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.dirname);
+export const { name, description, version } = require(join(import.meta.dirname, '..', 'package.json'));

package/dist/parse.js

@@ -0,0 +1,435 @@
+/**
+ * JSON5 parse — zero dependencies, ESM + TypeScript
+ *
+ * Suporta toda a spec JSON5:
+ *  - Chaves sem aspas (identificadores ES5/Unicode)
+ *  - Strings single ou double quoted com escapes e line continuation
+ *  - Comentários // e /* ... * /
+ *  - Trailing commas em objetos e arrays
+ *  - Números: hex, Infinity, NaN, +/- leading/trailing decimal
+ *  - Reviver opcional (mesmo comportamento do JSON.parse nativo)
+ */
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function err(ctx, msg) {
+    throw new SyntaxError(`JSON5: ${msg} at ${ctx.line}:${ctx.col}`);
+}
+function current(ctx) {
+    return ctx.src[ctx.pos] ?? '';
+}
+function peek(ctx, offset = 1) {
+    return ctx.src[ctx.pos + offset] ?? '';
+}
+function advance(ctx) {
+    const ch = ctx.src[ctx.pos++] ?? '';
+    if (ch === '\n') {
+        ctx.line++;
+        ctx.col = 1;
+    }
+    else {
+        ctx.col++;
+    }
+    return ch;
+}
+function startsWith(ctx, s) {
+    return ctx.src.startsWith(s, ctx.pos);
+}
+function consume(ctx, s) {
+    ctx.pos += s.length;
+    ctx.col += s.length;
+}
+// ─── Whitespace + Comments ────────────────────────────────────────────────────
+const WHITESPACE = new Set([
+    ' ',
+    '\t',
+    '\r',
+    '\n',
+    '\u00A0',
+    '\u2028',
+    '\u2029',
+    '\uFEFF'
+]);
+function skipWhitespaceAndComments(ctx) {
+    while (ctx.pos < ctx.src.length) {
+        const ch = current(ctx);
+        if (WHITESPACE.has(ch)) {
+            advance(ctx);
+            continue;
+        }
+        // Comentário de linha: //
+        if (ch === '/' && peek(ctx, 1) === '/') {
+            advance(ctx);
+            advance(ctx);
+            while (ctx.pos < ctx.src.length &&
+                current(ctx) !== '\n' &&
+                current(ctx) !== '\r' &&
+                current(ctx) !== '\u2028' &&
+                current(ctx) !== '\u2029')
+                advance(ctx);
+            continue;
+        }
+        // Comentário de bloco: /* ... */
+        if (ch === '/' && peek(ctx, 1) === '*') {
+            advance(ctx);
+            advance(ctx);
+            while (ctx.pos < ctx.src.length) {
+                if (current(ctx) === '*' && peek(ctx, 1) === '/') {
+                    advance(ctx);
+                    advance(ctx);
+                    break;
+                }
+                advance(ctx);
+            }
+            continue;
+        }
+        break;
+    }
+}
+// ─── String ───────────────────────────────────────────────────────────────────
+function parseString(ctx) {
+    const quote = advance(ctx); // ' ou "
+    let result = '';
+    while (ctx.pos < ctx.src.length) {
+        const ch = current(ctx);
+        if (ch === quote) {
+            advance(ctx);
+            return result;
+        }
+        if (ch === '\\') {
+            advance(ctx);
+            const esc = advance(ctx);
+            switch (esc) {
+                case '"':
+                    result += '"';
+                    break;
+                case "'":
+                    result += "'";
+                    break;
+                case '\\':
+                    result += '\\';
+                    break;
+                case '/':
+                    result += '/';
+                    break;
+                case 'b':
+                    result += '\b';
+                    break;
+                case 'f':
+                    result += '\f';
+                    break;
+                case 'n':
+                    result += '\n';
+                    break;
+                case 'r':
+                    result += '\r';
+                    break;
+                case 't':
+                    result += '\t';
+                    break;
+                case 'v':
+                    result += '\v';
+                    break;
+                case '0':
+                    if (/[0-9]/.test(current(ctx)))
+                        err(ctx, 'Octal escapes are not allowed');
+                    result += '\0';
+                    break;
+                case 'x': {
+                    const hex = ctx.src.slice(ctx.pos, ctx.pos + 2);
+                    if (!/^[0-9a-fA-F]{2}$/.test(hex))
+                        err(ctx, 'Invalid hex escape sequence');
+                    result += String.fromCharCode(parseInt(hex, 16));
+                    ctx.pos += 2;
+                    ctx.col += 2;
+                    break;
+                }
+                case 'u': {
+                    if (current(ctx) === '{') {
+                        // \u{XXXXXX}
+                        advance(ctx);
+                        let hexStr = '';
+                        while (ctx.pos < ctx.src.length && current(ctx) !== '}')
+                            hexStr += advance(ctx);
+                        if (current(ctx) !== '}')
+                            err(ctx, 'Unterminated unicode escape');
+                        advance(ctx);
+                        const cp = parseInt(hexStr, 16);
+                        if (isNaN(cp) || cp > 0x10ffff)
+                            err(ctx, `Invalid unicode code point: ${hexStr}`);
+                        result += String.fromCodePoint(cp);
+                    }
+                    else {
+                        // \uXXXX
+                        const hex = ctx.src.slice(ctx.pos, ctx.pos + 4);
+                        if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                            err(ctx, 'Invalid unicode escape sequence');
+                        result += String.fromCharCode(parseInt(hex, 16));
+                        ctx.pos += 4;
+                        ctx.col += 4;
+                    }
+                    break;
+                }
+                // Line continuation
+                case '\n':
+                case '\u2028':
+                case '\u2029':
+                    break;
+                case '\r':
+                    if (current(ctx) === '\n')
+                        advance(ctx);
+                    break;
+                default:
+                    result += esc;
+            }
+            continue;
+        }
+        if (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029') {
+            err(ctx, 'Unterminated string literal');
+        }
+        result += advance(ctx);
+    }
+    err(ctx, 'Unterminated string literal');
+}
+// ─── Identifier (chave sem aspas) ─────────────────────────────────────────────
+const IDENT_START = /[\p{L}\p{Nl}$_]/u;
+const IDENT_PART = /[\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}$_\u200C\u200D]/u;
+function isIdentStart(ch) {
+    return IDENT_START.test(ch);
+}
+function isIdentPart(ch) {
+    return IDENT_PART.test(ch);
+}
+function parseIdentifier(ctx) {
+    const first = current(ctx);
+    if (!isIdentStart(first))
+        err(ctx, `Unexpected character: ${JSON.stringify(first)}`);
+    let name = advance(ctx);
+    while (ctx.pos < ctx.src.length && isIdentPart(current(ctx))) {
+        name += advance(ctx);
+    }
+    return name;
+}
+// ─── Number ───────────────────────────────────────────────────────────────────
+function parseNumber(ctx) {
+    let numStr = '';
+    // Sinal opcional
+    if (current(ctx) === '+' || current(ctx) === '-') {
+        numStr += advance(ctx);
+    }
+    // Infinity
+    if (startsWith(ctx, 'Infinity')) {
+        consume(ctx, 'Infinity');
+        return numStr === '-' ? -Infinity : Infinity;
+    }
+    // NaN
+    if (startsWith(ctx, 'NaN')) {
+        consume(ctx, 'NaN');
+        return NaN;
+    }
+    // Hexadecimal: 0x / 0X
+    if (current(ctx) === '0' && (peek(ctx, 1) === 'x' || peek(ctx, 1) === 'X')) {
+        const sign = numStr; // pode ser '-' ou ''
+        numStr += advance(ctx); // '0'
+        numStr += advance(ctx); // 'x'
+        if (!/[0-9a-fA-F]/.test(current(ctx)))
+            err(ctx, 'Invalid hexadecimal number');
+        while (ctx.pos < ctx.src.length && /[0-9a-fA-F_]/.test(current(ctx))) {
+            const ch = advance(ctx);
+            if (ch !== '_')
+                numStr += ch;
+        }
+        const abs = parseInt(numStr, 16); // parseInt ignora o prefixo 0x corretamente
+        return sign === '-' ? -abs : abs;
+    }
+    // Parte inteira
+    while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
+        const ch = advance(ctx);
+        if (ch !== '_')
+            numStr += ch;
+    }
+    // Parte decimal
+    if (ctx.pos < ctx.src.length && current(ctx) === '.') {
+        numStr += advance(ctx);
+        while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
+            const ch = advance(ctx);
+            if (ch !== '_')
+                numStr += ch;
+        }
+    }
+    // Expoente
+    if (ctx.pos < ctx.src.length &&
+        (current(ctx) === 'e' || current(ctx) === 'E')) {
+        numStr += advance(ctx);
+        if (current(ctx) === '+' || current(ctx) === '-')
+            numStr += advance(ctx);
+        while (ctx.pos < ctx.src.length && /[0-9_]/.test(current(ctx))) {
+            const ch = advance(ctx);
+            if (ch !== '_')
+                numStr += ch;
+        }
+    }
+    const n = Number(numStr);
+    if (isNaN(n))
+        err(ctx, `Invalid number: ${numStr}`);
+    return n;
+}
+// ─── Value ────────────────────────────────────────────────────────────────────
+function parseValue(ctx) {
+    skipWhitespaceAndComments(ctx);
+    if (ctx.pos >= ctx.src.length)
+        err(ctx, 'Unexpected end of input');
+    const ch = current(ctx);
+    if (ch === '"' || ch === "'")
+        return parseString(ctx);
+    if (ch === '{')
+        return parseObject(ctx);
+    if (ch === '[')
+        return parseArray(ctx);
+    if (startsWith(ctx, 'true')) {
+        consume(ctx, 'true');
+        return true;
+    }
+    if (startsWith(ctx, 'false')) {
+        consume(ctx, 'false');
+        return false;
+    }
+    if (startsWith(ctx, 'null')) {
+        consume(ctx, 'null');
+        return null;
+    }
+    if (ch === '+' ||
+        ch === '-' ||
+        ch === '.' ||
+        (ch >= '0' && ch <= '9') ||
+        startsWith(ctx, 'Infinity') ||
+        startsWith(ctx, 'NaN'))
+        return parseNumber(ctx);
+    err(ctx, `Unexpected token: ${JSON.stringify(ch)}`);
+}
+// ─── Object ───────────────────────────────────────────────────────────────────
+function parseObject(ctx) {
+    advance(ctx); // {
+    const obj = {};
+    skipWhitespaceAndComments(ctx);
+    if (current(ctx) === '}') {
+        advance(ctx);
+        return obj;
+    }
+    while (ctx.pos < ctx.src.length) {
+        skipWhitespaceAndComments(ctx);
+        if (ctx.pos >= ctx.src.length)
+            err(ctx, 'Unterminated object');
+        // Trailing comma
+        if (current(ctx) === '}') {
+            advance(ctx);
+            return obj;
+        }
+        // Chave: string ou identifier
+        const ch = current(ctx);
+        const key = ch === '"' || ch === "'" ? parseString(ctx) : parseIdentifier(ctx);
+        skipWhitespaceAndComments(ctx);
+        if (current(ctx) !== ':')
+            err(ctx, `Expected ':' after key ${JSON.stringify(key)}`);
+        advance(ctx); // :
+        const entry = [key, parseValue(ctx)];
+        obj[entry[0]] = entry[1];
+        skipWhitespaceAndComments(ctx);
+        if (current(ctx) === ',') {
+            advance(ctx);
+            continue;
+        }
+        if (current(ctx) === '}') {
+            advance(ctx);
+            return obj;
+        }
+        err(ctx, 'Expected "," or "}" in object');
+    }
+    err(ctx, 'Unterminated object');
+}
+// ─── Array ────────────────────────────────────────────────────────────────────
+function parseArray(ctx) {
+    advance(ctx); // [
+    const arr = [];
+    skipWhitespaceAndComments(ctx);
+    if (current(ctx) === ']') {
+        advance(ctx);
+        return arr;
+    }
+    while (ctx.pos < ctx.src.length) {
+        skipWhitespaceAndComments(ctx);
+        if (ctx.pos >= ctx.src.length)
+            err(ctx, 'Unterminated array');
+        // Trailing comma
+        if (current(ctx) === ']') {
+            advance(ctx);
+            return arr;
+        }
+        arr.push(parseValue(ctx));
+        skipWhitespaceAndComments(ctx);
+        if (current(ctx) === ',') {
+            advance(ctx);
+            continue;
+        }
+        if (current(ctx) === ']') {
+            advance(ctx);
+            return arr;
+        }
+        err(ctx, 'Expected "," or "]" in array');
+    }
+    err(ctx, 'Unterminated array');
+}
+function applyReviver(reviver, holder, key) {
+    const val = holder[key];
+    if (val !== null && typeof val === 'object') {
+        const obj = val;
+        for (const k of Object.keys(obj)) {
+            const newVal = applyReviver(reviver, obj, k);
+            if (newVal === undefined)
+                delete obj[k];
+            else
+                obj[k] = newVal;
+        }
+    }
+    return reviver.call(holder, key, val);
+}
+// ─── API pública ──────────────────────────────────────────────────────────────
+/**
+ * Faz o parse de uma string JSON5 e retorna o valor JavaScript correspondente.
+ *
+ * @param source  - String JSON5 a ser parseada.
+ * @param reviver - Função opcional chamada para cada par chave/valor (igual ao `JSON.parse`).
+ * @returns O valor JavaScript resultante tipado como `T`.
+ *
+ * @throws {SyntaxError} Se a string não for JSON5 válido.
+ *
+ * @example
+ * ```ts
+ * // Sem generic — retorna Json5Value
+ * const raw = parse(`{ host: 'localhost' }`)
+ *
+ * // Com generic — cast para o tipo desejado
+ * interface TsConfig {
+ *   compilerOptions: {
+ *     paths: Record<string, string[]>
+ *     baseUrl: string
+ *   }
+ * }
+ * const { compilerOptions: { paths, baseUrl } } = parse<TsConfig>(data)
+ * ```
+ */
+export function parse(source, reviver) {
+    const ctx = {
+        src: String(source),
+        pos: 0,
+        line: 1,
+        col: 1
+    };
+    const result = parseValue(ctx);
+    skipWhitespaceAndComments(ctx);
+    if (ctx.pos < ctx.src.length) {
+        err(ctx, `Unexpected token after value: ${JSON.stringify(current(ctx))}`);
+    }
+    if (typeof reviver === 'function') {
+        return applyReviver(reviver, { '': result }, '');
+    }
+    return result;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsnite",
   "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "keywords": [
     "cli",
     "esm",
@@ -34,16 +34,15 @@
   "dependencies": {
     "@swc/core": "^1.15.18",
     "chokidar": "^5.0.0",
-    "commander": "^14.0.3",
-    "json5": "^2.2.3"
+    "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.4.2",
-    "@commitlint/config-conventional": "^20.4.2",
+    "@commitlint/cli": "^20.4.3",
+    "@commitlint/config-conventional": "^20.4.3",
     "@eslint/js": "^10.0.1",
     "@jest/globals": "^30.2.0",
     "@swc/jest": "^0.2.39",
-    "eslint": "^10.0.2",
+    "eslint": "^10.0.3",
     "eslint-plugin-jest": "^29.15.0",
     "eslint-plugin-prettier": "^5.5.5",
     "globals": "^17.4.0",
@@ -51,7 +50,7 @@
     "jest": "^30.2.0",
     "jest-environment-node": "^30.2.0",
     "jest-mock-extended": "^4.0.0",
-    "lint-staged": "^16.3.1",
+    "lint-staged": "^16.3.2",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.3",
     "tsc-alias": "^1.8.16",