tsnite 0.0.4

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# tsnite
+
+```
+TypeScript at full throttle—fast, safe, unstoppable. 🚀
+```
+
+`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.
+
+## ⚡ Recursos principais
+
+- **Execução rápida de arquivos TypeScript** sem build manual.
+- **Integração simples** com projetos existentes.
+- **Suporte a múltiplos roots** e configurações flexíveis de projeto.
+
+## 🚀 Install
+
+To add `tsnite` to your project as a development dependency, run:
+
+```bash
+npm install tsnite -D
+```
+
+Or, if you're using Yarn:
+
+```bash
+yarn add --dev tsnite
+```
+
+## 🛠️ How to use
+
+With `tsnite` installed, you can use it directly in your terminal to run TypeScript files without needing to compile them first.
+
+### Run a TypeScript file
+
+```bash
+npx tsnite caminho/do/arquivo.ts
+```
+
+This will execute the specified TypeScript file, allowing you to quickly test and run scripts during development.
+
+## 💡 Tips & Best Practices
+
+- Keep your TypeScript project configuration (tsconfig.json) up to date for best performance.
+- Use multiple source roots for large projects to organize files efficiently.
+- Combine tsnite with scripts in package.json for a smoother development workflow.
+
+## 📚 More information
+
+Check the official npm page for details, examples, and updates:
+[https://www.npmjs.com/package/tsnite](https://www.npmjs.com/package/tsnite)
+
+#
+
+Enjoy developing TypeScript at full throttle!

package/dist/builders/swc.js

@@ -0,0 +1,43 @@
+import { transformFile } from '@swc/core';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, parse } from 'node:path';
+import { loadTsConfigPaths } from '../utils/tsconfig-loader.js';
+import { outDir } from '../common/constants.js';
+const paths = await loadTsConfigPaths();
+export async function compile(filename, sourceRoot) {
+    const { code, map } = await transformFile(filename, {
+        jsc: {
+            baseUrl: join(process.cwd(), '.'),
+            parser: {
+                syntax: 'typescript',
+                decorators: true
+            },
+            target: 'es2022',
+            keepClassNames: true,
+            transform: {
+                treatConstEnumAsEnum: true,
+                decoratorMetadata: true,
+                legacyDecorator: true
+            },
+            experimental: {
+                keepImportAssertions: true
+            },
+            paths
+        },
+        module: {
+            type: 'es6',
+            strict: true,
+            outFileExtension: 'js',
+            resolveFully: true
+        },
+        sourceMaps: true
+    });
+    const { dir, name } = parse(filename
+        .replace(join(process.cwd(), '/'), '')
+        .replace(join(sourceRoot, '/'), ''));
+    await mkdir(join(outDir, dir), { recursive: true });
+    await writeFile(join(outDir, dir, `${name}.js`), `${code}\n//# sourceMappingURL=${join(outDir, dir, `${name}.js.map`)}`);
+    if (map) {
+        await writeFile(join(outDir, dir, `${name}.js.map`), map);
+    }
+}

