jopi-toolkit 3.0.24 → 3.1.22

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.24",
+  "version": "3.1.22",
   "name": "jopi-toolkit",
   "license": "MIT",
   "homepage": "https://github.com/johanpiquet/jopi-toolkit",
@@ -17,90 +17,102 @@
     "src"
   ],
   "scripts": {
-    "build:priority:1": "npx tsc",
-    "clean": "rm -rf ./dist .turbo tsconfig.tsbuildinfo",
-    "tsc": "tsc",
-    "bun-publish": "npx tsc && bun publish",
-    "untrack": "git rm -r --cached -- ./dist/**;",
     "jopiLink": "npx jopi-mono link-add",
-    "dev:tsc": "npx tsc --watch"
+    "bunLink": "bun link",
+    "dev:build": "tsc",
+    "dev:tsc-watch": "tsc --watch",
+    "dev:tsc-check": "tsc --noEmit"
   },
-  "devDependencies": {
+  "dependencies": {
     "@types/adm-zip": "^0.5.7",
     "@types/bun": "latest",
     "@types/mime-types": "latest",
-    "@types/node": "latest"
-  },
-  "dependencies": {
+    "@types/node": "latest",
     "@types/ws": "^8.18.1",
     "adm-zip": "^0.5.9",
     "mime-types": "^3.0.1",
     "ws": "^8.18.3"
   },
-  "publishedDate": "12/20/2025",
-  "publicPublishedDate": "12/20/2025",
+  "publishedDate": "1/12/2026",
+  "publicPublishedDate": "1/12/2026",
   "exports": {
     "./jk_schema": {
+      "types": "./src/jk_schemas/index.ts",
       "bun": "./src/jk_schemas/index.ts",
       "default": "./dist/jk_schemas/index.js"
     },
     "./jk_tools": {
+      "types": "./src/jk_tools/index.ts",
       "bun": "./src/jk_tools/index.ts",
       "default": "./dist/jk_tools/index.js"
     },
     "./jk_process": {
+      "types": "./src/jk_process/index.ts",
       "bun": "./src/jk_process/index.ts",
       "default": "./dist/jk_process/index.js"
     },
     "./jk_data": {
+      "types": "./src/jk_data/index.ts",
       "bun": "./src/jk_data/index.ts",
       "default": "./dist/jk_data/index.js"
     },
     "./jk_what": {
+      "types": "./src/jk_what/index.ts",
       "bun": "./src/jk_what/index.ts",
       "default": "./dist/jk_what/index.js"
     },
     "./jk_os": {
+      "types": "./src/jk_os/index.ts",
       "bun": "./src/jk_os/index.ts",
       "default": "./dist/jk_os/index.js"
     },
     "./jk_crypto": {
+      "types": "./src/jk_crypto/index.ts",
       "bun": "./src/jk_crypto/index.ts",
       "default": "./dist/jk_crypto/index.js"
     },
     "./jk_thread": {
+      "types": "./src/jk_thread/index.ts",
       "bun": "./src/jk_thread/index.ts",
       "default": "./dist/jk_thread/index.js"
     },
     "./jk_events": {
+      "types": "./src/jk_events/index.ts",
       "bun": "./src/jk_events/index.ts",
       "default": "./dist/jk_events/index.js"
     },
     "./jk_fs": {
+      "types": "./src/jk_fs/index.ts",
       "bun": "./src/jk_fs/index.ts",
       "default": "./dist/jk_fs/index.js"
     },
     "./jk_timer": {
+      "types": "./src/jk_timer/index.ts",
       "bun": "./src/jk_timer/index.ts",
       "default": "./dist/jk_timer/index.js"
     },
     "./jk_term": {
+      "types": "./src/jk_term/index.ts",
       "bun": "./src/jk_term/index.ts",
       "default": "./dist/jk_term/index.js"
     },
     "./jk_app": {
+      "types": "./src/jk_app/index.ts",
       "bun": "./src/jk_app/index.ts",
       "default": "./dist/jk_app/index.js"
     },
     "./jk_compress": {
+      "types": "./src/jk_compress/index.ts",
       "bun": "./src/jk_compress/index.ts",
       "default": "./dist/jk_compress/index.js"
     },
     "./jk_webSocket": {
+      "types": "./src/jk_webSocket/index.ts",
       "bun": "./src/jk_webSocket/index.ts",
       "default": "./dist/jk_webSocket/index.js"
     },
     "./jk_logs": {
+      "types": "./src/jk_logs/index.ts",
       "bun": "./src/jk_logs/index.ts",
       "default": "./dist/jk_logs/index.js"
     }

package/src/jk_app/common.js

@@ -258,31 +258,47 @@ var gIsExited = false;
 var gTempDir;
 //endregion
 //region Resolving
-export function findNodePackageDir(packageName, useLinuxPathFormat) {
-    if (useLinuxPathFormat === void 0) { useLinuxPathFormat = true; }
-    var currentDir = jk_fs.dirname(findPackageJson());
-    while (true) {
-        var packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
-        if (jk_fs.isDirectorySync(packagePath)) {
-            if (useLinuxPathFormat)
-                return jk_fs.win32ToLinuxPath(packagePath);
-            return packagePath;
-        }
-        var parentDir = jk_fs.dirname(currentDir);
-        // Reached root directory
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return undefined;
+export function findNodePackageDir(packageName_1) {
+    return __awaiter(this, arguments, void 0, function (packageName, searchFromDir) {
+        var currentDir, packagePath, parentDir;
+        if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    currentDir = jk_fs.resolve(searchFromDir);
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
+                    return [4 /*yield*/, jk_fs.isDirectory(packagePath)];
+                case 2:
+                    if (_a.sent())
+                        return [2 /*return*/, packagePath];
+                    parentDir = jk_fs.dirname(currentDir);
+                    if (parentDir === currentDir)
+                        return [3 /*break*/, 3];
+                    currentDir = parentDir;
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, undefined];
+            }
+        });
+    });
 }