package/dist/cli.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { join } from 'node:path';
+import { readdir, stat, rm, mkdir, cp, symlink } from 'node:fs/promises';
+import { fork } from 'node:child_process';
+import { watch } from 'chokidar';
+import { EventEmitter } from 'node:events';
+import { name, description, version, outDir } from './common/constants.js';
+import { compile } from './builders/swc.js';
+import { gradient } from './utils/gradient.js';
+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();
+const events = new EventEmitter();
+const pids = new Set();
+let starts = 0;
+export async function* discover(path) {
+    const entries = await readdir(path);
+    const ignores = /^(?:node_modules|dist|coverage|tests|\..+|.*\.(?:spec|test)\.ts)$/;
+    for (const entry of entries) {
+        if (ignores.test(entry))
+            continue;
+        const stats = await stat(join(path, entry));
+        if (stats.isDirectory()) {
+            yield* discover(join(path, entry));
+            continue;
+        }
+        yield join(path, entry);
+    }
+}
+async function handler() {
+    const options = program.opts();
+    const [entry, nodeArgs] = program.processedArgs;
+    try {
+        await rm(outDir, {
+            force: true,
+            recursive: true
+        });
+        await mkdir(outDir, { recursive: true });
+        await symlink(join(process.cwd(), 'node_modules'), join(outDir, 'node_modules'), 'junction');
+        starts = performance.now();
+        for await (const filename of discover(options.sourceRoot)) {
+            if (filename.endsWith('.ts')) {
+                await compile(join(process.cwd(), filename), options.sourceRoot);
+                continue;
+            }
+            if (options.includeAssets) {
+                await cp(join(process.cwd(), filename), join(outDir, join(filename.replace(`${join(options.sourceRoot)}/`, ''))), {
+                    force: true,
+                    recursive: true
+                });
+            }
+        }
+        const ends = performance.now();
+        const entrypoint = entry
+            .replace(join(options.sourceRoot, '/'), '')
+            .replace(/(.+).ts$/, '$1.js');
+        const { pid } = fork(join(outDir, entrypoint), {
+            execArgv: ['--enable-source-maps', ...nodeArgs],
+            stdio: 'inherit'
+        });
+        pids.add(pid);
+        process.stdout.write(`\x1b[1m${gradient(['#5e23e6', '#f88bc7'])(`➤ Compiled successfully in ${(ends - starts).toFixed(2)}ms`)}\x1b[0m\n`);
+    }
+    catch (err) {
+        process.stdout.write(`\x1b${gradient(['#cf4444', '#9b1e1e'])(`❌ Failed to compile!\n`)}\x1b[0m\n${err}`);
+    }
+    if (options.watch) {
+        const watcher = watch(join(process.cwd(), options.sourceRoot), {
+            atomic: true,
+            ignoreInitial: true,
+            ignored: [/.+\.(?:test|spec)\.ts$/i]
+        });
+        watcher.on('change', async function (path) {
+            process.stdout.write('\x1Bc');
+            starts = performance.now();
+            try {
+                if (!path.endsWith('.ts') && options.includeAssets) {
+                    await cp(path, join(outDir, path.replace(join(process.cwd(), options.sourceRoot, '/'), '')), { force: true, recursive: true });
+                    return;
+                }
+                await compile(path, options.sourceRoot);
+                events.emit('ready');
+            }
+            catch (err) {
+                process.stdout.write(`\x1b${gradient(['#cf4444', '#9b1e1e'])(`❌ Failed to compile!\n`)}\x1b[0m\n${err}`);
+            }
+        });
+        watcher.on('add', async function (path) {
+            process.stdout.write('\x1Bc');
+            starts = performance.now();
+            try {
+                if (!path.endsWith('.ts') && options.includeAssets) {
+                    await cp(path, join(outDir, path.replace(join(process.cwd(), options.sourceRoot, '/'), '')), { force: true, recursive: true });
+                    return;
+                }
+                await compile(path, options.sourceRoot);
+                events.emit('ready');
+            }
+            catch (err) {
+                process.stdout.write(`\x1b${gradient(['#cf4444', '#9b1e1e'])(`❌ Failed to compile!\n`)}\x1b[0m\n${err}`);
+            }
+        });
+        watcher.on('unlink', async function (path) {
+            process.stdout.write('\x1Bc');
+            starts = performance.now();
+            try {
+                await rm(join(outDir, path.replace(join(process.cwd(), options.sourceRoot, '/'), '')), {
+                    force: true,
+                    recursive: true
+                });
+                events.emit('ready');
+            }
+            catch (err) {
+                console.error(err);
+            }
+        });
+        events.on('ready', async function () {
+            try {
+                for (const pid of pids.values()) {
+                    try {
+                        process.kill(pid);
+                        pids.delete(pid);
+                    }
+                    catch {
+                        pids.delete(pid);
+                    }
+                }
+                const ends = performance.now();
+                const entrypoint = entry
+                    .replace(join(options.sourceRoot, '/'), '')
+                    .replace(/(.+).ts$/, '$1.js');
+                const { pid } = fork(join(outDir, entrypoint), {
+                    execArgv: ['--enable-source-maps', ...nodeArgs],
+                    stdio: 'inherit'
+                });
+                pids.add(pid);
+                process.stdout.write(`\x1b[1m${gradient(['#5e23e6', '#f88bc7'])(`› Compiled successfully in ${(ends - starts).toFixed(2)}ms`)}\x1b[0m\n`);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        });
+    }
+}
+program.action(handler);
+program.parse(process.argv);

package/dist/common/constants.js

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

package/dist/utils/gradient.js

@@ -0,0 +1,36 @@
+function hexToRgb(hex) {
+    hex = hex.replace(/^#/, '');
+    if (hex.length === 3) {
+        hex = hex
+            .split('')
+            .map((c) => c + c)
+            .join('');
+    }
+    const num = parseInt(hex, 16);
+    return [num >> 16, (num >> 8) & 255, num & 255];
+}
+function rgbToAnsi([r, g, b]) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+export function gradient(colors) {
+    return function (text) {
+        if (colors.length < 2) {
+            throw new Error('gradient needs at least 2 colors');
+        }
+        const segments = colors.length - 1;
+        const length = text.length;
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const pos = (i / (length - 1)) * segments;
+            const segIndex = Math.min(Math.floor(pos), segments - 1);
+            const t = pos - segIndex;
+            const start = hexToRgb(colors[segIndex]);
+            const end = hexToRgb(colors[segIndex + 1]);
+            const r = Math.round(start[0] + (end[0] - start[0]) * t);
+            const g = Math.round(start[1] + (end[1] - start[1]) * t);
+            const b = Math.round(start[2] + (end[2] - start[2]) * t);
+            result += rgbToAnsi([r, g, b]) + text[i];
+        }
+        return result + '\x1b[0m';
+    };
+}

package/dist/utils/tsconfig-loader.js

@@ -0,0 +1,13 @@
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import json5 from 'json5';
+export async function loadTsConfigPaths() {
+    try {
+        const data = await readFile(join(process.cwd(), 'tsconfig.json'), 'utf-8');
+        const { compilerOptions: { paths } } = json5.parse(data);
+        return paths;
+    }
+    catch {
+        return {};
+    }
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "tsnite",
+  "description": "TypeScript at full throttle—fast, safe, unstoppable. 🚀",
+  "keywords": [
+    "cli",
+    "esm",
+    "watch",
+    "nodejs",
+    "typescript"
+  ],
+  "version": "0.0.4",
+  "type": "module",
+  "bin": {
+    "tsnite": "dist/cli.js"
+  },
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "postbuild": "tsc-alias -f -p tsconfig.build.json",
+    "lint": "eslint . --config eslint.config.js",
+    "test": "jest --passWithNoTests --verbose",
+    "test:ci": "jest --passWithNoTests --ci",
+    "test:watch": "jest --passWithNoTests --watch",
+    "test:watchAll": "jest --passWithNoTests --watchAll",
+    "test:coverage": "jest --passWithNoTests --coverage",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@swc/core": "^1.13.5",
+    "chokidar": "^4.0.3",
+    "commander": "^14.0.0",
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.35.0",
+    "@jest/globals": "^30.1.2",
+    "@swc/jest": "^0.2.39",
+    "eslint": "^9.35.0",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.3.0",
+    "husky": "^9.1.7",
+    "jest": "^30.1.3",
+    "jest-environment-node": "^30.1.2",
+    "jest-mock-extended": "^4.0.0",
+    "lint-staged": "^16.1.6",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.42.0"
+  },
+  "author": {
+    "name": "Luciano Alves",
+    "url": "https://github.com/luas10c"
+  },
+  "engines": {
+    "node": "^20.9.0 || ^22.11.0"
+  },
+  "homepage": "https://github.com/luas10c/tsnite",
+  "repository": {
+    "type": "github",
+    "url": "git+https://github.com/luas10c/tsnite.git"
+  },
+  "bugs": {
+    "url": "https://gitbub.com/luas10c/tsnite/issues"
+  },
+  "license": "MIT"
+}