-export function requireNodePackageDir(packageName, useLinuxPathFormat) {
-    if (useLinuxPathFormat === void 0) { useLinuxPathFormat = true; }
-    var pkgDir = findNodePackageDir(packageName, useLinuxPathFormat);
-    if (!pkgDir)
-        throw new Error("Package '" + packageName + "' not found");
-    return pkgDir;
+export function requireNodePackageDir(packageName_1) {
+    return __awaiter(this, arguments, void 0, function (packageName, searchFromDir) {
+        var pkgDir;
+        if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findNodePackageDir(packageName, searchFromDir)];
+                case 1:
+                    pkgDir = _a.sent();
+                    if (!pkgDir)
+                        throw new Error("Package '" + packageName + "' not found");
+                    return [2 /*return*/, pkgDir];
+            }
+        });
+    });
 }
 export function findPackageJsonDir(searchFromDir) {
     if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }

package/src/jk_app/common.ts

@@ -164,6 +164,10 @@ export function getTempDir(): string {
     return gTempDir;
 }
 
+export function setTempDir(dir: string) {
+    gTempDir = dir;
+}
+
 let gIsExited = false;
 let gTempDir: string|undefined;
 
@@ -191,13 +195,27 @@ export async function requireNodePackageDir(packageName: string, searchFromDir =
     return pkgDir;
 }
 
-export function findPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string {
+export function findRequiredPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string {
+    let pkgJsonPath = findRequiredPackageJson(searchFromDir);
+    return jk_fs.dirname(pkgJsonPath);
+}
+
+export function findPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string|undefined {
     let pkgJsonPath = findPackageJson(searchFromDir);
+    if (!pkgJsonPath) return undefined;
     return jk_fs.dirname(pkgJsonPath);
 }
 
-export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string {
-    if (!searchFromDir && (gPackageJsonPath!==undefined)) return gPackageJsonPath;
+export function findRequiredPackageJson(searchFromDir = getCodeSourceDirHint()): string {
+    let res = findPackageJson(searchFromDir);
+    if (!res) throw new Error("No package.json found.");
+    return res;
+}
+
+export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string|undefined {
+    if (!searchFromDir && (gPackageJsonPath!==undefined)) {
+        return gPackageJsonPath;
+    }
 
     let currentDir = searchFromDir;
 
@@ -214,7 +232,7 @@ export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string
         currentDir = parentDir;
     }
 
-    throw "No package.json found."
+    return undefined;
 }
 //
 let gPackageJsonPath: string|undefined;
@@ -236,7 +254,7 @@ export function getCodeSourceDirHint() {
 export function getSourceCodeDir(): string {
     if (gSourceCodeDir) return gSourceCodeDir;
 
-    let pkgJsonPath = findPackageJson();
+    let pkgJsonPath = findRequiredPackageJson();
     let dirName = jk_fs.join(jk_fs.dirname(pkgJsonPath), "src");
 
     if (jk_fs.isDirectorySync(dirName)) {
@@ -259,7 +277,7 @@ export function getCompiledCodeDir(): string {
         return gCompiledSourcesDir = sourceCodeDir;
     }
 
-    let pkgJsonPath = findPackageJson();
+    let pkgJsonPath = findRequiredPackageJson();
 
     let rootDir = jk_fs.dirname(pkgJsonPath);
 
@@ -273,7 +291,7 @@ export function getCompiledCodeDir(): string {
     return rootDir;
 }
 
-export function getCompiledFilePathFor(sourceFilePath: string): string {
+export function getCompiledFilePathFor(sourceFilePath: string, replaceExtension = true): string {
     const compiledCodeDir = getCompiledCodeDir();
     const sourceCodeDir = getSourceCodeDir();
 
@@ -283,9 +301,16 @@ export function getCompiledFilePathFor(sourceFilePath: string): string {
 
     let filePath = sourceFilePath.substring(sourceCodeDir.length);
 
-    if (isNodeJS && !filePath.endsWith(".js")) {
+    if (replaceExtension && !filePath.endsWith(".js")) {
         let idx = filePath.lastIndexOf(".");
-        if (idx !== -1) filePath = filePath.substring(0, idx) + ".js";
+        let ext = filePath.substring(idx);
+
+        // This avoid case where there is no extension but a punct in the name.
+        // Ex: importing "@/lib/jopijs.menu.getManager"
+        //
+        if ((ext === ".ts") || (ext === ".tsx")) {
+            filePath = filePath.substring(0, idx) + ".js";
+        }
     }
 
     return jk_fs.join(compiledCodeDir, filePath);

package/src/jk_events/index.ts

@@ -1,15 +1,19 @@
-import {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
+import { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
+import { isBrowser } from "jopi-toolkit/jk_what";
 
 // Warning: it's export.
-export {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
+export { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
 
 // noinspection JSUnusedGlobalSymbols
 
-export type EventListener<T = any> = (e: T, eventName: string) => void|Promise<void>;
+export type EventListener<T = any> = (e: T, eventName: string) => void | Promise<void>;
 export type SyncEventListener<T = any> = (e: T, eventName: string) => void;
 
 export type EventListenerProvider = () => Promise<EventListener[]>;
 
+let gStaticEvents: Record<string, any> = {};
+let gStaticEventsThisValue: any;
+
 export class EventGroup {
     private readonly listenersFor: Record<string, PriorityArray<EventListener>> = {};
     private evenSpy: undefined | ((eventName: string, data?: any) => void);
@@ -28,7 +32,7 @@ export class EventGroup {
         if (events) events.remove(listener);
     }
 
-    sendEvent(eventName: string, e?: any|undefined): void {
+    sendEvent(eventName: string, e?: any | undefined): void {
         if (this.evenSpy) this.evenSpy(eventName, e);
 
         const events = this.listenersFor[eventName];
@@ -50,8 +54,8 @@ export class EventGroup {
         }
     }
 
-    async sendAsyncEvent(eventName: string, e?: any|undefined): Promise<void> {
-        if (eventName[0]!=='@') {
+    async sendAsyncEvent(eventName: string, e?: any | undefined): Promise<void> {
+        if (eventName[0] !== '@') {
             throw new Error(`Async events ${eventName} must start with @`);
         }
 
@@ -82,7 +86,7 @@ export class EventGroup {
         }
     }
 
-    addListener<T = any|undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
+    addListener<T = any | undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
         let priority: EventPriority;
         let actualListener: EventListener;
 
@@ -117,11 +121,11 @@ export class EventGroup {
  */
 class PriorityArray<T> {
     private entries: PriorityArrayEntry<T>[] = [];
-    private build: T[]|undefined;
+    private build: T[] | undefined;
 
     add(priority: EventPriority, value: T) {
         this.build = undefined;
-        this.entries.push({priority, value});
+        this.entries.push({ priority, value });
     }
 
     remove(value: T) {
@@ -135,7 +139,7 @@ class PriorityArray<T> {
         }
 
         return this.build = this.entries
-            .sort((a,b) => Number(a.priority) - Number(b.priority))
+            .sort((a, b) => Number(a.priority) - Number(b.priority))
             .map(e => e.value);
     }
 }
@@ -149,6 +153,7 @@ interface PriorityArrayEntry<T> {
 
 export interface StaticEvent {
     send<T>(data: T): T;
+    setThisValue(value: any): void;
 }
 
 export interface SEventController {
@@ -156,13 +161,17 @@ export interface SEventController {
 }
 
 class StaticEventImpl implements StaticEvent, SEventController {
+    private thisValue: any;
+
     constructor(public readonly eventName: string, private readonly eventItems: SyncEventListener[]) {
         gStaticEvents[eventName] = this;
     }
 
     send<T>(data: T): T {
+        let thisValue = this.thisValue ?? gStaticEventsThisValue;
+
         for (const listener of this.eventItems) {
-            listener(data, this.eventName);
+            listener.call(thisValue, data, this.eventName);
         }
 
         return data;
@@ -176,12 +185,25 @@ class StaticEventImpl implements StaticEvent, SEventController {
             if (idx >= 0) this.eventItems.splice(idx, 1);
         };
     }
+
+    setThisValue(thisValue: any): void {
+        if (isBrowser) {
+            this.thisValue = thisValue;
+        }
+    }
 }
 
 export function createStaticEvent(eventName: string, eventItems: SyncEventListener[]): StaticEvent {
     return new StaticEventImpl(eventName, eventItems);
 }
 
+export function setStaticEventsThisValue(thisValue: any) {
+    if (isBrowser) {
+        gStaticEventsThisValue = thisValue;
+    }
+}
+
+
 export const defaultEventGroup = new EventGroup();
 
 export function newEventGroup(): EventGroup {
@@ -193,8 +215,6 @@ export const removeListener = defaultEventGroup.removeListener.bind(defaultEvent
 export const sendEvent = defaultEventGroup.sendEvent.bind(defaultEventGroup);
 export const sendAsyncEvent = defaultEventGroup.sendAsyncEvent.bind(defaultEventGroup);
 
-export function addListener<T = any|undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
+export function addListener<T = any | undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
     defaultEventGroup.addListener(eventName, priorityOrListener as EventPriority, listener as EventListener<T>);
 }
-
-let gStaticEvents: Record<string, StaticEventImpl> = {};

package/src/jk_fs/jBundler_ifBrowser.ts

@@ -68,6 +68,14 @@ export function readTextFromFileSync(filePath: string): string {
     throw new Error("Not implemented");
 }
 
+export async function readJsonFromFile<T = any>(filePath: string, throwError: boolean = false): Promise<T> {
+    throw new Error("Not implemented");
+}
+
+export function readJsonFromFileSync<T = any>(filePath: string, throwError: boolean = false): T {
+    throw new Error("Not implemented");
+}
+
 export async function isFile(filePath: string): Promise<boolean> {
     throw new Error("Not implemented");
 }

package/src/jk_fs/jBundler_ifServer.ts

@@ -195,13 +195,27 @@ export async function readTextFromFile(filePath: string, throwError: boolean = f
     }
 }
 
+export function readTextFromFileSync(filePath: string, throwError: boolean = false): string {
+    if (throwError) {
+        return fss.readFileSync(filePath, 'utf8');
+    }
+
+    try {
+        return fss.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        // @ts-ignore
+        return undefined;
+    }
+}
+
 export async function readJsonFromFile<T = any>(filePath: string, throwError: boolean = false): Promise<T> {
     if (throwError) {
-        let txt = await fs.readFile(filePath, 'utf8');
+        let txt = await readTextFromFile(filePath, true);
         return JSON.parse(txt) as T;
     } else {
         try {
-            let txt = await fs.readFile(filePath, 'utf8');
+            let txt = await readTextFromFile(filePath);
             return JSON.parse(txt) as T;
         }
         catch {
@@ -211,8 +225,20 @@ export async function readJsonFromFile<T = any>(filePath: string, throwError: bo
     }
 }
 
-export function readTextFromFileSync(filePath: string): string {
-    return fss.readFileSync(filePath, 'utf8');
+export function readJsonFromFileSync<T = any>(filePath: string, throwError: boolean = false): T {
+    if (throwError) {
+        let txt = readTextFromFileSync(filePath);
+        return JSON.parse(txt) as T;
+    } else {
+        try {
+            let txt = readTextFromFileSync(filePath);
+            return JSON.parse(txt) as T;
+        }
+        catch {
+            // @ts-ignore
+            return undefined;
+        }
+    }
 }
 
 export async function isFile(filePath: string): Promise<boolean> {

package/src/jk_logs/jBundler_ifServer.ts

@@ -4,6 +4,12 @@ import type {LogInitializer} from "./index.ts";
 
 export function init(init: LogInitializer) {
     const mainDir = jk_app.findPackageJsonDir();
+    
+    // Possible that no package.json is found.
+    // For exemple, when using a command line tool (ex: jopi init).
+    //
+    if (!mainDir) return;
+
     const filePath = jk_fs.join(mainDir, "logConfig.json");
 
     if (!jk_fs.isFileSync(filePath)) return;

package/src/{jk_fs → jk_process}/index.js

@@ -1,2 +1 @@
 export * from "./jBundler_ifServer.ts";
-export * from "./common.ts";

package/src/jk_process/jBundler_ifServer.ts

@@ -1,4 +1,38 @@
+import * as inspector from "node:inspector";
+
 export const argv = process.argv;
 export const env = process.env as Record<string, string>;
 export const isProduction = process.env.NODE_ENV === 'production';
-export const isDevelopment: boolean = !isProduction;
+export const isDevelopment: boolean = !isProduction;
+
+/**
+ * Detect if Node.js or Bun.js is running with the debugger launcher.
+ */
+export function isLaunchedWithDebugger(): boolean {
+    const args = process.execArgv;
+    if (args.some((arg) => arg.includes("--inspect") || arg.includes("--debug") || arg.includes("bootloader.js"))) return true;
+
+    // Check environment variables
+    if (process.env.VSCODE_INSPECTOR_OPTIONS) return true;
+    
+    if (process.env.NODE_OPTIONS) {
+        const nodeOptions = process.env.NODE_OPTIONS;
+        if (nodeOptions.includes("--inspect") || 
+            nodeOptions.includes("--debug") || 
+            nodeOptions.includes("bootloader.js") || 
+            nodeOptions.includes("js-debug")) {
+            return true;
+        }
+    }
+
+    // Check Bun environment variables
+    if (process.env.BUN_INSPECT || process.env.BUN_INSPECT_BRK || process.env.BUN_INSPECT_WAIT) return true;
+
+
+    // Check inspector url. This is the most reliable way to detect if a debugger is attached.
+    try {
+        if (inspector.url()) return true;
+    } catch { /* ignore */ }
+
+    return false;
+}

package/src/jk_tools/jBundler_ifServer.ts

@@ -106,9 +106,11 @@ export function killPort(port: string = '3000'): Promise<void> {
     return new Promise<void>((resolve) => {
         const isWindows = os.platform() === 'win32';
 
+        // On Windows, we use netstat to find the PID of the process using the port as LOCAL address.
+        // On Unix, we use lsof with -sTCP:LISTEN to only get the listening process (avoiding killing clients/browsers).
         const command = isWindows
             ? `netstat -ano | findstr :${port}`
-            : `lsof -ti :${port}`;
+            : `lsof -ti :${port} -sTCP:LISTEN`;
 
         exec(command, (_error, stdout) => {
             if (!stdout) {
@@ -119,9 +121,17 @@ export function killPort(port: string = '3000'): Promise<void> {
             const pids = isWindows
                 ? [...new Set(stdout.trim().split('\n').map(line => {
                     const parts = line.trim().split(/\s+/);
-                    return parts[parts.length - 1];
-                }).filter(pid => pid && /^\d+$/.test(pid) && pid !== '0'))]
-                : stdout.trim().split('\n');
+                    // netstat -ano output: Proto, Local Address, Foreign Address, State, PID
+                    const localAddress = parts[1] || "";
+                    const pid = parts[parts.length - 1];
+                    // Check if it's exactly the port (avoiding :3000 matching :30000)
+                    // and ensure it's the local address (avoiding killing clients connected to this port)
+                    if (localAddress.endsWith(`:${port}`)) {
+                        return pid;
+                    }
+                    return null;
+                }).filter((pid): pid is string => !!(pid && /^\d+$/.test(pid) && pid !== '0')))]
+                : stdout.trim().split('\n').filter(pid => pid && /^\d+$/.test(pid));
 
             const killCmd = isWindows ? 'taskkill /PID' : 'kill -9';
             let pending = pids.length;
@@ -133,8 +143,11 @@ export function killPort(port: string = '3000'): Promise<void> {
 
             pids.forEach(pid => {
                 exec(`${killCmd} ${pid}${isWindows ? ' /F' : ''}`, async (err) => {
-                    if (err) console.error(`Failed to kill process ${pid}`);
-                    else console.log(`⚠️  Process ${pid} automatically killed to free the port ${port}`);
+                    if (err) {
+                        // Process might have already exited
+                    } else {
+                        console.log(`⚠️  Process ${pid} automatically killed to free the port ${port}`);
+                    }
 
                     if (--pending === 0) {
                         await jk_timer.tick(250);

package/src/jk_what/jBundler_ifServer.js

@@ -1,5 +1,8 @@
-export var isNodeJS = typeof (Bun) === "undefined";
-export var isBunJS = typeof (Bun) !== "undefined";
-export var isServerSide = true;
-export var isBrowser = false;
-export var serverType = isNodeJS ? "node" : "bun";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverType = exports.isBrowser = exports.isServerSide = exports.isBunJS = exports.isNodeJS = void 0;
+exports.isNodeJS = typeof (Bun) === "undefined";
+exports.isBunJS = typeof (Bun) !== "undefined";
+exports.isServerSide = true;
+exports.isBrowser = false;
+exports.serverType = exports.isNodeJS ? "node" : "bun";

package/src/jk_fs/common.js

@@ -1 +0,0 @@
-export {};